70 files changed, 137291 insertions, 112195 deletions

diff --git a/TAO/tao/Abstract_Servant_Base.h b/TAO/tao/Abstract_Servant_Base.h
index 387f58e7362..4ad7476dc06 100644
--- a/TAO/tao/Abstract_Servant_Base.h
+++ b/TAO/tao/Abstract_Servant_Base.h
@@ -37,10 +37,17 @@ public:
 
   /// Local implementation of the CORBA::Object::_is_a method.
   virtual CORBA::Boolean _is_a (const char* logical_type_id,
-                                CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()) = 0;
+                                CORBA_Environment &ACE_TRY_ENV = 
+                                  TAO_default_environment ()) = 0;
 
   /// Default <_non_existent>: always returns false.
-  virtual CORBA::Boolean _non_existent (CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()) = 0;
+  virtual CORBA::Boolean _non_existent (CORBA_Environment &ACE_TRY_ENV = 
+                                          TAO_default_environment ()) = 0;
+
+  /// Query the Interface Repository.
+  virtual CORBA_InterfaceDef_ptr _get_interface (
+      CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
+    ) = 0;
 
   //@{
   /// @name Reference counting hooks: no-ops by default.
diff --git a/TAO/tao/DomainC.cpp b/TAO/tao/DomainC.cpp
index f1307a2a9ad..e4110dca797 100644
--- a/TAO/tao/DomainC.cpp
+++ b/TAO/tao/DomainC.cpp
@@ -402,7 +402,7 @@ CORBA_ConstructionPolicy::_duplicate (CORBA_ConstructionPolicy_ptr obj)
 }
 
 void CORBA_ConstructionPolicy::make_domain_manager (
-    IR_InterfaceDef *object_type,
+    CORBA_InterfaceDef_ptr object_type,
     CORBA::Boolean constr_policy,
     CORBA::Environment &ACE_TRY_ENV
   )
diff --git a/TAO/tao/DomainC.h b/TAO/tao/DomainC.h
index 9813bd84d5d..d53b35b5508 100644
--- a/TAO/tao/DomainC.h
+++ b/TAO/tao/DomainC.h
@@ -20,8 +20,6 @@
 #include "PolicyC.h"
 #include "ClientRequestInfo.h"
 
-class IR_InterfaceDef;
-
 #if defined (TAO_EXPORT_MACRO)
 #undef TAO_EXPORT_MACRO
 #endif
@@ -300,7 +298,7 @@ public:
   static void _tao_any_destructor (void*);
 
   virtual void make_domain_manager (
-      IR_InterfaceDef* object_type,
+      CORBA_InterfaceDef_ptr object_type,
       CORBA::Boolean constr_policy,
       CORBA::Environment &ACE_TRY_ENV =
         TAO_default_environment ()
diff --git a/TAO/tao/IFR_Client/IFR_Base.pidl b/TAO/tao/IFR_Client/IFR_Base.pidl
new file mode 100644
index 00000000000..8077d3d7ad8
--- /dev/null
+++ b/TAO/tao/IFR_Client/IFR_Base.pidl
@@ -0,0 +1,310 @@
+//
+// $Id$
+//
+// ================================================================
+//
+// = LIBRARY
+//   TAO_IFR_Client
+//
+// = FILENAME
+//   IFR_Base.pidl
+//
+// = DESCRIPTION
+//   This file was used to generate the code in IFR_BaseC.{h,i,cpp}.
+//   The original file Interface.idl was split into four pieces, to
+//   keep the generated files to a manageable size and reduce build
+//   time. This IDL file contains the abstract base interfaces of
+//   the IFR as well as many of the non-interface data types used 
+//   by all other IFR interfaces.
+//
+//   The command used to generate code from this IDL file is:
+//
+//     tao_idl -o orig -Ge 1 \
+//          -Wb,export_macro=TAO_IFR_Client_Export \
+//          -Wb,export_include=ifr_client_export.h \
+//          -Wb,pre_include="ace/pre.h" \
+//          -Wb,post_include="ace/post.h" \
+//          IFR_Base.pidl
+//
+//   To regenerate the skeleton files IFR_BaseS.{h,i,cpp} and 
+//   IFR_BaseS_T.{h,i.cpp} in ACE_ROOT/TAO/orbsvcs/IFR_Service, use the 
+//   command
+//
+//     tao_idl -o ../../orbsvcs/IFR_Service/orig -Ge 1 \
+//          -Wb,pre_include="ace/pre.h" \
+//          -Wb,post_include="ace/post.h" \
+//          IFR_Base.pidl
+//
+// ================================================================
+
+#ifndef _IFR_BASE_IDL_
+#define _IFR_BASE_IDL_
+
+#pragma prefix "omg.org"
+
+module CORBA 
+{
+  typedef string Identifier;
+  typedef string ScopedName;
+  typedef string RepositoryId;
+
+  enum 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_AbstractInterface,
+    dk_LocalInterface
+  };
+
+  interface IRObject 
+  {
+    // read interface
+    readonly attribute DefinitionKind def_kind;
+    // write interface
+    void destroy ();
+  };
+
+  typedef string VersionSpec;
+
+  interface Contained;
+  interface Repository;
+  interface Container;
+
+  interface Contained : IRObject 
+  {
+    // read/write interface
+    attribute RepositoryId id;
+    attribute Identifier name;
+    attribute VersionSpec version;
+
+    // read interface
+    readonly attribute Container defined_in;
+    readonly attribute ScopedName absolute_name;
+    readonly attribute Repository containing_repository;
+    
+    struct Description 
+    {
+      DefinitionKind kind;
+      any value;
+    };
+
+    Description describe ();
+
+    // write interface
+    void move (
+        in Container new_container,
+        in Identifier new_name,
+        in VersionSpec new_version
+      );
+  };
+
+  typedef sequence <Contained> ContainedSeq;
+
+  interface ModuleDef;
+  interface ConstantDef;
+  interface IDLType;
+  interface StructDef;
+  interface UnionDef;
+  interface EnumDef;
+  interface AliasDef;
+  interface InterfaceDef;
+  typedef sequence<InterfaceDef> InterfaceDefSeq;
+  interface ExceptionDef;
+  interface NativeDef;
+  interface ValueDef;
+  typedef sequence<ValueDef> ValueDefSeq;
+  interface ValueBoxDef;
+  interface AbstractInterfaceDef;
+  typedef sequence<AbstractInterfaceDef> AbstractInterfaceDefSeq;
+  interface LocalInterfaceDef;
+  typedef sequence<LocalInterfaceDef> LocalInterfaceDefSeq;
+
+  struct StructMember 
+  {
+    Identifier name;
+    TypeCode type;
+    IDLType type_def;
+  };
+
+  typedef sequence <StructMember> StructMemberSeq;
+
+  struct Initializer 
+  {
+    StructMemberSeq members;
+    Identifier name;
+  };
+
+  typedef sequence <Initializer> InitializerSeq;
+
+  struct UnionMember 
+  {
+    Identifier name;
+    any label;
+    TypeCode type;
+    IDLType type_def;
+  };
+
+  typedef sequence <UnionMember> UnionMemberSeq;
+  typedef sequence <Identifier> EnumMemberSeq;
+
+  interface Container : IRObject 
+  {
+    // read interface
+    Contained lookup (
+        in ScopedName search_name
+      );
+    ContainedSeq contents (
+        in DefinitionKind limit_type,
+        in boolean exclude_inherited
+      );
+    ContainedSeq lookup_name (
+        in Identifier search_name,
+        in long levels_to_search,
+        in DefinitionKind limit_type,
+        in boolean exclude_inherited
+      );
+    struct Description 
+    {
+      Contained contained_object;
+      DefinitionKind kind;
+      any value;
+    };
+
+    typedef sequence<Description> DescriptionSeq;
+
+    DescriptionSeq describe_contents (
+        in DefinitionKind limit_type,
+        in boolean exclude_inherited,
+        in long max_returned_objs
+      );
+    // write interface
+    ModuleDef create_module (
+        in RepositoryId id,
+        in Identifier name,
+        in VersionSpec version
+      );
+    ConstantDef create_constant (
+        in RepositoryId id,
+        in Identifier name,
+        in VersionSpec version,
+        in IDLType type,
+        in any value
+      );
+    StructDef create_struct (
+        in RepositoryId id,
+        in Identifier name,
+        in VersionSpec version,
+        in StructMemberSeq members
+      );
+    UnionDef create_union (
+        in RepositoryId id,
+        in Identifier name,
+        in VersionSpec version,
+        in IDLType discriminator_type,
+        in UnionMemberSeq members
+      );
+    EnumDef create_enum (
+        in RepositoryId id,
+        in Identifier name,
+        in VersionSpec version,
+        in EnumMemberSeq members
+      );
+    AliasDef create_alias (
+        in RepositoryId id,
+        in Identifier name,
+        in VersionSpec version,
+        in IDLType original_type
+      );
+    InterfaceDef create_interface (
+        in RepositoryId id,
+        in Identifier name,
+        in VersionSpec version,
+        in InterfaceDefSeq base_interfaces
+      );
+    ValueDef create_value(
+        in RepositoryId id,
+        in Identifier name,
+        in VersionSpec version,
+        in boolean is_custom,
+        in boolean is_abstract,
+        in ValueDef base_value,
+        in boolean is_truncatable,
+        in ValueDefSeq abstract_base_values,
+        in InterfaceDefSeq supported_interfaces,
+        in InitializerSeq initializers
+      );
+    ValueBoxDef create_value_box(
+        in RepositoryId id,
+        in Identifier name,
+        in VersionSpec version,
+        in IDLType original_type_def
+      );
+    ExceptionDef create_exception(
+        in RepositoryId id,
+        in Identifier name,
+        in VersionSpec version,
+        in StructMemberSeq members
+      );
+    NativeDef create_native(
+        in RepositoryId id,
+        in Identifier name,
+        in VersionSpec version
+      );
+    AbstractInterfaceDef create_abstract_interface (
+        in RepositoryId id,
+        in Identifier name,
+        in VersionSpec version,
+        in AbstractInterfaceDefSeq base_interfaces
+      );
+    LocalInterfaceDef create_local_interface (
+        in RepositoryId id,
+        in Identifier name,
+        in VersionSpec version,
+        in InterfaceDefSeq base_interfaces
+      );
+  };
+
+  interface IDLType : IRObject 
+  {
+    readonly attribute TypeCode type;
+  };
+
+  interface TypedefDef : Contained, IDLType 
+  {
+  };
+
+  struct TypeDescription 
+  {
+    Identifier name;
+    RepositoryId id;
+    RepositoryId defined_in;
+    VersionSpec version;
+    TypeCode type;
+  };
+};
+
+#pragma prefix ""
+
+#endif /* _IFR_BASE_IDL_ */
diff --git a/TAO/tao/IFR_Client/IFR_BaseC.cpp b/TAO/tao/IFR_Client/IFR_BaseC.cpp
new file mode 100644
index 00000000000..3f4ba9fb788
--- /dev/null
+++ b/TAO/tao/IFR_Client/IFR_BaseC.cpp
@@ -0,0 +1,9243 @@
+// -*- C++ -*-
+//
+// $Id$
+
+// ****  Code generated by the The ACE ORB (TAO) IDL Compiler ****
+// TAO and the TAO IDL Compiler have been developed by:
+//       Center for Distributed Object Computing
+//       Washington University
+//       St. Louis, MO
+//       USA
+//       http://www.cs.wustl.edu/~schmidt/doc-center.html
+// and
+//       Distributed Object Computing Laboratory
+//       University of California at Irvine
+//       Irvine, CA
+//       USA
+//       http://doc.ece.uci.edu/
+//
+// Information about TAO is available at:
+//     http://www.cs.wustl.edu/~schmidt/TAO.html
+
+#include "IFR_BaseC.h"
+
+#if TAO_HAS_INTERCEPTORS == 1
+#include "tao/RequestInfo_Util.h"
+#endif  /* TAO_HAS_INTERCEPTORS == 1 */
+
+#if defined (__BORLANDC__)
+#pragma option -w-rvl -w-rch -w-ccc -w-aus
+#endif /* __BORLANDC__ */
+
+#if !defined (__ACE_INLINE__)
+#include "IFR_BaseC.i"
+#endif /* !defined INLINE */
+
+///////////////////////////////////////////////////////////////////////
+//                Base & Remote Proxy  Implementation. 
+//
+
+_TAO_IRObject_Proxy_Impl::_TAO_IRObject_Proxy_Impl (void)
+{}
+
+_TAO_IRObject_Remote_Proxy_Impl::_TAO_IRObject_Remote_Proxy_Impl (void)
+{}
+
+// Remote Implementation of the IDL interface methods
+
+CORBA::DefinitionKind _TAO_IRObject_Remote_Proxy_Impl::def_kind (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::DefinitionKind _tao_retval = (CORBA::DefinitionKind)0;
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), _tao_retval);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_def_kind",
+      13,
+      0,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::IRObject::TAO_ClientRequestInfo_CORBA_IRObject_def_kind_get ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN  (_tao_retval);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                _tao_retval
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_retval)
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                _tao_retval
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::DefinitionKind  _tao_retval_info = _tao_retval;
+               ri.result (_tao_retval_info);
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN  (_tao_retval);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_retval;
+}
+
+void _TAO_IRObject_Remote_Proxy_Impl::destroy (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW (CORBA::INTERNAL ());
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "destroy",
+      7,
+      0,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::IRObject::TAO_ClientRequestInfo_CORBA_IRObject_destroy ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK;
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK;
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK;
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK;
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK;
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)
+              );
+              
+            }
+          
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK;
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK;
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  
+}
+
+
+//
+//            End  Base & Remote  Proxy Implemeentation. 
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//           Remote & Base  Proxy Broker Implementation
+//
+
+_TAO_IRObject_Proxy_Broker::_TAO_IRObject_Proxy_Broker (void)
+{
+}
+
+_TAO_IRObject_Proxy_Broker::~_TAO_IRObject_Proxy_Broker (void)
+{
+}
+
+_TAO_IRObject_Proxy_Broker * (*CORBA__TAO_IRObject_Proxy_Broker_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  ) = 0;
+
+// Factory Member function Implementation.
+_TAO_IRObject_Remote_Proxy_Broker *
+_TAO_IRObject_Remote_Proxy_Broker::the_TAO_IRObject_Remote_Proxy_Broker (void)
+{
+  static ::_TAO_IRObject_Remote_Proxy_Broker remote_proxy_broker;
+  return &remote_proxy_broker;
+}
+
+_TAO_IRObject_Remote_Proxy_Broker::_TAO_IRObject_Remote_Proxy_Broker (void)
+{
+}
+
+_TAO_IRObject_Remote_Proxy_Broker::~_TAO_IRObject_Remote_Proxy_Broker (void)
+{
+}
+
+_TAO_IRObject_Proxy_Impl&
+_TAO_IRObject_Remote_Proxy_Broker::select_proxy (
+  ::CORBA_IRObject *,
+  CORBA::Environment &
+)
+{
+  return this->remote_proxy_impl_;
+}
+
+
+//
+//           End Remote & Base Proxy Broker Implementation
+///////////////////////////////////////////////////////////////////////
+
+
+// default constructor
+CORBA::IRObject::IRObject (int collocated)
+{
+  this->CORBA_IRObject_setup_collocation (collocated);
+}
+
+// destructor
+CORBA::IRObject::~IRObject (void)
+{}
+
+void
+CORBA::IRObject::CORBA_IRObject_setup_collocation (int collocated)
+{
+  if (collocated)
+    this->the_TAO_IRObject_Proxy_Broker_ =
+      ::CORBA__TAO_IRObject_Proxy_Broker_Factory_function_pointer (this);
+  else
+    this->the_TAO_IRObject_Proxy_Broker_ =
+      ::_TAO_IRObject_Remote_Proxy_Broker::the_TAO_IRObject_Remote_Proxy_Broker ();
+}
+
+void CORBA::IRObject::_tao_any_destructor (void *x)
+{
+  CORBA_IRObject *tmp = ACE_static_cast (CORBA_IRObject*,x);
+  CORBA::release (tmp);
+}
+
+CORBA::IRObject_ptr CORBA::IRObject::_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+{
+  if (CORBA::is_nil (obj))
+    return CORBA::IRObject::_nil ();
+  if (! obj->_is_local ())
+    {
+      CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/CORBA/IRObject:1.0", ACE_TRY_ENV);
+      ACE_CHECK_RETURN (CORBA::IRObject::_nil ());
+      if (is_a == 0)
+        return CORBA::IRObject::_nil ();
+    }
+  return CORBA::IRObject::_unchecked_narrow (obj, ACE_TRY_ENV);
+}
+
+CORBA::IRObject_ptr CORBA::IRObject::_unchecked_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &
+  )
+{
+  if (CORBA::is_nil (obj))
+    return CORBA::IRObject::_nil ();
+  if (! obj->_is_local ())
+    {
+      TAO_Stub* stub = obj->_stubobj ();
+      if (stub)
+        stub->_incr_refcnt ();
+      CORBA::IRObject_ptr default_proxy = CORBA::IRObject::_nil ();
+
+      if (
+          !CORBA::is_nil (stub->servant_orb_var ().ptr ()) &&
+          stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects () &&
+          obj->_is_collocated () &&CORBA__TAO_IRObject_Proxy_Broker_Factory_function_pointer != 0
+        )
+      {
+        ACE_NEW_RETURN (
+          default_proxy,
+          ::CORBA::IRObject (
+            stub,
+            1,
+            obj->_servant ()),
+            
+          CORBA::IRObject::_nil ());
+        }
+      if (CORBA::is_nil (default_proxy))
+        ACE_NEW_RETURN (default_proxy, ::CORBA::IRObject (stub, 0, obj->_servant ()), CORBA::IRObject::_nil ());
+        return default_proxy;
+      }
+    else 
+      return
+        ACE_reinterpret_cast
+          (
+            CORBA_IRObject_ptr,
+              obj->_tao_QueryInterface
+                (
+                  ACE_reinterpret_cast
+                    (
+                      ptr_arith_t,
+                      &CORBA_IRObject::_narrow
+                    )
+                )
+          );
+}
+
+CORBA::IRObject_ptr
+CORBA::IRObject::_duplicate (CORBA::IRObject_ptr obj)
+{
+  if (!CORBA::is_nil (obj))
+    obj->_add_ref ();
+  return obj;
+}
+
+CORBA::Boolean CORBA::IRObject::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
+{
+  if (
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
+  return 1; // success using local knowledge
+  else
+    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
+}
+
+void *CORBA::IRObject::_tao_QueryInterface (ptr_arith_t type)
+{
+  void *retv = 0;
+  if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      CORBA_IRObject::_narrow))
+    retv = ACE_reinterpret_cast (void*, this);
+  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
+    retv = ACE_reinterpret_cast (void *,
+      ACE_static_cast (CORBA::Object_ptr, this));
+    
+  if (retv)
+    this->_add_ref ();
+  return retv;
+}
+
+const char* CORBA::IRObject::_interface_repository_id (void) const
+{
+  return "IDL:omg.org/CORBA/IRObject:1.0";
+}
+
+CORBA::DefinitionKind CORBA::IRObject::def_kind (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_IRObject_Proxy_Impl &proxy = 
+    this->the_TAO_IRObject_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN ((CORBA::DefinitionKind)0);
+  
+  return proxy.def_kind (
+      this,
+      ACE_TRY_ENV
+    );
+}
+
+void CORBA::IRObject::destroy (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_IRObject_Proxy_Impl &proxy = 
+    this->the_TAO_IRObject_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK;
+  
+  proxy.destroy (
+      this,
+      ACE_TRY_ENV
+    );
+}
+
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+CORBA::IRObject::TAO_ClientRequestInfo_CORBA_IRObject_def_kind_get::TAO_ClientRequestInfo_CORBA_IRObject_def_kind_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
+{}
+
+Dynamic::ParameterList *
+CORBA::IRObject::TAO_ClientRequestInfo_CORBA_IRObject_def_kind_get::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return parameter_list;
+}
+
+Dynamic::ExceptionList *
+CORBA::IRObject::TAO_ClientRequestInfo_CORBA_IRObject_def_kind_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::IRObject::TAO_ClientRequestInfo_CORBA_IRObject_def_kind_get::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+CORBA::IRObject::TAO_ClientRequestInfo_CORBA_IRObject_def_kind_get::result (CORBA::DefinitionKind result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+CORBA::IRObject::TAO_ClientRequestInfo_CORBA_IRObject_destroy::TAO_ClientRequestInfo_CORBA_IRObject_destroy (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
+{}
+
+Dynamic::ParameterList *
+CORBA::IRObject::TAO_ClientRequestInfo_CORBA_IRObject_destroy::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return parameter_list;
+}
+
+Dynamic::ExceptionList *
+CORBA::IRObject::TAO_ClientRequestInfo_CORBA_IRObject_destroy::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::IRObject::TAO_ClientRequestInfo_CORBA_IRObject_destroy::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 1;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return result_any;
+}
+
+#endif /* TAO_HAS_INTERCEPTORS */
+
+///////////////////////////////////////////////////////////////////////
+//                Base & Remote Proxy  Implementation. 
+//
+
+_TAO_Contained_Proxy_Impl::_TAO_Contained_Proxy_Impl (void)
+{}
+
+_TAO_Contained_Remote_Proxy_Impl::_TAO_Contained_Remote_Proxy_Impl (void)
+{}
+
+// Remote Implementation of the IDL interface methods
+
+char * _TAO_Contained_Remote_Proxy_Impl::id (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::String_var _tao_safe_retval;
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_id",
+      7,
+      0,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::Contained::TAO_ClientRequestInfo_CORBA_Contained_id_get ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              char * _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+void _TAO_Contained_Remote_Proxy_Impl::id (
+    CORBA_Object *_collocated_tao_target_,
+    const char * id,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW (CORBA::INTERNAL ());
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_set_id",
+      7,
+      1,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::Contained::TAO_ClientRequestInfo_CORBA_Contained_id_set ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        id,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK;
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK;
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK;
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK;
+          
+          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+          if (!(
+                            (_tao_out << id)
+            ))
+            TAO_INTERCEPTOR_THROW (
+              CORBA::MARSHAL ()
+            );
+            
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK;
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)
+              );
+              
+            }
+          
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK;
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK;
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  
+}
+
+char * _TAO_Contained_Remote_Proxy_Impl::name (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::String_var _tao_safe_retval;
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_name",
+      9,
+      0,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::Contained::TAO_ClientRequestInfo_CORBA_Contained_name_get ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              char * _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+void _TAO_Contained_Remote_Proxy_Impl::name (
+    CORBA_Object *_collocated_tao_target_,
+    const char * name,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW (CORBA::INTERNAL ());
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_set_name",
+      9,
+      1,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::Contained::TAO_ClientRequestInfo_CORBA_Contained_name_set ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        name,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK;
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK;
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK;
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK;
+          
+          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+          if (!(
+                            (_tao_out << name)
+            ))
+            TAO_INTERCEPTOR_THROW (
+              CORBA::MARSHAL ()
+            );
+            
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK;
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)
+              );
+              
+            }
+          
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK;
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK;
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  
+}
+
+char * _TAO_Contained_Remote_Proxy_Impl::version (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::String_var _tao_safe_retval;
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_version",
+      12,
+      0,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::Contained::TAO_ClientRequestInfo_CORBA_Contained_version_get ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              char * _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+void _TAO_Contained_Remote_Proxy_Impl::version (
+    CORBA_Object *_collocated_tao_target_,
+    const char * version,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW (CORBA::INTERNAL ());
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_set_version",
+      12,
+      1,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::Contained::TAO_ClientRequestInfo_CORBA_Contained_version_set ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        version,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK;
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK;
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK;
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK;
+          
+          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+          if (!(
+                            (_tao_out << version)
+            ))
+            TAO_INTERCEPTOR_THROW (
+              CORBA::MARSHAL ()
+            );
+            
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK;
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)
+              );
+              
+            }
+          
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK;
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK;
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  
+}
+
+CORBA::Container_ptr _TAO_Contained_Remote_Proxy_Impl::defined_in (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::Container_ptr _tao_retval = CORBA::Container::_nil ();
+  CORBA::Container_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_defined_in",
+      15,
+      0,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::Contained::TAO_ClientRequestInfo_CORBA_Contained_defined_in_get ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::Container_ptr _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+char * _TAO_Contained_Remote_Proxy_Impl::absolute_name (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::String_var _tao_safe_retval;
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_absolute_name",
+      18,
+      0,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::Contained::TAO_ClientRequestInfo_CORBA_Contained_absolute_name_get ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              char * _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+CORBA::Contained::Description * _TAO_Contained_Remote_Proxy_Impl::describe (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::Contained::Description *_tao_retval = 0;
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  ACE_NEW_RETURN (_tao_retval, CORBA::Contained::Description, _tao_retval);
+  CORBA::Contained::Description_var _tao_safe_retval (_tao_retval);
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "describe",
+      8,
+      0,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::Contained::TAO_ClientRequestInfo_CORBA_Contained_describe ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::Contained::Description * _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+void _TAO_Contained_Remote_Proxy_Impl::move (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::Container_ptr new_container,
+    const char * new_name,
+    const char * new_version,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW (CORBA::INTERNAL ());
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "move",
+      4,
+      1,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::Contained::TAO_ClientRequestInfo_CORBA_Contained_move ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        new_container,
+        new_name,
+        new_version,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK;
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK;
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK;
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK;
+          
+          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+          if (!(
+                            (_tao_out << new_container) &&
+              (_tao_out << new_name) &&
+              (_tao_out << new_version)
+            ))
+            TAO_INTERCEPTOR_THROW (
+              CORBA::MARSHAL ()
+            );
+            
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK;
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)
+              );
+              
+            }
+          
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK;
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK;
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  
+}
+
+
+//
+//            End  Base & Remote  Proxy Implemeentation. 
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//           Remote & Base  Proxy Broker Implementation
+//
+
+_TAO_Contained_Proxy_Broker::_TAO_Contained_Proxy_Broker (void)
+{
+}
+
+_TAO_Contained_Proxy_Broker::~_TAO_Contained_Proxy_Broker (void)
+{
+}
+
+_TAO_Contained_Proxy_Broker * (*CORBA__TAO_Contained_Proxy_Broker_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  ) = 0;
+
+// Factory Member function Implementation.
+_TAO_Contained_Remote_Proxy_Broker *
+_TAO_Contained_Remote_Proxy_Broker::the_TAO_Contained_Remote_Proxy_Broker (void)
+{
+  static ::_TAO_Contained_Remote_Proxy_Broker remote_proxy_broker;
+  return &remote_proxy_broker;
+}
+
+_TAO_Contained_Remote_Proxy_Broker::_TAO_Contained_Remote_Proxy_Broker (void)
+{
+}
+
+_TAO_Contained_Remote_Proxy_Broker::~_TAO_Contained_Remote_Proxy_Broker (void)
+{
+}
+
+_TAO_Contained_Proxy_Impl&
+_TAO_Contained_Remote_Proxy_Broker::select_proxy (
+  ::CORBA_Contained *,
+  CORBA::Environment &
+)
+{
+  return this->remote_proxy_impl_;
+}
+
+
+//
+//           End Remote & Base Proxy Broker Implementation
+///////////////////////////////////////////////////////////////////////
+
+
+// default constructor
+CORBA::Contained::Contained (int collocated)
+{
+  this->CORBA_Contained_setup_collocation (collocated);
+}
+
+// destructor
+CORBA::Contained::~Contained (void)
+{}
+
+void
+CORBA::Contained::CORBA_Contained_setup_collocation (int collocated)
+{
+  if (collocated)
+    this->the_TAO_Contained_Proxy_Broker_ =
+      ::CORBA__TAO_Contained_Proxy_Broker_Factory_function_pointer (this);
+  else
+    this->the_TAO_Contained_Proxy_Broker_ =
+      ::_TAO_Contained_Remote_Proxy_Broker::the_TAO_Contained_Remote_Proxy_Broker ();
+  
+  this->CORBA_IRObject_setup_collocation (collocated);
+}
+
+void CORBA::Contained::_tao_any_destructor (void *x)
+{
+  CORBA_Contained *tmp = ACE_static_cast (CORBA_Contained*,x);
+  CORBA::release (tmp);
+}
+
+CORBA::Contained_ptr CORBA::Contained::_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+{
+  if (CORBA::is_nil (obj))
+    return CORBA::Contained::_nil ();
+  if (! obj->_is_local ())
+    {
+      CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/CORBA/Contained:1.0", ACE_TRY_ENV);
+      ACE_CHECK_RETURN (CORBA::Contained::_nil ());
+      if (is_a == 0)
+        return CORBA::Contained::_nil ();
+    }
+  return CORBA::Contained::_unchecked_narrow (obj, ACE_TRY_ENV);
+}
+
+CORBA::Contained_ptr CORBA::Contained::_unchecked_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &
+  )
+{
+  if (CORBA::is_nil (obj))
+    return CORBA::Contained::_nil ();
+  if (! obj->_is_local ())
+    {
+      TAO_Stub* stub = obj->_stubobj ();
+      if (stub)
+        stub->_incr_refcnt ();
+      CORBA::Contained_ptr default_proxy = CORBA::Contained::_nil ();
+
+      if (
+          !CORBA::is_nil (stub->servant_orb_var ().ptr ()) &&
+          stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects () &&
+          obj->_is_collocated () &&CORBA__TAO_Contained_Proxy_Broker_Factory_function_pointer != 0
+        )
+      {
+        ACE_NEW_RETURN (
+          default_proxy,
+          ::CORBA::Contained (
+            stub,
+            1,
+            obj->_servant ()),
+            
+          CORBA::Contained::_nil ());
+        }
+      if (CORBA::is_nil (default_proxy))
+        ACE_NEW_RETURN (default_proxy, ::CORBA::Contained (stub, 0, obj->_servant ()), CORBA::Contained::_nil ());
+        return default_proxy;
+      }
+    else 
+      return
+        ACE_reinterpret_cast
+          (
+            CORBA_Contained_ptr,
+              obj->_tao_QueryInterface
+                (
+                  ACE_reinterpret_cast
+                    (
+                      ptr_arith_t,
+                      &CORBA_Contained::_narrow
+                    )
+                )
+          );
+}
+
+CORBA::Contained_ptr
+CORBA::Contained::_duplicate (CORBA::Contained_ptr obj)
+{
+  if (!CORBA::is_nil (obj))
+    obj->_add_ref ();
+  return obj;
+}
+
+CORBA::Boolean CORBA::Contained::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
+{
+  if (
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Contained:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
+  return 1; // success using local knowledge
+  else
+    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
+}
+
+void *CORBA::Contained::_tao_QueryInterface (ptr_arith_t type)
+{
+  void *retv = 0;
+  if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      CORBA_Contained::_narrow))
+    retv = ACE_reinterpret_cast (void*, this);
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      CORBA_IRObject::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::IRObject_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
+    retv = ACE_reinterpret_cast (void *,
+      ACE_static_cast (CORBA::Object_ptr, this));
+    
+  if (retv)
+    this->_add_ref ();
+  return retv;
+}
+
+const char* CORBA::Contained::_interface_repository_id (void) const
+{
+  return "IDL:omg.org/CORBA/Contained:1.0";
+}
+
+char * CORBA::Contained::id (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_Contained_Proxy_Impl &proxy = 
+    this->the_TAO_Contained_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.id (
+      this,
+      ACE_TRY_ENV
+    );
+}
+
+void CORBA::Contained::id (
+    const char * id,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_Contained_Proxy_Impl &proxy = 
+    this->the_TAO_Contained_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK;
+  
+  proxy.id (
+      this,
+      id,
+      ACE_TRY_ENV
+    );
+}
+
+char * CORBA::Contained::name (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_Contained_Proxy_Impl &proxy = 
+    this->the_TAO_Contained_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.name (
+      this,
+      ACE_TRY_ENV
+    );
+}
+
+void CORBA::Contained::name (
+    const char * name,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_Contained_Proxy_Impl &proxy = 
+    this->the_TAO_Contained_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK;
+  
+  proxy.name (
+      this,
+      name,
+      ACE_TRY_ENV
+    );
+}
+
+char * CORBA::Contained::version (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_Contained_Proxy_Impl &proxy = 
+    this->the_TAO_Contained_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.version (
+      this,
+      ACE_TRY_ENV
+    );
+}
+
+void CORBA::Contained::version (
+    const char * version,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_Contained_Proxy_Impl &proxy = 
+    this->the_TAO_Contained_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK;
+  
+  proxy.version (
+      this,
+      version,
+      ACE_TRY_ENV
+    );
+}
+
+CORBA::Container_ptr CORBA::Contained::defined_in (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_Contained_Proxy_Impl &proxy = 
+    this->the_TAO_Contained_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.defined_in (
+      this,
+      ACE_TRY_ENV
+    );
+}
+
+char * CORBA::Contained::absolute_name (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_Contained_Proxy_Impl &proxy = 
+    this->the_TAO_Contained_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.absolute_name (
+      this,
+      ACE_TRY_ENV
+    );
+}
+
+CORBA::Repository_ptr CORBA::Contained::containing_repository (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_Contained_Proxy_Impl &proxy = 
+    this->the_TAO_Contained_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.containing_repository (
+      this,
+      ACE_TRY_ENV
+    );
+}
+
+static const CORBA::Long _oc_CORBA_Contained_Description[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  44,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x434f5242), 
+  ACE_NTOHL (0x412f436f), 
+  ACE_NTOHL (0x6e746169), 
+  ACE_NTOHL (0x6e65642f), 
+  ACE_NTOHL (0x44657363), 
+  ACE_NTOHL (0x72697074), 
+  ACE_NTOHL (0x696f6e3a), 
+  ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/Contained/Description:1.0
+  12,
+  ACE_NTOHL (0x44657363), 
+  ACE_NTOHL (0x72697074), 
+  ACE_NTOHL (0x696f6e00),  // name = Description
+  2, // member count
+  5,
+  ACE_NTOHL (0x6b696e64), 
+  ACE_NTOHL (0x0),  // name = kind
+  CORBA::tk_enum, // typecode kind
+  524, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    37,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x434f5242), 
+    ACE_NTOHL (0x412f4465), 
+    ACE_NTOHL (0x66696e69), 
+    ACE_NTOHL (0x74696f6e), 
+    ACE_NTOHL (0x4b696e64), 
+    ACE_NTOHL (0x3a312e30), 
+    ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/DefinitionKind:1.0
+    15,
+    ACE_NTOHL (0x44656669), 
+    ACE_NTOHL (0x6e697469), 
+    ACE_NTOHL (0x6f6e4b69), 
+    ACE_NTOHL (0x6e640000),  // name = DefinitionKind
+    26, // member count
+    8,
+    ACE_NTOHL (0x646b5f6e), 
+    ACE_NTOHL (0x6f6e6500),  // name = dk_none
+    7,
+    ACE_NTOHL (0x646b5f61), 
+    ACE_NTOHL (0x6c6c0000),  // name = dk_all
+    13,
+    ACE_NTOHL (0x646b5f41), 
+    ACE_NTOHL (0x74747269), 
+    ACE_NTOHL (0x62757465), 
+    ACE_NTOHL (0x0),  // name = dk_Attribute
+    12,
+    ACE_NTOHL (0x646b5f43), 
+    ACE_NTOHL (0x6f6e7374), 
+    ACE_NTOHL (0x616e7400),  // name = dk_Constant
+    13,
+    ACE_NTOHL (0x646b5f45), 
+    ACE_NTOHL (0x78636570), 
+    ACE_NTOHL (0x74696f6e), 
+    ACE_NTOHL (0x0),  // name = dk_Exception
+    13,
+    ACE_NTOHL (0x646b5f49), 
+    ACE_NTOHL (0x6e746572), 
+    ACE_NTOHL (0x66616365), 
+    ACE_NTOHL (0x0),  // name = dk_Interface
+    10,
+    ACE_NTOHL (0x646b5f4d), 
+    ACE_NTOHL (0x6f64756c), 
+    ACE_NTOHL (0x65000000),  // name = dk_Module
+    13,
+    ACE_NTOHL (0x646b5f4f), 
+    ACE_NTOHL (0x70657261), 
+    ACE_NTOHL (0x74696f6e), 
+    ACE_NTOHL (0x0),  // name = dk_Operation
+    11,
+    ACE_NTOHL (0x646b5f54), 
+    ACE_NTOHL (0x79706564), 
+    ACE_NTOHL (0x65660000),  // name = dk_Typedef
+    9,
+    ACE_NTOHL (0x646b5f41), 
+    ACE_NTOHL (0x6c696173), 
+    ACE_NTOHL (0x0),  // name = dk_Alias
+    10,
+    ACE_NTOHL (0x646b5f53), 
+    ACE_NTOHL (0x74727563), 
+    ACE_NTOHL (0x74000000),  // name = dk_Struct
+    9,
+    ACE_NTOHL (0x646b5f55), 
+    ACE_NTOHL (0x6e696f6e), 
+    ACE_NTOHL (0x0),  // name = dk_Union
+    8,
+    ACE_NTOHL (0x646b5f45), 
+    ACE_NTOHL (0x6e756d00),  // name = dk_Enum
+    13,
+    ACE_NTOHL (0x646b5f50), 
+    ACE_NTOHL (0x72696d69), 
+    ACE_NTOHL (0x74697665), 
+    ACE_NTOHL (0x0),  // name = dk_Primitive
+    10,
+    ACE_NTOHL (0x646b5f53), 
+    ACE_NTOHL (0x7472696e), 
+    ACE_NTOHL (0x67000000),  // name = dk_String
+    12,
+    ACE_NTOHL (0x646b5f53), 
+    ACE_NTOHL (0x65717565), 
+    ACE_NTOHL (0x6e636500),  // name = dk_Sequence
+    9,
+    ACE_NTOHL (0x646b5f41), 
+    ACE_NTOHL (0x72726179), 
+    ACE_NTOHL (0x0),  // name = dk_Array
+    14,
+    ACE_NTOHL (0x646b5f52), 
+    ACE_NTOHL (0x65706f73), 
+    ACE_NTOHL (0x69746f72), 
+    ACE_NTOHL (0x79000000),  // name = dk_Repository
+    11,
+    ACE_NTOHL (0x646b5f57), 
+    ACE_NTOHL (0x73747269), 
+    ACE_NTOHL (0x6e670000),  // name = dk_Wstring
+    9,
+    ACE_NTOHL (0x646b5f46), 
+    ACE_NTOHL (0x69786564), 
+    ACE_NTOHL (0x0),  // name = dk_Fixed
+    9,
+    ACE_NTOHL (0x646b5f56), 
+    ACE_NTOHL (0x616c7565), 
+    ACE_NTOHL (0x0),  // name = dk_Value
+    12,
+    ACE_NTOHL (0x646b5f56), 
+    ACE_NTOHL (0x616c7565), 
+    ACE_NTOHL (0x426f7800),  // name = dk_ValueBox
+    15,
+    ACE_NTOHL (0x646b5f56), 
+    ACE_NTOHL (0x616c7565), 
+    ACE_NTOHL (0x4d656d62), 
+    ACE_NTOHL (0x65720000),  // name = dk_ValueMember
+    10,
+    ACE_NTOHL (0x646b5f4e), 
+    ACE_NTOHL (0x61746976), 
+    ACE_NTOHL (0x65000000),  // name = dk_Native
+    21,
+    ACE_NTOHL (0x646b5f41), 
+    ACE_NTOHL (0x62737472), 
+    ACE_NTOHL (0x61637449), 
+    ACE_NTOHL (0x6e746572), 
+    ACE_NTOHL (0x66616365), 
+    ACE_NTOHL (0x0),  // name = dk_AbstractInterface
+    18,
+    ACE_NTOHL (0x646b5f4c), 
+    ACE_NTOHL (0x6f63616c), 
+    ACE_NTOHL (0x496e7465), 
+    ACE_NTOHL (0x72666163), 
+    ACE_NTOHL (0x65000000),  // name = dk_LocalInterface
+
+  6,
+  ACE_NTOHL (0x76616c75), 
+  ACE_NTOHL (0x65000000),  // name = value
+  CORBA::tk_any,
+
+};
+
+static CORBA::TypeCode _tc_TAO_tc_CORBA_Contained_Description (
+    CORBA::tk_struct,
+    sizeof (_oc_CORBA_Contained_Description),
+    (char *) &_oc_CORBA_Contained_Description,
+    0,
+    sizeof (CORBA::Contained::Description)
+  );
+
+CORBA::TypeCode_ptr CORBA::Contained::_tc_Description =
+  &_tc_TAO_tc_CORBA_Contained_Description;
+
+void CORBA::Contained::Description::_tao_any_destructor (void *x)
+{
+  Description *tmp = ACE_static_cast (Description*,x);
+  delete tmp;
+}
+
+CORBA::Contained::Description * CORBA::Contained::describe (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_Contained_Proxy_Impl &proxy = 
+    this->the_TAO_Contained_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.describe (
+      this,
+      ACE_TRY_ENV
+    );
+}
+
+void CORBA::Contained::move (
+    CORBA::Container_ptr new_container,
+    const char * new_name,
+    const char * new_version,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_Contained_Proxy_Impl &proxy = 
+    this->the_TAO_Contained_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK;
+  
+  proxy.move (
+      this,
+      new_container,
+      new_name,
+      new_version,
+      ACE_TRY_ENV
+    );
+}
+
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+CORBA::Contained::TAO_ClientRequestInfo_CORBA_Contained_id_get::TAO_ClientRequestInfo_CORBA_Contained_id_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
+{}
+
+Dynamic::ParameterList *
+CORBA::Contained::TAO_ClientRequestInfo_CORBA_Contained_id_get::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return parameter_list;
+}
+
+Dynamic::ExceptionList *
+CORBA::Contained::TAO_ClientRequestInfo_CORBA_Contained_id_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::Contained::TAO_ClientRequestInfo_CORBA_Contained_id_get::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+CORBA::Contained::TAO_ClientRequestInfo_CORBA_Contained_id_get::result (char * result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+CORBA::Contained::TAO_ClientRequestInfo_CORBA_Contained_id_set::TAO_ClientRequestInfo_CORBA_Contained_id_set (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const char * id,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
+    id_ (id)
+{}
+
+Dynamic::ParameterList *
+CORBA::Contained::TAO_ClientRequestInfo_CORBA_Contained_id_set::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
+    
+  CORBA::ULong length_id = parameter_list->length ();
+  parameter_list->length (length_id + 1);
+  (*parameter_list)[length_id].argument <<= id_;
+  (*parameter_list)[length_id].mode = Dynamic::PARAM_IN;
+  
+  return safe_parameter_list._retn ();
+}
+
+Dynamic::ExceptionList *
+CORBA::Contained::TAO_ClientRequestInfo_CORBA_Contained_id_set::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::Contained::TAO_ClientRequestInfo_CORBA_Contained_id_set::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 1;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return result_any;
+}
+
+CORBA::Contained::TAO_ClientRequestInfo_CORBA_Contained_name_get::TAO_ClientRequestInfo_CORBA_Contained_name_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
+{}
+
+Dynamic::ParameterList *
+CORBA::Contained::TAO_ClientRequestInfo_CORBA_Contained_name_get::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return parameter_list;
+}
+
+Dynamic::ExceptionList *
+CORBA::Contained::TAO_ClientRequestInfo_CORBA_Contained_name_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::Contained::TAO_ClientRequestInfo_CORBA_Contained_name_get::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+CORBA::Contained::TAO_ClientRequestInfo_CORBA_Contained_name_get::result (char * result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+CORBA::Contained::TAO_ClientRequestInfo_CORBA_Contained_name_set::TAO_ClientRequestInfo_CORBA_Contained_name_set (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const char * name,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
+    name_ (name)
+{}
+
+Dynamic::ParameterList *
+CORBA::Contained::TAO_ClientRequestInfo_CORBA_Contained_name_set::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
+    
+  CORBA::ULong length_name = parameter_list->length ();
+  parameter_list->length (length_name + 1);
+  (*parameter_list)[length_name].argument <<= name_;
+  (*parameter_list)[length_name].mode = Dynamic::PARAM_IN;
+  
+  return safe_parameter_list._retn ();
+}
+
+Dynamic::ExceptionList *
+CORBA::Contained::TAO_ClientRequestInfo_CORBA_Contained_name_set::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::Contained::TAO_ClientRequestInfo_CORBA_Contained_name_set::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 1;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return result_any;
+}
+
+CORBA::Contained::TAO_ClientRequestInfo_CORBA_Contained_version_get::TAO_ClientRequestInfo_CORBA_Contained_version_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
+{}
+
+Dynamic::ParameterList *
+CORBA::Contained::TAO_ClientRequestInfo_CORBA_Contained_version_get::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return parameter_list;
+}
+
+Dynamic::ExceptionList *
+CORBA::Contained::TAO_ClientRequestInfo_CORBA_Contained_version_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::Contained::TAO_ClientRequestInfo_CORBA_Contained_version_get::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+CORBA::Contained::TAO_ClientRequestInfo_CORBA_Contained_version_get::result (char * result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+CORBA::Contained::TAO_ClientRequestInfo_CORBA_Contained_version_set::TAO_ClientRequestInfo_CORBA_Contained_version_set (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const char * version,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
+    version_ (version)
+{}
+
+Dynamic::ParameterList *
+CORBA::Contained::TAO_ClientRequestInfo_CORBA_Contained_version_set::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
+    
+  CORBA::ULong length_version = parameter_list->length ();
+  parameter_list->length (length_version + 1);
+  (*parameter_list)[length_version].argument <<= version_;
+  (*parameter_list)[length_version].mode = Dynamic::PARAM_IN;
+  
+  return safe_parameter_list._retn ();
+}
+
+Dynamic::ExceptionList *
+CORBA::Contained::TAO_ClientRequestInfo_CORBA_Contained_version_set::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::Contained::TAO_ClientRequestInfo_CORBA_Contained_version_set::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 1;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return result_any;
+}
+
+CORBA::Contained::TAO_ClientRequestInfo_CORBA_Contained_defined_in_get::TAO_ClientRequestInfo_CORBA_Contained_defined_in_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
+{}
+
+Dynamic::ParameterList *
+CORBA::Contained::TAO_ClientRequestInfo_CORBA_Contained_defined_in_get::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return parameter_list;
+}
+
+Dynamic::ExceptionList *
+CORBA::Contained::TAO_ClientRequestInfo_CORBA_Contained_defined_in_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::Contained::TAO_ClientRequestInfo_CORBA_Contained_defined_in_get::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+CORBA::Contained::TAO_ClientRequestInfo_CORBA_Contained_defined_in_get::result (CORBA::Container_ptr result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+CORBA::Contained::TAO_ClientRequestInfo_CORBA_Contained_absolute_name_get::TAO_ClientRequestInfo_CORBA_Contained_absolute_name_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
+{}
+
+Dynamic::ParameterList *
+CORBA::Contained::TAO_ClientRequestInfo_CORBA_Contained_absolute_name_get::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return parameter_list;
+}
+
+Dynamic::ExceptionList *
+CORBA::Contained::TAO_ClientRequestInfo_CORBA_Contained_absolute_name_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::Contained::TAO_ClientRequestInfo_CORBA_Contained_absolute_name_get::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+CORBA::Contained::TAO_ClientRequestInfo_CORBA_Contained_absolute_name_get::result (char * result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+CORBA::Contained::TAO_ClientRequestInfo_CORBA_Contained_containing_repository_get::TAO_ClientRequestInfo_CORBA_Contained_containing_repository_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
+{}
+
+Dynamic::ParameterList *
+CORBA::Contained::TAO_ClientRequestInfo_CORBA_Contained_containing_repository_get::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return parameter_list;
+}
+
+Dynamic::ExceptionList *
+CORBA::Contained::TAO_ClientRequestInfo_CORBA_Contained_containing_repository_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+void 
+CORBA::Contained::TAO_ClientRequestInfo_CORBA_Contained_containing_repository_get::result (CORBA::Repository_ptr result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+CORBA::Contained::TAO_ClientRequestInfo_CORBA_Contained_describe::TAO_ClientRequestInfo_CORBA_Contained_describe (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
+{}
+
+Dynamic::ParameterList *
+CORBA::Contained::TAO_ClientRequestInfo_CORBA_Contained_describe::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return parameter_list;
+}
+
+Dynamic::ExceptionList *
+CORBA::Contained::TAO_ClientRequestInfo_CORBA_Contained_describe::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::Contained::TAO_ClientRequestInfo_CORBA_Contained_describe::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+CORBA::Contained::TAO_ClientRequestInfo_CORBA_Contained_describe::result (ACE_NESTED_CLASS (CORBA::Contained,Description) * result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+CORBA::Contained::TAO_ClientRequestInfo_CORBA_Contained_move::TAO_ClientRequestInfo_CORBA_Contained_move (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::Container_ptr new_container,
+    const char * new_name,
+    const char * new_version,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
+    new_container_ (new_container),
+    new_name_ (new_name),
+    new_version_ (new_version)
+{}
+
+Dynamic::ParameterList *
+CORBA::Contained::TAO_ClientRequestInfo_CORBA_Contained_move::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
+    
+  CORBA::ULong length_new_container = parameter_list->length ();
+  parameter_list->length (length_new_container + 1);
+  (*parameter_list)[length_new_container].argument <<=  this->new_container_;
+  
+  (*parameter_list)[length_new_container].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_new_name = parameter_list->length ();
+  parameter_list->length (length_new_name + 1);
+  (*parameter_list)[length_new_name].argument <<= new_name_;
+  (*parameter_list)[length_new_name].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_new_version = parameter_list->length ();
+  parameter_list->length (length_new_version + 1);
+  (*parameter_list)[length_new_version].argument <<= new_version_;
+  (*parameter_list)[length_new_version].mode = Dynamic::PARAM_IN;
+  
+  return safe_parameter_list._retn ();
+}
+
+Dynamic::ExceptionList *
+CORBA::Contained::TAO_ClientRequestInfo_CORBA_Contained_move::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::Contained::TAO_ClientRequestInfo_CORBA_Contained_move::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 1;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return result_any;
+}
+
+#endif /* TAO_HAS_INTERCEPTORS */
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_CONTAINEDSEQ_CS_)
+#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_CONTAINEDSEQ_CS_
+
+  // The Base_Sequence functions, please see tao/Sequence.h
+  void
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::_allocate_buffer (CORBA::ULong length)
+  {
+    Contained **tmp = 0;
+    tmp = _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::allocbuf (length);
+    
+    if (this->buffer_ != 0)
+    {
+      Contained **old = ACE_reinterpret_cast (Contained**, this->buffer_);
+      for (CORBA::ULong i = 0; i < this->length_; ++i)
+        if (!this->release_)
+          tmp[i] = Contained::_duplicate (old[i]);
+        else
+          tmp[i] = old[i];
+        
+      if (this->release_)
+        delete[] old;
+      
+    }
+    this->buffer_ = tmp;
+  }
+  
+  void
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::_deallocate_buffer (void)
+  {
+    if (this->buffer_ == 0 || this->release_ == 0)
+      return;
+    Contained **tmp = ACE_reinterpret_cast (Contained**, this->buffer_);
+    for (CORBA::ULong i = 0; i < this->length_; ++i)
+    {
+      CORBA::release (tmp[i]);
+      tmp[i] = Contained::_nil ();
+    }
+    _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::freebuf (tmp);
+    this->buffer_ = 0;
+  }
+  
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::~_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq (void)
+  {
+    this->_deallocate_buffer ();
+  }
+  
+  void
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::_shrink_buffer (CORBA::ULong nl, CORBA::ULong ol)
+  {
+    Contained **tmp = ACE_reinterpret_cast (Contained**, this->buffer_);
+    
+    for (CORBA::ULong i = nl; i < ol; ++i)
+    {
+      CORBA::release (tmp[i]);
+      tmp[i] = Contained::_nil ();
+    }
+  }
+  void 
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::_downcast (
+      void* target,
+      CORBA_Object *src,
+      CORBA_Environment &ACE_TRY_ENV
+    )
+  {
+    Contained **tmp = ACE_static_cast (Contained**, target);
+    *tmp = Contained::_narrow (src, ACE_TRY_ENV);
+    ACE_CHECK;
+  }
+
+  CORBA_Object*
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::_upcast (void *src) const
+  {
+    Contained **tmp = ACE_static_cast (Contained**, src);
+    return *tmp;
+  }
+  
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_CORBA_CONTAINEDSEQ_CS_)
+#define _CORBA_CONTAINEDSEQ_CS_
+
+// *************************************************************
+// CORBA_ContainedSeq
+// *************************************************************
+
+CORBA_ContainedSeq::CORBA_ContainedSeq (void)
+{}
+CORBA_ContainedSeq::CORBA_ContainedSeq (CORBA::ULong max) // uses max size
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<CORBA::Contained,CORBA::Contained_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (max)
+{}
+CORBA_ContainedSeq::CORBA_ContainedSeq (CORBA::ULong max, CORBA::ULong length, CORBA::Contained_ptr *buffer, CORBA::Boolean release)
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<CORBA::Contained,CORBA::Contained_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (max, length, buffer, release)
+{}
+CORBA_ContainedSeq::CORBA_ContainedSeq (const CORBA_ContainedSeq &seq) // copy ctor
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<CORBA::Contained,CORBA::Contained_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (seq)
+{}
+CORBA_ContainedSeq::~CORBA_ContainedSeq (void) // dtor
+{}
+void CORBA_ContainedSeq::_tao_any_destructor (void *x)
+{
+  CORBA_ContainedSeq *tmp = ACE_static_cast (CORBA_ContainedSeq*,x);
+  delete tmp;
+}
+
+
+#endif /* end #if !defined */
+
+void CORBA::StructMember::_tao_any_destructor (void *x)
+{
+  CORBA_StructMember *tmp = ACE_static_cast (CORBA_StructMember*,x);
+  delete tmp;
+}
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_SEQUENCE_CORBA_STRUCTMEMBERSEQ_CS_)
+#define __TAO_UNBOUNDED_SEQUENCE_CORBA_STRUCTMEMBERSEQ_CS_
+
+  void
+  CORBA::_TAO_Unbounded_Sequence_CORBA_StructMemberSeq::_allocate_buffer (CORBA::ULong length)
+  {
+    StructMember* tmp = 0;
+    tmp = _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::allocbuf (length);
+    
+    if (this->buffer_ != 0)
+    {
+      StructMember *old = ACE_reinterpret_cast (StructMember *,this->buffer_);
+      
+      for (CORBA::ULong i = 0; i < this->length_; ++i)
+        tmp[i] = old[i];
+      
+      if (this->release_)
+        _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::freebuf (old);
+      
+    }
+    this->buffer_ = tmp;
+  }
+  
+  void
+  CORBA::_TAO_Unbounded_Sequence_CORBA_StructMemberSeq::_deallocate_buffer (void)
+  {
+    if (this->buffer_ == 0 || this->release_ == 0)
+      return;
+    
+    StructMember *tmp = ACE_reinterpret_cast (StructMember *,this->buffer_);
+    
+    _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::freebuf (tmp);
+    this->buffer_ = 0;
+  } 
+  
+  CORBA::_TAO_Unbounded_Sequence_CORBA_StructMemberSeq::~_TAO_Unbounded_Sequence_CORBA_StructMemberSeq (void) // Dtor.
+  {
+    this->_deallocate_buffer ();
+  }
+  
+  
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_CORBA_STRUCTMEMBERSEQ_CS_)
+#define _CORBA_STRUCTMEMBERSEQ_CS_
+
+// *************************************************************
+// CORBA_StructMemberSeq
+// *************************************************************
+
+CORBA_StructMemberSeq::CORBA_StructMemberSeq (void)
+{}
+CORBA_StructMemberSeq::CORBA_StructMemberSeq (CORBA::ULong max) // uses max size
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Sequence_CORBA_StructMemberSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<CORBA::StructMember>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (max)
+{}
+CORBA_StructMemberSeq::CORBA_StructMemberSeq (CORBA::ULong max, CORBA::ULong length, CORBA::StructMember *buffer, CORBA::Boolean release)
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Sequence_CORBA_StructMemberSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<CORBA::StructMember>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (max, length, buffer, release)
+{}
+CORBA_StructMemberSeq::CORBA_StructMemberSeq (const CORBA_StructMemberSeq &seq) // copy ctor
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Sequence_CORBA_StructMemberSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<CORBA::StructMember>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (seq)
+{}
+CORBA_StructMemberSeq::~CORBA_StructMemberSeq (void) // dtor
+{}
+void CORBA_StructMemberSeq::_tao_any_destructor (void *x)
+{
+  CORBA_StructMemberSeq *tmp = ACE_static_cast (CORBA_StructMemberSeq*,x);
+  delete tmp;
+}
+
+
+#endif /* end #if !defined */
+
+void CORBA::Initializer::_tao_any_destructor (void *x)
+{
+  CORBA_Initializer *tmp = ACE_static_cast (CORBA_Initializer*,x);
+  delete tmp;
+}
+
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_SEQUENCE_CORBA_INITIALIZERSEQ_CS_)
+#define __TAO_UNBOUNDED_SEQUENCE_CORBA_INITIALIZERSEQ_CS_
+
+  void
+  CORBA::_TAO_Unbounded_Sequence_CORBA_InitializerSeq::_allocate_buffer (CORBA::ULong length)
+  {
+    Initializer* tmp = 0;
+    tmp = _TAO_Unbounded_Sequence_CORBA_InitializerSeq::allocbuf (length);
+    
+    if (this->buffer_ != 0)
+    {
+      Initializer *old = ACE_reinterpret_cast (Initializer *,this->buffer_);
+      
+      for (CORBA::ULong i = 0; i < this->length_; ++i)
+        tmp[i] = old[i];
+      
+      if (this->release_)
+        _TAO_Unbounded_Sequence_CORBA_InitializerSeq::freebuf (old);
+      
+    }
+    this->buffer_ = tmp;
+  }
+  
+  void
+  CORBA::_TAO_Unbounded_Sequence_CORBA_InitializerSeq::_deallocate_buffer (void)
+  {
+    if (this->buffer_ == 0 || this->release_ == 0)
+      return;
+    
+    Initializer *tmp = ACE_reinterpret_cast (Initializer *,this->buffer_);
+    
+    _TAO_Unbounded_Sequence_CORBA_InitializerSeq::freebuf (tmp);
+    this->buffer_ = 0;
+  } 
+  
+  CORBA::_TAO_Unbounded_Sequence_CORBA_InitializerSeq::~_TAO_Unbounded_Sequence_CORBA_InitializerSeq (void) // Dtor.
+  {
+    this->_deallocate_buffer ();
+  }
+  
+  
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_CORBA_INITIALIZERSEQ_CS_)
+#define _CORBA_INITIALIZERSEQ_CS_
+
+// *************************************************************
+// CORBA_InitializerSeq
+// *************************************************************
+
+CORBA_InitializerSeq::CORBA_InitializerSeq (void)
+{}
+CORBA_InitializerSeq::CORBA_InitializerSeq (CORBA::ULong max) // uses max size
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Sequence_CORBA_InitializerSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<CORBA::Initializer>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (max)
+{}
+CORBA_InitializerSeq::CORBA_InitializerSeq (CORBA::ULong max, CORBA::ULong length, CORBA::Initializer *buffer, CORBA::Boolean release)
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Sequence_CORBA_InitializerSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<CORBA::Initializer>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (max, length, buffer, release)
+{}
+CORBA_InitializerSeq::CORBA_InitializerSeq (const CORBA_InitializerSeq &seq) // copy ctor
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Sequence_CORBA_InitializerSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<CORBA::Initializer>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (seq)
+{}
+CORBA_InitializerSeq::~CORBA_InitializerSeq (void) // dtor
+{}
+void CORBA_InitializerSeq::_tao_any_destructor (void *x)
+{
+  CORBA_InitializerSeq *tmp = ACE_static_cast (CORBA_InitializerSeq*,x);
+  delete tmp;
+}
+
+
+#endif /* end #if !defined */
+
+void CORBA::UnionMember::_tao_any_destructor (void *x)
+{
+  CORBA_UnionMember *tmp = ACE_static_cast (CORBA_UnionMember*,x);
+  delete tmp;
+}
+
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_SEQUENCE_CORBA_UNIONMEMBERSEQ_CS_)
+#define __TAO_UNBOUNDED_SEQUENCE_CORBA_UNIONMEMBERSEQ_CS_
+
+  void
+  CORBA::_TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::_allocate_buffer (CORBA::ULong length)
+  {
+    UnionMember* tmp = 0;
+    tmp = _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::allocbuf (length);
+    
+    if (this->buffer_ != 0)
+    {
+      UnionMember *old = ACE_reinterpret_cast (UnionMember *,this->buffer_);
+      
+      for (CORBA::ULong i = 0; i < this->length_; ++i)
+        tmp[i] = old[i];
+      
+      if (this->release_)
+        _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::freebuf (old);
+      
+    }
+    this->buffer_ = tmp;
+  }
+  
+  void
+  CORBA::_TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::_deallocate_buffer (void)
+  {
+    if (this->buffer_ == 0 || this->release_ == 0)
+      return;
+    
+    UnionMember *tmp = ACE_reinterpret_cast (UnionMember *,this->buffer_);
+    
+    _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::freebuf (tmp);
+    this->buffer_ = 0;
+  } 
+  
+  CORBA::_TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::~_TAO_Unbounded_Sequence_CORBA_UnionMemberSeq (void) // Dtor.
+  {
+    this->_deallocate_buffer ();
+  }
+  
+  
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_CORBA_UNIONMEMBERSEQ_CS_)
+#define _CORBA_UNIONMEMBERSEQ_CS_
+
+// *************************************************************
+// CORBA_UnionMemberSeq
+// *************************************************************
+
+CORBA_UnionMemberSeq::CORBA_UnionMemberSeq (void)
+{}
+CORBA_UnionMemberSeq::CORBA_UnionMemberSeq (CORBA::ULong max) // uses max size
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<CORBA::UnionMember>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (max)
+{}
+CORBA_UnionMemberSeq::CORBA_UnionMemberSeq (CORBA::ULong max, CORBA::ULong length, CORBA::UnionMember *buffer, CORBA::Boolean release)
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<CORBA::UnionMember>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (max, length, buffer, release)
+{}
+CORBA_UnionMemberSeq::CORBA_UnionMemberSeq (const CORBA_UnionMemberSeq &seq) // copy ctor
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<CORBA::UnionMember>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (seq)
+{}
+CORBA_UnionMemberSeq::~CORBA_UnionMemberSeq (void) // dtor
+{}
+void CORBA_UnionMemberSeq::_tao_any_destructor (void *x)
+{
+  CORBA_UnionMemberSeq *tmp = ACE_static_cast (CORBA_UnionMemberSeq*,x);
+  delete tmp;
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_ENUMMEMBERSEQ_CS_)
+#define _CORBA_ENUMMEMBERSEQ_CS_
+
+// *************************************************************
+// CORBA_EnumMemberSeq
+// *************************************************************
+
+CORBA_EnumMemberSeq::CORBA_EnumMemberSeq (void)
+{}
+CORBA_EnumMemberSeq::CORBA_EnumMemberSeq (CORBA::ULong max) // uses max size
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  TAO_Unbounded_String_Sequence
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_String_Sequence
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (max)
+{}
+CORBA_EnumMemberSeq::CORBA_EnumMemberSeq (CORBA::ULong max, CORBA::ULong length, char * *buffer, CORBA::Boolean release)
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  TAO_Unbounded_String_Sequence
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_String_Sequence
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (max, length, buffer, release)
+{}
+CORBA_EnumMemberSeq::CORBA_EnumMemberSeq (const CORBA_EnumMemberSeq &seq) // copy ctor
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  TAO_Unbounded_String_Sequence
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_String_Sequence
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (seq)
+{}
+CORBA_EnumMemberSeq::~CORBA_EnumMemberSeq (void) // dtor
+{}
+void CORBA_EnumMemberSeq::_tao_any_destructor (void *x)
+{
+  CORBA_EnumMemberSeq *tmp = ACE_static_cast (CORBA_EnumMemberSeq*,x);
+  delete tmp;
+}
+
+
+#endif /* end #if !defined */
+
+///////////////////////////////////////////////////////////////////////
+//                Base & Remote Proxy  Implementation. 
+//
+
+_TAO_Container_Proxy_Impl::_TAO_Container_Proxy_Impl (void)
+{}
+
+_TAO_Container_Remote_Proxy_Impl::_TAO_Container_Remote_Proxy_Impl (void)
+{}
+
+// Remote Implementation of the IDL interface methods
+
+CORBA::Contained_ptr _TAO_Container_Remote_Proxy_Impl::lookup (
+    CORBA_Object *_collocated_tao_target_,
+    const char * search_name,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::Contained_ptr _tao_retval = CORBA::Contained::_nil ();
+  CORBA::Contained_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "lookup",
+      6,
+      1,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_lookup ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        search_name,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+          if (!(
+                            (_tao_out << search_name)
+            ))
+            TAO_INTERCEPTOR_THROW_RETURN (
+              CORBA::MARSHAL (),
+              0
+            );
+            
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::Contained_ptr _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+CORBA::ContainedSeq * _TAO_Container_Remote_Proxy_Impl::contents (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::DefinitionKind limit_type,
+    CORBA::Boolean exclude_inherited,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::ContainedSeq *_tao_retval = 0;
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  ACE_NEW_RETURN (_tao_retval, CORBA::ContainedSeq, _tao_retval);
+  CORBA::ContainedSeq_var _tao_safe_retval (_tao_retval);
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "contents",
+      8,
+      1,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_contents ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        limit_type,
+        exclude_inherited,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+          if (!(
+                            (_tao_out << limit_type) &&
+              (_tao_out << CORBA::Any::from_boolean (exclude_inherited))
+            ))
+            TAO_INTERCEPTOR_THROW_RETURN (
+              CORBA::MARSHAL (),
+              0
+            );
+            
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::ContainedSeq * _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+CORBA::ContainedSeq * _TAO_Container_Remote_Proxy_Impl::lookup_name (
+    CORBA_Object *_collocated_tao_target_,
+    const char * search_name,
+    CORBA::Long levels_to_search,
+    CORBA::DefinitionKind limit_type,
+    CORBA::Boolean exclude_inherited,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::ContainedSeq *_tao_retval = 0;
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  ACE_NEW_RETURN (_tao_retval, CORBA::ContainedSeq, _tao_retval);
+  CORBA::ContainedSeq_var _tao_safe_retval (_tao_retval);
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "lookup_name",
+      11,
+      1,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_lookup_name ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        search_name,
+        levels_to_search,
+        limit_type,
+        exclude_inherited,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+          if (!(
+                            (_tao_out << search_name) &&
+              (_tao_out << levels_to_search) &&
+              (_tao_out << limit_type) &&
+              (_tao_out << CORBA::Any::from_boolean (exclude_inherited))
+            ))
+            TAO_INTERCEPTOR_THROW_RETURN (
+              CORBA::MARSHAL (),
+              0
+            );
+            
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::ContainedSeq * _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+CORBA::Container::DescriptionSeq * _TAO_Container_Remote_Proxy_Impl::describe_contents (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::DefinitionKind limit_type,
+    CORBA::Boolean exclude_inherited,
+    CORBA::Long max_returned_objs,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::Container::DescriptionSeq *_tao_retval = 0;
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  ACE_NEW_RETURN (_tao_retval, CORBA::Container::DescriptionSeq, _tao_retval);
+  CORBA::Container::DescriptionSeq_var _tao_safe_retval (_tao_retval);
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "describe_contents",
+      17,
+      1,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_describe_contents ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        limit_type,
+        exclude_inherited,
+        max_returned_objs,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+          if (!(
+                            (_tao_out << limit_type) &&
+              (_tao_out << CORBA::Any::from_boolean (exclude_inherited)) &&
+              (_tao_out << max_returned_objs)
+            ))
+            TAO_INTERCEPTOR_THROW_RETURN (
+              CORBA::MARSHAL (),
+              0
+            );
+            
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::Container::DescriptionSeq * _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+//
+//            End  Base & Remote  Proxy Implemeentation. 
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//           Remote & Base  Proxy Broker Implementation
+//
+
+_TAO_Container_Proxy_Broker::_TAO_Container_Proxy_Broker (void)
+{
+}
+
+_TAO_Container_Proxy_Broker::~_TAO_Container_Proxy_Broker (void)
+{
+}
+
+_TAO_Container_Proxy_Broker * (*CORBA__TAO_Container_Proxy_Broker_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  ) = 0;
+
+// Factory Member function Implementation.
+_TAO_Container_Remote_Proxy_Broker *
+_TAO_Container_Remote_Proxy_Broker::the_TAO_Container_Remote_Proxy_Broker (void)
+{
+  static ::_TAO_Container_Remote_Proxy_Broker remote_proxy_broker;
+  return &remote_proxy_broker;
+}
+
+_TAO_Container_Remote_Proxy_Broker::_TAO_Container_Remote_Proxy_Broker (void)
+{
+}
+
+_TAO_Container_Remote_Proxy_Broker::~_TAO_Container_Remote_Proxy_Broker (void)
+{
+}
+
+_TAO_Container_Proxy_Impl&
+_TAO_Container_Remote_Proxy_Broker::select_proxy (
+  ::CORBA_Container *,
+  CORBA::Environment &
+)
+{
+  return this->remote_proxy_impl_;
+}
+
+
+//
+//           End Remote & Base Proxy Broker Implementation
+///////////////////////////////////////////////////////////////////////
+
+
+// default constructor
+CORBA::Container::Container (int collocated)
+{
+  this->CORBA_Container_setup_collocation (collocated);
+}
+
+// destructor
+CORBA::Container::~Container (void)
+{}
+
+void
+CORBA::Container::CORBA_Container_setup_collocation (int collocated)
+{
+  if (collocated)
+    this->the_TAO_Container_Proxy_Broker_ =
+      ::CORBA__TAO_Container_Proxy_Broker_Factory_function_pointer (this);
+  else
+    this->the_TAO_Container_Proxy_Broker_ =
+      ::_TAO_Container_Remote_Proxy_Broker::the_TAO_Container_Remote_Proxy_Broker ();
+  
+  this->CORBA_IRObject_setup_collocation (collocated);
+}
+
+void CORBA::Container::_tao_any_destructor (void *x)
+{
+  CORBA_Container *tmp = ACE_static_cast (CORBA_Container*,x);
+  CORBA::release (tmp);
+}
+
+CORBA::Container_ptr CORBA::Container::_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+{
+  if (CORBA::is_nil (obj))
+    return CORBA::Container::_nil ();
+  if (! obj->_is_local ())
+    {
+      CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/CORBA/Container:1.0", ACE_TRY_ENV);
+      ACE_CHECK_RETURN (CORBA::Container::_nil ());
+      if (is_a == 0)
+        return CORBA::Container::_nil ();
+    }
+  return CORBA::Container::_unchecked_narrow (obj, ACE_TRY_ENV);
+}
+
+CORBA::Container_ptr CORBA::Container::_unchecked_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &
+  )
+{
+  if (CORBA::is_nil (obj))
+    return CORBA::Container::_nil ();
+  if (! obj->_is_local ())
+    {
+      TAO_Stub* stub = obj->_stubobj ();
+      if (stub)
+        stub->_incr_refcnt ();
+      CORBA::Container_ptr default_proxy = CORBA::Container::_nil ();
+
+      if (
+          !CORBA::is_nil (stub->servant_orb_var ().ptr ()) &&
+          stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects () &&
+          obj->_is_collocated () &&CORBA__TAO_Container_Proxy_Broker_Factory_function_pointer != 0
+        )
+      {
+        ACE_NEW_RETURN (
+          default_proxy,
+          ::CORBA::Container (
+            stub,
+            1,
+            obj->_servant ()),
+            
+          CORBA::Container::_nil ());
+        }
+      if (CORBA::is_nil (default_proxy))
+        ACE_NEW_RETURN (default_proxy, ::CORBA::Container (stub, 0, obj->_servant ()), CORBA::Container::_nil ());
+        return default_proxy;
+      }
+    else 
+      return
+        ACE_reinterpret_cast
+          (
+            CORBA_Container_ptr,
+              obj->_tao_QueryInterface
+                (
+                  ACE_reinterpret_cast
+                    (
+                      ptr_arith_t,
+                      &CORBA_Container::_narrow
+                    )
+                )
+          );
+}
+
+CORBA::Container_ptr
+CORBA::Container::_duplicate (CORBA::Container_ptr obj)
+{
+  if (!CORBA::is_nil (obj))
+    obj->_add_ref ();
+  return obj;
+}
+
+CORBA::Boolean CORBA::Container::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
+{
+  if (
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Container:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
+  return 1; // success using local knowledge
+  else
+    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
+}
+
+void *CORBA::Container::_tao_QueryInterface (ptr_arith_t type)
+{
+  void *retv = 0;
+  if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      CORBA_Container::_narrow))
+    retv = ACE_reinterpret_cast (void*, this);
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      CORBA_IRObject::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::IRObject_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
+    retv = ACE_reinterpret_cast (void *,
+      ACE_static_cast (CORBA::Object_ptr, this));
+    
+  if (retv)
+    this->_add_ref ();
+  return retv;
+}
+
+const char* CORBA::Container::_interface_repository_id (void) const
+{
+  return "IDL:omg.org/CORBA/Container:1.0";
+}
+
+CORBA::Contained_ptr CORBA::Container::lookup (
+    const char * search_name,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_Container_Proxy_Impl &proxy = 
+    this->the_TAO_Container_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.lookup (
+      this,
+      search_name,
+      ACE_TRY_ENV
+    );
+}
+
+CORBA::ContainedSeq * CORBA::Container::contents (
+    CORBA::DefinitionKind limit_type,
+    CORBA::Boolean exclude_inherited,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_Container_Proxy_Impl &proxy = 
+    this->the_TAO_Container_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.contents (
+      this,
+      limit_type,
+      exclude_inherited,
+      ACE_TRY_ENV
+    );
+}
+
+CORBA::ContainedSeq * CORBA::Container::lookup_name (
+    const char * search_name,
+    CORBA::Long levels_to_search,
+    CORBA::DefinitionKind limit_type,
+    CORBA::Boolean exclude_inherited,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_Container_Proxy_Impl &proxy = 
+    this->the_TAO_Container_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.lookup_name (
+      this,
+      search_name,
+      levels_to_search,
+      limit_type,
+      exclude_inherited,
+      ACE_TRY_ENV
+    );
+}
+
+static const CORBA::Long _oc_CORBA_Container_Description[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  44,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x434f5242), 
+  ACE_NTOHL (0x412f436f), 
+  ACE_NTOHL (0x6e746169), 
+  ACE_NTOHL (0x6e65722f), 
+  ACE_NTOHL (0x44657363), 
+  ACE_NTOHL (0x72697074), 
+  ACE_NTOHL (0x696f6e3a), 
+  ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/Container/Description:1.0
+  12,
+  ACE_NTOHL (0x44657363), 
+  ACE_NTOHL (0x72697074), 
+  ACE_NTOHL (0x696f6e00),  // name = Description
+  3, // member count
+  17,
+  ACE_NTOHL (0x636f6e74), 
+  ACE_NTOHL (0x61696e65), 
+  ACE_NTOHL (0x645f6f62), 
+  ACE_NTOHL (0x6a656374), 
+  ACE_NTOHL (0x0),  // name = contained_object
+  CORBA::tk_objref, // typecode kind
+  56, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    32,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x434f5242), 
+    ACE_NTOHL (0x412f436f), 
+    ACE_NTOHL (0x6e746169), 
+    ACE_NTOHL (0x6e65643a), 
+    ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/Contained:1.0
+    10,
+    ACE_NTOHL (0x436f6e74), 
+    ACE_NTOHL (0x61696e65), 
+    ACE_NTOHL (0x64000000),  // name = Contained
+
+  5,
+  ACE_NTOHL (0x6b696e64), 
+  ACE_NTOHL (0x0),  // name = kind
+  CORBA::tk_enum, // typecode kind
+  524, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    37,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x434f5242), 
+    ACE_NTOHL (0x412f4465), 
+    ACE_NTOHL (0x66696e69), 
+    ACE_NTOHL (0x74696f6e), 
+    ACE_NTOHL (0x4b696e64), 
+    ACE_NTOHL (0x3a312e30), 
+    ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/DefinitionKind:1.0
+    15,
+    ACE_NTOHL (0x44656669), 
+    ACE_NTOHL (0x6e697469), 
+    ACE_NTOHL (0x6f6e4b69), 
+    ACE_NTOHL (0x6e640000),  // name = DefinitionKind
+    26, // member count
+    8,
+    ACE_NTOHL (0x646b5f6e), 
+    ACE_NTOHL (0x6f6e6500),  // name = dk_none
+    7,
+    ACE_NTOHL (0x646b5f61), 
+    ACE_NTOHL (0x6c6c0000),  // name = dk_all
+    13,
+    ACE_NTOHL (0x646b5f41), 
+    ACE_NTOHL (0x74747269), 
+    ACE_NTOHL (0x62757465), 
+    ACE_NTOHL (0x0),  // name = dk_Attribute
+    12,
+    ACE_NTOHL (0x646b5f43), 
+    ACE_NTOHL (0x6f6e7374), 
+    ACE_NTOHL (0x616e7400),  // name = dk_Constant
+    13,
+    ACE_NTOHL (0x646b5f45), 
+    ACE_NTOHL (0x78636570), 
+    ACE_NTOHL (0x74696f6e), 
+    ACE_NTOHL (0x0),  // name = dk_Exception
+    13,
+    ACE_NTOHL (0x646b5f49), 
+    ACE_NTOHL (0x6e746572), 
+    ACE_NTOHL (0x66616365), 
+    ACE_NTOHL (0x0),  // name = dk_Interface
+    10,
+    ACE_NTOHL (0x646b5f4d), 
+    ACE_NTOHL (0x6f64756c), 
+    ACE_NTOHL (0x65000000),  // name = dk_Module
+    13,
+    ACE_NTOHL (0x646b5f4f), 
+    ACE_NTOHL (0x70657261), 
+    ACE_NTOHL (0x74696f6e), 
+    ACE_NTOHL (0x0),  // name = dk_Operation
+    11,
+    ACE_NTOHL (0x646b5f54), 
+    ACE_NTOHL (0x79706564), 
+    ACE_NTOHL (0x65660000),  // name = dk_Typedef
+    9,
+    ACE_NTOHL (0x646b5f41), 
+    ACE_NTOHL (0x6c696173), 
+    ACE_NTOHL (0x0),  // name = dk_Alias
+    10,
+    ACE_NTOHL (0x646b5f53), 
+    ACE_NTOHL (0x74727563), 
+    ACE_NTOHL (0x74000000),  // name = dk_Struct
+    9,
+    ACE_NTOHL (0x646b5f55), 
+    ACE_NTOHL (0x6e696f6e), 
+    ACE_NTOHL (0x0),  // name = dk_Union
+    8,
+    ACE_NTOHL (0x646b5f45), 
+    ACE_NTOHL (0x6e756d00),  // name = dk_Enum
+    13,
+    ACE_NTOHL (0x646b5f50), 
+    ACE_NTOHL (0x72696d69), 
+    ACE_NTOHL (0x74697665), 
+    ACE_NTOHL (0x0),  // name = dk_Primitive
+    10,
+    ACE_NTOHL (0x646b5f53), 
+    ACE_NTOHL (0x7472696e), 
+    ACE_NTOHL (0x67000000),  // name = dk_String
+    12,
+    ACE_NTOHL (0x646b5f53), 
+    ACE_NTOHL (0x65717565), 
+    ACE_NTOHL (0x6e636500),  // name = dk_Sequence
+    9,
+    ACE_NTOHL (0x646b5f41), 
+    ACE_NTOHL (0x72726179), 
+    ACE_NTOHL (0x0),  // name = dk_Array
+    14,
+    ACE_NTOHL (0x646b5f52), 
+    ACE_NTOHL (0x65706f73), 
+    ACE_NTOHL (0x69746f72), 
+    ACE_NTOHL (0x79000000),  // name = dk_Repository
+    11,
+    ACE_NTOHL (0x646b5f57), 
+    ACE_NTOHL (0x73747269), 
+    ACE_NTOHL (0x6e670000),  // name = dk_Wstring
+    9,
+    ACE_NTOHL (0x646b5f46), 
+    ACE_NTOHL (0x69786564), 
+    ACE_NTOHL (0x0),  // name = dk_Fixed
+    9,
+    ACE_NTOHL (0x646b5f56), 
+    ACE_NTOHL (0x616c7565), 
+    ACE_NTOHL (0x0),  // name = dk_Value
+    12,
+    ACE_NTOHL (0x646b5f56), 
+    ACE_NTOHL (0x616c7565), 
+    ACE_NTOHL (0x426f7800),  // name = dk_ValueBox
+    15,
+    ACE_NTOHL (0x646b5f56), 
+    ACE_NTOHL (0x616c7565), 
+    ACE_NTOHL (0x4d656d62), 
+    ACE_NTOHL (0x65720000),  // name = dk_ValueMember
+    10,
+    ACE_NTOHL (0x646b5f4e), 
+    ACE_NTOHL (0x61746976), 
+    ACE_NTOHL (0x65000000),  // name = dk_Native
+    21,
+    ACE_NTOHL (0x646b5f41), 
+    ACE_NTOHL (0x62737472), 
+    ACE_NTOHL (0x61637449), 
+    ACE_NTOHL (0x6e746572), 
+    ACE_NTOHL (0x66616365), 
+    ACE_NTOHL (0x0),  // name = dk_AbstractInterface
+    18,
+    ACE_NTOHL (0x646b5f4c), 
+    ACE_NTOHL (0x6f63616c), 
+    ACE_NTOHL (0x496e7465), 
+    ACE_NTOHL (0x72666163), 
+    ACE_NTOHL (0x65000000),  // name = dk_LocalInterface
+
+  6,
+  ACE_NTOHL (0x76616c75), 
+  ACE_NTOHL (0x65000000),  // name = value
+  CORBA::tk_any,
+
+};
+
+static CORBA::TypeCode _tc_TAO_tc_CORBA_Container_Description (
+    CORBA::tk_struct,
+    sizeof (_oc_CORBA_Container_Description),
+    (char *) &_oc_CORBA_Container_Description,
+    0,
+    sizeof (CORBA::Container::Description)
+  );
+
+CORBA::TypeCode_ptr CORBA::Container::_tc_Description =
+  &_tc_TAO_tc_CORBA_Container_Description;
+
+void CORBA::Container::Description::_tao_any_destructor (void *x)
+{
+  Description *tmp = ACE_static_cast (Description*,x);
+  delete tmp;
+}
+
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_SEQUENCE_CORBA_CONTAINER_DESCRIPTIONSEQ_CS_)
+#define __TAO_UNBOUNDED_SEQUENCE_CORBA_CONTAINER_DESCRIPTIONSEQ_CS_
+
+  void
+  CORBA::Container::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::_allocate_buffer (CORBA::ULong length)
+  {
+    Description* tmp = 0;
+    tmp = _TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::allocbuf (length);
+    
+    if (this->buffer_ != 0)
+    {
+      Description *old = ACE_reinterpret_cast (Description *,this->buffer_);
+      
+      for (CORBA::ULong i = 0; i < this->length_; ++i)
+        tmp[i] = old[i];
+      
+      if (this->release_)
+        _TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::freebuf (old);
+      
+    }
+    this->buffer_ = tmp;
+  }
+  
+  void
+  CORBA::Container::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::_deallocate_buffer (void)
+  {
+    if (this->buffer_ == 0 || this->release_ == 0)
+      return;
+    
+    Description *tmp = ACE_reinterpret_cast (Description *,this->buffer_);
+    
+    _TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::freebuf (tmp);
+    this->buffer_ = 0;
+  } 
+  
+  CORBA::Container::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::~_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq (void) // Dtor.
+  {
+    this->_deallocate_buffer ();
+  }
+  
+  
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_CORBA_CONTAINER_DESCRIPTIONSEQ_CS_)
+#define _CORBA_CONTAINER_DESCRIPTIONSEQ_CS_
+
+// *************************************************************
+// CORBA::Container::DescriptionSeq
+// *************************************************************
+
+CORBA::Container::DescriptionSeq::DescriptionSeq (void)
+{}
+CORBA::Container::DescriptionSeq::DescriptionSeq (CORBA::ULong max) // uses max size
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<CORBA::Container::Description>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (max)
+{}
+CORBA::Container::DescriptionSeq::DescriptionSeq (CORBA::ULong max, CORBA::ULong length, CORBA::Container::Description *buffer, CORBA::Boolean release)
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<CORBA::Container::Description>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (max, length, buffer, release)
+{}
+CORBA::Container::DescriptionSeq::DescriptionSeq (const DescriptionSeq &seq) // copy ctor
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<CORBA::Container::Description>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (seq)
+{}
+CORBA::Container::DescriptionSeq::~DescriptionSeq (void) // dtor
+{}
+void CORBA::Container::DescriptionSeq::_tao_any_destructor (void *x)
+{
+  DescriptionSeq *tmp = ACE_static_cast (DescriptionSeq*,x);
+  delete tmp;
+}
+
+
+#endif /* end #if !defined */
+
+static const CORBA::Long _oc_CORBA_Container_DescriptionSeq[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  47,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x434f5242), 
+  ACE_NTOHL (0x412f436f), 
+  ACE_NTOHL (0x6e746169), 
+  ACE_NTOHL (0x6e65722f), 
+  ACE_NTOHL (0x44657363), 
+  ACE_NTOHL (0x72697074), 
+  ACE_NTOHL (0x696f6e53), 
+  ACE_NTOHL (0x65713a31), 
+  ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/Container/DescriptionSeq:1.0
+  15,
+  ACE_NTOHL (0x44657363), 
+  ACE_NTOHL (0x72697074), 
+  ACE_NTOHL (0x696f6e53), 
+  ACE_NTOHL (0x65710000),  // name = DescriptionSeq
+  CORBA::tk_sequence, // typecode kind
+  736, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    CORBA::tk_struct, // typecode kind
+    720, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      44,
+      ACE_NTOHL (0x49444c3a), 
+      ACE_NTOHL (0x6f6d672e), 
+      ACE_NTOHL (0x6f72672f), 
+      ACE_NTOHL (0x434f5242), 
+      ACE_NTOHL (0x412f436f), 
+      ACE_NTOHL (0x6e746169), 
+      ACE_NTOHL (0x6e65722f), 
+      ACE_NTOHL (0x44657363), 
+      ACE_NTOHL (0x72697074), 
+      ACE_NTOHL (0x696f6e3a), 
+      ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/Container/Description:1.0
+      12,
+      ACE_NTOHL (0x44657363), 
+      ACE_NTOHL (0x72697074), 
+      ACE_NTOHL (0x696f6e00),  // name = Description
+      3, // member count
+      17,
+      ACE_NTOHL (0x636f6e74), 
+      ACE_NTOHL (0x61696e65), 
+      ACE_NTOHL (0x645f6f62), 
+      ACE_NTOHL (0x6a656374), 
+      ACE_NTOHL (0x0),  // name = contained_object
+      CORBA::tk_objref, // typecode kind
+      56, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        32,
+        ACE_NTOHL (0x49444c3a), 
+        ACE_NTOHL (0x6f6d672e), 
+        ACE_NTOHL (0x6f72672f), 
+        ACE_NTOHL (0x434f5242), 
+        ACE_NTOHL (0x412f436f), 
+        ACE_NTOHL (0x6e746169), 
+        ACE_NTOHL (0x6e65643a), 
+        ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/Contained:1.0
+        10,
+        ACE_NTOHL (0x436f6e74), 
+        ACE_NTOHL (0x61696e65), 
+        ACE_NTOHL (0x64000000),  // name = Contained
+
+      5,
+      ACE_NTOHL (0x6b696e64), 
+      ACE_NTOHL (0x0),  // name = kind
+      CORBA::tk_enum, // typecode kind
+      524, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        37,
+        ACE_NTOHL (0x49444c3a), 
+        ACE_NTOHL (0x6f6d672e), 
+        ACE_NTOHL (0x6f72672f), 
+        ACE_NTOHL (0x434f5242), 
+        ACE_NTOHL (0x412f4465), 
+        ACE_NTOHL (0x66696e69), 
+        ACE_NTOHL (0x74696f6e), 
+        ACE_NTOHL (0x4b696e64), 
+        ACE_NTOHL (0x3a312e30), 
+        ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/DefinitionKind:1.0
+        15,
+        ACE_NTOHL (0x44656669), 
+        ACE_NTOHL (0x6e697469), 
+        ACE_NTOHL (0x6f6e4b69), 
+        ACE_NTOHL (0x6e640000),  // name = DefinitionKind
+        26, // member count
+        8,
+        ACE_NTOHL (0x646b5f6e), 
+        ACE_NTOHL (0x6f6e6500),  // name = dk_none
+        7,
+        ACE_NTOHL (0x646b5f61), 
+        ACE_NTOHL (0x6c6c0000),  // name = dk_all
+        13,
+        ACE_NTOHL (0x646b5f41), 
+        ACE_NTOHL (0x74747269), 
+        ACE_NTOHL (0x62757465), 
+        ACE_NTOHL (0x0),  // name = dk_Attribute
+        12,
+        ACE_NTOHL (0x646b5f43), 
+        ACE_NTOHL (0x6f6e7374), 
+        ACE_NTOHL (0x616e7400),  // name = dk_Constant
+        13,
+        ACE_NTOHL (0x646b5f45), 
+        ACE_NTOHL (0x78636570), 
+        ACE_NTOHL (0x74696f6e), 
+        ACE_NTOHL (0x0),  // name = dk_Exception
+        13,
+        ACE_NTOHL (0x646b5f49), 
+        ACE_NTOHL (0x6e746572), 
+        ACE_NTOHL (0x66616365), 
+        ACE_NTOHL (0x0),  // name = dk_Interface
+        10,
+        ACE_NTOHL (0x646b5f4d), 
+        ACE_NTOHL (0x6f64756c), 
+        ACE_NTOHL (0x65000000),  // name = dk_Module
+        13,
+        ACE_NTOHL (0x646b5f4f), 
+        ACE_NTOHL (0x70657261), 
+        ACE_NTOHL (0x74696f6e), 
+        ACE_NTOHL (0x0),  // name = dk_Operation
+        11,
+        ACE_NTOHL (0x646b5f54), 
+        ACE_NTOHL (0x79706564), 
+        ACE_NTOHL (0x65660000),  // name = dk_Typedef
+        9,
+        ACE_NTOHL (0x646b5f41), 
+        ACE_NTOHL (0x6c696173), 
+        ACE_NTOHL (0x0),  // name = dk_Alias
+        10,
+        ACE_NTOHL (0x646b5f53), 
+        ACE_NTOHL (0x74727563), 
+        ACE_NTOHL (0x74000000),  // name = dk_Struct
+        9,
+        ACE_NTOHL (0x646b5f55), 
+        ACE_NTOHL (0x6e696f6e), 
+        ACE_NTOHL (0x0),  // name = dk_Union
+        8,
+        ACE_NTOHL (0x646b5f45), 
+        ACE_NTOHL (0x6e756d00),  // name = dk_Enum
+        13,
+        ACE_NTOHL (0x646b5f50), 
+        ACE_NTOHL (0x72696d69), 
+        ACE_NTOHL (0x74697665), 
+        ACE_NTOHL (0x0),  // name = dk_Primitive
+        10,
+        ACE_NTOHL (0x646b5f53), 
+        ACE_NTOHL (0x7472696e), 
+        ACE_NTOHL (0x67000000),  // name = dk_String
+        12,
+        ACE_NTOHL (0x646b5f53), 
+        ACE_NTOHL (0x65717565), 
+        ACE_NTOHL (0x6e636500),  // name = dk_Sequence
+        9,
+        ACE_NTOHL (0x646b5f41), 
+        ACE_NTOHL (0x72726179), 
+        ACE_NTOHL (0x0),  // name = dk_Array
+        14,
+        ACE_NTOHL (0x646b5f52), 
+        ACE_NTOHL (0x65706f73), 
+        ACE_NTOHL (0x69746f72), 
+        ACE_NTOHL (0x79000000),  // name = dk_Repository
+        11,
+        ACE_NTOHL (0x646b5f57), 
+        ACE_NTOHL (0x73747269), 
+        ACE_NTOHL (0x6e670000),  // name = dk_Wstring
+        9,
+        ACE_NTOHL (0x646b5f46), 
+        ACE_NTOHL (0x69786564), 
+        ACE_NTOHL (0x0),  // name = dk_Fixed
+        9,
+        ACE_NTOHL (0x646b5f56), 
+        ACE_NTOHL (0x616c7565), 
+        ACE_NTOHL (0x0),  // name = dk_Value
+        12,
+        ACE_NTOHL (0x646b5f56), 
+        ACE_NTOHL (0x616c7565), 
+        ACE_NTOHL (0x426f7800),  // name = dk_ValueBox
+        15,
+        ACE_NTOHL (0x646b5f56), 
+        ACE_NTOHL (0x616c7565), 
+        ACE_NTOHL (0x4d656d62), 
+        ACE_NTOHL (0x65720000),  // name = dk_ValueMember
+        10,
+        ACE_NTOHL (0x646b5f4e), 
+        ACE_NTOHL (0x61746976), 
+        ACE_NTOHL (0x65000000),  // name = dk_Native
+        21,
+        ACE_NTOHL (0x646b5f41), 
+        ACE_NTOHL (0x62737472), 
+        ACE_NTOHL (0x61637449), 
+        ACE_NTOHL (0x6e746572), 
+        ACE_NTOHL (0x66616365), 
+        ACE_NTOHL (0x0),  // name = dk_AbstractInterface
+        18,
+        ACE_NTOHL (0x646b5f4c), 
+        ACE_NTOHL (0x6f63616c), 
+        ACE_NTOHL (0x496e7465), 
+        ACE_NTOHL (0x72666163), 
+        ACE_NTOHL (0x65000000),  // name = dk_LocalInterface
+
+      6,
+      ACE_NTOHL (0x76616c75), 
+      ACE_NTOHL (0x65000000),  // name = value
+      CORBA::tk_any,
+
+
+    0U,
+
+};
+
+static CORBA::TypeCode _tc_TAO_tc_CORBA_Container_DescriptionSeq (
+    CORBA::tk_alias,
+    sizeof (_oc_CORBA_Container_DescriptionSeq),
+    (char *) &_oc_CORBA_Container_DescriptionSeq,
+    0,
+    sizeof (CORBA::Container::DescriptionSeq)
+  );
+
+CORBA::TypeCode_ptr CORBA::Container::_tc_DescriptionSeq =
+  &_tc_TAO_tc_CORBA_Container_DescriptionSeq;
+
+CORBA::Container::DescriptionSeq * CORBA::Container::describe_contents (
+    CORBA::DefinitionKind limit_type,
+    CORBA::Boolean exclude_inherited,
+    CORBA::Long max_returned_objs,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_Container_Proxy_Impl &proxy = 
+    this->the_TAO_Container_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.describe_contents (
+      this,
+      limit_type,
+      exclude_inherited,
+      max_returned_objs,
+      ACE_TRY_ENV
+    );
+}
+
+CORBA::ModuleDef_ptr CORBA::Container::create_module (
+    const char * id,
+    const char * name,
+    const char * version,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_Container_Proxy_Impl &proxy = 
+    this->the_TAO_Container_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.create_module (
+      this,
+      id,
+      name,
+      version,
+      ACE_TRY_ENV
+    );
+}
+
+CORBA::ConstantDef_ptr CORBA::Container::create_constant (
+    const char * id,
+    const char * name,
+    const char * version,
+    CORBA::IDLType_ptr type,
+    const CORBA::Any & value,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_Container_Proxy_Impl &proxy = 
+    this->the_TAO_Container_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.create_constant (
+      this,
+      id,
+      name,
+      version,
+      type,
+      value,
+      ACE_TRY_ENV
+    );
+}
+
+CORBA::StructDef_ptr CORBA::Container::create_struct (
+    const char * id,
+    const char * name,
+    const char * version,
+    const CORBA::StructMemberSeq & members,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_Container_Proxy_Impl &proxy = 
+    this->the_TAO_Container_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.create_struct (
+      this,
+      id,
+      name,
+      version,
+      members,
+      ACE_TRY_ENV
+    );
+}
+
+CORBA::UnionDef_ptr CORBA::Container::create_union (
+    const char * id,
+    const char * name,
+    const char * version,
+    CORBA::IDLType_ptr discriminator_type,
+    const CORBA::UnionMemberSeq & members,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_Container_Proxy_Impl &proxy = 
+    this->the_TAO_Container_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.create_union (
+      this,
+      id,
+      name,
+      version,
+      discriminator_type,
+      members,
+      ACE_TRY_ENV
+    );
+}
+
+CORBA::EnumDef_ptr CORBA::Container::create_enum (
+    const char * id,
+    const char * name,
+    const char * version,
+    const CORBA::EnumMemberSeq & members,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_Container_Proxy_Impl &proxy = 
+    this->the_TAO_Container_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.create_enum (
+      this,
+      id,
+      name,
+      version,
+      members,
+      ACE_TRY_ENV
+    );
+}
+
+CORBA::AliasDef_ptr CORBA::Container::create_alias (
+    const char * id,
+    const char * name,
+    const char * version,
+    CORBA::IDLType_ptr original_type,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_Container_Proxy_Impl &proxy = 
+    this->the_TAO_Container_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.create_alias (
+      this,
+      id,
+      name,
+      version,
+      original_type,
+      ACE_TRY_ENV
+    );
+}
+
+CORBA::InterfaceDef_ptr CORBA::Container::create_interface (
+    const char * id,
+    const char * name,
+    const char * version,
+    const CORBA::InterfaceDefSeq & base_interfaces,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_Container_Proxy_Impl &proxy = 
+    this->the_TAO_Container_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.create_interface (
+      this,
+      id,
+      name,
+      version,
+      base_interfaces,
+      ACE_TRY_ENV
+    );
+}
+
+CORBA::ValueDef_ptr CORBA::Container::create_value (
+    const char * id,
+    const char * name,
+    const char * version,
+    CORBA::Boolean is_custom,
+    CORBA::Boolean is_abstract,
+    CORBA::ValueDef_ptr base_value,
+    CORBA::Boolean is_truncatable,
+    const CORBA::ValueDefSeq & abstract_base_values,
+    const CORBA::InterfaceDefSeq & supported_interfaces,
+    const CORBA::InitializerSeq & initializers,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_Container_Proxy_Impl &proxy = 
+    this->the_TAO_Container_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.create_value (
+      this,
+      id,
+      name,
+      version,
+      is_custom,
+      is_abstract,
+      base_value,
+      is_truncatable,
+      abstract_base_values,
+      supported_interfaces,
+      initializers,
+      ACE_TRY_ENV
+    );
+}
+
+CORBA::ValueBoxDef_ptr CORBA::Container::create_value_box (
+    const char * id,
+    const char * name,
+    const char * version,
+    CORBA::IDLType_ptr original_type_def,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_Container_Proxy_Impl &proxy = 
+    this->the_TAO_Container_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.create_value_box (
+      this,
+      id,
+      name,
+      version,
+      original_type_def,
+      ACE_TRY_ENV
+    );
+}
+
+CORBA::ExceptionDef_ptr CORBA::Container::create_exception (
+    const char * id,
+    const char * name,
+    const char * version,
+    const CORBA::StructMemberSeq & members,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_Container_Proxy_Impl &proxy = 
+    this->the_TAO_Container_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.create_exception (
+      this,
+      id,
+      name,
+      version,
+      members,
+      ACE_TRY_ENV
+    );
+}
+
+CORBA::NativeDef_ptr CORBA::Container::create_native (
+    const char * id,
+    const char * name,
+    const char * version,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_Container_Proxy_Impl &proxy = 
+    this->the_TAO_Container_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.create_native (
+      this,
+      id,
+      name,
+      version,
+      ACE_TRY_ENV
+    );
+}
+
+CORBA::AbstractInterfaceDef_ptr CORBA::Container::create_abstract_interface (
+    const char * id,
+    const char * name,
+    const char * version,
+    const CORBA::AbstractInterfaceDefSeq & base_interfaces,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_Container_Proxy_Impl &proxy = 
+    this->the_TAO_Container_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.create_abstract_interface (
+      this,
+      id,
+      name,
+      version,
+      base_interfaces,
+      ACE_TRY_ENV
+    );
+}
+
+CORBA::LocalInterfaceDef_ptr CORBA::Container::create_local_interface (
+    const char * id,
+    const char * name,
+    const char * version,
+    const CORBA::InterfaceDefSeq & base_interfaces,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_Container_Proxy_Impl &proxy = 
+    this->the_TAO_Container_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.create_local_interface (
+      this,
+      id,
+      name,
+      version,
+      base_interfaces,
+      ACE_TRY_ENV
+    );
+}
+
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_lookup::TAO_ClientRequestInfo_CORBA_Container_lookup (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const char * search_name,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
+    search_name_ (search_name)
+{}
+
+Dynamic::ParameterList *
+CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_lookup::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
+    
+  CORBA::ULong length_search_name = parameter_list->length ();
+  parameter_list->length (length_search_name + 1);
+  (*parameter_list)[length_search_name].argument <<= search_name_;
+  (*parameter_list)[length_search_name].mode = Dynamic::PARAM_IN;
+  
+  return safe_parameter_list._retn ();
+}
+
+Dynamic::ExceptionList *
+CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_lookup::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_lookup::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_lookup::result (CORBA::Contained_ptr result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_contents::TAO_ClientRequestInfo_CORBA_Container_contents (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::DefinitionKind & limit_type,
+    const CORBA::Boolean & exclude_inherited,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
+    limit_type_ (limit_type),
+    exclude_inherited_ (exclude_inherited)
+{}
+
+Dynamic::ParameterList *
+CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_contents::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
+    
+  CORBA::ULong length_limit_type = parameter_list->length ();
+  parameter_list->length (length_limit_type + 1);
+  (*parameter_list)[length_limit_type].argument <<=  this->limit_type_;
+  
+  (*parameter_list)[length_limit_type].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_exclude_inherited = parameter_list->length ();
+  parameter_list->length (length_exclude_inherited + 1);
+  (*parameter_list)[length_exclude_inherited].argument <<= CORBA::Any::from_boolean (this->exclude_inherited_);
+  (*parameter_list)[length_exclude_inherited].mode = Dynamic::PARAM_IN;
+  
+  return safe_parameter_list._retn ();
+}
+
+Dynamic::ExceptionList *
+CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_contents::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_contents::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_contents::result (CORBA::ContainedSeq * result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_lookup_name::TAO_ClientRequestInfo_CORBA_Container_lookup_name (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const char * search_name,
+    const CORBA::Long & levels_to_search,
+    CORBA::DefinitionKind & limit_type,
+    const CORBA::Boolean & exclude_inherited,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
+    search_name_ (search_name),
+    levels_to_search_ (levels_to_search),
+    limit_type_ (limit_type),
+    exclude_inherited_ (exclude_inherited)
+{}
+
+Dynamic::ParameterList *
+CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_lookup_name::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
+    
+  CORBA::ULong length_search_name = parameter_list->length ();
+  parameter_list->length (length_search_name + 1);
+  (*parameter_list)[length_search_name].argument <<= search_name_;
+  (*parameter_list)[length_search_name].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_levels_to_search = parameter_list->length ();
+  parameter_list->length (length_levels_to_search + 1);
+  (*parameter_list)[length_levels_to_search].argument <<= levels_to_search_;
+  (*parameter_list)[length_levels_to_search].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_limit_type = parameter_list->length ();
+  parameter_list->length (length_limit_type + 1);
+  (*parameter_list)[length_limit_type].argument <<=  this->limit_type_;
+  
+  (*parameter_list)[length_limit_type].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_exclude_inherited = parameter_list->length ();
+  parameter_list->length (length_exclude_inherited + 1);
+  (*parameter_list)[length_exclude_inherited].argument <<= CORBA::Any::from_boolean (this->exclude_inherited_);
+  (*parameter_list)[length_exclude_inherited].mode = Dynamic::PARAM_IN;
+  
+  return safe_parameter_list._retn ();
+}
+
+Dynamic::ExceptionList *
+CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_lookup_name::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_lookup_name::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_lookup_name::result (CORBA::ContainedSeq * result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_describe_contents::TAO_ClientRequestInfo_CORBA_Container_describe_contents (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::DefinitionKind & limit_type,
+    const CORBA::Boolean & exclude_inherited,
+    const CORBA::Long & max_returned_objs,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
+    limit_type_ (limit_type),
+    exclude_inherited_ (exclude_inherited),
+    max_returned_objs_ (max_returned_objs)
+{}
+
+Dynamic::ParameterList *
+CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_describe_contents::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
+    
+  CORBA::ULong length_limit_type = parameter_list->length ();
+  parameter_list->length (length_limit_type + 1);
+  (*parameter_list)[length_limit_type].argument <<=  this->limit_type_;
+  
+  (*parameter_list)[length_limit_type].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_exclude_inherited = parameter_list->length ();
+  parameter_list->length (length_exclude_inherited + 1);
+  (*parameter_list)[length_exclude_inherited].argument <<= CORBA::Any::from_boolean (this->exclude_inherited_);
+  (*parameter_list)[length_exclude_inherited].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_max_returned_objs = parameter_list->length ();
+  parameter_list->length (length_max_returned_objs + 1);
+  (*parameter_list)[length_max_returned_objs].argument <<= max_returned_objs_;
+  (*parameter_list)[length_max_returned_objs].mode = Dynamic::PARAM_IN;
+  
+  return safe_parameter_list._retn ();
+}
+
+Dynamic::ExceptionList *
+CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_describe_contents::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_describe_contents::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_describe_contents::result (ACE_NESTED_CLASS (CORBA::Container,DescriptionSeq) * result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_create_module::TAO_ClientRequestInfo_CORBA_Container_create_module (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const char * id,
+    const char * name,
+    const char * version,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
+    id_ (id),
+    name_ (name),
+    version_ (version)
+{}
+
+Dynamic::ParameterList *
+CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_create_module::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
+    
+  CORBA::ULong length_id = parameter_list->length ();
+  parameter_list->length (length_id + 1);
+  (*parameter_list)[length_id].argument <<= id_;
+  (*parameter_list)[length_id].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_name = parameter_list->length ();
+  parameter_list->length (length_name + 1);
+  (*parameter_list)[length_name].argument <<= name_;
+  (*parameter_list)[length_name].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_version = parameter_list->length ();
+  parameter_list->length (length_version + 1);
+  (*parameter_list)[length_version].argument <<= version_;
+  (*parameter_list)[length_version].mode = Dynamic::PARAM_IN;
+  
+  return safe_parameter_list._retn ();
+}
+
+Dynamic::ExceptionList *
+CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_create_module::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+void 
+CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_create_module::result (CORBA::ModuleDef_ptr result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_create_constant::TAO_ClientRequestInfo_CORBA_Container_create_constant (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const char * id,
+    const char * name,
+    const char * version,
+    CORBA::IDLType_ptr type,
+    const CORBA::Any & value,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
+    id_ (id),
+    name_ (name),
+    version_ (version),
+    type_ (type),
+    value_ (value)
+{}
+
+Dynamic::ParameterList *
+CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_create_constant::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
+    
+  CORBA::ULong length_id = parameter_list->length ();
+  parameter_list->length (length_id + 1);
+  (*parameter_list)[length_id].argument <<= id_;
+  (*parameter_list)[length_id].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_name = parameter_list->length ();
+  parameter_list->length (length_name + 1);
+  (*parameter_list)[length_name].argument <<= name_;
+  (*parameter_list)[length_name].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_version = parameter_list->length ();
+  parameter_list->length (length_version + 1);
+  (*parameter_list)[length_version].argument <<= version_;
+  (*parameter_list)[length_version].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_type = parameter_list->length ();
+  parameter_list->length (length_type + 1);
+  (*parameter_list)[length_type].argument <<=  this->type_;
+  
+  (*parameter_list)[length_type].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_value = parameter_list->length ();
+  parameter_list->length (length_value + 1);
+  (*parameter_list)[length_value].argument <<= value_;
+  (*parameter_list)[length_value].mode = Dynamic::PARAM_IN;
+  
+  return safe_parameter_list._retn ();
+}
+
+Dynamic::ExceptionList *
+CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_create_constant::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+void 
+CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_create_constant::result (CORBA::ConstantDef_ptr result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_create_struct::TAO_ClientRequestInfo_CORBA_Container_create_struct (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const char * id,
+    const char * name,
+    const char * version,
+    const CORBA::StructMemberSeq & members,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
+    id_ (id),
+    name_ (name),
+    version_ (version),
+    members_ (members)
+{}
+
+Dynamic::ParameterList *
+CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_create_struct::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
+    
+  CORBA::ULong length_id = parameter_list->length ();
+  parameter_list->length (length_id + 1);
+  (*parameter_list)[length_id].argument <<= id_;
+  (*parameter_list)[length_id].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_name = parameter_list->length ();
+  parameter_list->length (length_name + 1);
+  (*parameter_list)[length_name].argument <<= name_;
+  (*parameter_list)[length_name].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_version = parameter_list->length ();
+  parameter_list->length (length_version + 1);
+  (*parameter_list)[length_version].argument <<= version_;
+  (*parameter_list)[length_version].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_members = parameter_list->length ();
+  parameter_list->length (length_members + 1);
+  (*parameter_list)[length_members].argument <<=  this->members_;
+  
+  (*parameter_list)[length_members].mode = Dynamic::PARAM_IN;
+  
+  return safe_parameter_list._retn ();
+}
+
+Dynamic::ExceptionList *
+CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_create_struct::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+void 
+CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_create_struct::result (CORBA::StructDef_ptr result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_create_union::TAO_ClientRequestInfo_CORBA_Container_create_union (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const char * id,
+    const char * name,
+    const char * version,
+    CORBA::IDLType_ptr discriminator_type,
+    const CORBA::UnionMemberSeq & members,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
+    id_ (id),
+    name_ (name),
+    version_ (version),
+    discriminator_type_ (discriminator_type),
+    members_ (members)
+{}
+
+Dynamic::ParameterList *
+CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_create_union::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
+    
+  CORBA::ULong length_id = parameter_list->length ();
+  parameter_list->length (length_id + 1);
+  (*parameter_list)[length_id].argument <<= id_;
+  (*parameter_list)[length_id].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_name = parameter_list->length ();
+  parameter_list->length (length_name + 1);
+  (*parameter_list)[length_name].argument <<= name_;
+  (*parameter_list)[length_name].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_version = parameter_list->length ();
+  parameter_list->length (length_version + 1);
+  (*parameter_list)[length_version].argument <<= version_;
+  (*parameter_list)[length_version].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_discriminator_type = parameter_list->length ();
+  parameter_list->length (length_discriminator_type + 1);
+  (*parameter_list)[length_discriminator_type].argument <<=  this->discriminator_type_;
+  
+  (*parameter_list)[length_discriminator_type].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_members = parameter_list->length ();
+  parameter_list->length (length_members + 1);
+  (*parameter_list)[length_members].argument <<=  this->members_;
+  
+  (*parameter_list)[length_members].mode = Dynamic::PARAM_IN;
+  
+  return safe_parameter_list._retn ();
+}
+
+Dynamic::ExceptionList *
+CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_create_union::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+void 
+CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_create_union::result (CORBA::UnionDef_ptr result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_create_enum::TAO_ClientRequestInfo_CORBA_Container_create_enum (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const char * id,
+    const char * name,
+    const char * version,
+    const CORBA::EnumMemberSeq & members,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
+    id_ (id),
+    name_ (name),
+    version_ (version),
+    members_ (members)
+{}
+
+Dynamic::ParameterList *
+CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_create_enum::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
+    
+  CORBA::ULong length_id = parameter_list->length ();
+  parameter_list->length (length_id + 1);
+  (*parameter_list)[length_id].argument <<= id_;
+  (*parameter_list)[length_id].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_name = parameter_list->length ();
+  parameter_list->length (length_name + 1);
+  (*parameter_list)[length_name].argument <<= name_;
+  (*parameter_list)[length_name].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_version = parameter_list->length ();
+  parameter_list->length (length_version + 1);
+  (*parameter_list)[length_version].argument <<= version_;
+  (*parameter_list)[length_version].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_members = parameter_list->length ();
+  parameter_list->length (length_members + 1);
+  (*parameter_list)[length_members].argument <<=  this->members_;
+  
+  (*parameter_list)[length_members].mode = Dynamic::PARAM_IN;
+  
+  return safe_parameter_list._retn ();
+}
+
+Dynamic::ExceptionList *
+CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_create_enum::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+void 
+CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_create_enum::result (CORBA::EnumDef_ptr result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_create_alias::TAO_ClientRequestInfo_CORBA_Container_create_alias (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const char * id,
+    const char * name,
+    const char * version,
+    CORBA::IDLType_ptr original_type,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
+    id_ (id),
+    name_ (name),
+    version_ (version),
+    original_type_ (original_type)
+{}
+
+Dynamic::ParameterList *
+CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_create_alias::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
+    
+  CORBA::ULong length_id = parameter_list->length ();
+  parameter_list->length (length_id + 1);
+  (*parameter_list)[length_id].argument <<= id_;
+  (*parameter_list)[length_id].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_name = parameter_list->length ();
+  parameter_list->length (length_name + 1);
+  (*parameter_list)[length_name].argument <<= name_;
+  (*parameter_list)[length_name].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_version = parameter_list->length ();
+  parameter_list->length (length_version + 1);
+  (*parameter_list)[length_version].argument <<= version_;
+  (*parameter_list)[length_version].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_original_type = parameter_list->length ();
+  parameter_list->length (length_original_type + 1);
+  (*parameter_list)[length_original_type].argument <<=  this->original_type_;
+  
+  (*parameter_list)[length_original_type].mode = Dynamic::PARAM_IN;
+  
+  return safe_parameter_list._retn ();
+}
+
+Dynamic::ExceptionList *
+CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_create_alias::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+void 
+CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_create_alias::result (CORBA::AliasDef_ptr result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_create_interface::TAO_ClientRequestInfo_CORBA_Container_create_interface (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const char * id,
+    const char * name,
+    const char * version,
+    const CORBA::InterfaceDefSeq & base_interfaces,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
+    id_ (id),
+    name_ (name),
+    version_ (version),
+    base_interfaces_ (base_interfaces)
+{}
+
+Dynamic::ExceptionList *
+CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_create_interface::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+void 
+CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_create_interface::result (CORBA::InterfaceDef_ptr result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_create_value::TAO_ClientRequestInfo_CORBA_Container_create_value (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const char * id,
+    const char * name,
+    const char * version,
+    const CORBA::Boolean & is_custom,
+    const CORBA::Boolean & is_abstract,
+    CORBA::ValueDef_ptr base_value,
+    const CORBA::Boolean & is_truncatable,
+    const CORBA::ValueDefSeq & abstract_base_values,
+    const CORBA::InterfaceDefSeq & supported_interfaces,
+    const CORBA::InitializerSeq & initializers,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
+    id_ (id),
+    name_ (name),
+    version_ (version),
+    is_custom_ (is_custom),
+    is_abstract_ (is_abstract),
+    base_value_ (base_value),
+    is_truncatable_ (is_truncatable),
+    abstract_base_values_ (abstract_base_values),
+    supported_interfaces_ (supported_interfaces),
+    initializers_ (initializers)
+{}
+
+Dynamic::ExceptionList *
+CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_create_value::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+void 
+CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_create_value::result (CORBA::ValueDef_ptr result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_create_value_box::TAO_ClientRequestInfo_CORBA_Container_create_value_box (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const char * id,
+    const char * name,
+    const char * version,
+    CORBA::IDLType_ptr original_type_def,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
+    id_ (id),
+    name_ (name),
+    version_ (version),
+    original_type_def_ (original_type_def)
+{}
+
+Dynamic::ParameterList *
+CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_create_value_box::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
+    
+  CORBA::ULong length_id = parameter_list->length ();
+  parameter_list->length (length_id + 1);
+  (*parameter_list)[length_id].argument <<= id_;
+  (*parameter_list)[length_id].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_name = parameter_list->length ();
+  parameter_list->length (length_name + 1);
+  (*parameter_list)[length_name].argument <<= name_;
+  (*parameter_list)[length_name].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_version = parameter_list->length ();
+  parameter_list->length (length_version + 1);
+  (*parameter_list)[length_version].argument <<= version_;
+  (*parameter_list)[length_version].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_original_type_def = parameter_list->length ();
+  parameter_list->length (length_original_type_def + 1);
+  (*parameter_list)[length_original_type_def].argument <<=  this->original_type_def_;
+  
+  (*parameter_list)[length_original_type_def].mode = Dynamic::PARAM_IN;
+  
+  return safe_parameter_list._retn ();
+}
+
+Dynamic::ExceptionList *
+CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_create_value_box::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+void 
+CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_create_value_box::result (CORBA::ValueBoxDef_ptr result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_create_exception::TAO_ClientRequestInfo_CORBA_Container_create_exception (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const char * id,
+    const char * name,
+    const char * version,
+    const CORBA::StructMemberSeq & members,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
+    id_ (id),
+    name_ (name),
+    version_ (version),
+    members_ (members)
+{}
+
+Dynamic::ParameterList *
+CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_create_exception::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
+    
+  CORBA::ULong length_id = parameter_list->length ();
+  parameter_list->length (length_id + 1);
+  (*parameter_list)[length_id].argument <<= id_;
+  (*parameter_list)[length_id].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_name = parameter_list->length ();
+  parameter_list->length (length_name + 1);
+  (*parameter_list)[length_name].argument <<= name_;
+  (*parameter_list)[length_name].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_version = parameter_list->length ();
+  parameter_list->length (length_version + 1);
+  (*parameter_list)[length_version].argument <<= version_;
+  (*parameter_list)[length_version].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_members = parameter_list->length ();
+  parameter_list->length (length_members + 1);
+  (*parameter_list)[length_members].argument <<=  this->members_;
+  
+  (*parameter_list)[length_members].mode = Dynamic::PARAM_IN;
+  
+  return safe_parameter_list._retn ();
+}
+
+Dynamic::ExceptionList *
+CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_create_exception::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+void 
+CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_create_exception::result (CORBA::ExceptionDef_ptr result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_create_native::TAO_ClientRequestInfo_CORBA_Container_create_native (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const char * id,
+    const char * name,
+    const char * version,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
+    id_ (id),
+    name_ (name),
+    version_ (version)
+{}
+
+Dynamic::ParameterList *
+CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_create_native::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
+    
+  CORBA::ULong length_id = parameter_list->length ();
+  parameter_list->length (length_id + 1);
+  (*parameter_list)[length_id].argument <<= id_;
+  (*parameter_list)[length_id].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_name = parameter_list->length ();
+  parameter_list->length (length_name + 1);
+  (*parameter_list)[length_name].argument <<= name_;
+  (*parameter_list)[length_name].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_version = parameter_list->length ();
+  parameter_list->length (length_version + 1);
+  (*parameter_list)[length_version].argument <<= version_;
+  (*parameter_list)[length_version].mode = Dynamic::PARAM_IN;
+  
+  return safe_parameter_list._retn ();
+}
+
+Dynamic::ExceptionList *
+CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_create_native::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+void 
+CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_create_native::result (CORBA::NativeDef_ptr result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_create_abstract_interface::TAO_ClientRequestInfo_CORBA_Container_create_abstract_interface (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const char * id,
+    const char * name,
+    const char * version,
+    const CORBA::AbstractInterfaceDefSeq & base_interfaces,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
+    id_ (id),
+    name_ (name),
+    version_ (version),
+    base_interfaces_ (base_interfaces)
+{}
+
+Dynamic::ExceptionList *
+CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_create_abstract_interface::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+void 
+CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_create_abstract_interface::result (CORBA::AbstractInterfaceDef_ptr result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_create_local_interface::TAO_ClientRequestInfo_CORBA_Container_create_local_interface (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const char * id,
+    const char * name,
+    const char * version,
+    const CORBA::InterfaceDefSeq & base_interfaces,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
+    id_ (id),
+    name_ (name),
+    version_ (version),
+    base_interfaces_ (base_interfaces)
+{}
+
+Dynamic::ExceptionList *
+CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_create_local_interface::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+void 
+CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_create_local_interface::result (CORBA::LocalInterfaceDef_ptr result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+#endif /* TAO_HAS_INTERCEPTORS */
+
+///////////////////////////////////////////////////////////////////////
+//                Base & Remote Proxy  Implementation. 
+//
+
+_TAO_IDLType_Proxy_Impl::_TAO_IDLType_Proxy_Impl (void)
+{}
+
+_TAO_IDLType_Remote_Proxy_Impl::_TAO_IDLType_Remote_Proxy_Impl (void)
+{}
+
+// Remote Implementation of the IDL interface methods
+
+CORBA::TypeCode_ptr _TAO_IDLType_Remote_Proxy_Impl::type (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::TypeCode_ptr _tao_retval = CORBA::TypeCode::_nil ();
+  CORBA::TypeCode_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_type",
+      9,
+      0,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::IDLType::TAO_ClientRequestInfo_CORBA_IDLType_type_get ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::TypeCode_ptr _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+
+//
+//            End  Base & Remote  Proxy Implemeentation. 
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//           Remote & Base  Proxy Broker Implementation
+//
+
+_TAO_IDLType_Proxy_Broker::_TAO_IDLType_Proxy_Broker (void)
+{
+}
+
+_TAO_IDLType_Proxy_Broker::~_TAO_IDLType_Proxy_Broker (void)
+{
+}
+
+_TAO_IDLType_Proxy_Broker * (*CORBA__TAO_IDLType_Proxy_Broker_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  ) = 0;
+
+// Factory Member function Implementation.
+_TAO_IDLType_Remote_Proxy_Broker *
+_TAO_IDLType_Remote_Proxy_Broker::the_TAO_IDLType_Remote_Proxy_Broker (void)
+{
+  static ::_TAO_IDLType_Remote_Proxy_Broker remote_proxy_broker;
+  return &remote_proxy_broker;
+}
+
+_TAO_IDLType_Remote_Proxy_Broker::_TAO_IDLType_Remote_Proxy_Broker (void)
+{
+}
+
+_TAO_IDLType_Remote_Proxy_Broker::~_TAO_IDLType_Remote_Proxy_Broker (void)
+{
+}
+
+_TAO_IDLType_Proxy_Impl&
+_TAO_IDLType_Remote_Proxy_Broker::select_proxy (
+  ::CORBA_IDLType *,
+  CORBA::Environment &
+)
+{
+  return this->remote_proxy_impl_;
+}
+
+
+//
+//           End Remote & Base Proxy Broker Implementation
+///////////////////////////////////////////////////////////////////////
+
+
+// default constructor
+CORBA::IDLType::IDLType (int collocated)
+{
+  this->CORBA_IDLType_setup_collocation (collocated);
+}
+
+// destructor
+CORBA::IDLType::~IDLType (void)
+{}
+
+void
+CORBA::IDLType::CORBA_IDLType_setup_collocation (int collocated)
+{
+  if (collocated)
+    this->the_TAO_IDLType_Proxy_Broker_ =
+      ::CORBA__TAO_IDLType_Proxy_Broker_Factory_function_pointer (this);
+  else
+    this->the_TAO_IDLType_Proxy_Broker_ =
+      ::_TAO_IDLType_Remote_Proxy_Broker::the_TAO_IDLType_Remote_Proxy_Broker ();
+  
+  this->CORBA_IRObject_setup_collocation (collocated);
+}
+
+void CORBA::IDLType::_tao_any_destructor (void *x)
+{
+  CORBA_IDLType *tmp = ACE_static_cast (CORBA_IDLType*,x);
+  CORBA::release (tmp);
+}
+
+CORBA::IDLType_ptr CORBA::IDLType::_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+{
+  if (CORBA::is_nil (obj))
+    return CORBA::IDLType::_nil ();
+  if (! obj->_is_local ())
+    {
+      CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/CORBA/IDLType:1.0", ACE_TRY_ENV);
+      ACE_CHECK_RETURN (CORBA::IDLType::_nil ());
+      if (is_a == 0)
+        return CORBA::IDLType::_nil ();
+    }
+  return CORBA::IDLType::_unchecked_narrow (obj, ACE_TRY_ENV);
+}
+
+CORBA::IDLType_ptr CORBA::IDLType::_unchecked_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &
+  )
+{
+  if (CORBA::is_nil (obj))
+    return CORBA::IDLType::_nil ();
+  if (! obj->_is_local ())
+    {
+      TAO_Stub* stub = obj->_stubobj ();
+      if (stub)
+        stub->_incr_refcnt ();
+      CORBA::IDLType_ptr default_proxy = CORBA::IDLType::_nil ();
+
+      if (
+          !CORBA::is_nil (stub->servant_orb_var ().ptr ()) &&
+          stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects () &&
+          obj->_is_collocated () &&CORBA__TAO_IDLType_Proxy_Broker_Factory_function_pointer != 0
+        )
+      {
+        ACE_NEW_RETURN (
+          default_proxy,
+          ::CORBA::IDLType (
+            stub,
+            1,
+            obj->_servant ()),
+            
+          CORBA::IDLType::_nil ());
+        }
+      if (CORBA::is_nil (default_proxy))
+        ACE_NEW_RETURN (default_proxy, ::CORBA::IDLType (stub, 0, obj->_servant ()), CORBA::IDLType::_nil ());
+        return default_proxy;
+      }
+    else 
+      return
+        ACE_reinterpret_cast
+          (
+            CORBA_IDLType_ptr,
+              obj->_tao_QueryInterface
+                (
+                  ACE_reinterpret_cast
+                    (
+                      ptr_arith_t,
+                      &CORBA_IDLType::_narrow
+                    )
+                )
+          );
+}
+
+CORBA::IDLType_ptr
+CORBA::IDLType::_duplicate (CORBA::IDLType_ptr obj)
+{
+  if (!CORBA::is_nil (obj))
+    obj->_add_ref ();
+  return obj;
+}
+
+CORBA::Boolean CORBA::IDLType::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
+{
+  if (
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IDLType:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
+  return 1; // success using local knowledge
+  else
+    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
+}
+
+void *CORBA::IDLType::_tao_QueryInterface (ptr_arith_t type)
+{
+  void *retv = 0;
+  if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      CORBA_IDLType::_narrow))
+    retv = ACE_reinterpret_cast (void*, this);
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      CORBA_IRObject::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::IRObject_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
+    retv = ACE_reinterpret_cast (void *,
+      ACE_static_cast (CORBA::Object_ptr, this));
+    
+  if (retv)
+    this->_add_ref ();
+  return retv;
+}
+
+const char* CORBA::IDLType::_interface_repository_id (void) const
+{
+  return "IDL:omg.org/CORBA/IDLType:1.0";
+}
+
+CORBA::TypeCode_ptr CORBA::IDLType::type (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_IDLType_Proxy_Impl &proxy = 
+    this->the_TAO_IDLType_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.type (
+      this,
+      ACE_TRY_ENV
+    );
+}
+
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+CORBA::IDLType::TAO_ClientRequestInfo_CORBA_IDLType_type_get::TAO_ClientRequestInfo_CORBA_IDLType_type_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
+{}
+
+Dynamic::ParameterList *
+CORBA::IDLType::TAO_ClientRequestInfo_CORBA_IDLType_type_get::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return parameter_list;
+}
+
+Dynamic::ExceptionList *
+CORBA::IDLType::TAO_ClientRequestInfo_CORBA_IDLType_type_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::IDLType::TAO_ClientRequestInfo_CORBA_IDLType_type_get::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+CORBA::IDLType::TAO_ClientRequestInfo_CORBA_IDLType_type_get::result (CORBA::TypeCode_ptr result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+#endif /* TAO_HAS_INTERCEPTORS */
+
+///////////////////////////////////////////////////////////////////////
+//                Base & Remote Proxy  Implementation. 
+//
+
+_TAO_TypedefDef_Proxy_Impl::_TAO_TypedefDef_Proxy_Impl (void)
+{}
+
+_TAO_TypedefDef_Remote_Proxy_Impl::_TAO_TypedefDef_Remote_Proxy_Impl (void)
+{}
+
+// Remote Implementation of the IDL interface methods
+
+
+//
+//            End  Base & Remote  Proxy Implemeentation. 
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//           Remote & Base  Proxy Broker Implementation
+//
+
+_TAO_TypedefDef_Proxy_Broker::_TAO_TypedefDef_Proxy_Broker (void)
+{
+}
+
+_TAO_TypedefDef_Proxy_Broker::~_TAO_TypedefDef_Proxy_Broker (void)
+{
+}
+
+_TAO_TypedefDef_Proxy_Broker * (*CORBA__TAO_TypedefDef_Proxy_Broker_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  ) = 0;
+
+// Factory Member function Implementation.
+_TAO_TypedefDef_Remote_Proxy_Broker *
+_TAO_TypedefDef_Remote_Proxy_Broker::the_TAO_TypedefDef_Remote_Proxy_Broker (void)
+{
+  static ::_TAO_TypedefDef_Remote_Proxy_Broker remote_proxy_broker;
+  return &remote_proxy_broker;
+}
+
+_TAO_TypedefDef_Remote_Proxy_Broker::_TAO_TypedefDef_Remote_Proxy_Broker (void)
+{
+}
+
+_TAO_TypedefDef_Remote_Proxy_Broker::~_TAO_TypedefDef_Remote_Proxy_Broker (void)
+{
+}
+
+_TAO_TypedefDef_Proxy_Impl&
+_TAO_TypedefDef_Remote_Proxy_Broker::select_proxy (
+  ::CORBA_TypedefDef *,
+  CORBA::Environment &
+)
+{
+  return this->remote_proxy_impl_;
+}
+
+
+//
+//           End Remote & Base Proxy Broker Implementation
+///////////////////////////////////////////////////////////////////////
+
+
+// default constructor
+CORBA::TypedefDef::TypedefDef (int collocated)
+{
+  this->CORBA_TypedefDef_setup_collocation (collocated);
+}
+
+// destructor
+CORBA::TypedefDef::~TypedefDef (void)
+{}
+
+void
+CORBA::TypedefDef::CORBA_TypedefDef_setup_collocation (int collocated)
+{
+  if (collocated)
+    this->the_TAO_TypedefDef_Proxy_Broker_ =
+      ::CORBA__TAO_TypedefDef_Proxy_Broker_Factory_function_pointer (this);
+  else
+    this->the_TAO_TypedefDef_Proxy_Broker_ =
+      ::_TAO_TypedefDef_Remote_Proxy_Broker::the_TAO_TypedefDef_Remote_Proxy_Broker ();
+  
+  this->CORBA_Contained_setup_collocation (collocated);
+  
+  this->CORBA_IDLType_setup_collocation (collocated);
+}
+
+void CORBA::TypedefDef::_tao_any_destructor (void *x)
+{
+  CORBA_TypedefDef *tmp = ACE_static_cast (CORBA_TypedefDef*,x);
+  CORBA::release (tmp);
+}
+
+CORBA::TypedefDef_ptr CORBA::TypedefDef::_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+{
+  if (CORBA::is_nil (obj))
+    return CORBA::TypedefDef::_nil ();
+  if (! obj->_is_local ())
+    {
+      CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/CORBA/TypedefDef:1.0", ACE_TRY_ENV);
+      ACE_CHECK_RETURN (CORBA::TypedefDef::_nil ());
+      if (is_a == 0)
+        return CORBA::TypedefDef::_nil ();
+    }
+  return CORBA::TypedefDef::_unchecked_narrow (obj, ACE_TRY_ENV);
+}
+
+CORBA::TypedefDef_ptr CORBA::TypedefDef::_unchecked_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &
+  )
+{
+  if (CORBA::is_nil (obj))
+    return CORBA::TypedefDef::_nil ();
+  if (! obj->_is_local ())
+    {
+      TAO_Stub* stub = obj->_stubobj ();
+      if (stub)
+        stub->_incr_refcnt ();
+      CORBA::TypedefDef_ptr default_proxy = CORBA::TypedefDef::_nil ();
+
+      if (
+          !CORBA::is_nil (stub->servant_orb_var ().ptr ()) &&
+          stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects () &&
+          obj->_is_collocated () &&CORBA__TAO_TypedefDef_Proxy_Broker_Factory_function_pointer != 0
+        )
+      {
+        ACE_NEW_RETURN (
+          default_proxy,
+          ::CORBA::TypedefDef (
+            stub,
+            1,
+            obj->_servant ()),
+            
+          CORBA::TypedefDef::_nil ());
+        }
+      if (CORBA::is_nil (default_proxy))
+        ACE_NEW_RETURN (default_proxy, ::CORBA::TypedefDef (stub, 0, obj->_servant ()), CORBA::TypedefDef::_nil ());
+        return default_proxy;
+      }
+    else 
+      return
+        ACE_reinterpret_cast
+          (
+            CORBA_TypedefDef_ptr,
+              obj->_tao_QueryInterface
+                (
+                  ACE_reinterpret_cast
+                    (
+                      ptr_arith_t,
+                      &CORBA_TypedefDef::_narrow
+                    )
+                )
+          );
+}
+
+CORBA::TypedefDef_ptr
+CORBA::TypedefDef::_duplicate (CORBA::TypedefDef_ptr obj)
+{
+  if (!CORBA::is_nil (obj))
+    obj->_add_ref ();
+  return obj;
+}
+
+CORBA::Boolean CORBA::TypedefDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
+{
+  if (
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/TypedefDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Contained:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IDLType:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
+  return 1; // success using local knowledge
+  else
+    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
+}
+
+void *CORBA::TypedefDef::_tao_QueryInterface (ptr_arith_t type)
+{
+  void *retv = 0;
+  if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      CORBA_TypedefDef::_narrow))
+    retv = ACE_reinterpret_cast (void*, this);
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      CORBA_Contained::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::Contained_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      CORBA_IDLType::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::IDLType_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      CORBA_IRObject::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::IRObject_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
+    retv = ACE_reinterpret_cast (void *,
+      ACE_static_cast (CORBA::Object_ptr, this));
+    
+  if (retv)
+    this->_add_ref ();
+  return retv;
+}
+
+const char* CORBA::TypedefDef::_interface_repository_id (void) const
+{
+  return "IDL:omg.org/CORBA/TypedefDef:1.0";
+}
+
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+#endif /* TAO_HAS_INTERCEPTORS */
+
+void CORBA::TypeDescription::_tao_any_destructor (void *x)
+{
+  CORBA_TypeDescription *tmp = ACE_static_cast (CORBA_TypeDescription*,x);
+  delete tmp;
+}
+
+void operator<<= (CORBA::Any &_tao_any, CORBA::DefinitionKind _tao_elem)
+{
+  TAO_OutputCDR stream;
+  stream << _tao_elem;
+  _tao_any._tao_replace (
+      CORBA::_tc_DefinitionKind,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin ()
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::DefinitionKind &_tao_elem)
+{
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (CORBA::_tc_DefinitionKind, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    TAO_InputCDR stream (
+        _tao_any._tao_get_cdr (),
+        _tao_any._tao_byte_order ()
+      );
+    if (stream >> _tao_elem)
+    {
+      return 1;
+    }
+  }
+  ACE_CATCHANY
+  {
+    return 0;
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+void operator<<= (CORBA::Any &_tao_any, CORBA::IRObject_ptr _tao_elem)
+{
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        CORBA::_tc_IRObject, 
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin (),
+        1,
+        CORBA::IRObject::_duplicate (_tao_elem),
+        CORBA::IRObject::_tao_any_destructor
+      );
+  }
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::IRObject_ptr &_tao_elem)
+{
+  ACE_TRY_NEW_ENV
+  {
+    _tao_elem = CORBA::IRObject::_nil ();
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (CORBA::_tc_IRObject, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    TAO_InputCDR stream (
+        _tao_any._tao_get_cdr (),
+        _tao_any._tao_byte_order ()
+      );
+    if (stream >> _tao_elem)
+    {
+      ((CORBA::Any *)&_tao_any)->_tao_replace (
+          CORBA::_tc_IRObject,
+          1,
+          _tao_elem,
+          CORBA::IRObject::_tao_any_destructor
+        );
+      return 1;
+    }
+  }
+  ACE_CATCHANY
+  {
+    _tao_elem = CORBA::IRObject::_nil ();
+    return 0;
+  }
+  ACE_ENDTRY;
+  _tao_elem = CORBA::IRObject::_nil ();
+  return 0;
+}
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
+    defined (ACE_HAS_GNU_REPO)
+    template class TAO_Object_Manager<CORBA::IRObject,CORBA::IRObject_var>;
+  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+  #  pragma instantiate TAO_Object_Manager<CORBA::IRObject,CORBA::IRObject_var>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+void operator<<= (CORBA::Any &_tao_any, CORBA::Contained_ptr _tao_elem)
+{
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        CORBA::_tc_Contained, 
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin (),
+        1,
+        CORBA::Contained::_duplicate (_tao_elem),
+        CORBA::Contained::_tao_any_destructor
+      );
+  }
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::Contained_ptr &_tao_elem)
+{
+  ACE_TRY_NEW_ENV
+  {
+    _tao_elem = CORBA::Contained::_nil ();
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (CORBA::_tc_Contained, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    TAO_InputCDR stream (
+        _tao_any._tao_get_cdr (),
+        _tao_any._tao_byte_order ()
+      );
+    if (stream >> _tao_elem)
+    {
+      ((CORBA::Any *)&_tao_any)->_tao_replace (
+          CORBA::_tc_Contained,
+          1,
+          _tao_elem,
+          CORBA::Contained::_tao_any_destructor
+        );
+      return 1;
+    }
+  }
+  ACE_CATCHANY
+  {
+    _tao_elem = CORBA::Contained::_nil ();
+    return 0;
+  }
+  ACE_ENDTRY;
+  _tao_elem = CORBA::Contained::_nil ();
+  return 0;
+}
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
+    defined (ACE_HAS_GNU_REPO)
+    template class TAO_Object_Manager<CORBA::Contained,CORBA::Contained_var>;
+  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+  #  pragma instantiate TAO_Object_Manager<CORBA::Contained,CORBA::Contained_var>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+void operator<<= (CORBA::Any &_tao_any, const CORBA::Contained::Description &_tao_elem) // copying
+{
+  TAO_OutputCDR stream;
+  stream << _tao_elem;
+  _tao_any._tao_replace (
+      CORBA::Contained::_tc_Description,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin ()
+    );
+}
+
+void operator<<= (CORBA::Any &_tao_any, CORBA::Contained::Description *_tao_elem) // non copying
+{
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      CORBA::Contained::_tc_Description,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      CORBA::Contained::Description::_tao_any_destructor
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::Contained::Description *&_tao_elem)
+{
+  return _tao_any >>= ACE_const_cast(const CORBA::Contained::Description*&,_tao_elem);
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::Contained::Description *&_tao_elem)
+{
+  _tao_elem = 0;
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (CORBA::Contained::_tc_Description, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    if (_tao_any.any_owns_data ())
+    {
+      _tao_elem = ACE_static_cast(
+          const CORBA::Contained::Description*,
+          _tao_any.value ()
+        );
+      return 1;
+    }
+    else
+    {
+      CORBA::Contained::Description *tmp;
+      ACE_NEW_RETURN (tmp, CORBA::Contained::Description, 0);
+      TAO_InputCDR stream (
+          _tao_any._tao_get_cdr (),
+          _tao_any._tao_byte_order ()
+        );
+      if (stream >> *tmp)
+      {
+        ((CORBA::Any *)&_tao_any)->_tao_replace (
+            CORBA::Contained::_tc_Description,
+            1,
+            ACE_static_cast (void *, tmp),
+            CORBA::Contained::Description::_tao_any_destructor
+          );
+        _tao_elem = tmp;
+        return 1;
+      }
+      else
+      {
+        delete tmp;
+      }
+    }
+  }
+  ACE_CATCHANY
+  {
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+void operator<<= (
+    CORBA::Any &_tao_any,
+    const CORBA::ContainedSeq &_tao_elem
+  ) // copying
+{
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        CORBA::_tc_ContainedSeq,
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin ()
+      );
+  }
+}
+
+void operator<<= (CORBA::Any &_tao_any, CORBA::ContainedSeq *_tao_elem) // non copying
+{
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      CORBA::_tc_ContainedSeq,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      CORBA::ContainedSeq::_tao_any_destructor
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ContainedSeq *&_tao_elem)
+{
+  return _tao_any >>= ACE_const_cast(
+      const CORBA::ContainedSeq*&,
+      _tao_elem
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::ContainedSeq *&_tao_elem)
+{
+  _tao_elem = 0;
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (CORBA::_tc_ContainedSeq, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    if (_tao_any.any_owns_data ())
+    {
+      _tao_elem = ACE_static_cast(
+          const CORBA::ContainedSeq*,
+          _tao_any.value ()
+        );
+      return 1;
+    }
+    else
+    {
+      CORBA::ContainedSeq *tmp;
+      ACE_NEW_RETURN (tmp, CORBA::ContainedSeq, 0);
+      TAO_InputCDR stream (
+          _tao_any._tao_get_cdr (),
+          _tao_any._tao_byte_order ()
+        );
+      if (stream >> *tmp)
+      {
+        ((CORBA::Any *)&_tao_any)->_tao_replace (
+            CORBA::_tc_ContainedSeq,
+            1,
+            ACE_static_cast (void *, tmp),
+            CORBA::ContainedSeq::_tao_any_destructor
+          );
+        _tao_elem = tmp;
+        return 1;
+      }
+      else
+      {
+        delete tmp;
+      }
+    }
+  }
+  ACE_CATCHANY
+  {
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+void operator<<= (CORBA::Any &_tao_any, const CORBA::StructMember &_tao_elem) // copying
+{
+  TAO_OutputCDR stream;
+  stream << _tao_elem;
+  _tao_any._tao_replace (
+      CORBA::_tc_StructMember,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin ()
+    );
+}
+
+void operator<<= (CORBA::Any &_tao_any, CORBA::StructMember *_tao_elem) // non copying
+{
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      CORBA::_tc_StructMember,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      CORBA::StructMember::_tao_any_destructor
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::StructMember *&_tao_elem)
+{
+  return _tao_any >>= ACE_const_cast(const CORBA::StructMember*&,_tao_elem);
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::StructMember *&_tao_elem)
+{
+  _tao_elem = 0;
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (CORBA::_tc_StructMember, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    if (_tao_any.any_owns_data ())
+    {
+      _tao_elem = ACE_static_cast(
+          const CORBA::StructMember*,
+          _tao_any.value ()
+        );
+      return 1;
+    }
+    else
+    {
+      CORBA::StructMember *tmp;
+      ACE_NEW_RETURN (tmp, CORBA::StructMember, 0);
+      TAO_InputCDR stream (
+          _tao_any._tao_get_cdr (),
+          _tao_any._tao_byte_order ()
+        );
+      if (stream >> *tmp)
+      {
+        ((CORBA::Any *)&_tao_any)->_tao_replace (
+            CORBA::_tc_StructMember,
+            1,
+            ACE_static_cast (void *, tmp),
+            CORBA::StructMember::_tao_any_destructor
+          );
+        _tao_elem = tmp;
+        return 1;
+      }
+      else
+      {
+        delete tmp;
+      }
+    }
+  }
+  ACE_CATCHANY
+  {
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+void operator<<= (
+    CORBA::Any &_tao_any,
+    const CORBA::StructMemberSeq &_tao_elem
+  ) // copying
+{
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        CORBA::_tc_StructMemberSeq,
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin ()
+      );
+  }
+}
+
+void operator<<= (CORBA::Any &_tao_any, CORBA::StructMemberSeq *_tao_elem) // non copying
+{
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      CORBA::_tc_StructMemberSeq,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      CORBA::StructMemberSeq::_tao_any_destructor
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::StructMemberSeq *&_tao_elem)
+{
+  return _tao_any >>= ACE_const_cast(
+      const CORBA::StructMemberSeq*&,
+      _tao_elem
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::StructMemberSeq *&_tao_elem)
+{
+  _tao_elem = 0;
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (CORBA::_tc_StructMemberSeq, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    if (_tao_any.any_owns_data ())
+    {
+      _tao_elem = ACE_static_cast(
+          const CORBA::StructMemberSeq*,
+          _tao_any.value ()
+        );
+      return 1;
+    }
+    else
+    {
+      CORBA::StructMemberSeq *tmp;
+      ACE_NEW_RETURN (tmp, CORBA::StructMemberSeq, 0);
+      TAO_InputCDR stream (
+          _tao_any._tao_get_cdr (),
+          _tao_any._tao_byte_order ()
+        );
+      if (stream >> *tmp)
+      {
+        ((CORBA::Any *)&_tao_any)->_tao_replace (
+            CORBA::_tc_StructMemberSeq,
+            1,
+            ACE_static_cast (void *, tmp),
+            CORBA::StructMemberSeq::_tao_any_destructor
+          );
+        _tao_elem = tmp;
+        return 1;
+      }
+      else
+      {
+        delete tmp;
+      }
+    }
+  }
+  ACE_CATCHANY
+  {
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+void operator<<= (CORBA::Any &_tao_any, const CORBA::Initializer &_tao_elem) // copying
+{
+  TAO_OutputCDR stream;
+  stream << _tao_elem;
+  _tao_any._tao_replace (
+      CORBA::_tc_Initializer,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin ()
+    );
+}
+
+void operator<<= (CORBA::Any &_tao_any, CORBA::Initializer *_tao_elem) // non copying
+{
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      CORBA::_tc_Initializer,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      CORBA::Initializer::_tao_any_destructor
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::Initializer *&_tao_elem)
+{
+  return _tao_any >>= ACE_const_cast(const CORBA::Initializer*&,_tao_elem);
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::Initializer *&_tao_elem)
+{
+  _tao_elem = 0;
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (CORBA::_tc_Initializer, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    if (_tao_any.any_owns_data ())
+    {
+      _tao_elem = ACE_static_cast(
+          const CORBA::Initializer*,
+          _tao_any.value ()
+        );
+      return 1;
+    }
+    else
+    {
+      CORBA::Initializer *tmp;
+      ACE_NEW_RETURN (tmp, CORBA::Initializer, 0);
+      TAO_InputCDR stream (
+          _tao_any._tao_get_cdr (),
+          _tao_any._tao_byte_order ()
+        );
+      if (stream >> *tmp)
+      {
+        ((CORBA::Any *)&_tao_any)->_tao_replace (
+            CORBA::_tc_Initializer,
+            1,
+            ACE_static_cast (void *, tmp),
+            CORBA::Initializer::_tao_any_destructor
+          );
+        _tao_elem = tmp;
+        return 1;
+      }
+      else
+      {
+        delete tmp;
+      }
+    }
+  }
+  ACE_CATCHANY
+  {
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+void operator<<= (
+    CORBA::Any &_tao_any,
+    const CORBA::InitializerSeq &_tao_elem
+  ) // copying
+{
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        CORBA::_tc_InitializerSeq,
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin ()
+      );
+  }
+}
+
+void operator<<= (CORBA::Any &_tao_any, CORBA::InitializerSeq *_tao_elem) // non copying
+{
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      CORBA::_tc_InitializerSeq,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      CORBA::InitializerSeq::_tao_any_destructor
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::InitializerSeq *&_tao_elem)
+{
+  return _tao_any >>= ACE_const_cast(
+      const CORBA::InitializerSeq*&,
+      _tao_elem
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::InitializerSeq *&_tao_elem)
+{
+  _tao_elem = 0;
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (CORBA::_tc_InitializerSeq, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    if (_tao_any.any_owns_data ())
+    {
+      _tao_elem = ACE_static_cast(
+          const CORBA::InitializerSeq*,
+          _tao_any.value ()
+        );
+      return 1;
+    }
+    else
+    {
+      CORBA::InitializerSeq *tmp;
+      ACE_NEW_RETURN (tmp, CORBA::InitializerSeq, 0);
+      TAO_InputCDR stream (
+          _tao_any._tao_get_cdr (),
+          _tao_any._tao_byte_order ()
+        );
+      if (stream >> *tmp)
+      {
+        ((CORBA::Any *)&_tao_any)->_tao_replace (
+            CORBA::_tc_InitializerSeq,
+            1,
+            ACE_static_cast (void *, tmp),
+            CORBA::InitializerSeq::_tao_any_destructor
+          );
+        _tao_elem = tmp;
+        return 1;
+      }
+      else
+      {
+        delete tmp;
+      }
+    }
+  }
+  ACE_CATCHANY
+  {
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+void operator<<= (CORBA::Any &_tao_any, const CORBA::UnionMember &_tao_elem) // copying
+{
+  TAO_OutputCDR stream;
+  stream << _tao_elem;
+  _tao_any._tao_replace (
+      CORBA::_tc_UnionMember,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin ()
+    );
+}
+
+void operator<<= (CORBA::Any &_tao_any, CORBA::UnionMember *_tao_elem) // non copying
+{
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      CORBA::_tc_UnionMember,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      CORBA::UnionMember::_tao_any_destructor
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::UnionMember *&_tao_elem)
+{
+  return _tao_any >>= ACE_const_cast(const CORBA::UnionMember*&,_tao_elem);
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::UnionMember *&_tao_elem)
+{
+  _tao_elem = 0;
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (CORBA::_tc_UnionMember, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    if (_tao_any.any_owns_data ())
+    {
+      _tao_elem = ACE_static_cast(
+          const CORBA::UnionMember*,
+          _tao_any.value ()
+        );
+      return 1;
+    }
+    else
+    {
+      CORBA::UnionMember *tmp;
+      ACE_NEW_RETURN (tmp, CORBA::UnionMember, 0);
+      TAO_InputCDR stream (
+          _tao_any._tao_get_cdr (),
+          _tao_any._tao_byte_order ()
+        );
+      if (stream >> *tmp)
+      {
+        ((CORBA::Any *)&_tao_any)->_tao_replace (
+            CORBA::_tc_UnionMember,
+            1,
+            ACE_static_cast (void *, tmp),
+            CORBA::UnionMember::_tao_any_destructor
+          );
+        _tao_elem = tmp;
+        return 1;
+      }
+      else
+      {
+        delete tmp;
+      }
+    }
+  }
+  ACE_CATCHANY
+  {
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+void operator<<= (
+    CORBA::Any &_tao_any,
+    const CORBA::UnionMemberSeq &_tao_elem
+  ) // copying
+{
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        CORBA::_tc_UnionMemberSeq,
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin ()
+      );
+  }
+}
+
+void operator<<= (CORBA::Any &_tao_any, CORBA::UnionMemberSeq *_tao_elem) // non copying
+{
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      CORBA::_tc_UnionMemberSeq,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      CORBA::UnionMemberSeq::_tao_any_destructor
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::UnionMemberSeq *&_tao_elem)
+{
+  return _tao_any >>= ACE_const_cast(
+      const CORBA::UnionMemberSeq*&,
+      _tao_elem
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::UnionMemberSeq *&_tao_elem)
+{
+  _tao_elem = 0;
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (CORBA::_tc_UnionMemberSeq, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    if (_tao_any.any_owns_data ())
+    {
+      _tao_elem = ACE_static_cast(
+          const CORBA::UnionMemberSeq*,
+          _tao_any.value ()
+        );
+      return 1;
+    }
+    else
+    {
+      CORBA::UnionMemberSeq *tmp;
+      ACE_NEW_RETURN (tmp, CORBA::UnionMemberSeq, 0);
+      TAO_InputCDR stream (
+          _tao_any._tao_get_cdr (),
+          _tao_any._tao_byte_order ()
+        );
+      if (stream >> *tmp)
+      {
+        ((CORBA::Any *)&_tao_any)->_tao_replace (
+            CORBA::_tc_UnionMemberSeq,
+            1,
+            ACE_static_cast (void *, tmp),
+            CORBA::UnionMemberSeq::_tao_any_destructor
+          );
+        _tao_elem = tmp;
+        return 1;
+      }
+      else
+      {
+        delete tmp;
+      }
+    }
+  }
+  ACE_CATCHANY
+  {
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+void operator<<= (
+    CORBA::Any &_tao_any,
+    const CORBA::EnumMemberSeq &_tao_elem
+  ) // copying
+{
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        CORBA::_tc_EnumMemberSeq,
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin ()
+      );
+  }
+}
+
+void operator<<= (CORBA::Any &_tao_any, CORBA::EnumMemberSeq *_tao_elem) // non copying
+{
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      CORBA::_tc_EnumMemberSeq,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      CORBA::EnumMemberSeq::_tao_any_destructor
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::EnumMemberSeq *&_tao_elem)
+{
+  return _tao_any >>= ACE_const_cast(
+      const CORBA::EnumMemberSeq*&,
+      _tao_elem
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::EnumMemberSeq *&_tao_elem)
+{
+  _tao_elem = 0;
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (CORBA::_tc_EnumMemberSeq, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    if (_tao_any.any_owns_data ())
+    {
+      _tao_elem = ACE_static_cast(
+          const CORBA::EnumMemberSeq*,
+          _tao_any.value ()
+        );
+      return 1;
+    }
+    else
+    {
+      CORBA::EnumMemberSeq *tmp;
+      ACE_NEW_RETURN (tmp, CORBA::EnumMemberSeq, 0);
+      TAO_InputCDR stream (
+          _tao_any._tao_get_cdr (),
+          _tao_any._tao_byte_order ()
+        );
+      if (stream >> *tmp)
+      {
+        ((CORBA::Any *)&_tao_any)->_tao_replace (
+            CORBA::_tc_EnumMemberSeq,
+            1,
+            ACE_static_cast (void *, tmp),
+            CORBA::EnumMemberSeq::_tao_any_destructor
+          );
+        _tao_elem = tmp;
+        return 1;
+      }
+      else
+      {
+        delete tmp;
+      }
+    }
+  }
+  ACE_CATCHANY
+  {
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+void operator<<= (CORBA::Any &_tao_any, CORBA::Container_ptr _tao_elem)
+{
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        CORBA::_tc_Container, 
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin (),
+        1,
+        CORBA::Container::_duplicate (_tao_elem),
+        CORBA::Container::_tao_any_destructor
+      );
+  }
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::Container_ptr &_tao_elem)
+{
+  ACE_TRY_NEW_ENV
+  {
+    _tao_elem = CORBA::Container::_nil ();
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (CORBA::_tc_Container, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    TAO_InputCDR stream (
+        _tao_any._tao_get_cdr (),
+        _tao_any._tao_byte_order ()
+      );
+    if (stream >> _tao_elem)
+    {
+      ((CORBA::Any *)&_tao_any)->_tao_replace (
+          CORBA::_tc_Container,
+          1,
+          _tao_elem,
+          CORBA::Container::_tao_any_destructor
+        );
+      return 1;
+    }
+  }
+  ACE_CATCHANY
+  {
+    _tao_elem = CORBA::Container::_nil ();
+    return 0;
+  }
+  ACE_ENDTRY;
+  _tao_elem = CORBA::Container::_nil ();
+  return 0;
+}
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
+    defined (ACE_HAS_GNU_REPO)
+    template class TAO_Object_Manager<CORBA::Container,CORBA::Container_var>;
+  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+  #  pragma instantiate TAO_Object_Manager<CORBA::Container,CORBA::Container_var>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+void operator<<= (CORBA::Any &_tao_any, const CORBA::Container::Description &_tao_elem) // copying
+{
+  TAO_OutputCDR stream;
+  stream << _tao_elem;
+  _tao_any._tao_replace (
+      CORBA::Container::_tc_Description,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin ()
+    );
+}
+
+void operator<<= (CORBA::Any &_tao_any, CORBA::Container::Description *_tao_elem) // non copying
+{
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      CORBA::Container::_tc_Description,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      CORBA::Container::Description::_tao_any_destructor
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::Container::Description *&_tao_elem)
+{
+  return _tao_any >>= ACE_const_cast(const CORBA::Container::Description*&,_tao_elem);
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::Container::Description *&_tao_elem)
+{
+  _tao_elem = 0;
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (CORBA::Container::_tc_Description, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    if (_tao_any.any_owns_data ())
+    {
+      _tao_elem = ACE_static_cast(
+          const CORBA::Container::Description*,
+          _tao_any.value ()
+        );
+      return 1;
+    }
+    else
+    {
+      CORBA::Container::Description *tmp;
+      ACE_NEW_RETURN (tmp, CORBA::Container::Description, 0);
+      TAO_InputCDR stream (
+          _tao_any._tao_get_cdr (),
+          _tao_any._tao_byte_order ()
+        );
+      if (stream >> *tmp)
+      {
+        ((CORBA::Any *)&_tao_any)->_tao_replace (
+            CORBA::Container::_tc_Description,
+            1,
+            ACE_static_cast (void *, tmp),
+            CORBA::Container::Description::_tao_any_destructor
+          );
+        _tao_elem = tmp;
+        return 1;
+      }
+      else
+      {
+        delete tmp;
+      }
+    }
+  }
+  ACE_CATCHANY
+  {
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+void operator<<= (
+    CORBA::Any &_tao_any,
+    const CORBA::Container::DescriptionSeq &_tao_elem
+  ) // copying
+{
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        CORBA::Container::_tc_DescriptionSeq,
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin ()
+      );
+  }
+}
+
+void operator<<= (CORBA::Any &_tao_any, CORBA::Container::DescriptionSeq *_tao_elem) // non copying
+{
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      CORBA::Container::_tc_DescriptionSeq,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      CORBA::Container::DescriptionSeq::_tao_any_destructor
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::Container::DescriptionSeq *&_tao_elem)
+{
+  return _tao_any >>= ACE_const_cast(
+      const CORBA::Container::DescriptionSeq*&,
+      _tao_elem
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::Container::DescriptionSeq *&_tao_elem)
+{
+  _tao_elem = 0;
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (CORBA::Container::_tc_DescriptionSeq, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    if (_tao_any.any_owns_data ())
+    {
+      _tao_elem = ACE_static_cast(
+          const CORBA::Container::DescriptionSeq*,
+          _tao_any.value ()
+        );
+      return 1;
+    }
+    else
+    {
+      CORBA::Container::DescriptionSeq *tmp;
+      ACE_NEW_RETURN (tmp, CORBA::Container::DescriptionSeq, 0);
+      TAO_InputCDR stream (
+          _tao_any._tao_get_cdr (),
+          _tao_any._tao_byte_order ()
+        );
+      if (stream >> *tmp)
+      {
+        ((CORBA::Any *)&_tao_any)->_tao_replace (
+            CORBA::Container::_tc_DescriptionSeq,
+            1,
+            ACE_static_cast (void *, tmp),
+            CORBA::Container::DescriptionSeq::_tao_any_destructor
+          );
+        _tao_elem = tmp;
+        return 1;
+      }
+      else
+      {
+        delete tmp;
+      }
+    }
+  }
+  ACE_CATCHANY
+  {
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+void operator<<= (CORBA::Any &_tao_any, CORBA::IDLType_ptr _tao_elem)
+{
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        CORBA::_tc_IDLType, 
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin (),
+        1,
+        CORBA::IDLType::_duplicate (_tao_elem),
+        CORBA::IDLType::_tao_any_destructor
+      );
+  }
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::IDLType_ptr &_tao_elem)
+{
+  ACE_TRY_NEW_ENV
+  {
+    _tao_elem = CORBA::IDLType::_nil ();
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (CORBA::_tc_IDLType, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    TAO_InputCDR stream (
+        _tao_any._tao_get_cdr (),
+        _tao_any._tao_byte_order ()
+      );
+    if (stream >> _tao_elem)
+    {
+      ((CORBA::Any *)&_tao_any)->_tao_replace (
+          CORBA::_tc_IDLType,
+          1,
+          _tao_elem,
+          CORBA::IDLType::_tao_any_destructor
+        );
+      return 1;
+    }
+  }
+  ACE_CATCHANY
+  {
+    _tao_elem = CORBA::IDLType::_nil ();
+    return 0;
+  }
+  ACE_ENDTRY;
+  _tao_elem = CORBA::IDLType::_nil ();
+  return 0;
+}
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
+    defined (ACE_HAS_GNU_REPO)
+    template class TAO_Object_Manager<CORBA::IDLType,CORBA::IDLType_var>;
+  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+  #  pragma instantiate TAO_Object_Manager<CORBA::IDLType,CORBA::IDLType_var>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+void operator<<= (CORBA::Any &_tao_any, CORBA::TypedefDef_ptr _tao_elem)
+{
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        CORBA::_tc_TypedefDef, 
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin (),
+        1,
+        CORBA::TypedefDef::_duplicate (_tao_elem),
+        CORBA::TypedefDef::_tao_any_destructor
+      );
+  }
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::TypedefDef_ptr &_tao_elem)
+{
+  ACE_TRY_NEW_ENV
+  {
+    _tao_elem = CORBA::TypedefDef::_nil ();
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (CORBA::_tc_TypedefDef, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    TAO_InputCDR stream (
+        _tao_any._tao_get_cdr (),
+        _tao_any._tao_byte_order ()
+      );
+    if (stream >> _tao_elem)
+    {
+      ((CORBA::Any *)&_tao_any)->_tao_replace (
+          CORBA::_tc_TypedefDef,
+          1,
+          _tao_elem,
+          CORBA::TypedefDef::_tao_any_destructor
+        );
+      return 1;
+    }
+  }
+  ACE_CATCHANY
+  {
+    _tao_elem = CORBA::TypedefDef::_nil ();
+    return 0;
+  }
+  ACE_ENDTRY;
+  _tao_elem = CORBA::TypedefDef::_nil ();
+  return 0;
+}
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
+    defined (ACE_HAS_GNU_REPO)
+    template class TAO_Object_Manager<CORBA::TypedefDef,CORBA::TypedefDef_var>;
+  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+  #  pragma instantiate TAO_Object_Manager<CORBA::TypedefDef,CORBA::TypedefDef_var>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+void operator<<= (CORBA::Any &_tao_any, const CORBA::TypeDescription &_tao_elem) // copying
+{
+  TAO_OutputCDR stream;
+  stream << _tao_elem;
+  _tao_any._tao_replace (
+      CORBA::_tc_TypeDescription,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin ()
+    );
+}
+
+void operator<<= (CORBA::Any &_tao_any, CORBA::TypeDescription *_tao_elem) // non copying
+{
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      CORBA::_tc_TypeDescription,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      CORBA::TypeDescription::_tao_any_destructor
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::TypeDescription *&_tao_elem)
+{
+  return _tao_any >>= ACE_const_cast(const CORBA::TypeDescription*&,_tao_elem);
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::TypeDescription *&_tao_elem)
+{
+  _tao_elem = 0;
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (CORBA::_tc_TypeDescription, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    if (_tao_any.any_owns_data ())
+    {
+      _tao_elem = ACE_static_cast(
+          const CORBA::TypeDescription*,
+          _tao_any.value ()
+        );
+      return 1;
+    }
+    else
+    {
+      CORBA::TypeDescription *tmp;
+      ACE_NEW_RETURN (tmp, CORBA::TypeDescription, 0);
+      TAO_InputCDR stream (
+          _tao_any._tao_get_cdr (),
+          _tao_any._tao_byte_order ()
+        );
+      if (stream >> *tmp)
+      {
+        ((CORBA::Any *)&_tao_any)->_tao_replace (
+            CORBA::_tc_TypeDescription,
+            1,
+            ACE_static_cast (void *, tmp),
+            CORBA::TypeDescription::_tao_any_destructor
+          );
+        _tao_elem = tmp;
+        return 1;
+      }
+      else
+      {
+        delete tmp;
+      }
+    }
+  }
+  ACE_CATCHANY
+  {
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+CORBA::Boolean operator<< (
+    TAO_OutputCDR &strm,
+    const CORBA::ContainedSeq &_tao_sequence
+  )
+{
+  if (strm << _tao_sequence.length ())
+  {
+    // encode all elements
+    CORBA::Boolean _tao_marshal_flag = 1;
+    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
+      _tao_marshal_flag = (strm << _tao_sequence[i].in ());
+    }
+    return _tao_marshal_flag;
+  }
+  return 0; // error
+}
+
+CORBA::Boolean operator>> (
+    TAO_InputCDR &strm,
+    CORBA::ContainedSeq &_tao_sequence
+  )
+{
+  CORBA::ULong _tao_seq_len;
+  if (strm >> _tao_seq_len)
+  {
+    // set the length of the sequence
+    _tao_sequence.length (_tao_seq_len);
+    // If length is 0 we return true.
+    if (0 >= _tao_seq_len) 
+      return 1;
+    // retrieve all the elements
+    CORBA::Boolean _tao_marshal_flag = 1;
+    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
+      _tao_marshal_flag = (strm >> _tao_sequence[i].out ());
+    }
+    return _tao_marshal_flag;
+  }
+  return 0; // error
+}
+
+CORBA::Boolean operator<< (
+    TAO_OutputCDR &strm,
+    const CORBA::StructMemberSeq &_tao_sequence
+  )
+{
+  if (strm << _tao_sequence.length ())
+  {
+    // encode all elements
+    CORBA::Boolean _tao_marshal_flag = 1;
+    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
+      _tao_marshal_flag = (strm << _tao_sequence[i]);
+    }
+    return _tao_marshal_flag;
+  }
+  return 0; // error
+}
+
+CORBA::Boolean operator>> (
+    TAO_InputCDR &strm,
+    CORBA::StructMemberSeq &_tao_sequence
+  )
+{
+  CORBA::ULong _tao_seq_len;
+  if (strm >> _tao_seq_len)
+  {
+    // set the length of the sequence
+    _tao_sequence.length (_tao_seq_len);
+    // If length is 0 we return true.
+    if (0 >= _tao_seq_len) 
+      return 1;
+    // retrieve all the elements
+    CORBA::Boolean _tao_marshal_flag = 1;
+    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
+      _tao_marshal_flag = (strm >> _tao_sequence[i]);
+    }
+    return _tao_marshal_flag;
+  }
+  return 0; // error
+}
+
+CORBA::Boolean operator<< (
+    TAO_OutputCDR &strm,
+    const CORBA::InitializerSeq &_tao_sequence
+  )
+{
+  if (strm << _tao_sequence.length ())
+  {
+    // encode all elements
+    CORBA::Boolean _tao_marshal_flag = 1;
+    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
+      _tao_marshal_flag = (strm << _tao_sequence[i]);
+    }
+    return _tao_marshal_flag;
+  }
+  return 0; // error
+}
+
+CORBA::Boolean operator>> (
+    TAO_InputCDR &strm,
+    CORBA::InitializerSeq &_tao_sequence
+  )
+{
+  CORBA::ULong _tao_seq_len;
+  if (strm >> _tao_seq_len)
+  {
+    // set the length of the sequence
+    _tao_sequence.length (_tao_seq_len);
+    // If length is 0 we return true.
+    if (0 >= _tao_seq_len) 
+      return 1;
+    // retrieve all the elements
+    CORBA::Boolean _tao_marshal_flag = 1;
+    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
+      _tao_marshal_flag = (strm >> _tao_sequence[i]);
+    }
+    return _tao_marshal_flag;
+  }
+  return 0; // error
+}
+
+CORBA::Boolean operator<< (
+    TAO_OutputCDR &strm,
+    const CORBA::UnionMemberSeq &_tao_sequence
+  )
+{
+  if (strm << _tao_sequence.length ())
+  {
+    // encode all elements
+    CORBA::Boolean _tao_marshal_flag = 1;
+    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
+      _tao_marshal_flag = (strm << _tao_sequence[i]);
+    }
+    return _tao_marshal_flag;
+  }
+  return 0; // error
+}
+
+CORBA::Boolean operator>> (
+    TAO_InputCDR &strm,
+    CORBA::UnionMemberSeq &_tao_sequence
+  )
+{
+  CORBA::ULong _tao_seq_len;
+  if (strm >> _tao_seq_len)
+  {
+    // set the length of the sequence
+    _tao_sequence.length (_tao_seq_len);
+    // If length is 0 we return true.
+    if (0 >= _tao_seq_len) 
+      return 1;
+    // retrieve all the elements
+    CORBA::Boolean _tao_marshal_flag = 1;
+    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
+      _tao_marshal_flag = (strm >> _tao_sequence[i]);
+    }
+    return _tao_marshal_flag;
+  }
+  return 0; // error
+}
+
+CORBA::Boolean operator<< (
+    TAO_OutputCDR &strm,
+    const CORBA::EnumMemberSeq &_tao_sequence
+  )
+{
+  if (strm << _tao_sequence.length ())
+  {
+    // encode all elements
+    CORBA::Boolean _tao_marshal_flag = 1;
+    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
+      _tao_marshal_flag = (strm << _tao_sequence[i].in ());
+    }
+    return _tao_marshal_flag;
+  }
+  return 0; // error
+}
+
+CORBA::Boolean operator>> (
+    TAO_InputCDR &strm,
+    CORBA::EnumMemberSeq &_tao_sequence
+  )
+{
+  CORBA::ULong _tao_seq_len;
+  if (strm >> _tao_seq_len)
+  {
+    // set the length of the sequence
+    _tao_sequence.length (_tao_seq_len);
+    // If length is 0 we return true.
+    if (0 >= _tao_seq_len) 
+      return 1;
+    // retrieve all the elements
+    CORBA::Boolean _tao_marshal_flag = 1;
+    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
+      _tao_marshal_flag = (strm >> _tao_sequence[i].out ());
+    }
+    return _tao_marshal_flag;
+  }
+  return 0; // error
+}
+
+CORBA::Boolean operator<< (
+    TAO_OutputCDR &strm,
+    const CORBA::Container::DescriptionSeq &_tao_sequence
+  )
+{
+  if (strm << _tao_sequence.length ())
+  {
+    // encode all elements
+    CORBA::Boolean _tao_marshal_flag = 1;
+    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
+      _tao_marshal_flag = (strm << _tao_sequence[i]);
+    }
+    return _tao_marshal_flag;
+  }
+  return 0; // error
+}
+
+CORBA::Boolean operator>> (
+    TAO_InputCDR &strm,
+    CORBA::Container::DescriptionSeq &_tao_sequence
+  )
+{
+  CORBA::ULong _tao_seq_len;
+  if (strm >> _tao_seq_len)
+  {
+    // set the length of the sequence
+    _tao_sequence.length (_tao_seq_len);
+    // If length is 0 we return true.
+    if (0 >= _tao_seq_len) 
+      return 1;
+    // retrieve all the elements
+    CORBA::Boolean _tao_marshal_flag = 1;
+    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
+      _tao_marshal_flag = (strm >> _tao_sequence[i]);
+    }
+    return _tao_marshal_flag;
+  }
+  return 0; // error
+}
+
diff --git a/TAO/tao/IFR_Client/IFR_BaseC.h b/TAO/tao/IFR_Client/IFR_BaseC.h
new file mode 100644
index 00000000000..7659dea9aae
--- /dev/null
+++ b/TAO/tao/IFR_Client/IFR_BaseC.h
@@ -0,0 +1,5416 @@
+// -*- C++ -*-
+//
+// $Id$
+
+// ****  Code generated by the The ACE ORB (TAO) IDL Compiler ****
+// TAO and the TAO IDL Compiler have been developed by:
+//       Center for Distributed Object Computing
+//       Washington University
+//       St. Louis, MO
+//       USA
+//       http://www.cs.wustl.edu/~schmidt/doc-center.html
+// and
+//       Distributed Object Computing Laboratory
+//       University of California at Irvine
+//       Irvine, CA
+//       USA
+//       http://doc.ece.uci.edu/
+//
+// Information about TAO is available at:
+//     http://www.cs.wustl.edu/~schmidt/TAO.html
+
+#ifndef TAO_IDL_IFR_BASEC_H
+#define TAO_IDL_IFR_BASEC_H
+
+#include "ace/pre.h"
+#include "ifr_client_export.h"
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+# pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+#include "tao/Invocation.h"
+#include "tao/PortableInterceptor.h"
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  #include "tao/ClientRequestInfo.h"
+#endif /* TAO_HAS_INTERCEPTORS == 1 */
+
+#if defined (TAO_EXPORT_MACRO)
+#undef TAO_EXPORT_MACRO
+#endif
+#define TAO_EXPORT_MACRO TAO_IFR_Client_Export
+
+#if defined (TAO_EXPORT_NESTED_CLASSES)
+#  if defined (TAO_EXPORT_NESTED_MACRO)
+#    undef TAO_EXPORT_NESTED_MACRO
+#  endif /* defined (TAO_EXPORT_NESTED_MACRO) */
+#  define TAO_EXPORT_NESTED_MACRO TAO_IFR_Client_Export
+#endif /* TAO_EXPORT_NESTED_CLASSES */
+
+#if defined(_MSC_VER)
+#if (_MSC_VER >= 1200)
+#pragma warning(push)
+#endif /* _MSC_VER >= 1200 */
+#pragma warning(disable:4250)
+#endif /* _MSC_VER */
+
+#if defined (__BORLANDC__)
+#pragma option push -w-rvl -w-rch -w-ccc -w-inl
+#endif /* __BORLANDC__ */
+
+#if !defined (_CORBA_IROBJECT___VAR_CH_)
+#define _CORBA_IROBJECT___VAR_CH_
+
+  class TAO_IFR_Client_Export CORBA_IRObject_var : public TAO_Base_var
+  {
+  public:
+    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 CORBA_IRObject_ptr &() const;
+    operator CORBA_IRObject_ptr &();
+    // in, inout, out, _retn 
+    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:
+    CORBA_IRObject_ptr ptr_;
+    // Unimplemented - prevents widening assignment.
+    CORBA_IRObject_var (const TAO_Base_var &rhs);
+    CORBA_IRObject_var &operator= (const TAO_Base_var &rhs);
+  };
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_IROBJECT___OUT_CH_)
+#define _CORBA_IROBJECT___OUT_CH_
+
+  class TAO_IFR_Client_Export CORBA_IRObject_out
+  {
+  public:
+    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:
+    CORBA_IRObject_ptr &ptr_;
+  };
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_IROBJECT_CH_)
+#define _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_IFR_Client_Export CORBA_IRObject : public virtual CORBA_Object
+  {
+  public:
+  #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+    typedef CORBA_IRObject_ptr _ptr_type;
+    typedef CORBA_IRObject_var _var_type;
+  #endif /* ! __GNUC__ || g++ >= 2.8 */
+
+    // the static operations
+    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 CORBA_IRObject_ptr _unchecked_narrow (
+        CORBA::Object_ptr obj,
+        CORBA::Environment &ACE_TRY_ENV = 
+          TAO_default_environment ()
+      );
+    static CORBA_IRObject_ptr _nil (void)
+      {
+        return (CORBA_IRObject_ptr)0;
+      }
+
+    static void _tao_any_destructor (void*);
+
+    virtual CORBA::DefinitionKind def_kind (
+        CORBA::Environment &ACE_TRY_ENV = 
+          TAO_default_environment ()
+      )
+      ACE_THROW_SPEC ((
+        CORBA::SystemException
+      ));
+
+    virtual void destroy (
+        CORBA::Environment &ACE_TRY_ENV = 
+          TAO_default_environment ()
+      )
+      ACE_THROW_SPEC ((
+        CORBA::SystemException
+      ));
+
+    virtual CORBA::Boolean _is_a (
+        const CORBA::Char *type_id, 
+        CORBA::Environment &ACE_TRY_ENV = 
+          TAO_default_environment ()
+      );
+    virtual void *_tao_QueryInterface (ptr_arith_t type);
+    
+    virtual const char* _interface_repository_id (void) const;
+
+  private:
+    _TAO_IRObject_Proxy_Broker *the_TAO_IRObject_Proxy_Broker_;
+    
+  protected:
+    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 CORBA_IRObject_setup_collocation (int collocated);
+      
+      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 ~CORBA_IRObject (void);
+  private:
+    CORBA_IRObject (const CORBA_IRObject &);
+    void operator= (const CORBA_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 (
+        TAO_GIOP_Invocation *_tao_invocation,
+        CORBA::Object_ptr _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 (CORBA::DefinitionKind result);
+    // update the result 
+    CORBA::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 (
+      TAO_GIOP_Invocation *_tao_invocation,
+      CORBA::Object_ptr _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_destroy (const TAO_ClientRequestInfo_CORBA_IRObject_destroy &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_IRObject_destroy &);
+  
+};
+
+#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_IFR_Client_Export _TAO_IRObject_Proxy_Impl : public virtual TAO_Object_Proxy_Impl
+{
+public:
+  virtual ~_TAO_IRObject_Proxy_Impl (void) { }
+  
+    virtual CORBA::DefinitionKind def_kind (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual void destroy (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+protected:
+  _TAO_IRObject_Proxy_Impl (void);
+
+};
+//
+//                Base  Proxy Impl. Declaration
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//                    Remote  Impl. Declaration
+//
+
+class TAO_IFR_Client_Export _TAO_IRObject_Remote_Proxy_Impl : 
+  public virtual _TAO_IRObject_Proxy_Impl,
+  public virtual TAO_Remote_Object_Proxy_Impl
+{
+public:
+  _TAO_IRObject_Remote_Proxy_Impl (void);
+  
+  virtual ~_TAO_IRObject_Remote_Proxy_Impl (void) { }
+  
+    virtual CORBA::DefinitionKind def_kind (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void destroy (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+};
+
+//
+//                Base  Proxy Impl. Declaration
+///////////////////////////////////////////////////////////////////////
+
+
+// The Proxy Brokers are used by each interface to get
+// the right proxy for performing a call. In the new 
+// collocation scheme, the proxy to be used can vary on
+// a call by call basis. 
+
+
+
+///////////////////////////////////////////////////////////////////////
+//                 Base Proxy Broker Declaration 
+//
+
+class TAO_IFR_Client_Export _TAO_IRObject_Proxy_Broker
+{
+public:
+  virtual ~_TAO_IRObject_Proxy_Broker (void);
+  virtual _TAO_IRObject_Proxy_Impl &select_proxy (
+    CORBA_IRObject *object,
+    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
+  ) = 0;
+
+protected:
+  _TAO_IRObject_Proxy_Broker (void);
+  
+};
+
+//
+//              End Base Proxy Broker Declaration 
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//                 Remote Proxy Broker Declaration 
+//
+
+class TAO_IFR_Client_Export _TAO_IRObject_Remote_Proxy_Broker : public virtual _TAO_IRObject_Proxy_Broker
+{
+public: 
+  _TAO_IRObject_Remote_Proxy_Broker (void);
+  
+  virtual ~_TAO_IRObject_Remote_Proxy_Broker (void);
+  
+  virtual _TAO_IRObject_Proxy_Impl &select_proxy (
+    CORBA_IRObject *object,
+    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
+  );
+
+private:
+  _TAO_IRObject_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_IRObject_Remote_Proxy_Broker *the_TAO_IRObject_Remote_Proxy_Broker (void);
+};
+
+
+//
+//              End Remote Proxy Broker Declaration 
+///////////////////////////////////////////////////////////////////////
+
+
+#endif /* end #if !defined */
+
+typedef char * VersionSpec;
+typedef CORBA::String_var VersionSpec_var;
+typedef CORBA::String_out VersionSpec_out;
+class CORBA_Contained;
+
+#if !defined (_CORBA_CONTAINED___PTR_CH_)
+#define _CORBA_CONTAINED___PTR_CH_
+
+typedef CORBA_Contained *CORBA_Contained_ptr;
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_CONTAINED___VAR_CH_)
+#define _CORBA_CONTAINED___VAR_CH_
+
+class TAO_IFR_Client_Export CORBA_Contained_var : public TAO_Base_var
+{
+public:
+  CORBA_Contained_var (void); // default constructor
+  CORBA_Contained_var (CORBA_Contained_ptr p) : ptr_ (p) {} 
+  CORBA_Contained_var (const CORBA_Contained_var &); // copy constructor
+  ~CORBA_Contained_var (void); // destructor
+  
+  CORBA_Contained_var &operator= (CORBA_Contained_ptr);
+  CORBA_Contained_var &operator= (const CORBA_Contained_var &);
+  CORBA_Contained_ptr operator-> (void) const;
+  
+  operator const CORBA_Contained_ptr &() const;
+  operator CORBA_Contained_ptr &();
+  // in, inout, out, _retn 
+  CORBA_Contained_ptr in (void) const;
+  CORBA_Contained_ptr &inout (void);
+  CORBA_Contained_ptr &out (void);
+  CORBA_Contained_ptr _retn (void);
+  CORBA_Contained_ptr ptr (void) const;
+
+private:
+  CORBA_Contained_ptr ptr_;
+  // Unimplemented - prevents widening assignment.
+  CORBA_Contained_var (const TAO_Base_var &rhs);
+  CORBA_Contained_var &operator= (const TAO_Base_var &rhs);
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_CONTAINED___OUT_CH_)
+#define _CORBA_CONTAINED___OUT_CH_
+
+class TAO_IFR_Client_Export CORBA_Contained_out
+{
+public:
+  CORBA_Contained_out (CORBA_Contained_ptr &);
+  CORBA_Contained_out (CORBA_Contained_var &);
+  CORBA_Contained_out (const CORBA_Contained_out &);
+  CORBA_Contained_out &operator= (const CORBA_Contained_out &);
+  CORBA_Contained_out &operator= (const CORBA_Contained_var &);
+  CORBA_Contained_out &operator= (CORBA_Contained_ptr);
+  operator CORBA_Contained_ptr &();
+  CORBA_Contained_ptr &ptr (void);
+  CORBA_Contained_ptr operator-> (void);
+  
+private:
+  CORBA_Contained_ptr &ptr_;
+};
+
+
+#endif /* end #if !defined */
+
+class CORBA_Repository;
+
+#if !defined (_CORBA_REPOSITORY___PTR_CH_)
+#define _CORBA_REPOSITORY___PTR_CH_
+
+typedef CORBA_Repository *CORBA_Repository_ptr;
+
+#endif /* end #if !defined */
+
+
+class CORBA_Container;
+
+#if !defined (_CORBA_CONTAINER___PTR_CH_)
+#define _CORBA_CONTAINER___PTR_CH_
+
+typedef CORBA_Container *CORBA_Container_ptr;
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_CONTAINER___VAR_CH_)
+#define _CORBA_CONTAINER___VAR_CH_
+
+class TAO_IFR_Client_Export CORBA_Container_var : public TAO_Base_var
+{
+public:
+  CORBA_Container_var (void); // default constructor
+  CORBA_Container_var (CORBA_Container_ptr p) : ptr_ (p) {} 
+  CORBA_Container_var (const CORBA_Container_var &); // copy constructor
+  ~CORBA_Container_var (void); // destructor
+  
+  CORBA_Container_var &operator= (CORBA_Container_ptr);
+  CORBA_Container_var &operator= (const CORBA_Container_var &);
+  CORBA_Container_ptr operator-> (void) const;
+  
+  operator const CORBA_Container_ptr &() const;
+  operator CORBA_Container_ptr &();
+  // in, inout, out, _retn 
+  CORBA_Container_ptr in (void) const;
+  CORBA_Container_ptr &inout (void);
+  CORBA_Container_ptr &out (void);
+  CORBA_Container_ptr _retn (void);
+  CORBA_Container_ptr ptr (void) const;
+
+private:
+  CORBA_Container_ptr ptr_;
+  // Unimplemented - prevents widening assignment.
+  CORBA_Container_var (const TAO_Base_var &rhs);
+  CORBA_Container_var &operator= (const TAO_Base_var &rhs);
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_CONTAINER___OUT_CH_)
+#define _CORBA_CONTAINER___OUT_CH_
+
+class TAO_IFR_Client_Export CORBA_Container_out
+{
+public:
+  CORBA_Container_out (CORBA_Container_ptr &);
+  CORBA_Container_out (CORBA_Container_var &);
+  CORBA_Container_out (const CORBA_Container_out &);
+  CORBA_Container_out &operator= (const CORBA_Container_out &);
+  CORBA_Container_out &operator= (const CORBA_Container_var &);
+  CORBA_Container_out &operator= (CORBA_Container_ptr);
+  operator CORBA_Container_ptr &();
+  CORBA_Container_ptr &ptr (void);
+  CORBA_Container_ptr operator-> (void);
+  
+private:
+  CORBA_Container_ptr &ptr_;
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_CONTAINED___VAR_CH_)
+#define _CORBA_CONTAINED___VAR_CH_
+
+class TAO_IFR_Client_Export CORBA_Contained_var : public TAO_Base_var
+{
+public:
+  CORBA_Contained_var (void); // default constructor
+  CORBA_Contained_var (CORBA_Contained_ptr p) : ptr_ (p) {} 
+  CORBA_Contained_var (const CORBA_Contained_var &); // copy constructor
+  ~CORBA_Contained_var (void); // destructor
+  
+  CORBA_Contained_var &operator= (CORBA_Contained_ptr);
+  CORBA_Contained_var &operator= (const CORBA_Contained_var &);
+  CORBA_Contained_ptr operator-> (void) const;
+  
+  operator const CORBA_Contained_ptr &() const;
+  operator CORBA_Contained_ptr &();
+  // in, inout, out, _retn 
+  CORBA_Contained_ptr in (void) const;
+  CORBA_Contained_ptr &inout (void);
+  CORBA_Contained_ptr &out (void);
+  CORBA_Contained_ptr _retn (void);
+  CORBA_Contained_ptr ptr (void) const;
+
+private:
+  CORBA_Contained_ptr ptr_;
+  // Unimplemented - prevents widening assignment.
+  CORBA_Contained_var (const TAO_Base_var &rhs);
+  CORBA_Contained_var &operator= (const TAO_Base_var &rhs);
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_CONTAINED___OUT_CH_)
+#define _CORBA_CONTAINED___OUT_CH_
+
+class TAO_IFR_Client_Export CORBA_Contained_out
+{
+public:
+  CORBA_Contained_out (CORBA_Contained_ptr &);
+  CORBA_Contained_out (CORBA_Contained_var &);
+  CORBA_Contained_out (const CORBA_Contained_out &);
+  CORBA_Contained_out &operator= (const CORBA_Contained_out &);
+  CORBA_Contained_out &operator= (const CORBA_Contained_var &);
+  CORBA_Contained_out &operator= (CORBA_Contained_ptr);
+  operator CORBA_Contained_ptr &();
+  CORBA_Contained_ptr &ptr (void);
+  CORBA_Contained_ptr operator-> (void);
+  
+private:
+  CORBA_Contained_ptr &ptr_;
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_CONTAINED_CH_)
+#define _CORBA_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_IFR_Client_Export CORBA_Contained: public virtual CORBA_IRObject
+{
+public:
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef CORBA_Contained_ptr _ptr_type;
+  typedef CORBA_Contained_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  // the static operations
+  static CORBA_Contained_ptr _duplicate (CORBA_Contained_ptr obj);
+  static CORBA_Contained_ptr _narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    );
+  static CORBA_Contained_ptr _unchecked_narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    );
+  static CORBA_Contained_ptr _nil (void)
+    {
+      return (CORBA_Contained_ptr)0;
+    }
+
+  static void _tao_any_destructor (void*);
+
+  virtual char * id (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void id (
+      const char * id,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual char * name (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void name (
+      const char * name,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual char * version (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void version (
+      const char * version,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::Container_ptr defined_in (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual char * absolute_name (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::Repository_ptr containing_repository (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  struct Description;
+  class Description_var;
+  
+  struct TAO_IFR_Client_Export Description
+  {
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+    typedef Description_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+    static void _tao_any_destructor (void*);
+
+    CORBA::DefinitionKind kind;
+    CORBA::Any value;
+  };
+
+  class TAO_IFR_Client_Export Description_var
+  {
+  public:
+    Description_var (void); // default constructor
+    Description_var (Description *);
+    Description_var (const Description_var &); // copy constructor
+    ~Description_var (void); // destructor
+    
+    Description_var &operator= (Description *);
+    Description_var &operator= (const Description_var &);
+    Description *operator-> (void);
+    const Description *operator-> (void) const;
+    
+    operator const Description &() const;
+    operator Description &();
+    operator Description &() const;
+    operator Description *&(); // variable-size types only
+    
+    // in, inout, out, _retn 
+    const Description &in (void) const;
+    Description &inout (void);
+    Description *&out (void);
+    Description *_retn (void);
+    Description *ptr (void) const;
+
+  private:
+    Description *ptr_;
+  };
+
+  class TAO_IFR_Client_Export Description_out
+  {
+  public:
+    Description_out (Description *&);
+    Description_out (Description_var &);
+    Description_out (const Description_out &);
+    Description_out &operator= (const Description_out &);
+    Description_out &operator= (Description *);
+    operator Description *&();
+    Description *&ptr (void);
+    Description *operator-> (void);
+    
+  private:
+    Description *&ptr_;
+    // assignment from T_var not allowed
+    void operator= (const Description_var &);
+  };
+
+  static CORBA::TypeCode_ptr _tc_Description;
+
+  virtual CORBA::Contained::Description * describe (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void move (
+      CORBA::Container_ptr new_container,
+      const char * new_name,
+      const char * new_version,
+      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_Contained_Proxy_Broker *the_TAO_Contained_Proxy_Broker_;
+  
+protected:
+  CORBA_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 CORBA_Contained_setup_collocation (int collocated);
+    
+    CORBA_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 ~CORBA_Contained (void);
+private:
+  CORBA_Contained (const CORBA_Contained &);
+  void operator= (const CORBA_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_CORBA_Contained_id_get : public TAO_ClientRequestInfo
+  {
+  public:
+    friend class CORBA_Contained;
+    
+    friend class _TAO_Contained_Remote_Proxy_Impl;
+    friend class _TAO_Contained_ThruPOA_Proxy_Impl;
+    friend class _TAO_Contained_Direct_Proxy_Impl;
+  
+  TAO_ClientRequestInfo_CORBA_Contained_id_get (
+      TAO_GIOP_Invocation *_tao_invocation,
+      CORBA::Object_ptr _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_Contained_id_get (const TAO_ClientRequestInfo_CORBA_Contained_id_get &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_Contained_id_get &);
+  void result (char * result);
+  // update the result 
+  char * _result;
+};
+
+class TAO_ClientRequestInfo_CORBA_Contained_id_set : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_Contained;
+  
+  friend class _TAO_Contained_Remote_Proxy_Impl;
+  friend class _TAO_Contained_ThruPOA_Proxy_Impl;
+  friend class _TAO_Contained_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_Contained_id_set (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _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_CORBA_Contained_id_set (const TAO_ClientRequestInfo_CORBA_Contained_id_set &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_Contained_id_set &);
+  const char * id_;
+  
+};
+
+class TAO_ClientRequestInfo_CORBA_Contained_name_get : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_Contained;
+  
+  friend class _TAO_Contained_Remote_Proxy_Impl;
+  friend class _TAO_Contained_ThruPOA_Proxy_Impl;
+  friend class _TAO_Contained_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_Contained_name_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _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_Contained_name_get (const TAO_ClientRequestInfo_CORBA_Contained_name_get &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_Contained_name_get &);
+  void result (char * result);
+  // update the result 
+  char * _result;
+};
+
+class TAO_ClientRequestInfo_CORBA_Contained_name_set : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_Contained;
+  
+  friend class _TAO_Contained_Remote_Proxy_Impl;
+  friend class _TAO_Contained_ThruPOA_Proxy_Impl;
+  friend class _TAO_Contained_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_Contained_name_set (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _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));
+
+virtual CORBA::Any * result (
+    CORBA::Environment &ACE_TRY_ENV = 
+      TAO_default_environment ()
+  )
+  ACE_THROW_SPEC ((CORBA::SystemException));
+
+private:
+  TAO_ClientRequestInfo_CORBA_Contained_name_set (const TAO_ClientRequestInfo_CORBA_Contained_name_set &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_Contained_name_set &);
+  const char * name_;
+  
+};
+
+class TAO_ClientRequestInfo_CORBA_Contained_version_get : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_Contained;
+  
+  friend class _TAO_Contained_Remote_Proxy_Impl;
+  friend class _TAO_Contained_ThruPOA_Proxy_Impl;
+  friend class _TAO_Contained_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_Contained_version_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _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_Contained_version_get (const TAO_ClientRequestInfo_CORBA_Contained_version_get &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_Contained_version_get &);
+  void result (char * result);
+  // update the result 
+  char * _result;
+};
+
+class TAO_ClientRequestInfo_CORBA_Contained_version_set : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_Contained;
+  
+  friend class _TAO_Contained_Remote_Proxy_Impl;
+  friend class _TAO_Contained_ThruPOA_Proxy_Impl;
+  friend class _TAO_Contained_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_Contained_version_set (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _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_CORBA_Contained_version_set (const TAO_ClientRequestInfo_CORBA_Contained_version_set &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_Contained_version_set &);
+  const char * version_;
+  
+};
+
+class TAO_ClientRequestInfo_CORBA_Contained_defined_in_get : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_Contained;
+  
+  friend class _TAO_Contained_Remote_Proxy_Impl;
+  friend class _TAO_Contained_ThruPOA_Proxy_Impl;
+  friend class _TAO_Contained_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_Contained_defined_in_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _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_Contained_defined_in_get (const TAO_ClientRequestInfo_CORBA_Contained_defined_in_get &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_Contained_defined_in_get &);
+  void result (CORBA::Container_ptr result);
+  // update the result 
+  CORBA::Container_ptr _result;
+};
+
+class TAO_ClientRequestInfo_CORBA_Contained_absolute_name_get : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_Contained;
+  
+  friend class _TAO_Contained_Remote_Proxy_Impl;
+  friend class _TAO_Contained_ThruPOA_Proxy_Impl;
+  friend class _TAO_Contained_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_Contained_absolute_name_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _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_Contained_absolute_name_get (const TAO_ClientRequestInfo_CORBA_Contained_absolute_name_get &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_Contained_absolute_name_get &);
+  void result (char * result);
+  // update the result 
+  char * _result;
+};
+
+class TAO_ClientRequestInfo_CORBA_Contained_containing_repository_get : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_Contained;
+  
+  friend class _TAO_Contained_Remote_Proxy_Impl;
+  friend class _TAO_Contained_ThruPOA_Proxy_Impl;
+  friend class _TAO_Contained_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_Contained_containing_repository_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _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_Contained_containing_repository_get (const TAO_ClientRequestInfo_CORBA_Contained_containing_repository_get &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_Contained_containing_repository_get &);
+  void result (CORBA::Repository_ptr result);
+  // update the result 
+  CORBA::Repository_ptr _result;
+};
+
+class TAO_ClientRequestInfo_CORBA_Contained_describe : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_Contained;
+  
+  friend class _TAO_Contained_Remote_Proxy_Impl;
+  friend class _TAO_Contained_ThruPOA_Proxy_Impl;
+  friend class _TAO_Contained_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_Contained_describe (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _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_Contained_describe (const TAO_ClientRequestInfo_CORBA_Contained_describe &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_Contained_describe &);
+  void result (ACE_NESTED_CLASS (CORBA::Contained,Description) * result);
+  // update the result 
+  ACE_NESTED_CLASS (CORBA::Contained,Description) * _result;
+};
+
+class TAO_ClientRequestInfo_CORBA_Contained_move : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_Contained;
+  
+  friend class _TAO_Contained_Remote_Proxy_Impl;
+  friend class _TAO_Contained_ThruPOA_Proxy_Impl;
+  friend class _TAO_Contained_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_Contained_move (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::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_CORBA_Contained_move (const TAO_ClientRequestInfo_CORBA_Contained_move &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_Contained_move &);
+  CORBA::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_IFR_Client_Export _TAO_Contained_Proxy_Impl : 
+  public virtual _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 void name (
+      CORBA_Object *_collocated_tao_target_,
+      const char * name,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual char * version (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual void version (
+      CORBA_Object *_collocated_tao_target_,
+      const char * version,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual CORBA::Container_ptr defined_in (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual char * absolute_name (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual CORBA::Repository_ptr containing_repository (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual CORBA::Contained::Description * describe (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual void move (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Container_ptr new_container,
+      const char * new_name,
+      const char * new_version,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+protected:
+  _TAO_Contained_Proxy_Impl (void);
+
+};
+//
+//                Base  Proxy Impl. Declaration
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//                    Remote  Impl. Declaration
+//
+
+class TAO_IFR_Client_Export _TAO_Contained_Remote_Proxy_Impl : 
+  public virtual _TAO_Contained_Proxy_Impl,
+  public virtual TAO_Remote_Object_Proxy_Impl,
+  public virtual _TAO_IRObject_Remote_Proxy_Impl
+  
+{
+public:
+  _TAO_Contained_Remote_Proxy_Impl (void);
+  
+  virtual ~_TAO_Contained_Remote_Proxy_Impl (void) { }
+  
+    virtual char * id (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    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
+    ));
+
+  virtual char * name (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void name (
+      CORBA_Object *_collocated_tao_target_,
+      const char * name,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual char * version (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void version (
+      CORBA_Object *_collocated_tao_target_,
+      const char * version,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::Container_ptr defined_in (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual char * absolute_name (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::Repository_ptr containing_repository (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::Contained::Description * describe (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void move (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Container_ptr new_container,
+      const char * new_name,
+      const char * new_version,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+};
+
+//
+//                Base  Proxy Impl. Declaration
+///////////////////////////////////////////////////////////////////////
+
+
+// The Proxy Brokers are used by each interface to get
+// the right proxy for performing a call. In the new 
+// collocation scheme, the proxy to be used can vary on
+// a call by call basis. 
+
+
+
+///////////////////////////////////////////////////////////////////////
+//                 Base Proxy Broker Declaration 
+//
+
+class TAO_IFR_Client_Export _TAO_Contained_Proxy_Broker
+{
+public:
+  virtual ~_TAO_Contained_Proxy_Broker (void);
+  virtual _TAO_Contained_Proxy_Impl &select_proxy (
+    CORBA_Contained *object,
+    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
+  ) = 0;
+
+protected:
+  _TAO_Contained_Proxy_Broker (void);
+  
+};
+
+//
+//              End Base Proxy Broker Declaration 
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//                 Remote Proxy Broker Declaration 
+//
+
+class TAO_IFR_Client_Export _TAO_Contained_Remote_Proxy_Broker : public virtual _TAO_Contained_Proxy_Broker
+{
+public: 
+  _TAO_Contained_Remote_Proxy_Broker (void);
+  
+  virtual ~_TAO_Contained_Remote_Proxy_Broker (void);
+  
+  virtual _TAO_Contained_Proxy_Impl &select_proxy (
+    CORBA_Contained *object,
+    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
+  );
+
+private:
+  _TAO_Contained_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_Contained_Remote_Proxy_Broker *the_TAO_Contained_Remote_Proxy_Broker (void);
+};
+
+
+//
+//              End Remote Proxy Broker Declaration 
+///////////////////////////////////////////////////////////////////////
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_CONTAINEDSEQ_CH_)
+#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_CONTAINEDSEQ_CH_
+
+  class _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq : public TAO_Unbounded_Base_Sequence
+  {
+  public:
+    // = Initialization and termination methods.
+    
+    _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq (void);
+    _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq (CORBA::ULong maximum);
+    _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq (CORBA::ULong maximum,
+      CORBA::ULong length,
+      CORBA_Contained* *value,
+      CORBA::Boolean release = 0);
+    _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq(const _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq &rhs);
+    virtual ~_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq (void);
+    _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq &operator= (const _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq &rhs);
+    TAO_Object_Manager<CORBA::Contained,CORBA::Contained_var> operator[] (CORBA::ULong index) const;
+    static CORBA_Contained **allocbuf (CORBA::ULong nelems);
+    static void freebuf (CORBA_Contained **buffer);
+    // The Base_Sequence functions, please see tao/Sequence.h
+    virtual void _allocate_buffer (CORBA::ULong length);
+    virtual void _deallocate_buffer (void);
+    CORBA_Contained* *get_buffer (CORBA::Boolean orphan = 0);
+    const CORBA_Contained* *get_buffer (void) const;
+    virtual void _shrink_buffer (CORBA::ULong nl, CORBA::ULong ol);
+    virtual void _downcast (
+        void* target,
+        CORBA_Object *src,
+        CORBA_Environment &ACE_TRY_ENV = 
+          TAO_default_environment ()
+      );
+    virtual CORBA_Object* _upcast (void *src) const;
+    
+  };
+
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_CORBA_CONTAINEDSEQ_CH_)
+#define _CORBA_CONTAINEDSEQ_CH_
+
+class CORBA_ContainedSeq;
+class CORBA_ContainedSeq_var;
+
+// *************************************************************
+// CORBA_ContainedSeq
+// *************************************************************
+
+class TAO_IFR_Client_Export CORBA_ContainedSeq : public 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<CORBA_Contained,CORBA_Contained_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+{
+public:
+  CORBA_ContainedSeq (void); // default ctor
+  CORBA_ContainedSeq (CORBA::ULong max); // uses max size
+  CORBA_ContainedSeq (
+    CORBA::ULong max, 
+    CORBA::ULong length, 
+    CORBA_Contained_ptr *buffer, 
+    CORBA::Boolean release = 0
+  );
+  CORBA_ContainedSeq (const CORBA_ContainedSeq &); // copy ctor
+  ~CORBA_ContainedSeq (void);
+  static void _tao_any_destructor (void*);
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef CORBA_ContainedSeq_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+};
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_CONTAINEDSEQ___VAR_CH_)
+#define _CORBA_CONTAINEDSEQ___VAR_CH_
+
+// *************************************************************
+// class CORBA_ContainedSeq_var
+// *************************************************************
+
+class TAO_IFR_Client_Export CORBA_ContainedSeq_var
+{
+public:
+  CORBA_ContainedSeq_var (void); // default constructor
+  CORBA_ContainedSeq_var (CORBA_ContainedSeq *);
+  CORBA_ContainedSeq_var (const CORBA_ContainedSeq_var &); // copy constructor
+  ~CORBA_ContainedSeq_var (void); // destructor
+  
+  CORBA_ContainedSeq_var &operator= (CORBA_ContainedSeq *);
+  CORBA_ContainedSeq_var &operator= (const CORBA_ContainedSeq_var &);
+  CORBA_ContainedSeq *operator-> (void);
+  const CORBA_ContainedSeq *operator-> (void) const;
+  
+  operator const CORBA_ContainedSeq &() const;
+  operator CORBA_ContainedSeq &();
+  operator CORBA_ContainedSeq &() const;
+  operator CORBA_ContainedSeq *&(); // variable-size base types only
+  
+  TAO_Object_Manager<CORBA::Contained, CORBA::Contained_var> operator[] (CORBA::ULong index);
+  
+  // in, inout, out, _retn 
+  const CORBA_ContainedSeq &in (void) const;
+  CORBA_ContainedSeq &inout (void);
+  CORBA_ContainedSeq *&out (void);
+  CORBA_ContainedSeq *_retn (void);
+  CORBA_ContainedSeq *ptr (void) const;
+
+private:
+  CORBA_ContainedSeq *ptr_;
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_CONTAINEDSEQ___OUT_CH_)
+#define _CORBA_CONTAINEDSEQ___OUT_CH_
+
+class TAO_IFR_Client_Export CORBA_ContainedSeq_out
+{
+public:
+  CORBA_ContainedSeq_out (CORBA_ContainedSeq *&);
+  CORBA_ContainedSeq_out (CORBA_ContainedSeq_var &);
+  CORBA_ContainedSeq_out (const CORBA_ContainedSeq_out &);
+  CORBA_ContainedSeq_out &operator= (const CORBA_ContainedSeq_out &);
+  CORBA_ContainedSeq_out &operator= (CORBA_ContainedSeq *);
+  operator CORBA_ContainedSeq *&();
+  CORBA_ContainedSeq *&ptr (void);
+  CORBA_ContainedSeq *operator-> (void);
+  TAO_Object_Manager<CORBA::Contained, CORBA::Contained_var> operator[] (CORBA::ULong index);
+  
+private:
+  CORBA_ContainedSeq *&ptr_;
+  // assignment from T_var not allowed
+  void operator= (const CORBA_ContainedSeq_var &);
+};
+
+
+#endif /* end #if !defined */
+
+class CORBA_ModuleDef;
+
+#if !defined (_CORBA_MODULEDEF___PTR_CH_)
+#define _CORBA_MODULEDEF___PTR_CH_
+
+typedef CORBA_ModuleDef *CORBA_ModuleDef_ptr;
+
+#endif /* end #if !defined */
+
+
+class CORBA_IDLType;
+
+#if !defined (_CORBA_IDLTYPE___PTR_CH_)
+#define _CORBA_IDLTYPE___PTR_CH_
+
+typedef CORBA_IDLType *CORBA_IDLType_ptr;
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_IDLTYPE___VAR_CH_)
+#define _CORBA_IDLTYPE___VAR_CH_
+
+class TAO_IFR_Client_Export CORBA_IDLType_var : public TAO_Base_var
+{
+public:
+  CORBA_IDLType_var (void); // default constructor
+  CORBA_IDLType_var (CORBA_IDLType_ptr p) : ptr_ (p) {} 
+  CORBA_IDLType_var (const CORBA_IDLType_var &); // copy constructor
+  ~CORBA_IDLType_var (void); // destructor
+  
+  CORBA_IDLType_var &operator= (CORBA_IDLType_ptr);
+  CORBA_IDLType_var &operator= (const CORBA_IDLType_var &);
+  CORBA_IDLType_ptr operator-> (void) const;
+  
+  operator const CORBA_IDLType_ptr &() const;
+  operator CORBA_IDLType_ptr &();
+  // in, inout, out, _retn 
+  CORBA_IDLType_ptr in (void) const;
+  CORBA_IDLType_ptr &inout (void);
+  CORBA_IDLType_ptr &out (void);
+  CORBA_IDLType_ptr _retn (void);
+  CORBA_IDLType_ptr ptr (void) const;
+
+private:
+  CORBA_IDLType_ptr ptr_;
+  // Unimplemented - prevents widening assignment.
+  CORBA_IDLType_var (const TAO_Base_var &rhs);
+  CORBA_IDLType_var &operator= (const TAO_Base_var &rhs);
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_IDLTYPE___OUT_CH_)
+#define _CORBA_IDLTYPE___OUT_CH_
+
+class TAO_IFR_Client_Export CORBA_IDLType_out
+{
+public:
+  CORBA_IDLType_out (CORBA_IDLType_ptr &);
+  CORBA_IDLType_out (CORBA_IDLType_var &);
+  CORBA_IDLType_out (const CORBA_IDLType_out &);
+  CORBA_IDLType_out &operator= (const CORBA_IDLType_out &);
+  CORBA_IDLType_out &operator= (const CORBA_IDLType_var &);
+  CORBA_IDLType_out &operator= (CORBA_IDLType_ptr);
+  operator CORBA_IDLType_ptr &();
+  CORBA_IDLType_ptr &ptr (void);
+  CORBA_IDLType_ptr operator-> (void);
+  
+private:
+  CORBA_IDLType_ptr &ptr_;
+};
+
+
+#endif /* end #if !defined */
+
+struct CORBA_StructMember;
+class CORBA_StructMember_var;
+
+struct TAO_IFR_Client_Export CORBA_StructMember
+{
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef CORBA_StructMember_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  static void _tao_any_destructor (void*);
+
+  TAO_String_Manager name;
+  CORBA::TypeCode_var type;
+  CORBA::IDLType_var type_def;
+};
+
+class TAO_IFR_Client_Export CORBA_StructMember_var
+{
+public:
+  CORBA_StructMember_var (void); // default constructor
+  CORBA_StructMember_var (CORBA_StructMember *);
+  CORBA_StructMember_var (const CORBA_StructMember_var &); // copy constructor
+  ~CORBA_StructMember_var (void); // destructor
+  
+  CORBA_StructMember_var &operator= (CORBA_StructMember *);
+  CORBA_StructMember_var &operator= (const CORBA_StructMember_var &);
+  CORBA_StructMember *operator-> (void);
+  const CORBA_StructMember *operator-> (void) const;
+  
+  operator const CORBA_StructMember &() const;
+  operator CORBA_StructMember &();
+  operator CORBA_StructMember &() const;
+  operator CORBA_StructMember *&(); // variable-size types only
+  
+  // in, inout, out, _retn 
+  const CORBA_StructMember &in (void) const;
+  CORBA_StructMember &inout (void);
+  CORBA_StructMember *&out (void);
+  CORBA_StructMember *_retn (void);
+  CORBA_StructMember *ptr (void) const;
+
+private:
+  CORBA_StructMember *ptr_;
+};
+
+class TAO_IFR_Client_Export CORBA_StructMember_out
+{
+public:
+  CORBA_StructMember_out (CORBA_StructMember *&);
+  CORBA_StructMember_out (CORBA_StructMember_var &);
+  CORBA_StructMember_out (const CORBA_StructMember_out &);
+  CORBA_StructMember_out &operator= (const CORBA_StructMember_out &);
+  CORBA_StructMember_out &operator= (CORBA_StructMember *);
+  operator CORBA_StructMember *&();
+  CORBA_StructMember *&ptr (void);
+  CORBA_StructMember *operator-> (void);
+  
+private:
+  CORBA_StructMember *&ptr_;
+  // assignment from T_var not allowed
+  void operator= (const CORBA_StructMember_var &);
+};
+
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_SEQUENCE_CORBA_STRUCTMEMBERSEQ_CH_)
+#define __TAO_UNBOUNDED_SEQUENCE_CORBA_STRUCTMEMBERSEQ_CH_
+
+  class TAO_EXPORT_NESTED_MACRO _TAO_Unbounded_Sequence_CORBA_StructMemberSeq : public TAO_Unbounded_Base_Sequence
+  {
+  public:
+    // = Initialization and termination methods.
+    
+    _TAO_Unbounded_Sequence_CORBA_StructMemberSeq (void); // Default constructor.
+    _TAO_Unbounded_Sequence_CORBA_StructMemberSeq (CORBA::ULong maximum); 
+    _TAO_Unbounded_Sequence_CORBA_StructMemberSeq (CORBA::ULong maximum,
+      CORBA::ULong length,
+      CORBA_StructMember *data,
+      CORBA::Boolean release = 0);
+    _TAO_Unbounded_Sequence_CORBA_StructMemberSeq (const _TAO_Unbounded_Sequence_CORBA_StructMemberSeq &rhs);
+    _TAO_Unbounded_Sequence_CORBA_StructMemberSeq &operator= (const _TAO_Unbounded_Sequence_CORBA_StructMemberSeq &rhs);
+    virtual ~_TAO_Unbounded_Sequence_CORBA_StructMemberSeq (void); // Dtor.
+    // = Accessors.
+    CORBA_StructMember &operator[] (CORBA::ULong i);
+    const CORBA_StructMember &operator[] (CORBA::ULong i) const;
+    // = Static operations.
+    static CORBA_StructMember *allocbuf (CORBA::ULong size);
+    static void freebuf (CORBA_StructMember *buffer);
+    virtual void _allocate_buffer (CORBA::ULong length);
+    virtual void _deallocate_buffer (void);
+    // Implement the TAO_Base_Sequence methods (see Sequence.h)
+    
+    CORBA_StructMember *get_buffer (CORBA::Boolean orphan = 0);
+    const CORBA_StructMember *get_buffer (void) const;
+    void replace (CORBA::ULong max,
+      CORBA::ULong length,
+      CORBA_StructMember *data,
+      CORBA::Boolean release);
+  };
+
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_CORBA_STRUCTMEMBERSEQ_CH_)
+#define _CORBA_STRUCTMEMBERSEQ_CH_
+
+class CORBA_StructMemberSeq;
+class CORBA_StructMemberSeq_var;
+
+// *************************************************************
+// CORBA_StructMemberSeq
+// *************************************************************
+
+class TAO_IFR_Client_Export CORBA_StructMemberSeq : public 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Sequence_CORBA_StructMemberSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<CORBA_StructMember>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+{
+public:
+  CORBA_StructMemberSeq (void); // default ctor
+  CORBA_StructMemberSeq (CORBA::ULong max); // uses max size
+  CORBA_StructMemberSeq (
+    CORBA::ULong max, 
+    CORBA::ULong length, 
+    CORBA::StructMember *buffer, 
+    CORBA::Boolean release = 0
+  );
+  CORBA_StructMemberSeq (const CORBA_StructMemberSeq &); // copy ctor
+  ~CORBA_StructMemberSeq (void);
+  static void _tao_any_destructor (void*);
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef CORBA_StructMemberSeq_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+};
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_STRUCTMEMBERSEQ___VAR_CH_)
+#define _CORBA_STRUCTMEMBERSEQ___VAR_CH_
+
+// *************************************************************
+// class CORBA_StructMemberSeq_var
+// *************************************************************
+
+class TAO_IFR_Client_Export CORBA_StructMemberSeq_var
+{
+public:
+  CORBA_StructMemberSeq_var (void); // default constructor
+  CORBA_StructMemberSeq_var (CORBA_StructMemberSeq *);
+  CORBA_StructMemberSeq_var (const CORBA_StructMemberSeq_var &); // copy constructor
+  ~CORBA_StructMemberSeq_var (void); // destructor
+  
+  CORBA_StructMemberSeq_var &operator= (CORBA_StructMemberSeq *);
+  CORBA_StructMemberSeq_var &operator= (const CORBA_StructMemberSeq_var &);
+  CORBA_StructMemberSeq *operator-> (void);
+  const CORBA_StructMemberSeq *operator-> (void) const;
+  
+  operator const CORBA_StructMemberSeq &() const;
+  operator CORBA_StructMemberSeq &();
+  operator CORBA_StructMemberSeq &() const;
+  operator CORBA_StructMemberSeq *&(); // variable-size base types only
+  
+  CORBA::StructMember & operator[] (CORBA::ULong index);
+  const CORBA::StructMember & operator[] (CORBA::ULong index) const;
+  
+  // in, inout, out, _retn 
+  const CORBA_StructMemberSeq &in (void) const;
+  CORBA_StructMemberSeq &inout (void);
+  CORBA_StructMemberSeq *&out (void);
+  CORBA_StructMemberSeq *_retn (void);
+  CORBA_StructMemberSeq *ptr (void) const;
+
+private:
+  CORBA_StructMemberSeq *ptr_;
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_STRUCTMEMBERSEQ___OUT_CH_)
+#define _CORBA_STRUCTMEMBERSEQ___OUT_CH_
+
+class TAO_IFR_Client_Export CORBA_StructMemberSeq_out
+{
+public:
+  CORBA_StructMemberSeq_out (CORBA_StructMemberSeq *&);
+  CORBA_StructMemberSeq_out (CORBA_StructMemberSeq_var &);
+  CORBA_StructMemberSeq_out (const CORBA_StructMemberSeq_out &);
+  CORBA_StructMemberSeq_out &operator= (const CORBA_StructMemberSeq_out &);
+  CORBA_StructMemberSeq_out &operator= (CORBA_StructMemberSeq *);
+  operator CORBA_StructMemberSeq *&();
+  CORBA_StructMemberSeq *&ptr (void);
+  CORBA_StructMemberSeq *operator-> (void);
+  CORBA::StructMember & operator[] (CORBA::ULong index);
+  
+private:
+  CORBA_StructMemberSeq *&ptr_;
+  // assignment from T_var not allowed
+  void operator= (const CORBA_StructMemberSeq_var &);
+};
+
+
+#endif /* end #if !defined */
+
+struct CORBA_Initializer;
+class CORBA_Initializer_var;
+
+struct TAO_IFR_Client_Export CORBA_Initializer
+{
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef CORBA_Initializer_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  static void _tao_any_destructor (void*);
+
+  CORBA::StructMemberSeq members;
+  TAO_String_Manager name;
+};
+
+class TAO_IFR_Client_Export CORBA_Initializer_var
+{
+public:
+  CORBA_Initializer_var (void); // default constructor
+  CORBA_Initializer_var (CORBA_Initializer *);
+  CORBA_Initializer_var (const CORBA_Initializer_var &); // copy constructor
+  ~CORBA_Initializer_var (void); // destructor
+  
+  CORBA_Initializer_var &operator= (CORBA_Initializer *);
+  CORBA_Initializer_var &operator= (const CORBA_Initializer_var &);
+  CORBA_Initializer *operator-> (void);
+  const CORBA_Initializer *operator-> (void) const;
+  
+  operator const CORBA_Initializer &() const;
+  operator CORBA_Initializer &();
+  operator CORBA_Initializer &() const;
+  operator CORBA_Initializer *&(); // variable-size types only
+  
+  // in, inout, out, _retn 
+  const CORBA_Initializer &in (void) const;
+  CORBA_Initializer &inout (void);
+  CORBA_Initializer *&out (void);
+  CORBA_Initializer *_retn (void);
+  CORBA_Initializer *ptr (void) const;
+
+private:
+  CORBA_Initializer *ptr_;
+};
+
+class TAO_IFR_Client_Export CORBA_Initializer_out
+{
+public:
+  CORBA_Initializer_out (CORBA_Initializer *&);
+  CORBA_Initializer_out (CORBA_Initializer_var &);
+  CORBA_Initializer_out (const CORBA_Initializer_out &);
+  CORBA_Initializer_out &operator= (const CORBA_Initializer_out &);
+  CORBA_Initializer_out &operator= (CORBA_Initializer *);
+  operator CORBA_Initializer *&();
+  CORBA_Initializer *&ptr (void);
+  CORBA_Initializer *operator-> (void);
+  
+private:
+  CORBA_Initializer *&ptr_;
+  // assignment from T_var not allowed
+  void operator= (const CORBA_Initializer_var &);
+};
+
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_SEQUENCE_CORBA_INITIALIZERSEQ_CH_)
+#define __TAO_UNBOUNDED_SEQUENCE_CORBA_INITIALIZERSEQ_CH_
+
+  class TAO_EXPORT_NESTED_MACRO _TAO_Unbounded_Sequence_CORBA_InitializerSeq : public TAO_Unbounded_Base_Sequence
+  {
+  public:
+    // = Initialization and termination methods.
+    
+    _TAO_Unbounded_Sequence_CORBA_InitializerSeq (void); // Default constructor.
+    _TAO_Unbounded_Sequence_CORBA_InitializerSeq (CORBA::ULong maximum); 
+    _TAO_Unbounded_Sequence_CORBA_InitializerSeq (CORBA::ULong maximum,
+      CORBA::ULong length,
+      CORBA_Initializer *data,
+      CORBA::Boolean release = 0);
+    _TAO_Unbounded_Sequence_CORBA_InitializerSeq (const _TAO_Unbounded_Sequence_CORBA_InitializerSeq &rhs);
+    _TAO_Unbounded_Sequence_CORBA_InitializerSeq &operator= (const _TAO_Unbounded_Sequence_CORBA_InitializerSeq &rhs);
+    virtual ~_TAO_Unbounded_Sequence_CORBA_InitializerSeq (void); // Dtor.
+    // = Accessors.
+    CORBA_Initializer &operator[] (CORBA::ULong i);
+    const CORBA_Initializer &operator[] (CORBA::ULong i) const;
+    // = Static operations.
+    static CORBA_Initializer *allocbuf (CORBA::ULong size);
+    static void freebuf (CORBA_Initializer *buffer);
+    virtual void _allocate_buffer (CORBA::ULong length);
+    virtual void _deallocate_buffer (void);
+    // Implement the TAO_Base_Sequence methods (see Sequence.h)
+    
+    CORBA_Initializer *get_buffer (CORBA::Boolean orphan = 0);
+    const CORBA_Initializer *get_buffer (void) const;
+    void replace (CORBA::ULong max,
+      CORBA::ULong length,
+      CORBA_Initializer *data,
+      CORBA::Boolean release);
+  };
+
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_CORBA_INITIALIZERSEQ_CH_)
+#define _CORBA_INITIALIZERSEQ_CH_
+
+class CORBA_InitializerSeq;
+class CORBA_InitializerSeq_var;
+
+// *************************************************************
+// CORBA_InitializerSeq
+// *************************************************************
+
+class TAO_IFR_Client_Export CORBA_InitializerSeq : public 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Sequence_CORBA_InitializerSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<CORBA_Initializer>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+{
+public:
+  CORBA_InitializerSeq (void); // default ctor
+  CORBA_InitializerSeq (CORBA::ULong max); // uses max size
+  CORBA_InitializerSeq (
+    CORBA::ULong max, 
+    CORBA::ULong length, 
+    CORBA::Initializer *buffer, 
+    CORBA::Boolean release = 0
+  );
+  CORBA_InitializerSeq (const CORBA_InitializerSeq &); // copy ctor
+  ~CORBA_InitializerSeq (void);
+  static void _tao_any_destructor (void*);
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef CORBA_InitializerSeq_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+};
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_INITIALIZERSEQ___VAR_CH_)
+#define _CORBA_INITIALIZERSEQ___VAR_CH_
+
+// *************************************************************
+// class CORBA_InitializerSeq_var
+// *************************************************************
+
+class TAO_IFR_Client_Export CORBA_InitializerSeq_var
+{
+public:
+  CORBA_InitializerSeq_var (void); // default constructor
+  CORBA_InitializerSeq_var (CORBA_InitializerSeq *);
+  CORBA_InitializerSeq_var (const CORBA_InitializerSeq_var &); // copy constructor
+  ~CORBA_InitializerSeq_var (void); // destructor
+  
+  CORBA_InitializerSeq_var &operator= (CORBA_InitializerSeq *);
+  CORBA_InitializerSeq_var &operator= (const CORBA_InitializerSeq_var &);
+  CORBA_InitializerSeq *operator-> (void);
+  const CORBA_InitializerSeq *operator-> (void) const;
+  
+  operator const CORBA_InitializerSeq &() const;
+  operator CORBA_InitializerSeq &();
+  operator CORBA_InitializerSeq &() const;
+  operator CORBA_InitializerSeq *&(); // variable-size base types only
+  
+  CORBA::Initializer & operator[] (CORBA::ULong index);
+  const CORBA::Initializer & operator[] (CORBA::ULong index) const;
+  
+  // in, inout, out, _retn 
+  const CORBA_InitializerSeq &in (void) const;
+  CORBA_InitializerSeq &inout (void);
+  CORBA_InitializerSeq *&out (void);
+  CORBA_InitializerSeq *_retn (void);
+  CORBA_InitializerSeq *ptr (void) const;
+
+private:
+  CORBA_InitializerSeq *ptr_;
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_INITIALIZERSEQ___OUT_CH_)
+#define _CORBA_INITIALIZERSEQ___OUT_CH_
+
+class TAO_IFR_Client_Export CORBA_InitializerSeq_out
+{
+public:
+  CORBA_InitializerSeq_out (CORBA_InitializerSeq *&);
+  CORBA_InitializerSeq_out (CORBA_InitializerSeq_var &);
+  CORBA_InitializerSeq_out (const CORBA_InitializerSeq_out &);
+  CORBA_InitializerSeq_out &operator= (const CORBA_InitializerSeq_out &);
+  CORBA_InitializerSeq_out &operator= (CORBA_InitializerSeq *);
+  operator CORBA_InitializerSeq *&();
+  CORBA_InitializerSeq *&ptr (void);
+  CORBA_InitializerSeq *operator-> (void);
+  CORBA::Initializer & operator[] (CORBA::ULong index);
+  
+private:
+  CORBA_InitializerSeq *&ptr_;
+  // assignment from T_var not allowed
+  void operator= (const CORBA_InitializerSeq_var &);
+};
+
+
+#endif /* end #if !defined */
+
+struct CORBA_UnionMember;
+class CORBA_UnionMember_var;
+
+struct TAO_IFR_Client_Export CORBA_UnionMember
+{
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef CORBA_UnionMember_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  static void _tao_any_destructor (void*);
+
+  TAO_String_Manager name;
+  CORBA::Any label;
+  CORBA::TypeCode_var type;
+  CORBA::IDLType_var type_def;
+};
+
+class TAO_IFR_Client_Export CORBA_UnionMember_var
+{
+public:
+  CORBA_UnionMember_var (void); // default constructor
+  CORBA_UnionMember_var (CORBA_UnionMember *);
+  CORBA_UnionMember_var (const CORBA_UnionMember_var &); // copy constructor
+  ~CORBA_UnionMember_var (void); // destructor
+  
+  CORBA_UnionMember_var &operator= (CORBA_UnionMember *);
+  CORBA_UnionMember_var &operator= (const CORBA_UnionMember_var &);
+  CORBA_UnionMember *operator-> (void);
+  const CORBA_UnionMember *operator-> (void) const;
+  
+  operator const CORBA_UnionMember &() const;
+  operator CORBA_UnionMember &();
+  operator CORBA_UnionMember &() const;
+  operator CORBA_UnionMember *&(); // variable-size types only
+  
+  // in, inout, out, _retn 
+  const CORBA_UnionMember &in (void) const;
+  CORBA_UnionMember &inout (void);
+  CORBA_UnionMember *&out (void);
+  CORBA_UnionMember *_retn (void);
+  CORBA_UnionMember *ptr (void) const;
+
+private:
+  CORBA_UnionMember *ptr_;
+};
+
+class TAO_IFR_Client_Export CORBA_UnionMember_out
+{
+public:
+  CORBA_UnionMember_out (CORBA_UnionMember *&);
+  CORBA_UnionMember_out (CORBA_UnionMember_var &);
+  CORBA_UnionMember_out (const CORBA_UnionMember_out &);
+  CORBA_UnionMember_out &operator= (const CORBA_UnionMember_out &);
+  CORBA_UnionMember_out &operator= (CORBA_UnionMember *);
+  operator CORBA_UnionMember *&();
+  CORBA_UnionMember *&ptr (void);
+  CORBA_UnionMember *operator-> (void);
+  
+private:
+  CORBA_UnionMember *&ptr_;
+  // assignment from T_var not allowed
+  void operator= (const CORBA_UnionMember_var &);
+};
+
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_SEQUENCE_CORBA_UNIONMEMBERSEQ_CH_)
+#define __TAO_UNBOUNDED_SEQUENCE_CORBA_UNIONMEMBERSEQ_CH_
+
+  class TAO_EXPORT_NESTED_MACRO _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq : public TAO_Unbounded_Base_Sequence
+  {
+  public:
+    // = Initialization and termination methods.
+    
+    _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq (void); // Default constructor.
+    _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq (CORBA::ULong maximum); 
+    _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq (CORBA::ULong maximum,
+      CORBA::ULong length,
+      CORBA_UnionMember *data,
+      CORBA::Boolean release = 0);
+    _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq (const _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq &rhs);
+    _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq &operator= (const _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq &rhs);
+    virtual ~_TAO_Unbounded_Sequence_CORBA_UnionMemberSeq (void); // Dtor.
+    // = Accessors.
+    CORBA_UnionMember &operator[] (CORBA::ULong i);
+    const CORBA_UnionMember &operator[] (CORBA::ULong i) const;
+    // = Static operations.
+    static CORBA_UnionMember *allocbuf (CORBA::ULong size);
+    static void freebuf (CORBA_UnionMember *buffer);
+    virtual void _allocate_buffer (CORBA::ULong length);
+    virtual void _deallocate_buffer (void);
+    // Implement the TAO_Base_Sequence methods (see Sequence.h)
+    
+    CORBA_UnionMember *get_buffer (CORBA::Boolean orphan = 0);
+    const CORBA_UnionMember *get_buffer (void) const;
+    void replace (CORBA::ULong max,
+      CORBA::ULong length,
+      CORBA_UnionMember *data,
+      CORBA::Boolean release);
+  };
+
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_CORBA_UNIONMEMBERSEQ_CH_)
+#define _CORBA_UNIONMEMBERSEQ_CH_
+
+class CORBA_UnionMemberSeq;
+class CORBA_UnionMemberSeq_var;
+
+// *************************************************************
+// CORBA_UnionMemberSeq
+// *************************************************************
+
+class TAO_IFR_Client_Export CORBA_UnionMemberSeq : public 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<CORBA_UnionMember>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+{
+public:
+  CORBA_UnionMemberSeq (void); // default ctor
+  CORBA_UnionMemberSeq (CORBA::ULong max); // uses max size
+  CORBA_UnionMemberSeq (
+    CORBA::ULong max, 
+    CORBA::ULong length, 
+    CORBA::UnionMember *buffer, 
+    CORBA::Boolean release = 0
+  );
+  CORBA_UnionMemberSeq (const CORBA_UnionMemberSeq &); // copy ctor
+  ~CORBA_UnionMemberSeq (void);
+  static void _tao_any_destructor (void*);
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef CORBA_UnionMemberSeq_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+};
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_UNIONMEMBERSEQ___VAR_CH_)
+#define _CORBA_UNIONMEMBERSEQ___VAR_CH_
+
+// *************************************************************
+// class CORBA_UnionMemberSeq_var
+// *************************************************************
+
+class TAO_IFR_Client_Export CORBA_UnionMemberSeq_var
+{
+public:
+  CORBA_UnionMemberSeq_var (void); // default constructor
+  CORBA_UnionMemberSeq_var (CORBA_UnionMemberSeq *);
+  CORBA_UnionMemberSeq_var (const CORBA_UnionMemberSeq_var &); // copy constructor
+  ~CORBA_UnionMemberSeq_var (void); // destructor
+  
+  CORBA_UnionMemberSeq_var &operator= (CORBA_UnionMemberSeq *);
+  CORBA_UnionMemberSeq_var &operator= (const CORBA_UnionMemberSeq_var &);
+  CORBA_UnionMemberSeq *operator-> (void);
+  const CORBA_UnionMemberSeq *operator-> (void) const;
+  
+  operator const CORBA_UnionMemberSeq &() const;
+  operator CORBA_UnionMemberSeq &();
+  operator CORBA_UnionMemberSeq &() const;
+  operator CORBA_UnionMemberSeq *&(); // variable-size base types only
+  
+  CORBA::UnionMember & operator[] (CORBA::ULong index);
+  const CORBA::UnionMember & operator[] (CORBA::ULong index) const;
+  
+  // in, inout, out, _retn 
+  const CORBA_UnionMemberSeq &in (void) const;
+  CORBA_UnionMemberSeq &inout (void);
+  CORBA_UnionMemberSeq *&out (void);
+  CORBA_UnionMemberSeq *_retn (void);
+  CORBA_UnionMemberSeq *ptr (void) const;
+
+private:
+  CORBA_UnionMemberSeq *ptr_;
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_UNIONMEMBERSEQ___OUT_CH_)
+#define _CORBA_UNIONMEMBERSEQ___OUT_CH_
+
+class TAO_IFR_Client_Export CORBA_UnionMemberSeq_out
+{
+public:
+  CORBA_UnionMemberSeq_out (CORBA_UnionMemberSeq *&);
+  CORBA_UnionMemberSeq_out (CORBA_UnionMemberSeq_var &);
+  CORBA_UnionMemberSeq_out (const CORBA_UnionMemberSeq_out &);
+  CORBA_UnionMemberSeq_out &operator= (const CORBA_UnionMemberSeq_out &);
+  CORBA_UnionMemberSeq_out &operator= (CORBA_UnionMemberSeq *);
+  operator CORBA_UnionMemberSeq *&();
+  CORBA_UnionMemberSeq *&ptr (void);
+  CORBA_UnionMemberSeq *operator-> (void);
+  CORBA::UnionMember & operator[] (CORBA::ULong index);
+  
+private:
+  CORBA_UnionMemberSeq *&ptr_;
+  // assignment from T_var not allowed
+  void operator= (const CORBA_UnionMemberSeq_var &);
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_ENUMMEMBERSEQ_CH_)
+#define _CORBA_ENUMMEMBERSEQ_CH_
+
+class CORBA_EnumMemberSeq;
+class CORBA_EnumMemberSeq_var;
+
+// *************************************************************
+// CORBA_EnumMemberSeq
+// *************************************************************
+
+class TAO_IFR_Client_Export CORBA_EnumMemberSeq : public 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  TAO_Unbounded_String_Sequence
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_String_Sequence
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+{
+public:
+  CORBA_EnumMemberSeq (void); // default ctor
+  CORBA_EnumMemberSeq (CORBA::ULong max); // uses max size
+  CORBA_EnumMemberSeq (
+    CORBA::ULong max, 
+    CORBA::ULong length, 
+    char * *buffer, 
+    CORBA::Boolean release = 0
+  );
+  CORBA_EnumMemberSeq (const CORBA_EnumMemberSeq &); // copy ctor
+  ~CORBA_EnumMemberSeq (void);
+  static void _tao_any_destructor (void*);
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef CORBA_EnumMemberSeq_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+};
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_ENUMMEMBERSEQ___VAR_CH_)
+#define _CORBA_ENUMMEMBERSEQ___VAR_CH_
+
+// *************************************************************
+// class CORBA_EnumMemberSeq_var
+// *************************************************************
+
+class TAO_IFR_Client_Export CORBA_EnumMemberSeq_var
+{
+public:
+  CORBA_EnumMemberSeq_var (void); // default constructor
+  CORBA_EnumMemberSeq_var (CORBA_EnumMemberSeq *);
+  CORBA_EnumMemberSeq_var (const CORBA_EnumMemberSeq_var &); // copy constructor
+  ~CORBA_EnumMemberSeq_var (void); // destructor
+  
+  CORBA_EnumMemberSeq_var &operator= (CORBA_EnumMemberSeq *);
+  CORBA_EnumMemberSeq_var &operator= (const CORBA_EnumMemberSeq_var &);
+  CORBA_EnumMemberSeq *operator-> (void);
+  const CORBA_EnumMemberSeq *operator-> (void) const;
+  
+  operator const CORBA_EnumMemberSeq &() const;
+  operator CORBA_EnumMemberSeq &();
+  operator CORBA_EnumMemberSeq &() const;
+  operator CORBA_EnumMemberSeq *&(); // variable-size base types only
+  
+  TAO_SeqElem_String_Manager operator[] (CORBA::ULong index);
+  
+  // in, inout, out, _retn 
+  const CORBA_EnumMemberSeq &in (void) const;
+  CORBA_EnumMemberSeq &inout (void);
+  CORBA_EnumMemberSeq *&out (void);
+  CORBA_EnumMemberSeq *_retn (void);
+  CORBA_EnumMemberSeq *ptr (void) const;
+
+private:
+  CORBA_EnumMemberSeq *ptr_;
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_ENUMMEMBERSEQ___OUT_CH_)
+#define _CORBA_ENUMMEMBERSEQ___OUT_CH_
+
+class TAO_IFR_Client_Export CORBA_EnumMemberSeq_out
+{
+public:
+  CORBA_EnumMemberSeq_out (CORBA_EnumMemberSeq *&);
+  CORBA_EnumMemberSeq_out (CORBA_EnumMemberSeq_var &);
+  CORBA_EnumMemberSeq_out (const CORBA_EnumMemberSeq_out &);
+  CORBA_EnumMemberSeq_out &operator= (const CORBA_EnumMemberSeq_out &);
+  CORBA_EnumMemberSeq_out &operator= (CORBA_EnumMemberSeq *);
+  operator CORBA_EnumMemberSeq *&();
+  CORBA_EnumMemberSeq *&ptr (void);
+  CORBA_EnumMemberSeq *operator-> (void);
+  TAO_SeqElem_String_Manager operator[] (CORBA::ULong index);
+  
+private:
+  CORBA_EnumMemberSeq *&ptr_;
+  // assignment from T_var not allowed
+  void operator= (const CORBA_EnumMemberSeq_var &);
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_CONTAINER___VAR_CH_)
+#define _CORBA_CONTAINER___VAR_CH_
+
+class TAO_IFR_Client_Export CORBA_Container_var : public TAO_Base_var
+{
+public:
+  CORBA_Container_var (void); // default constructor
+  CORBA_Container_var (CORBA_Container_ptr p) : ptr_ (p) {} 
+  CORBA_Container_var (const CORBA_Container_var &); // copy constructor
+  ~CORBA_Container_var (void); // destructor
+  
+  CORBA_Container_var &operator= (CORBA_Container_ptr);
+  CORBA_Container_var &operator= (const CORBA_Container_var &);
+  CORBA_Container_ptr operator-> (void) const;
+  
+  operator const CORBA_Container_ptr &() const;
+  operator CORBA_Container_ptr &();
+  // in, inout, out, _retn 
+  CORBA_Container_ptr in (void) const;
+  CORBA_Container_ptr &inout (void);
+  CORBA_Container_ptr &out (void);
+  CORBA_Container_ptr _retn (void);
+  CORBA_Container_ptr ptr (void) const;
+
+private:
+  CORBA_Container_ptr ptr_;
+  // Unimplemented - prevents widening assignment.
+  CORBA_Container_var (const TAO_Base_var &rhs);
+  CORBA_Container_var &operator= (const TAO_Base_var &rhs);
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_CONTAINER___OUT_CH_)
+#define _CORBA_CONTAINER___OUT_CH_
+
+class TAO_IFR_Client_Export CORBA_Container_out
+{
+public:
+  CORBA_Container_out (CORBA_Container_ptr &);
+  CORBA_Container_out (CORBA_Container_var &);
+  CORBA_Container_out (const CORBA_Container_out &);
+  CORBA_Container_out &operator= (const CORBA_Container_out &);
+  CORBA_Container_out &operator= (const CORBA_Container_var &);
+  CORBA_Container_out &operator= (CORBA_Container_ptr);
+  operator CORBA_Container_ptr &();
+  CORBA_Container_ptr &ptr (void);
+  CORBA_Container_ptr operator-> (void);
+  
+private:
+  CORBA_Container_ptr &ptr_;
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_CONTAINER_CH_)
+#define _CORBA_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_IFR_Client_Export CORBA_Container: public virtual CORBA_IRObject
+{
+public:
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef CORBA_Container_ptr _ptr_type;
+  typedef CORBA_Container_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  // the static operations
+  static CORBA_Container_ptr _duplicate (CORBA_Container_ptr obj);
+  static CORBA_Container_ptr _narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    );
+  static CORBA_Container_ptr _unchecked_narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    );
+  static CORBA_Container_ptr _nil (void)
+    {
+      return (CORBA_Container_ptr)0;
+    }
+
+  static void _tao_any_destructor (void*);
+
+  virtual CORBA::Contained_ptr lookup (
+      const char * search_name,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::ContainedSeq * contents (
+      CORBA::DefinitionKind limit_type,
+      CORBA::Boolean exclude_inherited,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::ContainedSeq * lookup_name (
+      const char * search_name,
+      CORBA::Long levels_to_search,
+      CORBA::DefinitionKind limit_type,
+      CORBA::Boolean exclude_inherited,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  struct Description;
+  class Description_var;
+  
+  struct TAO_IFR_Client_Export Description
+  {
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+    typedef Description_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+    static void _tao_any_destructor (void*);
+
+    CORBA::Contained_var contained_object;
+    CORBA::DefinitionKind kind;
+    CORBA::Any value;
+  };
+
+  class TAO_IFR_Client_Export Description_var
+  {
+  public:
+    Description_var (void); // default constructor
+    Description_var (Description *);
+    Description_var (const Description_var &); // copy constructor
+    ~Description_var (void); // destructor
+    
+    Description_var &operator= (Description *);
+    Description_var &operator= (const Description_var &);
+    Description *operator-> (void);
+    const Description *operator-> (void) const;
+    
+    operator const Description &() const;
+    operator Description &();
+    operator Description &() const;
+    operator Description *&(); // variable-size types only
+    
+    // in, inout, out, _retn 
+    const Description &in (void) const;
+    Description &inout (void);
+    Description *&out (void);
+    Description *_retn (void);
+    Description *ptr (void) const;
+
+  private:
+    Description *ptr_;
+  };
+
+  class TAO_IFR_Client_Export Description_out
+  {
+  public:
+    Description_out (Description *&);
+    Description_out (Description_var &);
+    Description_out (const Description_out &);
+    Description_out &operator= (const Description_out &);
+    Description_out &operator= (Description *);
+    operator Description *&();
+    Description *&ptr (void);
+    Description *operator-> (void);
+    
+  private:
+    Description *&ptr_;
+    // assignment from T_var not allowed
+    void operator= (const Description_var &);
+  };
+
+  static CORBA::TypeCode_ptr _tc_Description;
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+    
+#if !defined (__TAO_UNBOUNDED_SEQUENCE_CORBA_CONTAINER_DESCRIPTIONSEQ_CH_)
+#define __TAO_UNBOUNDED_SEQUENCE_CORBA_CONTAINER_DESCRIPTIONSEQ_CH_
+
+    class TAO_EXPORT_NESTED_MACRO _TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq : public TAO_Unbounded_Base_Sequence
+    {
+    public:
+      // = Initialization and termination methods.
+      
+      _TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq (void); // Default constructor.
+      _TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq (CORBA::ULong maximum); 
+      _TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq (CORBA::ULong maximum,
+        CORBA::ULong length,
+        Description *data,
+        CORBA::Boolean release = 0);
+      _TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq (const _TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq &rhs);
+      _TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq &operator= (const _TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq &rhs);
+      virtual ~_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq (void); // Dtor.
+      // = Accessors.
+      Description &operator[] (CORBA::ULong i);
+      const Description &operator[] (CORBA::ULong i) const;
+      // = Static operations.
+      static Description *allocbuf (CORBA::ULong size);
+      static void freebuf (Description *buffer);
+      virtual void _allocate_buffer (CORBA::ULong length);
+      virtual void _deallocate_buffer (void);
+      // Implement the TAO_Base_Sequence methods (see Sequence.h)
+      
+      Description *get_buffer (CORBA::Boolean orphan = 0);
+      const Description *get_buffer (void) const;
+      void replace (CORBA::ULong max,
+        CORBA::ULong length,
+        Description *data,
+        CORBA::Boolean release);
+    };
+
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+  
+#if !defined (_CORBA_CONTAINER_DESCRIPTIONSEQ_CH_)
+#define _CORBA_CONTAINER_DESCRIPTIONSEQ_CH_
+
+  class DescriptionSeq;
+  class DescriptionSeq_var;
+  
+  // *************************************************************
+  // DescriptionSeq
+  // *************************************************************
+  
+  class TAO_IFR_Client_Export DescriptionSeq : public 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+    _TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+    TAO_Unbounded_Sequence<Description>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+  {
+  public:
+    DescriptionSeq (void); // default ctor
+    DescriptionSeq (CORBA::ULong max); // uses max size
+    DescriptionSeq (
+      CORBA::ULong max, 
+      CORBA::ULong length, 
+      Description *buffer, 
+      CORBA::Boolean release = 0
+    );
+    DescriptionSeq (const DescriptionSeq &); // copy ctor
+    ~DescriptionSeq (void);
+    static void _tao_any_destructor (void*);
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+    typedef DescriptionSeq_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  };
+  
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_CONTAINER_DESCRIPTIONSEQ___VAR_CH_)
+#define _CORBA_CONTAINER_DESCRIPTIONSEQ___VAR_CH_
+
+  // *************************************************************
+  // class DescriptionSeq_var
+  // *************************************************************
+
+  class TAO_IFR_Client_Export DescriptionSeq_var
+  {
+  public:
+    DescriptionSeq_var (void); // default constructor
+    DescriptionSeq_var (DescriptionSeq *);
+    DescriptionSeq_var (const DescriptionSeq_var &); // copy constructor
+    ~DescriptionSeq_var (void); // destructor
+    
+    DescriptionSeq_var &operator= (DescriptionSeq *);
+    DescriptionSeq_var &operator= (const DescriptionSeq_var &);
+    DescriptionSeq *operator-> (void);
+    const DescriptionSeq *operator-> (void) const;
+    
+    operator const DescriptionSeq &() const;
+    operator DescriptionSeq &();
+    operator DescriptionSeq &() const;
+    operator DescriptionSeq *&(); // variable-size base types only
+    
+    Description & operator[] (CORBA::ULong index);
+    const Description & operator[] (CORBA::ULong index) const;
+    
+    // in, inout, out, _retn 
+    const DescriptionSeq &in (void) const;
+    DescriptionSeq &inout (void);
+    DescriptionSeq *&out (void);
+    DescriptionSeq *_retn (void);
+    DescriptionSeq *ptr (void) const;
+
+  private:
+    DescriptionSeq *ptr_;
+  };
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_CONTAINER_DESCRIPTIONSEQ___OUT_CH_)
+#define _CORBA_CONTAINER_DESCRIPTIONSEQ___OUT_CH_
+
+  class TAO_IFR_Client_Export DescriptionSeq_out
+  {
+  public:
+    DescriptionSeq_out (DescriptionSeq *&);
+    DescriptionSeq_out (DescriptionSeq_var &);
+    DescriptionSeq_out (const DescriptionSeq_out &);
+    DescriptionSeq_out &operator= (const DescriptionSeq_out &);
+    DescriptionSeq_out &operator= (DescriptionSeq *);
+    operator DescriptionSeq *&();
+    DescriptionSeq *&ptr (void);
+    DescriptionSeq *operator-> (void);
+    Description & operator[] (CORBA::ULong index);
+    
+  private:
+    DescriptionSeq *&ptr_;
+    // assignment from T_var not allowed
+    void operator= (const DescriptionSeq_var &);
+  };
+
+  static CORBA::TypeCode_ptr _tc_DescriptionSeq;
+
+#endif /* end #if !defined */
+
+  virtual CORBA::Container::DescriptionSeq * describe_contents (
+      CORBA::DefinitionKind limit_type,
+      CORBA::Boolean exclude_inherited,
+      CORBA::Long max_returned_objs,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::ModuleDef_ptr create_module (
+      const char * id,
+      const char * name,
+      const char * version,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::ConstantDef_ptr create_constant (
+      const char * id,
+      const char * name,
+      const char * version,
+      CORBA::IDLType_ptr type,
+      const CORBA::Any & value,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::StructDef_ptr create_struct (
+      const char * id,
+      const char * name,
+      const char * version,
+      const CORBA::StructMemberSeq & members,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::UnionDef_ptr create_union (
+      const char * id,
+      const char * name,
+      const char * version,
+      CORBA::IDLType_ptr discriminator_type,
+      const CORBA::UnionMemberSeq & members,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::EnumDef_ptr create_enum (
+      const char * id,
+      const char * name,
+      const char * version,
+      const CORBA::EnumMemberSeq & members,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::AliasDef_ptr create_alias (
+      const char * id,
+      const char * name,
+      const char * version,
+      CORBA::IDLType_ptr original_type,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::InterfaceDef_ptr create_interface (
+      const char * id,
+      const char * name,
+      const char * version,
+      const CORBA::InterfaceDefSeq & base_interfaces,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::ValueDef_ptr create_value (
+      const char * id,
+      const char * name,
+      const char * version,
+      CORBA::Boolean is_custom,
+      CORBA::Boolean is_abstract,
+      CORBA::ValueDef_ptr base_value,
+      CORBA::Boolean is_truncatable,
+      const CORBA::ValueDefSeq & abstract_base_values,
+      const CORBA::InterfaceDefSeq & supported_interfaces,
+      const CORBA::InitializerSeq & initializers,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::ValueBoxDef_ptr create_value_box (
+      const char * id,
+      const char * name,
+      const char * version,
+      CORBA::IDLType_ptr original_type_def,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::ExceptionDef_ptr create_exception (
+      const char * id,
+      const char * name,
+      const char * version,
+      const CORBA::StructMemberSeq & members,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::NativeDef_ptr create_native (
+      const char * id,
+      const char * name,
+      const char * version,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::AbstractInterfaceDef_ptr create_abstract_interface (
+      const char * id,
+      const char * name,
+      const char * version,
+      const CORBA::AbstractInterfaceDefSeq & base_interfaces,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::LocalInterfaceDef_ptr create_local_interface (
+      const char * id,
+      const char * name,
+      const char * version,
+      const CORBA::InterfaceDefSeq & base_interfaces,
+      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_Container_Proxy_Broker *the_TAO_Container_Proxy_Broker_;
+  
+protected:
+  CORBA_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 CORBA_Container_setup_collocation (int collocated);
+    
+    CORBA_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 ~CORBA_Container (void);
+private:
+  CORBA_Container (const CORBA_Container &);
+  void operator= (const CORBA_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_CORBA_Container_lookup : public TAO_ClientRequestInfo
+  {
+  public:
+    friend class CORBA_Container;
+    
+    friend class _TAO_Container_Remote_Proxy_Impl;
+    friend class _TAO_Container_ThruPOA_Proxy_Impl;
+    friend class _TAO_Container_Direct_Proxy_Impl;
+  
+  TAO_ClientRequestInfo_CORBA_Container_lookup (
+      TAO_GIOP_Invocation *_tao_invocation,
+      CORBA::Object_ptr _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_CORBA_Container_lookup (const TAO_ClientRequestInfo_CORBA_Container_lookup &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_Container_lookup &);
+  const char * search_name_;
+  void result (CORBA::Contained_ptr result);
+  // update the result 
+  CORBA::Contained_ptr _result;
+};
+
+class TAO_ClientRequestInfo_CORBA_Container_contents : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_Container;
+  
+  friend class _TAO_Container_Remote_Proxy_Impl;
+  friend class _TAO_Container_ThruPOA_Proxy_Impl;
+  friend class _TAO_Container_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_Container_contents (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::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_CORBA_Container_contents (const TAO_ClientRequestInfo_CORBA_Container_contents &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_Container_contents &);
+  const CORBA::DefinitionKind & limit_type_;
+  const CORBA::Boolean & exclude_inherited_;
+  void result (CORBA::ContainedSeq * result);
+  // update the result 
+  CORBA::ContainedSeq * _result;
+};
+
+class TAO_ClientRequestInfo_CORBA_Container_lookup_name : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_Container;
+  
+  friend class _TAO_Container_Remote_Proxy_Impl;
+  friend class _TAO_Container_ThruPOA_Proxy_Impl;
+  friend class _TAO_Container_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_Container_lookup_name (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const char * search_name,
+    const CORBA::Long & levels_to_search,
+    CORBA::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_CORBA_Container_lookup_name (const TAO_ClientRequestInfo_CORBA_Container_lookup_name &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_Container_lookup_name &);
+  const char * search_name_;
+  const CORBA::Long & levels_to_search_;
+  const CORBA::DefinitionKind & limit_type_;
+  const CORBA::Boolean & exclude_inherited_;
+  void result (CORBA::ContainedSeq * result);
+  // update the result 
+  CORBA::ContainedSeq * _result;
+};
+
+class TAO_ClientRequestInfo_CORBA_Container_describe_contents : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_Container;
+  
+  friend class _TAO_Container_Remote_Proxy_Impl;
+  friend class _TAO_Container_ThruPOA_Proxy_Impl;
+  friend class _TAO_Container_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_Container_describe_contents (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::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_CORBA_Container_describe_contents (const TAO_ClientRequestInfo_CORBA_Container_describe_contents &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_Container_describe_contents &);
+  const CORBA::DefinitionKind & limit_type_;
+  const CORBA::Boolean & exclude_inherited_;
+  const CORBA::Long & max_returned_objs_;
+  void result (ACE_NESTED_CLASS (CORBA::Container,DescriptionSeq) * result);
+  // update the result 
+  ACE_NESTED_CLASS (CORBA::Container,DescriptionSeq) * _result;
+};
+
+class TAO_ClientRequestInfo_CORBA_Container_create_module : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_Container;
+  
+  friend class _TAO_Container_Remote_Proxy_Impl;
+  friend class _TAO_Container_ThruPOA_Proxy_Impl;
+  friend class _TAO_Container_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_Container_create_module (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _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_CORBA_Container_create_module (const TAO_ClientRequestInfo_CORBA_Container_create_module &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_Container_create_module &);
+  const char * id_;
+  const char * name_;
+  const char * version_;
+  void result (CORBA::ModuleDef_ptr result);
+  // update the result 
+  CORBA::ModuleDef_ptr _result;
+};
+
+class TAO_ClientRequestInfo_CORBA_Container_create_constant : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_Container;
+  
+  friend class _TAO_Container_Remote_Proxy_Impl;
+  friend class _TAO_Container_ThruPOA_Proxy_Impl;
+  friend class _TAO_Container_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_Container_create_constant (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const char * id,
+    const char * name,
+    const char * version,
+    CORBA::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_CORBA_Container_create_constant (const TAO_ClientRequestInfo_CORBA_Container_create_constant &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_Container_create_constant &);
+  const char * id_;
+  const char * name_;
+  const char * version_;
+  CORBA::IDLType_ptr type_;
+  const CORBA::Any & value_;
+  void result (CORBA::ConstantDef_ptr result);
+  // update the result 
+  CORBA::ConstantDef_ptr _result;
+};
+
+class TAO_ClientRequestInfo_CORBA_Container_create_struct : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_Container;
+  
+  friend class _TAO_Container_Remote_Proxy_Impl;
+  friend class _TAO_Container_ThruPOA_Proxy_Impl;
+  friend class _TAO_Container_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_Container_create_struct (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const char * id,
+    const char * name,
+    const char * version,
+    const CORBA::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_CORBA_Container_create_struct (const TAO_ClientRequestInfo_CORBA_Container_create_struct &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_Container_create_struct &);
+  const char * id_;
+  const char * name_;
+  const char * version_;
+  const CORBA::StructMemberSeq & members_;
+  void result (CORBA::StructDef_ptr result);
+  // update the result 
+  CORBA::StructDef_ptr _result;
+};
+
+class TAO_ClientRequestInfo_CORBA_Container_create_union : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_Container;
+  
+  friend class _TAO_Container_Remote_Proxy_Impl;
+  friend class _TAO_Container_ThruPOA_Proxy_Impl;
+  friend class _TAO_Container_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_Container_create_union (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const char * id,
+    const char * name,
+    const char * version,
+    CORBA::IDLType_ptr discriminator_type,
+    const CORBA::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_CORBA_Container_create_union (const TAO_ClientRequestInfo_CORBA_Container_create_union &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_Container_create_union &);
+  const char * id_;
+  const char * name_;
+  const char * version_;
+  CORBA::IDLType_ptr discriminator_type_;
+  const CORBA::UnionMemberSeq & members_;
+  void result (CORBA::UnionDef_ptr result);
+  // update the result 
+  CORBA::UnionDef_ptr _result;
+};
+
+class TAO_ClientRequestInfo_CORBA_Container_create_enum : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_Container;
+  
+  friend class _TAO_Container_Remote_Proxy_Impl;
+  friend class _TAO_Container_ThruPOA_Proxy_Impl;
+  friend class _TAO_Container_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_Container_create_enum (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const char * id,
+    const char * name,
+    const char * version,
+    const CORBA::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_CORBA_Container_create_enum (const TAO_ClientRequestInfo_CORBA_Container_create_enum &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_Container_create_enum &);
+  const char * id_;
+  const char * name_;
+  const char * version_;
+  const CORBA::EnumMemberSeq & members_;
+  void result (CORBA::EnumDef_ptr result);
+  // update the result 
+  CORBA::EnumDef_ptr _result;
+};
+
+class TAO_ClientRequestInfo_CORBA_Container_create_alias : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_Container;
+  
+  friend class _TAO_Container_Remote_Proxy_Impl;
+  friend class _TAO_Container_ThruPOA_Proxy_Impl;
+  friend class _TAO_Container_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_Container_create_alias (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const char * id,
+    const char * name,
+    const char * version,
+    CORBA::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_CORBA_Container_create_alias (const TAO_ClientRequestInfo_CORBA_Container_create_alias &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_Container_create_alias &);
+  const char * id_;
+  const char * name_;
+  const char * version_;
+  CORBA::IDLType_ptr original_type_;
+  void result (CORBA::AliasDef_ptr result);
+  // update the result 
+  CORBA::AliasDef_ptr _result;
+};
+
+class TAO_ClientRequestInfo_CORBA_Container_create_interface : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_Container;
+  
+  friend class _TAO_Container_Remote_Proxy_Impl;
+  friend class _TAO_Container_ThruPOA_Proxy_Impl;
+  friend class _TAO_Container_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_Container_create_interface (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const char * id,
+    const char * name,
+    const char * version,
+    const CORBA::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_CORBA_Container_create_interface (const TAO_ClientRequestInfo_CORBA_Container_create_interface &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_Container_create_interface &);
+  const char * id_;
+  const char * name_;
+  const char * version_;
+  const CORBA::InterfaceDefSeq & base_interfaces_;
+  void result (CORBA::InterfaceDef_ptr result);
+  // update the result 
+  CORBA::InterfaceDef_ptr _result;
+};
+
+class TAO_ClientRequestInfo_CORBA_Container_create_value : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_Container;
+  
+  friend class _TAO_Container_Remote_Proxy_Impl;
+  friend class _TAO_Container_ThruPOA_Proxy_Impl;
+  friend class _TAO_Container_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_Container_create_value (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const char * id,
+    const char * name,
+    const char * version,
+    const CORBA::Boolean & is_custom,
+    const CORBA::Boolean & is_abstract,
+    CORBA::ValueDef_ptr base_value,
+    const CORBA::Boolean & is_truncatable,
+    const CORBA::ValueDefSeq & abstract_base_values,
+    const CORBA::InterfaceDefSeq & supported_interfaces,
+    const CORBA::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_CORBA_Container_create_value (const TAO_ClientRequestInfo_CORBA_Container_create_value &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_Container_create_value &);
+  const char * id_;
+  const char * name_;
+  const char * version_;
+  const CORBA::Boolean & is_custom_;
+  const CORBA::Boolean & is_abstract_;
+  CORBA::ValueDef_ptr base_value_;
+  const CORBA::Boolean & is_truncatable_;
+  const CORBA::ValueDefSeq & abstract_base_values_;
+  const CORBA::InterfaceDefSeq & supported_interfaces_;
+  const CORBA::InitializerSeq & initializers_;
+  void result (CORBA::ValueDef_ptr result);
+  // update the result 
+  CORBA::ValueDef_ptr _result;
+};
+
+class TAO_ClientRequestInfo_CORBA_Container_create_value_box : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_Container;
+  
+  friend class _TAO_Container_Remote_Proxy_Impl;
+  friend class _TAO_Container_ThruPOA_Proxy_Impl;
+  friend class _TAO_Container_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_Container_create_value_box (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const char * id,
+    const char * name,
+    const char * version,
+    CORBA::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_CORBA_Container_create_value_box (const TAO_ClientRequestInfo_CORBA_Container_create_value_box &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_Container_create_value_box &);
+  const char * id_;
+  const char * name_;
+  const char * version_;
+  CORBA::IDLType_ptr original_type_def_;
+  void result (CORBA::ValueBoxDef_ptr result);
+  // update the result 
+  CORBA::ValueBoxDef_ptr _result;
+};
+
+class TAO_ClientRequestInfo_CORBA_Container_create_exception : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_Container;
+  
+  friend class _TAO_Container_Remote_Proxy_Impl;
+  friend class _TAO_Container_ThruPOA_Proxy_Impl;
+  friend class _TAO_Container_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_Container_create_exception (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const char * id,
+    const char * name,
+    const char * version,
+    const CORBA::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_CORBA_Container_create_exception (const TAO_ClientRequestInfo_CORBA_Container_create_exception &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_Container_create_exception &);
+  const char * id_;
+  const char * name_;
+  const char * version_;
+  const CORBA::StructMemberSeq & members_;
+  void result (CORBA::ExceptionDef_ptr result);
+  // update the result 
+  CORBA::ExceptionDef_ptr _result;
+};
+
+class TAO_ClientRequestInfo_CORBA_Container_create_native : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_Container;
+  
+  friend class _TAO_Container_Remote_Proxy_Impl;
+  friend class _TAO_Container_ThruPOA_Proxy_Impl;
+  friend class _TAO_Container_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_Container_create_native (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _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_CORBA_Container_create_native (const TAO_ClientRequestInfo_CORBA_Container_create_native &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_Container_create_native &);
+  const char * id_;
+  const char * name_;
+  const char * version_;
+  void result (CORBA::NativeDef_ptr result);
+  // update the result 
+  CORBA::NativeDef_ptr _result;
+};
+
+class TAO_ClientRequestInfo_CORBA_Container_create_abstract_interface : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_Container;
+  
+  friend class _TAO_Container_Remote_Proxy_Impl;
+  friend class _TAO_Container_ThruPOA_Proxy_Impl;
+  friend class _TAO_Container_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_Container_create_abstract_interface (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const char * id,
+    const char * name,
+    const char * version,
+    const CORBA::AbstractInterfaceDefSeq & 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_CORBA_Container_create_abstract_interface (const TAO_ClientRequestInfo_CORBA_Container_create_abstract_interface &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_Container_create_abstract_interface &);
+  const char * id_;
+  const char * name_;
+  const char * version_;
+  const CORBA::AbstractInterfaceDefSeq & base_interfaces_;
+  void result (CORBA::AbstractInterfaceDef_ptr result);
+  // update the result 
+  CORBA::AbstractInterfaceDef_ptr _result;
+};
+
+class TAO_ClientRequestInfo_CORBA_Container_create_local_interface : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_Container;
+  
+  friend class _TAO_Container_Remote_Proxy_Impl;
+  friend class _TAO_Container_ThruPOA_Proxy_Impl;
+  friend class _TAO_Container_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_Container_create_local_interface (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const char * id,
+    const char * name,
+    const char * version,
+    const CORBA::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_CORBA_Container_create_local_interface (const TAO_ClientRequestInfo_CORBA_Container_create_local_interface &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_Container_create_local_interface &);
+  const char * id_;
+  const char * name_;
+  const char * version_;
+  const CORBA::InterfaceDefSeq & base_interfaces_;
+  void result (CORBA::LocalInterfaceDef_ptr result);
+  // update the result 
+  CORBA::LocalInterfaceDef_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_IFR_Client_Export _TAO_Container_Proxy_Impl : 
+  public virtual _TAO_IRObject_Proxy_Impl
+{
+public:
+  virtual ~_TAO_Container_Proxy_Impl (void) { }
+  
+    virtual CORBA::Contained_ptr lookup (
+      CORBA_Object *_collocated_tao_target_,
+      const char * search_name,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual CORBA::ContainedSeq * contents (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::DefinitionKind limit_type,
+      CORBA::Boolean exclude_inherited,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual CORBA::ContainedSeq * lookup_name (
+      CORBA_Object *_collocated_tao_target_,
+      const char * search_name,
+      CORBA::Long levels_to_search,
+      CORBA::DefinitionKind limit_type,
+      CORBA::Boolean exclude_inherited,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual CORBA::Container::DescriptionSeq * describe_contents (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::DefinitionKind limit_type,
+      CORBA::Boolean exclude_inherited,
+      CORBA::Long max_returned_objs,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual CORBA::ModuleDef_ptr create_module (
+      CORBA_Object *_collocated_tao_target_,
+      const char * id,
+      const char * name,
+      const char * version,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual CORBA::ConstantDef_ptr create_constant (
+      CORBA_Object *_collocated_tao_target_,
+      const char * id,
+      const char * name,
+      const char * version,
+      CORBA::IDLType_ptr type,
+      const CORBA::Any & value,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual CORBA::StructDef_ptr create_struct (
+      CORBA_Object *_collocated_tao_target_,
+      const char * id,
+      const char * name,
+      const char * version,
+      const CORBA::StructMemberSeq & members,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual CORBA::UnionDef_ptr create_union (
+      CORBA_Object *_collocated_tao_target_,
+      const char * id,
+      const char * name,
+      const char * version,
+      CORBA::IDLType_ptr discriminator_type,
+      const CORBA::UnionMemberSeq & members,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual CORBA::EnumDef_ptr create_enum (
+      CORBA_Object *_collocated_tao_target_,
+      const char * id,
+      const char * name,
+      const char * version,
+      const CORBA::EnumMemberSeq & members,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual CORBA::AliasDef_ptr create_alias (
+      CORBA_Object *_collocated_tao_target_,
+      const char * id,
+      const char * name,
+      const char * version,
+      CORBA::IDLType_ptr original_type,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual CORBA::InterfaceDef_ptr create_interface (
+      CORBA_Object *_collocated_tao_target_,
+      const char * id,
+      const char * name,
+      const char * version,
+      const CORBA::InterfaceDefSeq & base_interfaces,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual CORBA::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,
+      CORBA::ValueDef_ptr base_value,
+      CORBA::Boolean is_truncatable,
+      const CORBA::ValueDefSeq & abstract_base_values,
+      const CORBA::InterfaceDefSeq & supported_interfaces,
+      const CORBA::InitializerSeq & initializers,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual CORBA::ValueBoxDef_ptr create_value_box (
+      CORBA_Object *_collocated_tao_target_,
+      const char * id,
+      const char * name,
+      const char * version,
+      CORBA::IDLType_ptr original_type_def,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual CORBA::ExceptionDef_ptr create_exception (
+      CORBA_Object *_collocated_tao_target_,
+      const char * id,
+      const char * name,
+      const char * version,
+      const CORBA::StructMemberSeq & members,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual CORBA::NativeDef_ptr create_native (
+      CORBA_Object *_collocated_tao_target_,
+      const char * id,
+      const char * name,
+      const char * version,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual CORBA::AbstractInterfaceDef_ptr create_abstract_interface (
+      CORBA_Object *_collocated_tao_target_,
+      const char * id,
+      const char * name,
+      const char * version,
+      const CORBA::AbstractInterfaceDefSeq & base_interfaces,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual CORBA::LocalInterfaceDef_ptr create_local_interface (
+      CORBA_Object *_collocated_tao_target_,
+      const char * id,
+      const char * name,
+      const char * version,
+      const CORBA::InterfaceDefSeq & base_interfaces,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+protected:
+  _TAO_Container_Proxy_Impl (void);
+
+};
+//
+//                Base  Proxy Impl. Declaration
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//                    Remote  Impl. Declaration
+//
+
+class TAO_IFR_Client_Export _TAO_Container_Remote_Proxy_Impl : 
+  public virtual _TAO_Container_Proxy_Impl,
+  public virtual TAO_Remote_Object_Proxy_Impl,
+  public virtual _TAO_IRObject_Remote_Proxy_Impl
+  
+{
+public:
+  _TAO_Container_Remote_Proxy_Impl (void);
+  
+  virtual ~_TAO_Container_Remote_Proxy_Impl (void) { }
+  
+    virtual CORBA::Contained_ptr lookup (
+      CORBA_Object *_collocated_tao_target_,
+      const char * search_name,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::ContainedSeq * contents (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::DefinitionKind limit_type,
+      CORBA::Boolean exclude_inherited,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::ContainedSeq * lookup_name (
+      CORBA_Object *_collocated_tao_target_,
+      const char * search_name,
+      CORBA::Long levels_to_search,
+      CORBA::DefinitionKind limit_type,
+      CORBA::Boolean exclude_inherited,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::Container::DescriptionSeq * describe_contents (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::DefinitionKind limit_type,
+      CORBA::Boolean exclude_inherited,
+      CORBA::Long max_returned_objs,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::ModuleDef_ptr create_module (
+      CORBA_Object *_collocated_tao_target_,
+      const char * id,
+      const char * name,
+      const char * version,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::ConstantDef_ptr create_constant (
+      CORBA_Object *_collocated_tao_target_,
+      const char * id,
+      const char * name,
+      const char * version,
+      CORBA::IDLType_ptr type,
+      const CORBA::Any & value,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::StructDef_ptr create_struct (
+      CORBA_Object *_collocated_tao_target_,
+      const char * id,
+      const char * name,
+      const char * version,
+      const CORBA::StructMemberSeq & members,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::UnionDef_ptr create_union (
+      CORBA_Object *_collocated_tao_target_,
+      const char * id,
+      const char * name,
+      const char * version,
+      CORBA::IDLType_ptr discriminator_type,
+      const CORBA::UnionMemberSeq & members,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::EnumDef_ptr create_enum (
+      CORBA_Object *_collocated_tao_target_,
+      const char * id,
+      const char * name,
+      const char * version,
+      const CORBA::EnumMemberSeq & members,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::AliasDef_ptr create_alias (
+      CORBA_Object *_collocated_tao_target_,
+      const char * id,
+      const char * name,
+      const char * version,
+      CORBA::IDLType_ptr original_type,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::InterfaceDef_ptr create_interface (
+      CORBA_Object *_collocated_tao_target_,
+      const char * id,
+      const char * name,
+      const char * version,
+      const CORBA::InterfaceDefSeq & base_interfaces,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::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,
+      CORBA::ValueDef_ptr base_value,
+      CORBA::Boolean is_truncatable,
+      const CORBA::ValueDefSeq & abstract_base_values,
+      const CORBA::InterfaceDefSeq & supported_interfaces,
+      const CORBA::InitializerSeq & initializers,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::ValueBoxDef_ptr create_value_box (
+      CORBA_Object *_collocated_tao_target_,
+      const char * id,
+      const char * name,
+      const char * version,
+      CORBA::IDLType_ptr original_type_def,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::ExceptionDef_ptr create_exception (
+      CORBA_Object *_collocated_tao_target_,
+      const char * id,
+      const char * name,
+      const char * version,
+      const CORBA::StructMemberSeq & members,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::NativeDef_ptr create_native (
+      CORBA_Object *_collocated_tao_target_,
+      const char * id,
+      const char * name,
+      const char * version,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::AbstractInterfaceDef_ptr create_abstract_interface (
+      CORBA_Object *_collocated_tao_target_,
+      const char * id,
+      const char * name,
+      const char * version,
+      const CORBA::AbstractInterfaceDefSeq & base_interfaces,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::LocalInterfaceDef_ptr create_local_interface (
+      CORBA_Object *_collocated_tao_target_,
+      const char * id,
+      const char * name,
+      const char * version,
+      const CORBA::InterfaceDefSeq & base_interfaces,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+};
+
+//
+//                Base  Proxy Impl. Declaration
+///////////////////////////////////////////////////////////////////////
+
+
+// The Proxy Brokers are used by each interface to get
+// the right proxy for performing a call. In the new 
+// collocation scheme, the proxy to be used can vary on
+// a call by call basis. 
+
+
+
+///////////////////////////////////////////////////////////////////////
+//                 Base Proxy Broker Declaration 
+//
+
+class TAO_IFR_Client_Export _TAO_Container_Proxy_Broker
+{
+public:
+  virtual ~_TAO_Container_Proxy_Broker (void);
+  virtual _TAO_Container_Proxy_Impl &select_proxy (
+    CORBA_Container *object,
+    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
+  ) = 0;
+
+protected:
+  _TAO_Container_Proxy_Broker (void);
+  
+};
+
+//
+//              End Base Proxy Broker Declaration 
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//                 Remote Proxy Broker Declaration 
+//
+
+class TAO_IFR_Client_Export _TAO_Container_Remote_Proxy_Broker : public virtual _TAO_Container_Proxy_Broker
+{
+public: 
+  _TAO_Container_Remote_Proxy_Broker (void);
+  
+  virtual ~_TAO_Container_Remote_Proxy_Broker (void);
+  
+  virtual _TAO_Container_Proxy_Impl &select_proxy (
+    CORBA_Container *object,
+    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
+  );
+
+private:
+  _TAO_Container_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_Container_Remote_Proxy_Broker *the_TAO_Container_Remote_Proxy_Broker (void);
+};
+
+
+//
+//              End Remote Proxy Broker Declaration 
+///////////////////////////////////////////////////////////////////////
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_IDLTYPE___VAR_CH_)
+#define _CORBA_IDLTYPE___VAR_CH_
+
+class TAO_IFR_Client_Export CORBA_IDLType_var : public TAO_Base_var
+{
+public:
+  CORBA_IDLType_var (void); // default constructor
+  CORBA_IDLType_var (CORBA_IDLType_ptr p) : ptr_ (p) {} 
+  CORBA_IDLType_var (const CORBA_IDLType_var &); // copy constructor
+  ~CORBA_IDLType_var (void); // destructor
+  
+  CORBA_IDLType_var &operator= (CORBA_IDLType_ptr);
+  CORBA_IDLType_var &operator= (const CORBA_IDLType_var &);
+  CORBA_IDLType_ptr operator-> (void) const;
+  
+  operator const CORBA_IDLType_ptr &() const;
+  operator CORBA_IDLType_ptr &();
+  // in, inout, out, _retn 
+  CORBA_IDLType_ptr in (void) const;
+  CORBA_IDLType_ptr &inout (void);
+  CORBA_IDLType_ptr &out (void);
+  CORBA_IDLType_ptr _retn (void);
+  CORBA_IDLType_ptr ptr (void) const;
+
+private:
+  CORBA_IDLType_ptr ptr_;
+  // Unimplemented - prevents widening assignment.
+  CORBA_IDLType_var (const TAO_Base_var &rhs);
+  CORBA_IDLType_var &operator= (const TAO_Base_var &rhs);
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_IDLTYPE___OUT_CH_)
+#define _CORBA_IDLTYPE___OUT_CH_
+
+class TAO_IFR_Client_Export CORBA_IDLType_out
+{
+public:
+  CORBA_IDLType_out (CORBA_IDLType_ptr &);
+  CORBA_IDLType_out (CORBA_IDLType_var &);
+  CORBA_IDLType_out (const CORBA_IDLType_out &);
+  CORBA_IDLType_out &operator= (const CORBA_IDLType_out &);
+  CORBA_IDLType_out &operator= (const CORBA_IDLType_var &);
+  CORBA_IDLType_out &operator= (CORBA_IDLType_ptr);
+  operator CORBA_IDLType_ptr &();
+  CORBA_IDLType_ptr &ptr (void);
+  CORBA_IDLType_ptr operator-> (void);
+  
+private:
+  CORBA_IDLType_ptr &ptr_;
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_IDLTYPE_CH_)
+#define _CORBA_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_IFR_Client_Export CORBA_IDLType: public virtual CORBA_IRObject
+{
+public:
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef CORBA_IDLType_ptr _ptr_type;
+  typedef CORBA_IDLType_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  // the static operations
+  static CORBA_IDLType_ptr _duplicate (CORBA_IDLType_ptr obj);
+  static CORBA_IDLType_ptr _narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    );
+  static CORBA_IDLType_ptr _unchecked_narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    );
+  static CORBA_IDLType_ptr _nil (void)
+    {
+      return (CORBA_IDLType_ptr)0;
+    }
+
+  static void _tao_any_destructor (void*);
+
+  virtual CORBA::TypeCode_ptr type (
+      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_IDLType_Proxy_Broker *the_TAO_IDLType_Proxy_Broker_;
+  
+protected:
+  CORBA_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 CORBA_IDLType_setup_collocation (int collocated);
+    
+    CORBA_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 ~CORBA_IDLType (void);
+private:
+  CORBA_IDLType (const CORBA_IDLType &);
+  void operator= (const CORBA_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_CORBA_IDLType_type_get : public TAO_ClientRequestInfo
+  {
+  public:
+    friend class CORBA_IDLType;
+    
+    friend class _TAO_IDLType_Remote_Proxy_Impl;
+    friend class _TAO_IDLType_ThruPOA_Proxy_Impl;
+    friend class _TAO_IDLType_Direct_Proxy_Impl;
+  
+  TAO_ClientRequestInfo_CORBA_IDLType_type_get (
+      TAO_GIOP_Invocation *_tao_invocation,
+      CORBA::Object_ptr _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_IDLType_type_get (const TAO_ClientRequestInfo_CORBA_IDLType_type_get &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_IDLType_type_get &);
+  void result (CORBA::TypeCode_ptr result);
+  // update the result 
+  CORBA::TypeCode_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_IFR_Client_Export _TAO_IDLType_Proxy_Impl : 
+  public virtual _TAO_IRObject_Proxy_Impl
+{
+public:
+  virtual ~_TAO_IDLType_Proxy_Impl (void) { }
+  
+    virtual CORBA::TypeCode_ptr type (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+protected:
+  _TAO_IDLType_Proxy_Impl (void);
+
+};
+//
+//                Base  Proxy Impl. Declaration
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//                    Remote  Impl. Declaration
+//
+
+class TAO_IFR_Client_Export _TAO_IDLType_Remote_Proxy_Impl : 
+  public virtual _TAO_IDLType_Proxy_Impl,
+  public virtual TAO_Remote_Object_Proxy_Impl,
+  public virtual _TAO_IRObject_Remote_Proxy_Impl
+  
+{
+public:
+  _TAO_IDLType_Remote_Proxy_Impl (void);
+  
+  virtual ~_TAO_IDLType_Remote_Proxy_Impl (void) { }
+  
+    virtual CORBA::TypeCode_ptr type (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+};
+
+//
+//                Base  Proxy Impl. Declaration
+///////////////////////////////////////////////////////////////////////
+
+
+// The Proxy Brokers are used by each interface to get
+// the right proxy for performing a call. In the new 
+// collocation scheme, the proxy to be used can vary on
+// a call by call basis. 
+
+
+
+///////////////////////////////////////////////////////////////////////
+//                 Base Proxy Broker Declaration 
+//
+
+class TAO_IFR_Client_Export _TAO_IDLType_Proxy_Broker
+{
+public:
+  virtual ~_TAO_IDLType_Proxy_Broker (void);
+  virtual _TAO_IDLType_Proxy_Impl &select_proxy (
+    CORBA_IDLType *object,
+    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
+  ) = 0;
+
+protected:
+  _TAO_IDLType_Proxy_Broker (void);
+  
+};
+
+//
+//              End Base Proxy Broker Declaration 
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//                 Remote Proxy Broker Declaration 
+//
+
+class TAO_IFR_Client_Export _TAO_IDLType_Remote_Proxy_Broker : public virtual _TAO_IDLType_Proxy_Broker
+{
+public: 
+  _TAO_IDLType_Remote_Proxy_Broker (void);
+  
+  virtual ~_TAO_IDLType_Remote_Proxy_Broker (void);
+  
+  virtual _TAO_IDLType_Proxy_Impl &select_proxy (
+    CORBA_IDLType *object,
+    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
+  );
+
+private:
+  _TAO_IDLType_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_IDLType_Remote_Proxy_Broker *the_TAO_IDLType_Remote_Proxy_Broker (void);
+};
+
+
+//
+//              End Remote Proxy Broker Declaration 
+///////////////////////////////////////////////////////////////////////
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_TYPEDEFDEF___VAR_CH_)
+#define _CORBA_TYPEDEFDEF___VAR_CH_
+
+class TAO_IFR_Client_Export CORBA_TypedefDef_var : public TAO_Base_var
+{
+public:
+  CORBA_TypedefDef_var (void); // default constructor
+  CORBA_TypedefDef_var (CORBA_TypedefDef_ptr p) : ptr_ (p) {} 
+  CORBA_TypedefDef_var (const CORBA_TypedefDef_var &); // copy constructor
+  ~CORBA_TypedefDef_var (void); // destructor
+  
+  CORBA_TypedefDef_var &operator= (CORBA_TypedefDef_ptr);
+  CORBA_TypedefDef_var &operator= (const CORBA_TypedefDef_var &);
+  CORBA_TypedefDef_ptr operator-> (void) const;
+  
+  operator const CORBA_TypedefDef_ptr &() const;
+  operator CORBA_TypedefDef_ptr &();
+  // in, inout, out, _retn 
+  CORBA_TypedefDef_ptr in (void) const;
+  CORBA_TypedefDef_ptr &inout (void);
+  CORBA_TypedefDef_ptr &out (void);
+  CORBA_TypedefDef_ptr _retn (void);
+  CORBA_TypedefDef_ptr ptr (void) const;
+
+private:
+  CORBA_TypedefDef_ptr ptr_;
+  // Unimplemented - prevents widening assignment.
+  CORBA_TypedefDef_var (const TAO_Base_var &rhs);
+  CORBA_TypedefDef_var &operator= (const TAO_Base_var &rhs);
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_TYPEDEFDEF___OUT_CH_)
+#define _CORBA_TYPEDEFDEF___OUT_CH_
+
+class TAO_IFR_Client_Export CORBA_TypedefDef_out
+{
+public:
+  CORBA_TypedefDef_out (CORBA_TypedefDef_ptr &);
+  CORBA_TypedefDef_out (CORBA_TypedefDef_var &);
+  CORBA_TypedefDef_out (const CORBA_TypedefDef_out &);
+  CORBA_TypedefDef_out &operator= (const CORBA_TypedefDef_out &);
+  CORBA_TypedefDef_out &operator= (const CORBA_TypedefDef_var &);
+  CORBA_TypedefDef_out &operator= (CORBA_TypedefDef_ptr);
+  operator CORBA_TypedefDef_ptr &();
+  CORBA_TypedefDef_ptr &ptr (void);
+  CORBA_TypedefDef_ptr operator-> (void);
+  
+private:
+  CORBA_TypedefDef_ptr &ptr_;
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_TYPEDEFDEF_CH_)
+#define _CORBA_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_IFR_Client_Export CORBA_TypedefDef: public virtual CORBA_Contained, public virtual CORBA_IDLType
+{
+public:
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef CORBA_TypedefDef_ptr _ptr_type;
+  typedef CORBA_TypedefDef_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  // the static operations
+  static CORBA_TypedefDef_ptr _duplicate (CORBA_TypedefDef_ptr obj);
+  static CORBA_TypedefDef_ptr _narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    );
+  static CORBA_TypedefDef_ptr _unchecked_narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    );
+  static CORBA_TypedefDef_ptr _nil (void)
+    {
+      return (CORBA_TypedefDef_ptr)0;
+    }
+
+  static void _tao_any_destructor (void*);
+
+  virtual CORBA::Boolean _is_a (
+      const CORBA::Char *type_id, 
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    );
+  virtual void *_tao_QueryInterface (ptr_arith_t type);
+  
+  virtual const char* _interface_repository_id (void) const;
+
+private:
+  _TAO_TypedefDef_Proxy_Broker *the_TAO_TypedefDef_Proxy_Broker_;
+  
+protected:
+  CORBA_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 CORBA_TypedefDef_setup_collocation (int collocated);
+    
+    CORBA_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;
+  
+  virtual ~CORBA_TypedefDef (void);
+private:
+  CORBA_TypedefDef (const CORBA_TypedefDef &);
+  void operator= (const CORBA_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 */
+
+};
+
+
+// The Proxy Implementations are used by each interface to
+// perform a call. Each different implementation encapsulate
+// an invocation logics.
+
+
+///////////////////////////////////////////////////////////////////////
+//                    Base  Impl. Declaration
+//
+
+class TAO_IFR_Client_Export _TAO_TypedefDef_Proxy_Impl : 
+  public virtual _TAO_Contained_Proxy_Impl, 
+  public virtual _TAO_IDLType_Proxy_Impl
+{
+public:
+  virtual ~_TAO_TypedefDef_Proxy_Impl (void) { }
+  
+  protected:
+  _TAO_TypedefDef_Proxy_Impl (void);
+
+};
+//
+//                Base  Proxy Impl. Declaration
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//                    Remote  Impl. Declaration
+//
+
+class TAO_IFR_Client_Export _TAO_TypedefDef_Remote_Proxy_Impl : 
+  public virtual _TAO_TypedefDef_Proxy_Impl,
+  public virtual TAO_Remote_Object_Proxy_Impl,
+  public virtual _TAO_Contained_Remote_Proxy_Impl, 
+  public virtual _TAO_IDLType_Remote_Proxy_Impl
+  
+{
+public:
+  _TAO_TypedefDef_Remote_Proxy_Impl (void);
+  
+  virtual ~_TAO_TypedefDef_Remote_Proxy_Impl (void) { }
+  
+  };
+
+//
+//                Base  Proxy Impl. Declaration
+///////////////////////////////////////////////////////////////////////
+
+
+// The Proxy Brokers are used by each interface to get
+// the right proxy for performing a call. In the new 
+// collocation scheme, the proxy to be used can vary on
+// a call by call basis. 
+
+
+
+///////////////////////////////////////////////////////////////////////
+//                 Base Proxy Broker Declaration 
+//
+
+class TAO_IFR_Client_Export _TAO_TypedefDef_Proxy_Broker
+{
+public:
+  virtual ~_TAO_TypedefDef_Proxy_Broker (void);
+  virtual _TAO_TypedefDef_Proxy_Impl &select_proxy (
+    CORBA_TypedefDef *object,
+    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
+  ) = 0;
+
+protected:
+  _TAO_TypedefDef_Proxy_Broker (void);
+  
+};
+
+//
+//              End Base Proxy Broker Declaration 
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//                 Remote Proxy Broker Declaration 
+//
+
+class TAO_IFR_Client_Export _TAO_TypedefDef_Remote_Proxy_Broker : public virtual _TAO_TypedefDef_Proxy_Broker
+{
+public: 
+  _TAO_TypedefDef_Remote_Proxy_Broker (void);
+  
+  virtual ~_TAO_TypedefDef_Remote_Proxy_Broker (void);
+  
+  virtual _TAO_TypedefDef_Proxy_Impl &select_proxy (
+    CORBA_TypedefDef *object,
+    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
+  );
+
+private:
+  _TAO_TypedefDef_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_TypedefDef_Remote_Proxy_Broker *the_TAO_TypedefDef_Remote_Proxy_Broker (void);
+};
+
+
+//
+//              End Remote Proxy Broker Declaration 
+///////////////////////////////////////////////////////////////////////
+
+
+#endif /* end #if !defined */
+
+struct CORBA_TypeDescription;
+class CORBA_TypeDescription_var;
+
+struct TAO_IFR_Client_Export CORBA_TypeDescription
+{
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef CORBA_TypeDescription_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  static void _tao_any_destructor (void*);
+
+  TAO_String_Manager name;
+  TAO_String_Manager id;
+  TAO_String_Manager defined_in;
+  TAO_String_Manager version;
+  CORBA::TypeCode_var type;
+};
+
+class TAO_IFR_Client_Export CORBA_TypeDescription_var
+{
+public:
+  CORBA_TypeDescription_var (void); // default constructor
+  CORBA_TypeDescription_var (CORBA_TypeDescription *);
+  CORBA_TypeDescription_var (const CORBA_TypeDescription_var &); // copy constructor
+  ~CORBA_TypeDescription_var (void); // destructor
+  
+  CORBA_TypeDescription_var &operator= (CORBA_TypeDescription *);
+  CORBA_TypeDescription_var &operator= (const CORBA_TypeDescription_var &);
+  CORBA_TypeDescription *operator-> (void);
+  const CORBA_TypeDescription *operator-> (void) const;
+  
+  operator const CORBA_TypeDescription &() const;
+  operator CORBA_TypeDescription &();
+  operator CORBA_TypeDescription &() const;
+  operator CORBA_TypeDescription *&(); // variable-size types only
+  
+  // in, inout, out, _retn 
+  const CORBA_TypeDescription &in (void) const;
+  CORBA_TypeDescription &inout (void);
+  CORBA_TypeDescription *&out (void);
+  CORBA_TypeDescription *_retn (void);
+  CORBA_TypeDescription *ptr (void) const;
+
+private:
+  CORBA_TypeDescription *ptr_;
+};
+
+class TAO_IFR_Client_Export CORBA_TypeDescription_out
+{
+public:
+  CORBA_TypeDescription_out (CORBA_TypeDescription *&);
+  CORBA_TypeDescription_out (CORBA_TypeDescription_var &);
+  CORBA_TypeDescription_out (const CORBA_TypeDescription_out &);
+  CORBA_TypeDescription_out &operator= (const CORBA_TypeDescription_out &);
+  CORBA_TypeDescription_out &operator= (CORBA_TypeDescription *);
+  operator CORBA_TypeDescription *&();
+  CORBA_TypeDescription *&ptr (void);
+  CORBA_TypeDescription *operator-> (void);
+  
+private:
+  CORBA_TypeDescription *&ptr_;
+  // assignment from T_var not allowed
+  void operator= (const CORBA_TypeDescription_var &);
+};
+
+// Proxy Broker Factory function pointer declarations.
+
+extern TAO_IFR_Client_Export _TAO_IRObject_Proxy_Broker * (*CORBA__TAO_IRObject_Proxy_Broker_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  );
+
+extern TAO_IFR_Client_Export _TAO_Contained_Proxy_Broker * (*CORBA__TAO_Contained_Proxy_Broker_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  );
+
+extern TAO_IFR_Client_Export _TAO_Container_Proxy_Broker * (*CORBA__TAO_Container_Proxy_Broker_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  );
+
+extern TAO_IFR_Client_Export _TAO_IDLType_Proxy_Broker * (*CORBA__TAO_IDLType_Proxy_Broker_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  );
+
+extern TAO_IFR_Client_Export _TAO_TypedefDef_Proxy_Broker * (*CORBA__TAO_TypedefDef_Proxy_Broker_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  );
+
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, CORBA::DefinitionKind);
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::DefinitionKind &);
+// Any operators for interface CORBA::IRObject
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, CORBA::IRObject_ptr);
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::IRObject *&);
+// Any operators for interface CORBA::Contained
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, CORBA::Contained_ptr);
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::Contained *&);
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const CORBA::Contained::Description &); // copying version
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, CORBA::Contained::Description*); // noncopying version
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::Contained::Description *&); // deprecated
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA::Contained::Description *&);
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const CORBA::ContainedSeq &); // copying version
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, CORBA::ContainedSeq*); // noncopying version
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::ContainedSeq *&); // deprecated
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA::ContainedSeq *&);
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const CORBA::StructMember &); // copying version
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, CORBA::StructMember*); // noncopying version
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::StructMember *&); // deprecated
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA::StructMember *&);
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const CORBA::StructMemberSeq &); // copying version
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, CORBA::StructMemberSeq*); // noncopying version
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::StructMemberSeq *&); // deprecated
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA::StructMemberSeq *&);
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const CORBA::Initializer &); // copying version
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, CORBA::Initializer*); // noncopying version
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::Initializer *&); // deprecated
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA::Initializer *&);
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const CORBA::InitializerSeq &); // copying version
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, CORBA::InitializerSeq*); // noncopying version
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::InitializerSeq *&); // deprecated
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA::InitializerSeq *&);
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const CORBA::UnionMember &); // copying version
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, CORBA::UnionMember*); // noncopying version
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::UnionMember *&); // deprecated
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA::UnionMember *&);
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const CORBA::UnionMemberSeq &); // copying version
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, CORBA::UnionMemberSeq*); // noncopying version
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::UnionMemberSeq *&); // deprecated
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA::UnionMemberSeq *&);
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const CORBA::EnumMemberSeq &); // copying version
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, CORBA::EnumMemberSeq*); // noncopying version
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::EnumMemberSeq *&); // deprecated
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA::EnumMemberSeq *&);
+// Any operators for interface CORBA::Container
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, CORBA::Container_ptr);
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::Container *&);
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const CORBA::Container::Description &); // copying version
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, CORBA::Container::Description*); // noncopying version
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::Container::Description *&); // deprecated
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA::Container::Description *&);
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const CORBA::Container::DescriptionSeq &); // copying version
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, CORBA::Container::DescriptionSeq*); // noncopying version
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::Container::DescriptionSeq *&); // deprecated
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA::Container::DescriptionSeq *&);
+// Any operators for interface CORBA::IDLType
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, CORBA::IDLType_ptr);
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::IDLType *&);
+// Any operators for interface CORBA::TypedefDef
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, CORBA::TypedefDef_ptr);
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::TypedefDef *&);
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const CORBA::TypeDescription &); // copying version
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, CORBA::TypeDescription*); // noncopying version
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::TypeDescription *&); // deprecated
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA::TypeDescription *&);
+
+#ifndef __ACE_INLINE__
+
+TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::DefinitionKind &); // 
+TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::DefinitionKind &);
+TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::IRObject_ptr );
+TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::IRObject_ptr &);
+TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::Contained_ptr );
+TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::Contained_ptr &);
+TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::Contained::Description &);
+TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::Contained::Description &);
+
+#if !defined _TAO_CDR_OP_CORBA_ContainedSeq_H_
+#define _TAO_CDR_OP_CORBA_ContainedSeq_H_
+
+TAO_IFR_Client_Export CORBA::Boolean operator<< (
+    TAO_OutputCDR &,
+    const CORBA::ContainedSeq &
+  );
+TAO_IFR_Client_Export CORBA::Boolean operator>> (
+    TAO_InputCDR &,
+    CORBA::ContainedSeq &
+  );
+
+#endif /* _TAO_CDR_OP_CORBA_ContainedSeq_H_ */
+
+
+TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::StructMember &);
+TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::StructMember &);
+
+#if !defined _TAO_CDR_OP_CORBA_StructMemberSeq_H_
+#define _TAO_CDR_OP_CORBA_StructMemberSeq_H_
+
+TAO_IFR_Client_Export CORBA::Boolean operator<< (
+    TAO_OutputCDR &,
+    const CORBA::StructMemberSeq &
+  );
+TAO_IFR_Client_Export CORBA::Boolean operator>> (
+    TAO_InputCDR &,
+    CORBA::StructMemberSeq &
+  );
+
+#endif /* _TAO_CDR_OP_CORBA_StructMemberSeq_H_ */
+
+TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::Initializer &);
+TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::Initializer &);
+
+#if !defined _TAO_CDR_OP_CORBA_InitializerSeq_H_
+#define _TAO_CDR_OP_CORBA_InitializerSeq_H_
+
+TAO_IFR_Client_Export CORBA::Boolean operator<< (
+    TAO_OutputCDR &,
+    const CORBA::InitializerSeq &
+  );
+TAO_IFR_Client_Export CORBA::Boolean operator>> (
+    TAO_InputCDR &,
+    CORBA::InitializerSeq &
+  );
+
+#endif /* _TAO_CDR_OP_CORBA_InitializerSeq_H_ */
+
+TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::UnionMember &);
+TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::UnionMember &);
+
+#if !defined _TAO_CDR_OP_CORBA_UnionMemberSeq_H_
+#define _TAO_CDR_OP_CORBA_UnionMemberSeq_H_
+
+TAO_IFR_Client_Export CORBA::Boolean operator<< (
+    TAO_OutputCDR &,
+    const CORBA::UnionMemberSeq &
+  );
+TAO_IFR_Client_Export CORBA::Boolean operator>> (
+    TAO_InputCDR &,
+    CORBA::UnionMemberSeq &
+  );
+
+#endif /* _TAO_CDR_OP_CORBA_UnionMemberSeq_H_ */
+
+
+#if !defined _TAO_CDR_OP_CORBA_EnumMemberSeq_H_
+#define _TAO_CDR_OP_CORBA_EnumMemberSeq_H_
+
+TAO_IFR_Client_Export CORBA::Boolean operator<< (
+    TAO_OutputCDR &,
+    const CORBA::EnumMemberSeq &
+  );
+TAO_IFR_Client_Export CORBA::Boolean operator>> (
+    TAO_InputCDR &,
+    CORBA::EnumMemberSeq &
+  );
+
+#endif /* _TAO_CDR_OP_CORBA_EnumMemberSeq_H_ */
+
+TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::Container_ptr );
+TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::Container_ptr &);
+TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::Container::Description &);
+TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::Container::Description &);
+
+#if !defined _TAO_CDR_OP_CORBA_Container_DescriptionSeq_H_
+#define _TAO_CDR_OP_CORBA_Container_DescriptionSeq_H_
+
+TAO_IFR_Client_Export CORBA::Boolean operator<< (
+    TAO_OutputCDR &,
+    const CORBA::Container::DescriptionSeq &
+  );
+TAO_IFR_Client_Export CORBA::Boolean operator>> (
+    TAO_InputCDR &,
+    CORBA::Container::DescriptionSeq &
+  );
+
+#endif /* _TAO_CDR_OP_CORBA_Container_DescriptionSeq_H_ */
+
+TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::IDLType_ptr );
+TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::IDLType_ptr &);
+TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::TypedefDef_ptr );
+TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::TypedefDef_ptr &);
+TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::TypeDescription &);
+TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::TypeDescription &);
+
+#endif /* __ACE_INLINE__ */
+
+
+#if defined (__ACE_INLINE__)
+#include "IFR_BaseC.i"
+#endif /* defined INLINE */
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+#pragma warning(pop)
+#endif /* _MSC_VER */
+
+#if defined (__BORLANDC__)
+#pragma option pop
+#endif /* __BORLANDC__ */
+
+#include "ace/post.h"
+#endif /* ifndef */
diff --git a/TAO/tao/IFR_Client/IFR_BaseC.i b/TAO/tao/IFR_Client/IFR_BaseC.i
new file mode 100644
index 00000000000..66e731e5d46
--- /dev/null
+++ b/TAO/tao/IFR_Client/IFR_BaseC.i
@@ -0,0 +1,4816 @@
+// -*- C++ -*-
+//
+// $Id$
+
+// ****  Code generated by the The ACE ORB (TAO) IDL Compiler ****
+// TAO and the TAO IDL Compiler have been developed by:
+//       Center for Distributed Object Computing
+//       Washington University
+//       St. Louis, MO
+//       USA
+//       http://www.cs.wustl.edu/~schmidt/doc-center.html
+// and
+//       Distributed Object Computing Laboratory
+//       University of California at Irvine
+//       Irvine, CA
+//       USA
+//       http://doc.ece.uci.edu/
+//
+// Information about TAO is available at:
+//     http://www.cs.wustl.edu/~schmidt/TAO.html
+
+
+#if !defined (_CORBA_IROBJECT___CI_)
+#define _CORBA_IROBJECT___CI_
+
+ACE_INLINE
+CORBA_IRObject::CORBA_IRObject (
+    TAO_Stub *objref,
+    CORBA::Boolean _tao_collocated,
+    TAO_Abstract_ServantBase *servant
+  )
+  : CORBA_Object (objref, _tao_collocated, servant)
+{
+  this->CORBA_IRObject_setup_collocation (_tao_collocated);
+}
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_IROBJECT___VAR_CI_)
+#define _CORBA_IROBJECT___VAR_CI_
+
+// *************************************************************
+// Inline operations for class CORBA_IRObject_var
+// *************************************************************
+
+ACE_INLINE
+CORBA_IRObject_var::CORBA_IRObject_var (void) // default constructor
+  : ptr_ (CORBA_IRObject::_nil ())
+{}
+
+ACE_INLINE ::CORBA_IRObject_ptr
+CORBA_IRObject_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+CORBA_IRObject_var::CORBA_IRObject_var (const ::CORBA_IRObject_var &p) // copy constructor
+  : TAO_Base_var (),
+    ptr_ (CORBA_IRObject::_duplicate (p.ptr ()))
+{}
+
+ACE_INLINE
+CORBA_IRObject_var::~CORBA_IRObject_var (void) // destructor
+{
+  CORBA::release (this->ptr_);
+}
+
+ACE_INLINE CORBA_IRObject_var &
+CORBA_IRObject_var::operator= (CORBA_IRObject_ptr p)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE CORBA_IRObject_var &
+CORBA_IRObject_var::operator= (const ::CORBA_IRObject_var &p)
+{
+  if (this != &p)
+  {
+    CORBA::release (this->ptr_);
+    this->ptr_ = ::CORBA_IRObject::_duplicate (p.ptr ());
+  }
+  return *this;
+}
+
+ACE_INLINE 
+CORBA_IRObject_var::operator const ::CORBA_IRObject_ptr &() const // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+CORBA_IRObject_var::operator ::CORBA_IRObject_ptr &() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_IRObject_ptr
+CORBA_IRObject_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_IRObject_ptr
+CORBA_IRObject_var::in (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_IRObject_ptr &
+CORBA_IRObject_var::inout (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_IRObject_ptr &
+CORBA_IRObject_var::out (void)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = ::CORBA_IRObject::_nil ();
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_IRObject_ptr
+CORBA_IRObject_var::_retn (void)
+{
+  // yield ownership of managed obj reference
+  ::CORBA_IRObject_ptr val = this->ptr_;
+  this->ptr_ = ::CORBA_IRObject::_nil ();
+  return val;
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_IROBJECT___OUT_CI_)
+#define _CORBA_IROBJECT___OUT_CI_
+
+// *************************************************************
+// Inline operations for class CORBA_IRObject_out
+// *************************************************************
+
+ACE_INLINE
+CORBA_IRObject_out::CORBA_IRObject_out (CORBA_IRObject_ptr &p)
+  : ptr_ (p)
+{
+  this->ptr_ = ::CORBA_IRObject::_nil ();
+}
+
+ACE_INLINE
+CORBA_IRObject_out::CORBA_IRObject_out (CORBA_IRObject_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = ::CORBA_IRObject::_nil ();
+}
+
+ACE_INLINE
+CORBA_IRObject_out::CORBA_IRObject_out (const ::CORBA_IRObject_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (CORBA_IRObject_out &, p).ptr_)
+{}
+
+ACE_INLINE ::CORBA_IRObject_out &
+CORBA_IRObject_out::operator= (const ::CORBA_IRObject_out &p)
+{
+  this->ptr_ = ACE_const_cast (CORBA_IRObject_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE CORBA_IRObject_out &
+CORBA_IRObject_out::operator= (const ::CORBA_IRObject_var &p)
+{
+  this->ptr_ = ::CORBA_IRObject::_duplicate (p.ptr ());
+  return *this;
+}
+
+ACE_INLINE CORBA_IRObject_out &
+CORBA_IRObject_out::operator= (CORBA_IRObject_ptr p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+CORBA_IRObject_out::operator ::CORBA_IRObject_ptr &() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_IRObject_ptr &
+CORBA_IRObject_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_IRObject_ptr
+CORBA_IRObject_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_CONTAINED___CI_)
+#define _CORBA_CONTAINED___CI_
+
+ACE_INLINE
+CORBA_Contained::CORBA_Contained (
+    TAO_Stub *objref,
+    CORBA::Boolean _tao_collocated,
+    TAO_Abstract_ServantBase *servant
+  )
+  : CORBA_Object (objref, _tao_collocated, servant)
+{
+  this->CORBA_Contained_setup_collocation (_tao_collocated);
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_CONTAINED___VAR_CI_)
+#define _CORBA_CONTAINED___VAR_CI_
+
+// *************************************************************
+// Inline operations for class CORBA_Contained_var
+// *************************************************************
+
+ACE_INLINE
+CORBA_Contained_var::CORBA_Contained_var (void) // default constructor
+  : ptr_ (CORBA_Contained::_nil ())
+{}
+
+ACE_INLINE CORBA_Contained_ptr 
+CORBA_Contained_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+CORBA_Contained_var::CORBA_Contained_var (const CORBA_Contained_var &p) // copy constructor
+  : TAO_Base_var (),
+    ptr_ (CORBA_Contained::_duplicate (p.ptr ()))
+{}
+
+ACE_INLINE
+CORBA_Contained_var::~CORBA_Contained_var (void) // destructor
+{
+  CORBA::release (this->ptr_);
+}
+
+ACE_INLINE CORBA_Contained_var &
+CORBA_Contained_var::operator= (CORBA_Contained_ptr p)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE CORBA_Contained_var &
+CORBA_Contained_var::operator= (const CORBA_Contained_var &p)
+{
+  if (this != &p)
+  {
+    CORBA::release (this->ptr_);
+    this->ptr_ = CORBA_Contained::_duplicate (p.ptr ());
+  }
+  return *this;
+}
+
+ACE_INLINE 
+CORBA_Contained_var::operator const CORBA_Contained_ptr &() const // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+CORBA_Contained_var::operator CORBA_Contained_ptr &() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE CORBA_Contained_ptr 
+CORBA_Contained_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE CORBA_Contained_ptr
+CORBA_Contained_var::in (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE CORBA_Contained_ptr &
+CORBA_Contained_var::inout (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE CORBA_Contained_ptr &
+CORBA_Contained_var::out (void)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = CORBA_Contained::_nil ();
+  return this->ptr_;
+}
+
+ACE_INLINE CORBA_Contained_ptr 
+CORBA_Contained_var::_retn (void)
+{
+  // yield ownership of managed obj reference
+  CORBA_Contained_ptr val = this->ptr_;
+  this->ptr_ = CORBA_Contained::_nil ();
+  return val;
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_CONTAINED___OUT_CI_)
+#define _CORBA_CONTAINED___OUT_CI_
+
+// *************************************************************
+// Inline operations for class CORBA_Contained_out
+// *************************************************************
+
+ACE_INLINE
+CORBA_Contained_out::CORBA_Contained_out (CORBA_Contained_ptr &p)
+  : ptr_ (p)
+{
+  this->ptr_ = CORBA_Contained::_nil ();
+}
+
+ACE_INLINE
+CORBA_Contained_out::CORBA_Contained_out (CORBA_Contained_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = CORBA_Contained::_nil ();
+}
+
+ACE_INLINE
+CORBA_Contained_out::CORBA_Contained_out (const CORBA_Contained_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (CORBA_Contained_out&,p).ptr_)
+{}
+
+ACE_INLINE CORBA_Contained_out &
+CORBA_Contained_out::operator= (const CORBA_Contained_out &p)
+{
+  this->ptr_ = ACE_const_cast (CORBA_Contained_out&,p).ptr_;
+  return *this;
+}
+
+ACE_INLINE CORBA_Contained_out &
+CORBA_Contained_out::operator= (const CORBA_Contained_var &p)
+{
+  this->ptr_ = CORBA_Contained::_duplicate (p.ptr ());
+  return *this;
+}
+
+ACE_INLINE CORBA_Contained_out &
+CORBA_Contained_out::operator= (CORBA_Contained_ptr p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+CORBA_Contained_out::operator CORBA_Contained_ptr &() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE CORBA_Contained_ptr &
+CORBA_Contained_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE CORBA_Contained_ptr 
+CORBA_Contained_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_CONTAINER___CI_)
+#define _CORBA_CONTAINER___CI_
+
+ACE_INLINE
+CORBA_Container::CORBA_Container (
+    TAO_Stub *objref,
+    CORBA::Boolean _tao_collocated,
+    TAO_Abstract_ServantBase *servant
+  )
+  : CORBA_Object (objref, _tao_collocated, servant)
+{
+  this->CORBA_Container_setup_collocation (_tao_collocated);
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_CONTAINER___VAR_CI_)
+#define _CORBA_CONTAINER___VAR_CI_
+
+// *************************************************************
+// Inline operations for class CORBA_Container_var
+// *************************************************************
+
+ACE_INLINE
+CORBA_Container_var::CORBA_Container_var (void) // default constructor
+  : ptr_ (CORBA_Container::_nil ())
+{}
+
+ACE_INLINE CORBA_Container_ptr 
+CORBA_Container_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+CORBA_Container_var::CORBA_Container_var (const CORBA_Container_var &p) // copy constructor
+  : TAO_Base_var (),
+    ptr_ (CORBA_Container::_duplicate (p.ptr ()))
+{}
+
+ACE_INLINE
+CORBA_Container_var::~CORBA_Container_var (void) // destructor
+{
+  CORBA::release (this->ptr_);
+}
+
+ACE_INLINE CORBA_Container_var &
+CORBA_Container_var::operator= (CORBA_Container_ptr p)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE CORBA_Container_var &
+CORBA_Container_var::operator= (const CORBA_Container_var &p)
+{
+  if (this != &p)
+  {
+    CORBA::release (this->ptr_);
+    this->ptr_ = CORBA_Container::_duplicate (p.ptr ());
+  }
+  return *this;
+}
+
+ACE_INLINE 
+CORBA_Container_var::operator const CORBA_Container_ptr &() const // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+CORBA_Container_var::operator CORBA_Container_ptr &() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE CORBA_Container_ptr 
+CORBA_Container_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE CORBA_Container_ptr
+CORBA_Container_var::in (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE CORBA_Container_ptr &
+CORBA_Container_var::inout (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE CORBA_Container_ptr &
+CORBA_Container_var::out (void)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = CORBA_Container::_nil ();
+  return this->ptr_;
+}
+
+ACE_INLINE CORBA_Container_ptr 
+CORBA_Container_var::_retn (void)
+{
+  // yield ownership of managed obj reference
+  CORBA_Container_ptr val = this->ptr_;
+  this->ptr_ = CORBA_Container::_nil ();
+  return val;
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_CONTAINER___OUT_CI_)
+#define _CORBA_CONTAINER___OUT_CI_
+
+// *************************************************************
+// Inline operations for class CORBA_Container_out
+// *************************************************************
+
+ACE_INLINE
+CORBA_Container_out::CORBA_Container_out (CORBA_Container_ptr &p)
+  : ptr_ (p)
+{
+  this->ptr_ = CORBA_Container::_nil ();
+}
+
+ACE_INLINE
+CORBA_Container_out::CORBA_Container_out (CORBA_Container_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = CORBA_Container::_nil ();
+}
+
+ACE_INLINE
+CORBA_Container_out::CORBA_Container_out (const CORBA_Container_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (CORBA_Container_out&,p).ptr_)
+{}
+
+ACE_INLINE CORBA_Container_out &
+CORBA_Container_out::operator= (const CORBA_Container_out &p)
+{
+  this->ptr_ = ACE_const_cast (CORBA_Container_out&,p).ptr_;
+  return *this;
+}
+
+ACE_INLINE CORBA_Container_out &
+CORBA_Container_out::operator= (const CORBA_Container_var &p)
+{
+  this->ptr_ = CORBA_Container::_duplicate (p.ptr ());
+  return *this;
+}
+
+ACE_INLINE CORBA_Container_out &
+CORBA_Container_out::operator= (CORBA_Container_ptr p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+CORBA_Container_out::operator CORBA_Container_ptr &() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE CORBA_Container_ptr &
+CORBA_Container_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE CORBA_Container_ptr 
+CORBA_Container_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+
+#endif /* end #if !defined */
+
+// *************************************************************
+// Inline operations for class CORBA::Contained::Description_var
+// *************************************************************
+
+ACE_INLINE
+CORBA::Contained::Description_var::Description_var (void) // default constructor
+  : ptr_ (0)
+{}
+
+ACE_INLINE
+CORBA::Contained::Description_var::Description_var (Description *p)
+  : ptr_ (p)
+{}
+
+ACE_INLINE
+CORBA::Contained::Description_var::Description_var (const ::CORBA::Contained::Description_var &p) // copy constructor
+{
+  if (p.ptr_)
+    ACE_NEW (this->ptr_, ::CORBA::Contained::Description (*p.ptr_));
+  else
+    this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA::Contained::Description_var::~Description_var (void) // destructor
+{
+  delete this->ptr_;
+}
+
+ACE_INLINE CORBA::Contained::Description_var &
+CORBA::Contained::Description_var::operator= (Description *p)
+{
+  delete this->ptr_;
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE ::CORBA::Contained::Description_var &
+CORBA::Contained::Description_var::operator= (const ::CORBA::Contained::Description_var &p)
+{
+  if (this != &p)
+    {
+      if (p.ptr_ == 0)
+        {
+          delete this->ptr_;
+          this->ptr_ = 0;
+        }
+      else
+        {
+          Description *deep_copy =
+            new Description (*p.ptr_);
+          
+          if (deep_copy != 0)
+            {
+              Description *tmp = deep_copy;
+              deep_copy = this->ptr_;
+              this->ptr_ = tmp;
+              delete deep_copy;
+            }
+        }
+    }
+  
+  return *this;
+}
+
+ACE_INLINE const ::CORBA::Contained::Description *
+CORBA::Contained::Description_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA::Contained::Description *
+CORBA::Contained::Description_var::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+CORBA::Contained::Description_var::operator const ::CORBA::Contained::Description &() const // cast
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE
+CORBA::Contained::Description_var::operator ::CORBA::Contained::Description &() // cast 
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE
+CORBA::Contained::Description_var::operator ::CORBA::Contained::Description &() const // cast 
+{
+  return *this->ptr_;
+}
+
+// variable-size types only
+ACE_INLINE
+CORBA::Contained::Description_var::operator ::CORBA::Contained::Description *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE const ::CORBA::Contained::Description &
+CORBA::Contained::Description_var::in (void) const
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE ::CORBA::Contained::Description &
+CORBA::Contained::Description_var::inout (void)
+{
+  return *this->ptr_;
+}
+
+// mapping for variable size 
+ACE_INLINE ::CORBA::Contained::Description *&
+CORBA::Contained::Description_var::out (void)
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA::Contained::Description *
+CORBA::Contained::Description_var::_retn (void)
+{
+  ::CORBA::Contained::Description *tmp = this->ptr_;
+  this->ptr_ = 0;
+  return tmp;
+}
+
+ACE_INLINE ::CORBA::Contained::Description *
+CORBA::Contained::Description_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+// *************************************************************
+// Inline operations for class CORBA::Contained::Description_out
+// *************************************************************
+
+ACE_INLINE
+CORBA::Contained::Description_out::Description_out (::CORBA::Contained::Description *&p)
+  : ptr_ (p)
+{
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA::Contained::Description_out::Description_out (Description_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA::Contained::Description_out::Description_out (const ::CORBA::Contained::Description_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (Description_out&, p).ptr_)
+{}
+
+ACE_INLINE CORBA::Contained::Description_out &
+CORBA::Contained::Description_out::operator= (const ::CORBA::Contained::Description_out &p)
+{
+  this->ptr_ = ACE_const_cast (Description_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE CORBA::Contained::Description_out &
+CORBA::Contained::Description_out::operator= (Description *p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+CORBA::Contained::Description_out::operator ::CORBA::Contained::Description *&() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA::Contained::Description *&
+CORBA::Contained::Description_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA::Contained::Description *
+CORBA::Contained::Description_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_CONTAINEDSEQ_CI_)
+#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_CONTAINEDSEQ_CI_
+
+  ACE_INLINE Contained **
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::allocbuf (CORBA::ULong nelems)
+  {
+    Contained **buf = 0;
+    
+    ACE_NEW_RETURN (buf, Contained*[nelems], 0);
+    
+    for (CORBA::ULong i = 0; i < nelems; i++)
+      buf[i] = Contained::_nil ();
+    
+    return buf;
+  }
+  
+  ACE_INLINE void 
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::freebuf (Contained **buffer)
+  {
+    if (buffer == 0)
+      return;
+    delete[] buffer;
+  }
+  
+  ACE_INLINE
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq (void)
+  {
+  }
+  
+  ACE_INLINE
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq (CORBA::ULong maximum)
+    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::allocbuf (maximum))
+  {
+  }
+  
+  ACE_INLINE
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq (CORBA::ULong maximum,
+    CORBA::ULong length,
+    Contained* *value,
+    CORBA::Boolean release)
+  : TAO_Unbounded_Base_Sequence (maximum, length, value, release)
+  {
+  }
+  
+  ACE_INLINE
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq(const _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq &rhs)
+    : TAO_Unbounded_Base_Sequence (rhs)
+  {
+    if (rhs.buffer_ != 0)
+    {
+      Contained **tmp1 = _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::allocbuf (this->maximum_);
+      Contained ** const tmp2 = ACE_reinterpret_cast (Contained ** ACE_CAST_CONST, rhs.buffer_);
+      
+      for (CORBA::ULong i = 0; i < rhs.length_; ++i)
+        tmp1[i] = Contained::_duplicate (tmp2[i]);
+      
+      this->buffer_ = tmp1;
+    }
+    else
+    {
+      this->buffer_ = 0;
+    }
+  }
+  
+  ACE_INLINE CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq &
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::operator= (const _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq &rhs)
+  {
+    if (this == &rhs)
+      return *this;
+    
+    if (this->release_)
+    {
+      Contained **tmp = ACE_reinterpret_cast (Contained **, this->buffer_);
+      
+      for (CORBA::ULong i = 0; i < this->length_; ++i)
+      {
+        CORBA::release (tmp[i]);
+        tmp[i] = Contained::_nil ();
+      }
+      if (this->maximum_ < rhs.maximum_)
+      {
+        _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::freebuf (tmp);
+        this->buffer_ = _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::allocbuf (rhs.maximum_);
+      }
+    }
+    else
+      this->buffer_ = _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::allocbuf (rhs.maximum_);
+    
+    TAO_Unbounded_Base_Sequence::operator= (rhs);
+    
+    Contained **tmp1 = ACE_reinterpret_cast (Contained **, this->buffer_);
+    Contained ** const tmp2 = ACE_reinterpret_cast (Contained ** ACE_CAST_CONST, rhs.buffer_);
+    
+    for (CORBA::ULong i = 0; i < rhs.length_; ++i)
+      tmp1[i] = Contained::_duplicate (tmp2[i]);
+    
+    return *this;
+  }
+  
+  ACE_INLINE TAO_Object_Manager<CORBA::Contained,CORBA::Contained_var>
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::operator[] (CORBA::ULong index) const
+  // read-write accessor
+  {
+    ACE_ASSERT (index < this->maximum_);
+    Contained ** const tmp = ACE_reinterpret_cast (Contained ** ACE_CAST_CONST, this->buffer_);
+    return TAO_Object_Manager<CORBA::Contained,CORBA::Contained_var> (tmp + index, this->release_);
+  }
+  
+  ACE_INLINE Contained* *
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::get_buffer (CORBA::Boolean orphan)
+  {
+    Contained **result = 0;
+    if (orphan == 0)
+    {
+      // We retain ownership.
+      if (this->buffer_ == 0)
+      {
+        result = _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::allocbuf (this->maximum_);
+        this->buffer_ = result;
+        this->release_ = 1;
+      }
+      else
+      {
+        result = ACE_reinterpret_cast (Contained**, this->buffer_);
+      }
+    }
+    else // if (orphan == 1)
+    {
+      if (this->release_ != 0)
+      {
+        // We set the state back to default and relinquish
+        // ownership.
+        result = ACE_reinterpret_cast(Contained**,this->buffer_);
+        this->maximum_ = 0;
+        this->length_ = 0;
+        this->buffer_ = 0;
+        this->release_ = 0;
+      }
+    }
+    return result;
+  }
+  
+  ACE_INLINE const Contained* *
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::get_buffer (void) const
+  {
+    return ACE_reinterpret_cast(const Contained ** ACE_CAST_CONST, this->buffer_);
+  }
+  
+  
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_CORBA_CONTAINEDSEQ_CI_)
+#define _CORBA_CONTAINEDSEQ_CI_
+
+// *************************************************************
+// Inline operations for class CORBA_ContainedSeq_var
+// *************************************************************
+
+ACE_INLINE
+CORBA_ContainedSeq_var::CORBA_ContainedSeq_var (void) // default constructor
+  : ptr_ (0)
+{}
+
+ACE_INLINE
+CORBA_ContainedSeq_var::CORBA_ContainedSeq_var (CORBA_ContainedSeq *p)
+  : ptr_ (p)
+{}
+
+ACE_INLINE
+CORBA_ContainedSeq_var::CORBA_ContainedSeq_var (const ::CORBA_ContainedSeq_var &p) // copy constructor
+{
+  if (p.ptr_)
+    ACE_NEW (this->ptr_, ::CORBA::ContainedSeq (*p.ptr_));
+  else
+    this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA_ContainedSeq_var::~CORBA_ContainedSeq_var (void) // destructor
+{
+  delete this->ptr_;
+}
+
+ACE_INLINE CORBA_ContainedSeq_var &
+CORBA_ContainedSeq_var::operator= (CORBA_ContainedSeq *p)
+{
+  delete this->ptr_;
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE ::CORBA_ContainedSeq_var &
+CORBA_ContainedSeq_var::operator= (const ::CORBA_ContainedSeq_var &p)
+{
+  if (this != &p)
+    {
+      if (p.ptr_ == 0)
+        {
+          delete this->ptr_;
+          this->ptr_ = 0;
+        }
+      else
+        {
+          CORBA_ContainedSeq *deep_copy =
+            new CORBA_ContainedSeq (*p.ptr_);
+          
+          if (deep_copy != 0)
+            {
+              CORBA_ContainedSeq *tmp = deep_copy;
+              deep_copy = this->ptr_;
+              this->ptr_ = tmp;
+              delete deep_copy;
+            }
+        }
+    }
+  
+  return *this;
+}
+
+ACE_INLINE const ::CORBA::ContainedSeq *
+CORBA_ContainedSeq_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA::ContainedSeq *
+CORBA_ContainedSeq_var::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+CORBA_ContainedSeq_var::operator const ::CORBA::ContainedSeq &() const // cast
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE 
+CORBA_ContainedSeq_var::operator ::CORBA::ContainedSeq &() // cast 
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE 
+CORBA_ContainedSeq_var::operator ::CORBA::ContainedSeq &() const // cast 
+{
+  return *this->ptr_;
+}
+
+// variable-size types only
+ACE_INLINE
+CORBA_ContainedSeq_var::operator ::CORBA::ContainedSeq *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE TAO_Object_Manager<CORBA::Contained, CORBA::Contained_var>
+CORBA_ContainedSeq_var::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+ACE_INLINE const ::CORBA::ContainedSeq &
+CORBA_ContainedSeq_var::in (void) const
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE ::CORBA::ContainedSeq &
+CORBA_ContainedSeq_var::inout (void)
+{
+  return *this->ptr_;
+}
+
+// mapping for variable size 
+ACE_INLINE ::CORBA::ContainedSeq *&
+CORBA_ContainedSeq_var::out (void)
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA::ContainedSeq *
+CORBA_ContainedSeq_var::_retn (void)
+{
+  ::CORBA::ContainedSeq *tmp = this->ptr_;
+  this->ptr_ = 0;
+  return tmp;
+}
+
+ACE_INLINE ::CORBA::ContainedSeq *
+CORBA_ContainedSeq_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+// *************************************************************
+// Inline operations for class CORBA_ContainedSeq_out
+// *************************************************************
+
+ACE_INLINE
+CORBA_ContainedSeq_out::CORBA_ContainedSeq_out (CORBA_ContainedSeq *&p)
+  : ptr_ (p)
+{
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA_ContainedSeq_out::CORBA_ContainedSeq_out (CORBA_ContainedSeq_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA_ContainedSeq_out::CORBA_ContainedSeq_out (const ::CORBA_ContainedSeq_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (CORBA_ContainedSeq_out&, p).ptr_)
+{}
+
+ACE_INLINE ::CORBA_ContainedSeq_out &
+CORBA_ContainedSeq_out::operator= (const ::CORBA_ContainedSeq_out &p)
+{
+  this->ptr_ = ACE_const_cast (CORBA_ContainedSeq_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE ::CORBA_ContainedSeq_out &
+CORBA_ContainedSeq_out::operator= (CORBA_ContainedSeq *p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+CORBA_ContainedSeq_out::operator ::CORBA::ContainedSeq *&() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA::ContainedSeq *&
+CORBA_ContainedSeq_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA::ContainedSeq *
+CORBA_ContainedSeq_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE TAO_Object_Manager<CORBA::Contained, CORBA::Contained_var>
+CORBA_ContainedSeq_out::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_IDLTYPE___CI_)
+#define _CORBA_IDLTYPE___CI_
+
+ACE_INLINE
+CORBA_IDLType::CORBA_IDLType (
+    TAO_Stub *objref,
+    CORBA::Boolean _tao_collocated,
+    TAO_Abstract_ServantBase *servant
+  )
+  : CORBA_Object (objref, _tao_collocated, servant)
+{
+  this->CORBA_IDLType_setup_collocation (_tao_collocated);
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_IDLTYPE___VAR_CI_)
+#define _CORBA_IDLTYPE___VAR_CI_
+
+// *************************************************************
+// Inline operations for class CORBA_IDLType_var
+// *************************************************************
+
+ACE_INLINE
+CORBA_IDLType_var::CORBA_IDLType_var (void) // default constructor
+  : ptr_ (CORBA_IDLType::_nil ())
+{}
+
+ACE_INLINE CORBA_IDLType_ptr 
+CORBA_IDLType_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+CORBA_IDLType_var::CORBA_IDLType_var (const CORBA_IDLType_var &p) // copy constructor
+  : TAO_Base_var (),
+    ptr_ (CORBA_IDLType::_duplicate (p.ptr ()))
+{}
+
+ACE_INLINE
+CORBA_IDLType_var::~CORBA_IDLType_var (void) // destructor
+{
+  CORBA::release (this->ptr_);
+}
+
+ACE_INLINE CORBA_IDLType_var &
+CORBA_IDLType_var::operator= (CORBA_IDLType_ptr p)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE CORBA_IDLType_var &
+CORBA_IDLType_var::operator= (const CORBA_IDLType_var &p)
+{
+  if (this != &p)
+  {
+    CORBA::release (this->ptr_);
+    this->ptr_ = CORBA_IDLType::_duplicate (p.ptr ());
+  }
+  return *this;
+}
+
+ACE_INLINE 
+CORBA_IDLType_var::operator const CORBA_IDLType_ptr &() const // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+CORBA_IDLType_var::operator CORBA_IDLType_ptr &() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE CORBA_IDLType_ptr 
+CORBA_IDLType_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE CORBA_IDLType_ptr
+CORBA_IDLType_var::in (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE CORBA_IDLType_ptr &
+CORBA_IDLType_var::inout (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE CORBA_IDLType_ptr &
+CORBA_IDLType_var::out (void)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = CORBA_IDLType::_nil ();
+  return this->ptr_;
+}
+
+ACE_INLINE CORBA_IDLType_ptr 
+CORBA_IDLType_var::_retn (void)
+{
+  // yield ownership of managed obj reference
+  CORBA_IDLType_ptr val = this->ptr_;
+  this->ptr_ = CORBA_IDLType::_nil ();
+  return val;
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_IDLTYPE___OUT_CI_)
+#define _CORBA_IDLTYPE___OUT_CI_
+
+// *************************************************************
+// Inline operations for class CORBA_IDLType_out
+// *************************************************************
+
+ACE_INLINE
+CORBA_IDLType_out::CORBA_IDLType_out (CORBA_IDLType_ptr &p)
+  : ptr_ (p)
+{
+  this->ptr_ = CORBA_IDLType::_nil ();
+}
+
+ACE_INLINE
+CORBA_IDLType_out::CORBA_IDLType_out (CORBA_IDLType_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = CORBA_IDLType::_nil ();
+}
+
+ACE_INLINE
+CORBA_IDLType_out::CORBA_IDLType_out (const CORBA_IDLType_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (CORBA_IDLType_out&,p).ptr_)
+{}
+
+ACE_INLINE CORBA_IDLType_out &
+CORBA_IDLType_out::operator= (const CORBA_IDLType_out &p)
+{
+  this->ptr_ = ACE_const_cast (CORBA_IDLType_out&,p).ptr_;
+  return *this;
+}
+
+ACE_INLINE CORBA_IDLType_out &
+CORBA_IDLType_out::operator= (const CORBA_IDLType_var &p)
+{
+  this->ptr_ = CORBA_IDLType::_duplicate (p.ptr ());
+  return *this;
+}
+
+ACE_INLINE CORBA_IDLType_out &
+CORBA_IDLType_out::operator= (CORBA_IDLType_ptr p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+CORBA_IDLType_out::operator CORBA_IDLType_ptr &() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE CORBA_IDLType_ptr &
+CORBA_IDLType_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE CORBA_IDLType_ptr 
+CORBA_IDLType_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+
+#endif /* end #if !defined */
+
+
+// *************************************************************
+// Inline operations for class CORBA_StructMember_var
+// *************************************************************
+
+ACE_INLINE
+CORBA_StructMember_var::CORBA_StructMember_var (void) // default constructor
+  : ptr_ (0)
+{}
+
+ACE_INLINE
+CORBA_StructMember_var::CORBA_StructMember_var (CORBA_StructMember *p)
+  : ptr_ (p)
+{}
+
+ACE_INLINE
+CORBA_StructMember_var::CORBA_StructMember_var (const ::CORBA_StructMember_var &p) // copy constructor
+{
+  if (p.ptr_)
+    ACE_NEW (this->ptr_, ::CORBA_StructMember (*p.ptr_));
+  else
+    this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA_StructMember_var::~CORBA_StructMember_var (void) // destructor
+{
+  delete this->ptr_;
+}
+
+ACE_INLINE CORBA_StructMember_var &
+CORBA_StructMember_var::operator= (CORBA_StructMember *p)
+{
+  delete this->ptr_;
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE ::CORBA_StructMember_var &
+CORBA_StructMember_var::operator= (const ::CORBA_StructMember_var &p)
+{
+  if (this != &p)
+    {
+      if (p.ptr_ == 0)
+        {
+          delete this->ptr_;
+          this->ptr_ = 0;
+        }
+      else
+        {
+          CORBA_StructMember *deep_copy =
+            new CORBA_StructMember (*p.ptr_);
+          
+          if (deep_copy != 0)
+            {
+              CORBA_StructMember *tmp = deep_copy;
+              deep_copy = this->ptr_;
+              this->ptr_ = tmp;
+              delete deep_copy;
+            }
+        }
+    }
+  
+  return *this;
+}
+
+ACE_INLINE const ::CORBA_StructMember *
+CORBA_StructMember_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_StructMember *
+CORBA_StructMember_var::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+CORBA_StructMember_var::operator const ::CORBA_StructMember &() const // cast
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE
+CORBA_StructMember_var::operator ::CORBA_StructMember &() // cast 
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE
+CORBA_StructMember_var::operator ::CORBA_StructMember &() const // cast 
+{
+  return *this->ptr_;
+}
+
+// variable-size types only
+ACE_INLINE
+CORBA_StructMember_var::operator ::CORBA_StructMember *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE const ::CORBA_StructMember &
+CORBA_StructMember_var::in (void) const
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE ::CORBA_StructMember &
+CORBA_StructMember_var::inout (void)
+{
+  return *this->ptr_;
+}
+
+// mapping for variable size 
+ACE_INLINE ::CORBA_StructMember *&
+CORBA_StructMember_var::out (void)
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_StructMember *
+CORBA_StructMember_var::_retn (void)
+{
+  ::CORBA_StructMember *tmp = this->ptr_;
+  this->ptr_ = 0;
+  return tmp;
+}
+
+ACE_INLINE ::CORBA_StructMember *
+CORBA_StructMember_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+// *************************************************************
+// Inline operations for class CORBA_StructMember_out
+// *************************************************************
+
+ACE_INLINE
+CORBA_StructMember_out::CORBA_StructMember_out (::CORBA_StructMember *&p)
+  : ptr_ (p)
+{
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA_StructMember_out::CORBA_StructMember_out (CORBA_StructMember_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA_StructMember_out::CORBA_StructMember_out (const ::CORBA_StructMember_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (CORBA_StructMember_out&, p).ptr_)
+{}
+
+ACE_INLINE CORBA_StructMember_out &
+CORBA_StructMember_out::operator= (const ::CORBA_StructMember_out &p)
+{
+  this->ptr_ = ACE_const_cast (CORBA_StructMember_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE CORBA_StructMember_out &
+CORBA_StructMember_out::operator= (CORBA_StructMember *p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+CORBA_StructMember_out::operator ::CORBA_StructMember *&() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_StructMember *&
+CORBA_StructMember_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_StructMember *
+CORBA_StructMember_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_SEQUENCE_CORBA_STRUCTMEMBERSEQ_CI_)
+#define __TAO_UNBOUNDED_SEQUENCE_CORBA_STRUCTMEMBERSEQ_CI_
+
+  // = Static operations.
+  ACE_INLINE StructMember *
+  CORBA::_TAO_Unbounded_Sequence_CORBA_StructMemberSeq::allocbuf (CORBA::ULong size)
+  // Allocate storage for the sequence.
+  {
+    StructMember *retval = 0;
+    ACE_NEW_RETURN (retval, StructMember[size], 0);
+    return retval;
+  }
+  
+  ACE_INLINE void CORBA::_TAO_Unbounded_Sequence_CORBA_StructMemberSeq::freebuf (StructMember *buffer)
+  // Free the sequence.
+  {
+    delete [] buffer;
+  }
+  
+  ACE_INLINE
+  CORBA::_TAO_Unbounded_Sequence_CORBA_StructMemberSeq::_TAO_Unbounded_Sequence_CORBA_StructMemberSeq (void) // Default constructor.
+  {
+  }
+  
+  ACE_INLINE
+  CORBA::_TAO_Unbounded_Sequence_CORBA_StructMemberSeq::_TAO_Unbounded_Sequence_CORBA_StructMemberSeq (CORBA::ULong maximum) // Constructor using a maximum length value.
+    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::allocbuf (maximum))
+  {
+  }
+  
+  ACE_INLINE
+  CORBA::_TAO_Unbounded_Sequence_CORBA_StructMemberSeq::_TAO_Unbounded_Sequence_CORBA_StructMemberSeq (CORBA::ULong maximum,
+    CORBA::ULong length,
+    StructMember *data,
+    CORBA::Boolean release)
+  : TAO_Unbounded_Base_Sequence (maximum, length, data, release)
+  {
+  }
+  
+  ACE_INLINE
+  CORBA::_TAO_Unbounded_Sequence_CORBA_StructMemberSeq::_TAO_Unbounded_Sequence_CORBA_StructMemberSeq (const _TAO_Unbounded_Sequence_CORBA_StructMemberSeq &rhs)
+  // Copy constructor.
+    : TAO_Unbounded_Base_Sequence (rhs)
+  {
+    if (rhs.buffer_ != 0)
+    {
+      StructMember *tmp1 = _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::allocbuf (this->maximum_);
+      StructMember * const tmp2 = ACE_reinterpret_cast (StructMember * ACE_CAST_CONST, rhs.buffer_);
+      
+      for (CORBA::ULong i = 0; i < this->length_; ++i)
+        tmp1[i] = tmp2[i];
+      
+      this->buffer_ = tmp1;
+    }
+    else
+    {
+      this->buffer_ = 0;
+    }
+  }
+  
+  ACE_INLINE CORBA::_TAO_Unbounded_Sequence_CORBA_StructMemberSeq &
+  CORBA::_TAO_Unbounded_Sequence_CORBA_StructMemberSeq::operator= (const _TAO_Unbounded_Sequence_CORBA_StructMemberSeq &rhs)
+  // Assignment operator.
+  {
+    if (this == &rhs)
+      return *this;
+    
+    if (this->release_)
+    {
+      if (this->maximum_ < rhs.maximum_)
+      {
+        // free the old buffer
+        StructMember *tmp = ACE_reinterpret_cast (StructMember *, this->buffer_);
+        _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::freebuf (tmp);
+        this->buffer_ = _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::allocbuf (rhs.maximum_);
+      }
+    }
+    else
+      this->buffer_ = _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::allocbuf (rhs.maximum_);
+    
+    TAO_Unbounded_Base_Sequence::operator= (rhs);
+    
+    StructMember *tmp1 = ACE_reinterpret_cast (StructMember *, this->buffer_);
+    StructMember * const tmp2 = ACE_reinterpret_cast (StructMember * ACE_CAST_CONST, rhs.buffer_);
+    
+    for (CORBA::ULong i = 0; i < this->length_; ++i)
+      tmp1[i] = tmp2[i];
+    
+    return *this;
+  }
+  
+  // = Accessors.
+  ACE_INLINE StructMember &
+  CORBA::_TAO_Unbounded_Sequence_CORBA_StructMemberSeq::operator[] (CORBA::ULong i)
+  // operator []
+  {
+    ACE_ASSERT (i < this->maximum_);
+    StructMember* tmp = ACE_reinterpret_cast(StructMember*,this->buffer_);
+    return tmp[i];
+  }
+  
+  ACE_INLINE const StructMember &
+  CORBA::_TAO_Unbounded_Sequence_CORBA_StructMemberSeq::operator[] (CORBA::ULong i) const
+  // operator []
+  {
+    ACE_ASSERT (i < this->maximum_);
+    StructMember * const tmp = ACE_reinterpret_cast (StructMember* ACE_CAST_CONST, this->buffer_);
+    return tmp[i];
+  }
+  
+  // Implement the TAO_Base_Sequence methods (see Sequence.h)
+  
+  ACE_INLINE StructMember *
+  CORBA::_TAO_Unbounded_Sequence_CORBA_StructMemberSeq::get_buffer (CORBA::Boolean orphan)
+  {
+    StructMember *result = 0;
+    if (orphan == 0)
+    {
+      // We retain ownership.
+      if (this->buffer_ == 0)
+      {
+        result = _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::allocbuf (this->length_);
+        this->buffer_ = result;
+        this->release_ = 1;
+      }
+      else
+      {
+        result = ACE_reinterpret_cast (StructMember*, this->buffer_);
+      }
+    }
+    else // if (orphan == 1)
+    {
+      if (this->release_ != 0)
+      {
+        // We set the state back to default and relinquish
+        // ownership.
+        result = ACE_reinterpret_cast(StructMember*,this->buffer_);
+        this->maximum_ = 0;
+        this->length_ = 0;
+        this->buffer_ = 0;
+        this->release_ = 0;
+      }
+    }
+    return result;
+  }
+  
+  ACE_INLINE const StructMember *
+  CORBA::_TAO_Unbounded_Sequence_CORBA_StructMemberSeq::get_buffer (void) const
+  {
+    return ACE_reinterpret_cast(const StructMember * ACE_CAST_CONST, this->buffer_);
+  }
+  
+  ACE_INLINE void
+  CORBA::_TAO_Unbounded_Sequence_CORBA_StructMemberSeq::replace (CORBA::ULong max,
+  CORBA::ULong length,
+  StructMember *data,
+  CORBA::Boolean release)
+  {
+    this->maximum_ = max;
+    this->length_ = length;
+    if (this->buffer_ && this->release_ == 1)
+    {
+      StructMember *tmp = ACE_reinterpret_cast(StructMember*,this->buffer_);
+      _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::freebuf (tmp);
+    }
+    this->buffer_ = data;
+    this->release_ = release;
+  }
+  
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_CORBA_STRUCTMEMBERSEQ_CI_)
+#define _CORBA_STRUCTMEMBERSEQ_CI_
+
+// *************************************************************
+// Inline operations for class CORBA_StructMemberSeq_var
+// *************************************************************
+
+ACE_INLINE
+CORBA_StructMemberSeq_var::CORBA_StructMemberSeq_var (void) // default constructor
+  : ptr_ (0)
+{}
+
+ACE_INLINE
+CORBA_StructMemberSeq_var::CORBA_StructMemberSeq_var (CORBA_StructMemberSeq *p)
+  : ptr_ (p)
+{}
+
+ACE_INLINE
+CORBA_StructMemberSeq_var::CORBA_StructMemberSeq_var (const ::CORBA_StructMemberSeq_var &p) // copy constructor
+{
+  if (p.ptr_)
+    ACE_NEW (this->ptr_, ::CORBA::StructMemberSeq (*p.ptr_));
+  else
+    this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA_StructMemberSeq_var::~CORBA_StructMemberSeq_var (void) // destructor
+{
+  delete this->ptr_;
+}
+
+ACE_INLINE CORBA_StructMemberSeq_var &
+CORBA_StructMemberSeq_var::operator= (CORBA_StructMemberSeq *p)
+{
+  delete this->ptr_;
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE ::CORBA_StructMemberSeq_var &
+CORBA_StructMemberSeq_var::operator= (const ::CORBA_StructMemberSeq_var &p)
+{
+  if (this != &p)
+    {
+      if (p.ptr_ == 0)
+        {
+          delete this->ptr_;
+          this->ptr_ = 0;
+        }
+      else
+        {
+          CORBA_StructMemberSeq *deep_copy =
+            new CORBA_StructMemberSeq (*p.ptr_);
+          
+          if (deep_copy != 0)
+            {
+              CORBA_StructMemberSeq *tmp = deep_copy;
+              deep_copy = this->ptr_;
+              this->ptr_ = tmp;
+              delete deep_copy;
+            }
+        }
+    }
+  
+  return *this;
+}
+
+ACE_INLINE const ::CORBA::StructMemberSeq *
+CORBA_StructMemberSeq_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA::StructMemberSeq *
+CORBA_StructMemberSeq_var::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+CORBA_StructMemberSeq_var::operator const ::CORBA::StructMemberSeq &() const // cast
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE 
+CORBA_StructMemberSeq_var::operator ::CORBA::StructMemberSeq &() // cast 
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE 
+CORBA_StructMemberSeq_var::operator ::CORBA::StructMemberSeq &() const // cast 
+{
+  return *this->ptr_;
+}
+
+// variable-size types only
+ACE_INLINE
+CORBA_StructMemberSeq_var::operator ::CORBA::StructMemberSeq *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE CORBA::StructMember &
+CORBA_StructMemberSeq_var::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+ACE_INLINE const CORBA::StructMember &
+CORBA_StructMemberSeq_var::operator[] (CORBA::ULong index) const
+{
+  return ACE_const_cast (const CORBA::StructMember &, this->ptr_->operator[] (index));
+}
+
+ACE_INLINE const ::CORBA::StructMemberSeq &
+CORBA_StructMemberSeq_var::in (void) const
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE ::CORBA::StructMemberSeq &
+CORBA_StructMemberSeq_var::inout (void)
+{
+  return *this->ptr_;
+}
+
+// mapping for variable size 
+ACE_INLINE ::CORBA::StructMemberSeq *&
+CORBA_StructMemberSeq_var::out (void)
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA::StructMemberSeq *
+CORBA_StructMemberSeq_var::_retn (void)
+{
+  ::CORBA::StructMemberSeq *tmp = this->ptr_;
+  this->ptr_ = 0;
+  return tmp;
+}
+
+ACE_INLINE ::CORBA::StructMemberSeq *
+CORBA_StructMemberSeq_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+// *************************************************************
+// Inline operations for class CORBA_StructMemberSeq_out
+// *************************************************************
+
+ACE_INLINE
+CORBA_StructMemberSeq_out::CORBA_StructMemberSeq_out (CORBA_StructMemberSeq *&p)
+  : ptr_ (p)
+{
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA_StructMemberSeq_out::CORBA_StructMemberSeq_out (CORBA_StructMemberSeq_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA_StructMemberSeq_out::CORBA_StructMemberSeq_out (const ::CORBA_StructMemberSeq_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (CORBA_StructMemberSeq_out&, p).ptr_)
+{}
+
+ACE_INLINE ::CORBA_StructMemberSeq_out &
+CORBA_StructMemberSeq_out::operator= (const ::CORBA_StructMemberSeq_out &p)
+{
+  this->ptr_ = ACE_const_cast (CORBA_StructMemberSeq_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE ::CORBA_StructMemberSeq_out &
+CORBA_StructMemberSeq_out::operator= (CORBA_StructMemberSeq *p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+CORBA_StructMemberSeq_out::operator ::CORBA::StructMemberSeq *&() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA::StructMemberSeq *&
+CORBA_StructMemberSeq_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA::StructMemberSeq *
+CORBA_StructMemberSeq_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE CORBA::StructMember &
+CORBA_StructMemberSeq_out::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+
+#endif /* end #if !defined */
+
+// *************************************************************
+// Inline operations for class CORBA_Initializer_var
+// *************************************************************
+
+ACE_INLINE
+CORBA_Initializer_var::CORBA_Initializer_var (void) // default constructor
+  : ptr_ (0)
+{}
+
+ACE_INLINE
+CORBA_Initializer_var::CORBA_Initializer_var (CORBA_Initializer *p)
+  : ptr_ (p)
+{}
+
+ACE_INLINE
+CORBA_Initializer_var::CORBA_Initializer_var (const ::CORBA_Initializer_var &p) // copy constructor
+{
+  if (p.ptr_)
+    ACE_NEW (this->ptr_, ::CORBA_Initializer (*p.ptr_));
+  else
+    this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA_Initializer_var::~CORBA_Initializer_var (void) // destructor
+{
+  delete this->ptr_;
+}
+
+ACE_INLINE CORBA_Initializer_var &
+CORBA_Initializer_var::operator= (CORBA_Initializer *p)
+{
+  delete this->ptr_;
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE ::CORBA_Initializer_var &
+CORBA_Initializer_var::operator= (const ::CORBA_Initializer_var &p)
+{
+  if (this != &p)
+    {
+      if (p.ptr_ == 0)
+        {
+          delete this->ptr_;
+          this->ptr_ = 0;
+        }
+      else
+        {
+          CORBA_Initializer *deep_copy =
+            new CORBA_Initializer (*p.ptr_);
+          
+          if (deep_copy != 0)
+            {
+              CORBA_Initializer *tmp = deep_copy;
+              deep_copy = this->ptr_;
+              this->ptr_ = tmp;
+              delete deep_copy;
+            }
+        }
+    }
+  
+  return *this;
+}
+
+ACE_INLINE const ::CORBA_Initializer *
+CORBA_Initializer_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_Initializer *
+CORBA_Initializer_var::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+CORBA_Initializer_var::operator const ::CORBA_Initializer &() const // cast
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE
+CORBA_Initializer_var::operator ::CORBA_Initializer &() // cast 
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE
+CORBA_Initializer_var::operator ::CORBA_Initializer &() const // cast 
+{
+  return *this->ptr_;
+}
+
+// variable-size types only
+ACE_INLINE
+CORBA_Initializer_var::operator ::CORBA_Initializer *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE const ::CORBA_Initializer &
+CORBA_Initializer_var::in (void) const
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE ::CORBA_Initializer &
+CORBA_Initializer_var::inout (void)
+{
+  return *this->ptr_;
+}
+
+// mapping for variable size 
+ACE_INLINE ::CORBA_Initializer *&
+CORBA_Initializer_var::out (void)
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_Initializer *
+CORBA_Initializer_var::_retn (void)
+{
+  ::CORBA_Initializer *tmp = this->ptr_;
+  this->ptr_ = 0;
+  return tmp;
+}
+
+ACE_INLINE ::CORBA_Initializer *
+CORBA_Initializer_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+// *************************************************************
+// Inline operations for class CORBA_Initializer_out
+// *************************************************************
+
+ACE_INLINE
+CORBA_Initializer_out::CORBA_Initializer_out (::CORBA_Initializer *&p)
+  : ptr_ (p)
+{
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA_Initializer_out::CORBA_Initializer_out (CORBA_Initializer_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA_Initializer_out::CORBA_Initializer_out (const ::CORBA_Initializer_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (CORBA_Initializer_out&, p).ptr_)
+{}
+
+ACE_INLINE CORBA_Initializer_out &
+CORBA_Initializer_out::operator= (const ::CORBA_Initializer_out &p)
+{
+  this->ptr_ = ACE_const_cast (CORBA_Initializer_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE CORBA_Initializer_out &
+CORBA_Initializer_out::operator= (CORBA_Initializer *p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+CORBA_Initializer_out::operator ::CORBA_Initializer *&() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_Initializer *&
+CORBA_Initializer_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_Initializer *
+CORBA_Initializer_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_SEQUENCE_CORBA_INITIALIZERSEQ_CI_)
+#define __TAO_UNBOUNDED_SEQUENCE_CORBA_INITIALIZERSEQ_CI_
+
+  // = Static operations.
+  ACE_INLINE Initializer *
+  CORBA::_TAO_Unbounded_Sequence_CORBA_InitializerSeq::allocbuf (CORBA::ULong size)
+  // Allocate storage for the sequence.
+  {
+    Initializer *retval = 0;
+    ACE_NEW_RETURN (retval, Initializer[size], 0);
+    return retval;
+  }
+  
+  ACE_INLINE void CORBA::_TAO_Unbounded_Sequence_CORBA_InitializerSeq::freebuf (Initializer *buffer)
+  // Free the sequence.
+  {
+    delete [] buffer;
+  }
+  
+  ACE_INLINE
+  CORBA::_TAO_Unbounded_Sequence_CORBA_InitializerSeq::_TAO_Unbounded_Sequence_CORBA_InitializerSeq (void) // Default constructor.
+  {
+  }
+  
+  ACE_INLINE
+  CORBA::_TAO_Unbounded_Sequence_CORBA_InitializerSeq::_TAO_Unbounded_Sequence_CORBA_InitializerSeq (CORBA::ULong maximum) // Constructor using a maximum length value.
+    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Sequence_CORBA_InitializerSeq::allocbuf (maximum))
+  {
+  }
+  
+  ACE_INLINE
+  CORBA::_TAO_Unbounded_Sequence_CORBA_InitializerSeq::_TAO_Unbounded_Sequence_CORBA_InitializerSeq (CORBA::ULong maximum,
+    CORBA::ULong length,
+    Initializer *data,
+    CORBA::Boolean release)
+  : TAO_Unbounded_Base_Sequence (maximum, length, data, release)
+  {
+  }
+  
+  ACE_INLINE
+  CORBA::_TAO_Unbounded_Sequence_CORBA_InitializerSeq::_TAO_Unbounded_Sequence_CORBA_InitializerSeq (const _TAO_Unbounded_Sequence_CORBA_InitializerSeq &rhs)
+  // Copy constructor.
+    : TAO_Unbounded_Base_Sequence (rhs)
+  {
+    if (rhs.buffer_ != 0)
+    {
+      Initializer *tmp1 = _TAO_Unbounded_Sequence_CORBA_InitializerSeq::allocbuf (this->maximum_);
+      Initializer * const tmp2 = ACE_reinterpret_cast (Initializer * ACE_CAST_CONST, rhs.buffer_);
+      
+      for (CORBA::ULong i = 0; i < this->length_; ++i)
+        tmp1[i] = tmp2[i];
+      
+      this->buffer_ = tmp1;
+    }
+    else
+    {
+      this->buffer_ = 0;
+    }
+  }
+  
+  ACE_INLINE CORBA::_TAO_Unbounded_Sequence_CORBA_InitializerSeq &
+  CORBA::_TAO_Unbounded_Sequence_CORBA_InitializerSeq::operator= (const _TAO_Unbounded_Sequence_CORBA_InitializerSeq &rhs)
+  // Assignment operator.
+  {
+    if (this == &rhs)
+      return *this;
+    
+    if (this->release_)
+    {
+      if (this->maximum_ < rhs.maximum_)
+      {
+        // free the old buffer
+        Initializer *tmp = ACE_reinterpret_cast (Initializer *, this->buffer_);
+        _TAO_Unbounded_Sequence_CORBA_InitializerSeq::freebuf (tmp);
+        this->buffer_ = _TAO_Unbounded_Sequence_CORBA_InitializerSeq::allocbuf (rhs.maximum_);
+      }
+    }
+    else
+      this->buffer_ = _TAO_Unbounded_Sequence_CORBA_InitializerSeq::allocbuf (rhs.maximum_);
+    
+    TAO_Unbounded_Base_Sequence::operator= (rhs);
+    
+    Initializer *tmp1 = ACE_reinterpret_cast (Initializer *, this->buffer_);
+    Initializer * const tmp2 = ACE_reinterpret_cast (Initializer * ACE_CAST_CONST, rhs.buffer_);
+    
+    for (CORBA::ULong i = 0; i < this->length_; ++i)
+      tmp1[i] = tmp2[i];
+    
+    return *this;
+  }
+  
+  // = Accessors.
+  ACE_INLINE Initializer &
+  CORBA::_TAO_Unbounded_Sequence_CORBA_InitializerSeq::operator[] (CORBA::ULong i)
+  // operator []
+  {
+    ACE_ASSERT (i < this->maximum_);
+    Initializer* tmp = ACE_reinterpret_cast(Initializer*,this->buffer_);
+    return tmp[i];
+  }
+  
+  ACE_INLINE const Initializer &
+  CORBA::_TAO_Unbounded_Sequence_CORBA_InitializerSeq::operator[] (CORBA::ULong i) const
+  // operator []
+  {
+    ACE_ASSERT (i < this->maximum_);
+    Initializer * const tmp = ACE_reinterpret_cast (Initializer* ACE_CAST_CONST, this->buffer_);
+    return tmp[i];
+  }
+  
+  // Implement the TAO_Base_Sequence methods (see Sequence.h)
+  
+  ACE_INLINE Initializer *
+  CORBA::_TAO_Unbounded_Sequence_CORBA_InitializerSeq::get_buffer (CORBA::Boolean orphan)
+  {
+    Initializer *result = 0;
+    if (orphan == 0)
+    {
+      // We retain ownership.
+      if (this->buffer_ == 0)
+      {
+        result = _TAO_Unbounded_Sequence_CORBA_InitializerSeq::allocbuf (this->length_);
+        this->buffer_ = result;
+        this->release_ = 1;
+      }
+      else
+      {
+        result = ACE_reinterpret_cast (Initializer*, this->buffer_);
+      }
+    }
+    else // if (orphan == 1)
+    {
+      if (this->release_ != 0)
+      {
+        // We set the state back to default and relinquish
+        // ownership.
+        result = ACE_reinterpret_cast(Initializer*,this->buffer_);
+        this->maximum_ = 0;
+        this->length_ = 0;
+        this->buffer_ = 0;
+        this->release_ = 0;
+      }
+    }
+    return result;
+  }
+  
+  ACE_INLINE const Initializer *
+  CORBA::_TAO_Unbounded_Sequence_CORBA_InitializerSeq::get_buffer (void) const
+  {
+    return ACE_reinterpret_cast(const Initializer * ACE_CAST_CONST, this->buffer_);
+  }
+  
+  ACE_INLINE void
+  CORBA::_TAO_Unbounded_Sequence_CORBA_InitializerSeq::replace (CORBA::ULong max,
+  CORBA::ULong length,
+  Initializer *data,
+  CORBA::Boolean release)
+  {
+    this->maximum_ = max;
+    this->length_ = length;
+    if (this->buffer_ && this->release_ == 1)
+    {
+      Initializer *tmp = ACE_reinterpret_cast(Initializer*,this->buffer_);
+      _TAO_Unbounded_Sequence_CORBA_InitializerSeq::freebuf (tmp);
+    }
+    this->buffer_ = data;
+    this->release_ = release;
+  }
+  
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_CORBA_INITIALIZERSEQ_CI_)
+#define _CORBA_INITIALIZERSEQ_CI_
+
+// *************************************************************
+// Inline operations for class CORBA_InitializerSeq_var
+// *************************************************************
+
+ACE_INLINE
+CORBA_InitializerSeq_var::CORBA_InitializerSeq_var (void) // default constructor
+  : ptr_ (0)
+{}
+
+ACE_INLINE
+CORBA_InitializerSeq_var::CORBA_InitializerSeq_var (CORBA_InitializerSeq *p)
+  : ptr_ (p)
+{}
+
+ACE_INLINE
+CORBA_InitializerSeq_var::CORBA_InitializerSeq_var (const ::CORBA_InitializerSeq_var &p) // copy constructor
+{
+  if (p.ptr_)
+    ACE_NEW (this->ptr_, ::CORBA::InitializerSeq (*p.ptr_));
+  else
+    this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA_InitializerSeq_var::~CORBA_InitializerSeq_var (void) // destructor
+{
+  delete this->ptr_;
+}
+
+ACE_INLINE CORBA_InitializerSeq_var &
+CORBA_InitializerSeq_var::operator= (CORBA_InitializerSeq *p)
+{
+  delete this->ptr_;
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE ::CORBA_InitializerSeq_var &
+CORBA_InitializerSeq_var::operator= (const ::CORBA_InitializerSeq_var &p)
+{
+  if (this != &p)
+    {
+      if (p.ptr_ == 0)
+        {
+          delete this->ptr_;
+          this->ptr_ = 0;
+        }
+      else
+        {
+          CORBA_InitializerSeq *deep_copy =
+            new CORBA_InitializerSeq (*p.ptr_);
+          
+          if (deep_copy != 0)
+            {
+              CORBA_InitializerSeq *tmp = deep_copy;
+              deep_copy = this->ptr_;
+              this->ptr_ = tmp;
+              delete deep_copy;
+            }
+        }
+    }
+  
+  return *this;
+}
+
+ACE_INLINE const ::CORBA::InitializerSeq *
+CORBA_InitializerSeq_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA::InitializerSeq *
+CORBA_InitializerSeq_var::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+CORBA_InitializerSeq_var::operator const ::CORBA::InitializerSeq &() const // cast
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE 
+CORBA_InitializerSeq_var::operator ::CORBA::InitializerSeq &() // cast 
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE 
+CORBA_InitializerSeq_var::operator ::CORBA::InitializerSeq &() const // cast 
+{
+  return *this->ptr_;
+}
+
+// variable-size types only
+ACE_INLINE
+CORBA_InitializerSeq_var::operator ::CORBA::InitializerSeq *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE CORBA::Initializer &
+CORBA_InitializerSeq_var::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+ACE_INLINE const CORBA::Initializer &
+CORBA_InitializerSeq_var::operator[] (CORBA::ULong index) const
+{
+  return ACE_const_cast (const CORBA::Initializer &, this->ptr_->operator[] (index));
+}
+
+ACE_INLINE const ::CORBA::InitializerSeq &
+CORBA_InitializerSeq_var::in (void) const
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE ::CORBA::InitializerSeq &
+CORBA_InitializerSeq_var::inout (void)
+{
+  return *this->ptr_;
+}
+
+// mapping for variable size 
+ACE_INLINE ::CORBA::InitializerSeq *&
+CORBA_InitializerSeq_var::out (void)
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA::InitializerSeq *
+CORBA_InitializerSeq_var::_retn (void)
+{
+  ::CORBA::InitializerSeq *tmp = this->ptr_;
+  this->ptr_ = 0;
+  return tmp;
+}
+
+ACE_INLINE ::CORBA::InitializerSeq *
+CORBA_InitializerSeq_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+// *************************************************************
+// Inline operations for class CORBA_InitializerSeq_out
+// *************************************************************
+
+ACE_INLINE
+CORBA_InitializerSeq_out::CORBA_InitializerSeq_out (CORBA_InitializerSeq *&p)
+  : ptr_ (p)
+{
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA_InitializerSeq_out::CORBA_InitializerSeq_out (CORBA_InitializerSeq_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA_InitializerSeq_out::CORBA_InitializerSeq_out (const ::CORBA_InitializerSeq_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (CORBA_InitializerSeq_out&, p).ptr_)
+{}
+
+ACE_INLINE ::CORBA_InitializerSeq_out &
+CORBA_InitializerSeq_out::operator= (const ::CORBA_InitializerSeq_out &p)
+{
+  this->ptr_ = ACE_const_cast (CORBA_InitializerSeq_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE ::CORBA_InitializerSeq_out &
+CORBA_InitializerSeq_out::operator= (CORBA_InitializerSeq *p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+CORBA_InitializerSeq_out::operator ::CORBA::InitializerSeq *&() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA::InitializerSeq *&
+CORBA_InitializerSeq_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA::InitializerSeq *
+CORBA_InitializerSeq_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE CORBA::Initializer &
+CORBA_InitializerSeq_out::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+
+#endif /* end #if !defined */
+
+// *************************************************************
+// Inline operations for class CORBA_UnionMember_var
+// *************************************************************
+
+ACE_INLINE
+CORBA_UnionMember_var::CORBA_UnionMember_var (void) // default constructor
+  : ptr_ (0)
+{}
+
+ACE_INLINE
+CORBA_UnionMember_var::CORBA_UnionMember_var (CORBA_UnionMember *p)
+  : ptr_ (p)
+{}
+
+ACE_INLINE
+CORBA_UnionMember_var::CORBA_UnionMember_var (const ::CORBA_UnionMember_var &p) // copy constructor
+{
+  if (p.ptr_)
+    ACE_NEW (this->ptr_, ::CORBA_UnionMember (*p.ptr_));
+  else
+    this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA_UnionMember_var::~CORBA_UnionMember_var (void) // destructor
+{
+  delete this->ptr_;
+}
+
+ACE_INLINE CORBA_UnionMember_var &
+CORBA_UnionMember_var::operator= (CORBA_UnionMember *p)
+{
+  delete this->ptr_;
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE ::CORBA_UnionMember_var &
+CORBA_UnionMember_var::operator= (const ::CORBA_UnionMember_var &p)
+{
+  if (this != &p)
+    {
+      if (p.ptr_ == 0)
+        {
+          delete this->ptr_;
+          this->ptr_ = 0;
+        }
+      else
+        {
+          CORBA_UnionMember *deep_copy =
+            new CORBA_UnionMember (*p.ptr_);
+          
+          if (deep_copy != 0)
+            {
+              CORBA_UnionMember *tmp = deep_copy;
+              deep_copy = this->ptr_;
+              this->ptr_ = tmp;
+              delete deep_copy;
+            }
+        }
+    }
+  
+  return *this;
+}
+
+ACE_INLINE const ::CORBA_UnionMember *
+CORBA_UnionMember_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_UnionMember *
+CORBA_UnionMember_var::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+CORBA_UnionMember_var::operator const ::CORBA_UnionMember &() const // cast
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE
+CORBA_UnionMember_var::operator ::CORBA_UnionMember &() // cast 
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE
+CORBA_UnionMember_var::operator ::CORBA_UnionMember &() const // cast 
+{
+  return *this->ptr_;
+}
+
+// variable-size types only
+ACE_INLINE
+CORBA_UnionMember_var::operator ::CORBA_UnionMember *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE const ::CORBA_UnionMember &
+CORBA_UnionMember_var::in (void) const
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE ::CORBA_UnionMember &
+CORBA_UnionMember_var::inout (void)
+{
+  return *this->ptr_;
+}
+
+// mapping for variable size 
+ACE_INLINE ::CORBA_UnionMember *&
+CORBA_UnionMember_var::out (void)
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_UnionMember *
+CORBA_UnionMember_var::_retn (void)
+{
+  ::CORBA_UnionMember *tmp = this->ptr_;
+  this->ptr_ = 0;
+  return tmp;
+}
+
+ACE_INLINE ::CORBA_UnionMember *
+CORBA_UnionMember_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+// *************************************************************
+// Inline operations for class CORBA_UnionMember_out
+// *************************************************************
+
+ACE_INLINE
+CORBA_UnionMember_out::CORBA_UnionMember_out (::CORBA_UnionMember *&p)
+  : ptr_ (p)
+{
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA_UnionMember_out::CORBA_UnionMember_out (CORBA_UnionMember_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA_UnionMember_out::CORBA_UnionMember_out (const ::CORBA_UnionMember_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (CORBA_UnionMember_out&, p).ptr_)
+{}
+
+ACE_INLINE CORBA_UnionMember_out &
+CORBA_UnionMember_out::operator= (const ::CORBA_UnionMember_out &p)
+{
+  this->ptr_ = ACE_const_cast (CORBA_UnionMember_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE CORBA_UnionMember_out &
+CORBA_UnionMember_out::operator= (CORBA_UnionMember *p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+CORBA_UnionMember_out::operator ::CORBA_UnionMember *&() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_UnionMember *&
+CORBA_UnionMember_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_UnionMember *
+CORBA_UnionMember_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_SEQUENCE_CORBA_UNIONMEMBERSEQ_CI_)
+#define __TAO_UNBOUNDED_SEQUENCE_CORBA_UNIONMEMBERSEQ_CI_
+
+  // = Static operations.
+  ACE_INLINE UnionMember *
+  CORBA::_TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::allocbuf (CORBA::ULong size)
+  // Allocate storage for the sequence.
+  {
+    UnionMember *retval = 0;
+    ACE_NEW_RETURN (retval, UnionMember[size], 0);
+    return retval;
+  }
+  
+  ACE_INLINE void CORBA::_TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::freebuf (UnionMember *buffer)
+  // Free the sequence.
+  {
+    delete [] buffer;
+  }
+  
+  ACE_INLINE
+  CORBA::_TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::_TAO_Unbounded_Sequence_CORBA_UnionMemberSeq (void) // Default constructor.
+  {
+  }
+  
+  ACE_INLINE
+  CORBA::_TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::_TAO_Unbounded_Sequence_CORBA_UnionMemberSeq (CORBA::ULong maximum) // Constructor using a maximum length value.
+    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::allocbuf (maximum))
+  {
+  }
+  
+  ACE_INLINE
+  CORBA::_TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::_TAO_Unbounded_Sequence_CORBA_UnionMemberSeq (CORBA::ULong maximum,
+    CORBA::ULong length,
+    UnionMember *data,
+    CORBA::Boolean release)
+  : TAO_Unbounded_Base_Sequence (maximum, length, data, release)
+  {
+  }
+  
+  ACE_INLINE
+  CORBA::_TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::_TAO_Unbounded_Sequence_CORBA_UnionMemberSeq (const _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq &rhs)
+  // Copy constructor.
+    : TAO_Unbounded_Base_Sequence (rhs)
+  {
+    if (rhs.buffer_ != 0)
+    {
+      UnionMember *tmp1 = _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::allocbuf (this->maximum_);
+      UnionMember * const tmp2 = ACE_reinterpret_cast (UnionMember * ACE_CAST_CONST, rhs.buffer_);
+      
+      for (CORBA::ULong i = 0; i < this->length_; ++i)
+        tmp1[i] = tmp2[i];
+      
+      this->buffer_ = tmp1;
+    }
+    else
+    {
+      this->buffer_ = 0;
+    }
+  }
+  
+  ACE_INLINE CORBA::_TAO_Unbounded_Sequence_CORBA_UnionMemberSeq &
+  CORBA::_TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::operator= (const _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq &rhs)
+  // Assignment operator.
+  {
+    if (this == &rhs)
+      return *this;
+    
+    if (this->release_)
+    {
+      if (this->maximum_ < rhs.maximum_)
+      {
+        // free the old buffer
+        UnionMember *tmp = ACE_reinterpret_cast (UnionMember *, this->buffer_);
+        _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::freebuf (tmp);
+        this->buffer_ = _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::allocbuf (rhs.maximum_);
+      }
+    }
+    else
+      this->buffer_ = _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::allocbuf (rhs.maximum_);
+    
+    TAO_Unbounded_Base_Sequence::operator= (rhs);
+    
+    UnionMember *tmp1 = ACE_reinterpret_cast (UnionMember *, this->buffer_);
+    UnionMember * const tmp2 = ACE_reinterpret_cast (UnionMember * ACE_CAST_CONST, rhs.buffer_);
+    
+    for (CORBA::ULong i = 0; i < this->length_; ++i)
+      tmp1[i] = tmp2[i];
+    
+    return *this;
+  }
+  
+  // = Accessors.
+  ACE_INLINE UnionMember &
+  CORBA::_TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::operator[] (CORBA::ULong i)
+  // operator []
+  {
+    ACE_ASSERT (i < this->maximum_);
+    UnionMember* tmp = ACE_reinterpret_cast(UnionMember*,this->buffer_);
+    return tmp[i];
+  }
+  
+  ACE_INLINE const UnionMember &
+  CORBA::_TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::operator[] (CORBA::ULong i) const
+  // operator []
+  {
+    ACE_ASSERT (i < this->maximum_);
+    UnionMember * const tmp = ACE_reinterpret_cast (UnionMember* ACE_CAST_CONST, this->buffer_);
+    return tmp[i];
+  }
+  
+  // Implement the TAO_Base_Sequence methods (see Sequence.h)
+  
+  ACE_INLINE UnionMember *
+  CORBA::_TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::get_buffer (CORBA::Boolean orphan)
+  {
+    UnionMember *result = 0;
+    if (orphan == 0)
+    {
+      // We retain ownership.
+      if (this->buffer_ == 0)
+      {
+        result = _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::allocbuf (this->length_);
+        this->buffer_ = result;
+        this->release_ = 1;
+      }
+      else
+      {
+        result = ACE_reinterpret_cast (UnionMember*, this->buffer_);
+      }
+    }
+    else // if (orphan == 1)
+    {
+      if (this->release_ != 0)
+      {
+        // We set the state back to default and relinquish
+        // ownership.
+        result = ACE_reinterpret_cast(UnionMember*,this->buffer_);
+        this->maximum_ = 0;
+        this->length_ = 0;
+        this->buffer_ = 0;
+        this->release_ = 0;
+      }
+    }
+    return result;
+  }
+  
+  ACE_INLINE const UnionMember *
+  CORBA::_TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::get_buffer (void) const
+  {
+    return ACE_reinterpret_cast(const UnionMember * ACE_CAST_CONST, this->buffer_);
+  }
+  
+  ACE_INLINE void
+  CORBA::_TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::replace (CORBA::ULong max,
+  CORBA::ULong length,
+  UnionMember *data,
+  CORBA::Boolean release)
+  {
+    this->maximum_ = max;
+    this->length_ = length;
+    if (this->buffer_ && this->release_ == 1)
+    {
+      UnionMember *tmp = ACE_reinterpret_cast(UnionMember*,this->buffer_);
+      _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::freebuf (tmp);
+    }
+    this->buffer_ = data;
+    this->release_ = release;
+  }
+  
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_CORBA_UNIONMEMBERSEQ_CI_)
+#define _CORBA_UNIONMEMBERSEQ_CI_
+
+// *************************************************************
+// Inline operations for class CORBA_UnionMemberSeq_var
+// *************************************************************
+
+ACE_INLINE
+CORBA_UnionMemberSeq_var::CORBA_UnionMemberSeq_var (void) // default constructor
+  : ptr_ (0)
+{}
+
+ACE_INLINE
+CORBA_UnionMemberSeq_var::CORBA_UnionMemberSeq_var (CORBA_UnionMemberSeq *p)
+  : ptr_ (p)
+{}
+
+ACE_INLINE
+CORBA_UnionMemberSeq_var::CORBA_UnionMemberSeq_var (const ::CORBA_UnionMemberSeq_var &p) // copy constructor
+{
+  if (p.ptr_)
+    ACE_NEW (this->ptr_, ::CORBA::UnionMemberSeq (*p.ptr_));
+  else
+    this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA_UnionMemberSeq_var::~CORBA_UnionMemberSeq_var (void) // destructor
+{
+  delete this->ptr_;
+}
+
+ACE_INLINE CORBA_UnionMemberSeq_var &
+CORBA_UnionMemberSeq_var::operator= (CORBA_UnionMemberSeq *p)
+{
+  delete this->ptr_;
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE ::CORBA_UnionMemberSeq_var &
+CORBA_UnionMemberSeq_var::operator= (const ::CORBA_UnionMemberSeq_var &p)
+{
+  if (this != &p)
+    {
+      if (p.ptr_ == 0)
+        {
+          delete this->ptr_;
+          this->ptr_ = 0;
+        }
+      else
+        {
+          CORBA_UnionMemberSeq *deep_copy =
+            new CORBA_UnionMemberSeq (*p.ptr_);
+          
+          if (deep_copy != 0)
+            {
+              CORBA_UnionMemberSeq *tmp = deep_copy;
+              deep_copy = this->ptr_;
+              this->ptr_ = tmp;
+              delete deep_copy;
+            }
+        }
+    }
+  
+  return *this;
+}
+
+ACE_INLINE const ::CORBA::UnionMemberSeq *
+CORBA_UnionMemberSeq_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA::UnionMemberSeq *
+CORBA_UnionMemberSeq_var::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+CORBA_UnionMemberSeq_var::operator const ::CORBA::UnionMemberSeq &() const // cast
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE 
+CORBA_UnionMemberSeq_var::operator ::CORBA::UnionMemberSeq &() // cast 
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE 
+CORBA_UnionMemberSeq_var::operator ::CORBA::UnionMemberSeq &() const // cast 
+{
+  return *this->ptr_;
+}
+
+// variable-size types only
+ACE_INLINE
+CORBA_UnionMemberSeq_var::operator ::CORBA::UnionMemberSeq *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE CORBA::UnionMember &
+CORBA_UnionMemberSeq_var::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+ACE_INLINE const CORBA::UnionMember &
+CORBA_UnionMemberSeq_var::operator[] (CORBA::ULong index) const
+{
+  return ACE_const_cast (const CORBA::UnionMember &, this->ptr_->operator[] (index));
+}
+
+ACE_INLINE const ::CORBA::UnionMemberSeq &
+CORBA_UnionMemberSeq_var::in (void) const
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE ::CORBA::UnionMemberSeq &
+CORBA_UnionMemberSeq_var::inout (void)
+{
+  return *this->ptr_;
+}
+
+// mapping for variable size 
+ACE_INLINE ::CORBA::UnionMemberSeq *&
+CORBA_UnionMemberSeq_var::out (void)
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA::UnionMemberSeq *
+CORBA_UnionMemberSeq_var::_retn (void)
+{
+  ::CORBA::UnionMemberSeq *tmp = this->ptr_;
+  this->ptr_ = 0;
+  return tmp;
+}
+
+ACE_INLINE ::CORBA::UnionMemberSeq *
+CORBA_UnionMemberSeq_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+// *************************************************************
+// Inline operations for class CORBA_UnionMemberSeq_out
+// *************************************************************
+
+ACE_INLINE
+CORBA_UnionMemberSeq_out::CORBA_UnionMemberSeq_out (CORBA_UnionMemberSeq *&p)
+  : ptr_ (p)
+{
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA_UnionMemberSeq_out::CORBA_UnionMemberSeq_out (CORBA_UnionMemberSeq_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA_UnionMemberSeq_out::CORBA_UnionMemberSeq_out (const ::CORBA_UnionMemberSeq_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (CORBA_UnionMemberSeq_out&, p).ptr_)
+{}
+
+ACE_INLINE ::CORBA_UnionMemberSeq_out &
+CORBA_UnionMemberSeq_out::operator= (const ::CORBA_UnionMemberSeq_out &p)
+{
+  this->ptr_ = ACE_const_cast (CORBA_UnionMemberSeq_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE ::CORBA_UnionMemberSeq_out &
+CORBA_UnionMemberSeq_out::operator= (CORBA_UnionMemberSeq *p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+CORBA_UnionMemberSeq_out::operator ::CORBA::UnionMemberSeq *&() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA::UnionMemberSeq *&
+CORBA_UnionMemberSeq_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA::UnionMemberSeq *
+CORBA_UnionMemberSeq_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE CORBA::UnionMember &
+CORBA_UnionMemberSeq_out::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_ENUMMEMBERSEQ_CI_)
+#define _CORBA_ENUMMEMBERSEQ_CI_
+
+// *************************************************************
+// Inline operations for class CORBA_EnumMemberSeq_var
+// *************************************************************
+
+ACE_INLINE
+CORBA_EnumMemberSeq_var::CORBA_EnumMemberSeq_var (void) // default constructor
+  : ptr_ (0)
+{}
+
+ACE_INLINE
+CORBA_EnumMemberSeq_var::CORBA_EnumMemberSeq_var (CORBA_EnumMemberSeq *p)
+  : ptr_ (p)
+{}
+
+ACE_INLINE
+CORBA_EnumMemberSeq_var::CORBA_EnumMemberSeq_var (const ::CORBA_EnumMemberSeq_var &p) // copy constructor
+{
+  if (p.ptr_)
+    ACE_NEW (this->ptr_, ::CORBA::EnumMemberSeq (*p.ptr_));
+  else
+    this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA_EnumMemberSeq_var::~CORBA_EnumMemberSeq_var (void) // destructor
+{
+  delete this->ptr_;
+}
+
+ACE_INLINE CORBA_EnumMemberSeq_var &
+CORBA_EnumMemberSeq_var::operator= (CORBA_EnumMemberSeq *p)
+{
+  delete this->ptr_;
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE ::CORBA_EnumMemberSeq_var &
+CORBA_EnumMemberSeq_var::operator= (const ::CORBA_EnumMemberSeq_var &p)
+{
+  if (this != &p)
+    {
+      if (p.ptr_ == 0)
+        {
+          delete this->ptr_;
+          this->ptr_ = 0;
+        }
+      else
+        {
+          CORBA_EnumMemberSeq *deep_copy =
+            new CORBA_EnumMemberSeq (*p.ptr_);
+          
+          if (deep_copy != 0)
+            {
+              CORBA_EnumMemberSeq *tmp = deep_copy;
+              deep_copy = this->ptr_;
+              this->ptr_ = tmp;
+              delete deep_copy;
+            }
+        }
+    }
+  
+  return *this;
+}
+
+ACE_INLINE const ::CORBA::EnumMemberSeq *
+CORBA_EnumMemberSeq_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA::EnumMemberSeq *
+CORBA_EnumMemberSeq_var::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+CORBA_EnumMemberSeq_var::operator const ::CORBA::EnumMemberSeq &() const // cast
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE 
+CORBA_EnumMemberSeq_var::operator ::CORBA::EnumMemberSeq &() // cast 
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE 
+CORBA_EnumMemberSeq_var::operator ::CORBA::EnumMemberSeq &() const // cast 
+{
+  return *this->ptr_;
+}
+
+// variable-size types only
+ACE_INLINE
+CORBA_EnumMemberSeq_var::operator ::CORBA::EnumMemberSeq *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE TAO_SeqElem_String_Manager
+CORBA_EnumMemberSeq_var::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+ACE_INLINE const ::CORBA::EnumMemberSeq &
+CORBA_EnumMemberSeq_var::in (void) const
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE ::CORBA::EnumMemberSeq &
+CORBA_EnumMemberSeq_var::inout (void)
+{
+  return *this->ptr_;
+}
+
+// mapping for variable size 
+ACE_INLINE ::CORBA::EnumMemberSeq *&
+CORBA_EnumMemberSeq_var::out (void)
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA::EnumMemberSeq *
+CORBA_EnumMemberSeq_var::_retn (void)
+{
+  ::CORBA::EnumMemberSeq *tmp = this->ptr_;
+  this->ptr_ = 0;
+  return tmp;
+}
+
+ACE_INLINE ::CORBA::EnumMemberSeq *
+CORBA_EnumMemberSeq_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+// *************************************************************
+// Inline operations for class CORBA_EnumMemberSeq_out
+// *************************************************************
+
+ACE_INLINE
+CORBA_EnumMemberSeq_out::CORBA_EnumMemberSeq_out (CORBA_EnumMemberSeq *&p)
+  : ptr_ (p)
+{
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA_EnumMemberSeq_out::CORBA_EnumMemberSeq_out (CORBA_EnumMemberSeq_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA_EnumMemberSeq_out::CORBA_EnumMemberSeq_out (const ::CORBA_EnumMemberSeq_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (CORBA_EnumMemberSeq_out&, p).ptr_)
+{}
+
+ACE_INLINE ::CORBA_EnumMemberSeq_out &
+CORBA_EnumMemberSeq_out::operator= (const ::CORBA_EnumMemberSeq_out &p)
+{
+  this->ptr_ = ACE_const_cast (CORBA_EnumMemberSeq_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE ::CORBA_EnumMemberSeq_out &
+CORBA_EnumMemberSeq_out::operator= (CORBA_EnumMemberSeq *p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+CORBA_EnumMemberSeq_out::operator ::CORBA::EnumMemberSeq *&() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA::EnumMemberSeq *&
+CORBA_EnumMemberSeq_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA::EnumMemberSeq *
+CORBA_EnumMemberSeq_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE TAO_SeqElem_String_Manager
+CORBA_EnumMemberSeq_out::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+
+#endif /* end #if !defined */
+
+// *************************************************************
+// Inline operations for class CORBA::Container::Description_var
+// *************************************************************
+
+ACE_INLINE
+CORBA::Container::Description_var::Description_var (void) // default constructor
+  : ptr_ (0)
+{}
+
+ACE_INLINE
+CORBA::Container::Description_var::Description_var (Description *p)
+  : ptr_ (p)
+{}
+
+ACE_INLINE
+CORBA::Container::Description_var::Description_var (const ::CORBA::Container::Description_var &p) // copy constructor
+{
+  if (p.ptr_)
+    ACE_NEW (this->ptr_, ::CORBA::Container::Description (*p.ptr_));
+  else
+    this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA::Container::Description_var::~Description_var (void) // destructor
+{
+  delete this->ptr_;
+}
+
+ACE_INLINE CORBA::Container::Description_var &
+CORBA::Container::Description_var::operator= (Description *p)
+{
+  delete this->ptr_;
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE ::CORBA::Container::Description_var &
+CORBA::Container::Description_var::operator= (const ::CORBA::Container::Description_var &p)
+{
+  if (this != &p)
+    {
+      if (p.ptr_ == 0)
+        {
+          delete this->ptr_;
+          this->ptr_ = 0;
+        }
+      else
+        {
+          Description *deep_copy =
+            new Description (*p.ptr_);
+          
+          if (deep_copy != 0)
+            {
+              Description *tmp = deep_copy;
+              deep_copy = this->ptr_;
+              this->ptr_ = tmp;
+              delete deep_copy;
+            }
+        }
+    }
+  
+  return *this;
+}
+
+ACE_INLINE const ::CORBA::Container::Description *
+CORBA::Container::Description_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA::Container::Description *
+CORBA::Container::Description_var::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+CORBA::Container::Description_var::operator const ::CORBA::Container::Description &() const // cast
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE
+CORBA::Container::Description_var::operator ::CORBA::Container::Description &() // cast 
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE
+CORBA::Container::Description_var::operator ::CORBA::Container::Description &() const // cast 
+{
+  return *this->ptr_;
+}
+
+// variable-size types only
+ACE_INLINE
+CORBA::Container::Description_var::operator ::CORBA::Container::Description *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE const ::CORBA::Container::Description &
+CORBA::Container::Description_var::in (void) const
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE ::CORBA::Container::Description &
+CORBA::Container::Description_var::inout (void)
+{
+  return *this->ptr_;
+}
+
+// mapping for variable size 
+ACE_INLINE ::CORBA::Container::Description *&
+CORBA::Container::Description_var::out (void)
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA::Container::Description *
+CORBA::Container::Description_var::_retn (void)
+{
+  ::CORBA::Container::Description *tmp = this->ptr_;
+  this->ptr_ = 0;
+  return tmp;
+}
+
+ACE_INLINE ::CORBA::Container::Description *
+CORBA::Container::Description_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+// *************************************************************
+// Inline operations for class CORBA::Container::Description_out
+// *************************************************************
+
+ACE_INLINE
+CORBA::Container::Description_out::Description_out (::CORBA::Container::Description *&p)
+  : ptr_ (p)
+{
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA::Container::Description_out::Description_out (Description_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA::Container::Description_out::Description_out (const ::CORBA::Container::Description_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (Description_out&, p).ptr_)
+{}
+
+ACE_INLINE CORBA::Container::Description_out &
+CORBA::Container::Description_out::operator= (const ::CORBA::Container::Description_out &p)
+{
+  this->ptr_ = ACE_const_cast (Description_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE CORBA::Container::Description_out &
+CORBA::Container::Description_out::operator= (Description *p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+CORBA::Container::Description_out::operator ::CORBA::Container::Description *&() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA::Container::Description *&
+CORBA::Container::Description_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA::Container::Description *
+CORBA::Container::Description_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_SEQUENCE_CORBA_CONTAINER_DESCRIPTIONSEQ_CI_)
+#define __TAO_UNBOUNDED_SEQUENCE_CORBA_CONTAINER_DESCRIPTIONSEQ_CI_
+
+  // = Static operations.
+  ACE_INLINE Description *
+  CORBA::Container::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::allocbuf (CORBA::ULong size)
+  // Allocate storage for the sequence.
+  {
+    Description *retval = 0;
+    ACE_NEW_RETURN (retval, Description[size], 0);
+    return retval;
+  }
+  
+  ACE_INLINE void CORBA::Container::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::freebuf (Description *buffer)
+  // Free the sequence.
+  {
+    delete [] buffer;
+  }
+  
+  ACE_INLINE
+  CORBA::Container::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq (void) // Default constructor.
+  {
+  }
+  
+  ACE_INLINE
+  CORBA::Container::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq (CORBA::ULong maximum) // Constructor using a maximum length value.
+    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::allocbuf (maximum))
+  {
+  }
+  
+  ACE_INLINE
+  CORBA::Container::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq (CORBA::ULong maximum,
+    CORBA::ULong length,
+    Description *data,
+    CORBA::Boolean release)
+  : TAO_Unbounded_Base_Sequence (maximum, length, data, release)
+  {
+  }
+  
+  ACE_INLINE
+  CORBA::Container::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq (const _TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq &rhs)
+  // Copy constructor.
+    : TAO_Unbounded_Base_Sequence (rhs)
+  {
+    if (rhs.buffer_ != 0)
+    {
+      Description *tmp1 = _TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::allocbuf (this->maximum_);
+      Description * const tmp2 = ACE_reinterpret_cast (Description * ACE_CAST_CONST, rhs.buffer_);
+      
+      for (CORBA::ULong i = 0; i < this->length_; ++i)
+        tmp1[i] = tmp2[i];
+      
+      this->buffer_ = tmp1;
+    }
+    else
+    {
+      this->buffer_ = 0;
+    }
+  }
+  
+  ACE_INLINE CORBA::Container::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq &
+  CORBA::Container::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::operator= (const _TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq &rhs)
+  // Assignment operator.
+  {
+    if (this == &rhs)
+      return *this;
+    
+    if (this->release_)
+    {
+      if (this->maximum_ < rhs.maximum_)
+      {
+        // free the old buffer
+        Description *tmp = ACE_reinterpret_cast (Description *, this->buffer_);
+        _TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::freebuf (tmp);
+        this->buffer_ = _TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::allocbuf (rhs.maximum_);
+      }
+    }
+    else
+      this->buffer_ = _TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::allocbuf (rhs.maximum_);
+    
+    TAO_Unbounded_Base_Sequence::operator= (rhs);
+    
+    Description *tmp1 = ACE_reinterpret_cast (Description *, this->buffer_);
+    Description * const tmp2 = ACE_reinterpret_cast (Description * ACE_CAST_CONST, rhs.buffer_);
+    
+    for (CORBA::ULong i = 0; i < this->length_; ++i)
+      tmp1[i] = tmp2[i];
+    
+    return *this;
+  }
+  
+  // = Accessors.
+  ACE_INLINE Description &
+  CORBA::Container::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::operator[] (CORBA::ULong i)
+  // operator []
+  {
+    ACE_ASSERT (i < this->maximum_);
+    Description* tmp = ACE_reinterpret_cast(Description*,this->buffer_);
+    return tmp[i];
+  }
+  
+  ACE_INLINE const Description &
+  CORBA::Container::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::operator[] (CORBA::ULong i) const
+  // operator []
+  {
+    ACE_ASSERT (i < this->maximum_);
+    Description * const tmp = ACE_reinterpret_cast (Description* ACE_CAST_CONST, this->buffer_);
+    return tmp[i];
+  }
+  
+  // Implement the TAO_Base_Sequence methods (see Sequence.h)
+  
+  ACE_INLINE Description *
+  CORBA::Container::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::get_buffer (CORBA::Boolean orphan)
+  {
+    Description *result = 0;
+    if (orphan == 0)
+    {
+      // We retain ownership.
+      if (this->buffer_ == 0)
+      {
+        result = _TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::allocbuf (this->length_);
+        this->buffer_ = result;
+        this->release_ = 1;
+      }
+      else
+      {
+        result = ACE_reinterpret_cast (Description*, this->buffer_);
+      }
+    }
+    else // if (orphan == 1)
+    {
+      if (this->release_ != 0)
+      {
+        // We set the state back to default and relinquish
+        // ownership.
+        result = ACE_reinterpret_cast(Description*,this->buffer_);
+        this->maximum_ = 0;
+        this->length_ = 0;
+        this->buffer_ = 0;
+        this->release_ = 0;
+      }
+    }
+    return result;
+  }
+  
+  ACE_INLINE const Description *
+  CORBA::Container::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::get_buffer (void) const
+  {
+    return ACE_reinterpret_cast(const Description * ACE_CAST_CONST, this->buffer_);
+  }
+  
+  ACE_INLINE void
+  CORBA::Container::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::replace (CORBA::ULong max,
+  CORBA::ULong length,
+  Description *data,
+  CORBA::Boolean release)
+  {
+    this->maximum_ = max;
+    this->length_ = length;
+    if (this->buffer_ && this->release_ == 1)
+    {
+      Description *tmp = ACE_reinterpret_cast(Description*,this->buffer_);
+      _TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::freebuf (tmp);
+    }
+    this->buffer_ = data;
+    this->release_ = release;
+  }
+  
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_CORBA_CONTAINER_DESCRIPTIONSEQ_CI_)
+#define _CORBA_CONTAINER_DESCRIPTIONSEQ_CI_
+
+// *************************************************************
+// Inline operations for class CORBA::Container::DescriptionSeq_var
+// *************************************************************
+
+ACE_INLINE
+CORBA::Container::DescriptionSeq_var::DescriptionSeq_var (void) // default constructor
+  : ptr_ (0)
+{}
+
+ACE_INLINE
+CORBA::Container::DescriptionSeq_var::DescriptionSeq_var (DescriptionSeq *p)
+  : ptr_ (p)
+{}
+
+ACE_INLINE
+CORBA::Container::DescriptionSeq_var::DescriptionSeq_var (const ::CORBA::Container::DescriptionSeq_var &p) // copy constructor
+{
+  if (p.ptr_)
+    ACE_NEW (this->ptr_, ::CORBA::Container::DescriptionSeq (*p.ptr_));
+  else
+    this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA::Container::DescriptionSeq_var::~DescriptionSeq_var (void) // destructor
+{
+  delete this->ptr_;
+}
+
+ACE_INLINE CORBA::Container::DescriptionSeq_var &
+CORBA::Container::DescriptionSeq_var::operator= (DescriptionSeq *p)
+{
+  delete this->ptr_;
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE ::CORBA::Container::DescriptionSeq_var &
+CORBA::Container::DescriptionSeq_var::operator= (const ::CORBA::Container::DescriptionSeq_var &p)
+{
+  if (this != &p)
+    {
+      if (p.ptr_ == 0)
+        {
+          delete this->ptr_;
+          this->ptr_ = 0;
+        }
+      else
+        {
+          DescriptionSeq *deep_copy =
+            new DescriptionSeq (*p.ptr_);
+          
+          if (deep_copy != 0)
+            {
+              DescriptionSeq *tmp = deep_copy;
+              deep_copy = this->ptr_;
+              this->ptr_ = tmp;
+              delete deep_copy;
+            }
+        }
+    }
+  
+  return *this;
+}
+
+ACE_INLINE const ::CORBA::Container::DescriptionSeq *
+CORBA::Container::DescriptionSeq_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA::Container::DescriptionSeq *
+CORBA::Container::DescriptionSeq_var::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+CORBA::Container::DescriptionSeq_var::operator const ::CORBA::Container::DescriptionSeq &() const // cast
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE 
+CORBA::Container::DescriptionSeq_var::operator ::CORBA::Container::DescriptionSeq &() // cast 
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE 
+CORBA::Container::DescriptionSeq_var::operator ::CORBA::Container::DescriptionSeq &() const // cast 
+{
+  return *this->ptr_;
+}
+
+// variable-size types only
+ACE_INLINE
+CORBA::Container::DescriptionSeq_var::operator ::CORBA::Container::DescriptionSeq *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE CORBA::Container::Description &
+CORBA::Container::DescriptionSeq_var::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+ACE_INLINE const CORBA::Container::Description &
+CORBA::Container::DescriptionSeq_var::operator[] (CORBA::ULong index) const
+{
+  return ACE_const_cast (const CORBA::Container::Description &, this->ptr_->operator[] (index));
+}
+
+ACE_INLINE const ::CORBA::Container::DescriptionSeq &
+CORBA::Container::DescriptionSeq_var::in (void) const
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE ::CORBA::Container::DescriptionSeq &
+CORBA::Container::DescriptionSeq_var::inout (void)
+{
+  return *this->ptr_;
+}
+
+// mapping for variable size 
+ACE_INLINE ::CORBA::Container::DescriptionSeq *&
+CORBA::Container::DescriptionSeq_var::out (void)
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA::Container::DescriptionSeq *
+CORBA::Container::DescriptionSeq_var::_retn (void)
+{
+  ::CORBA::Container::DescriptionSeq *tmp = this->ptr_;
+  this->ptr_ = 0;
+  return tmp;
+}
+
+ACE_INLINE ::CORBA::Container::DescriptionSeq *
+CORBA::Container::DescriptionSeq_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+// *************************************************************
+// Inline operations for class CORBA::Container::DescriptionSeq_out
+// *************************************************************
+
+ACE_INLINE
+CORBA::Container::DescriptionSeq_out::DescriptionSeq_out (DescriptionSeq *&p)
+  : ptr_ (p)
+{
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA::Container::DescriptionSeq_out::DescriptionSeq_out (DescriptionSeq_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA::Container::DescriptionSeq_out::DescriptionSeq_out (const ::CORBA::Container::DescriptionSeq_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (DescriptionSeq_out&, p).ptr_)
+{}
+
+ACE_INLINE ::CORBA::Container::DescriptionSeq_out &
+CORBA::Container::DescriptionSeq_out::operator= (const ::CORBA::Container::DescriptionSeq_out &p)
+{
+  this->ptr_ = ACE_const_cast (DescriptionSeq_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE ::CORBA::Container::DescriptionSeq_out &
+CORBA::Container::DescriptionSeq_out::operator= (DescriptionSeq *p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+CORBA::Container::DescriptionSeq_out::operator ::CORBA::Container::DescriptionSeq *&() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA::Container::DescriptionSeq *&
+CORBA::Container::DescriptionSeq_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA::Container::DescriptionSeq *
+CORBA::Container::DescriptionSeq_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE CORBA::Container::Description &
+CORBA::Container::DescriptionSeq_out::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_TYPEDEFDEF___CI_)
+#define _CORBA_TYPEDEFDEF___CI_
+
+ACE_INLINE
+CORBA_TypedefDef::CORBA_TypedefDef (
+    TAO_Stub *objref,
+    CORBA::Boolean _tao_collocated,
+    TAO_Abstract_ServantBase *servant
+  )
+  : CORBA_Object (objref, _tao_collocated, servant)
+{
+  this->CORBA_TypedefDef_setup_collocation (_tao_collocated);
+}
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_TYPEDEFDEF___VAR_CI_)
+#define _CORBA_TYPEDEFDEF___VAR_CI_
+
+// *************************************************************
+// Inline operations for class CORBA_TypedefDef_var
+// *************************************************************
+
+ACE_INLINE
+CORBA_TypedefDef_var::CORBA_TypedefDef_var (void) // default constructor
+  : ptr_ (CORBA_TypedefDef::_nil ())
+{}
+
+ACE_INLINE ::CORBA_TypedefDef_ptr
+CORBA_TypedefDef_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+CORBA_TypedefDef_var::CORBA_TypedefDef_var (const ::CORBA_TypedefDef_var &p) // copy constructor
+  : TAO_Base_var (),
+    ptr_ (CORBA_TypedefDef::_duplicate (p.ptr ()))
+{}
+
+ACE_INLINE
+CORBA_TypedefDef_var::~CORBA_TypedefDef_var (void) // destructor
+{
+  CORBA::release (this->ptr_);
+}
+
+ACE_INLINE CORBA_TypedefDef_var &
+CORBA_TypedefDef_var::operator= (CORBA_TypedefDef_ptr p)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE CORBA_TypedefDef_var &
+CORBA_TypedefDef_var::operator= (const ::CORBA_TypedefDef_var &p)
+{
+  if (this != &p)
+  {
+    CORBA::release (this->ptr_);
+    this->ptr_ = ::CORBA_TypedefDef::_duplicate (p.ptr ());
+  }
+  return *this;
+}
+
+ACE_INLINE 
+CORBA_TypedefDef_var::operator const ::CORBA_TypedefDef_ptr &() const // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+CORBA_TypedefDef_var::operator ::CORBA_TypedefDef_ptr &() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_TypedefDef_ptr
+CORBA_TypedefDef_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_TypedefDef_ptr
+CORBA_TypedefDef_var::in (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_TypedefDef_ptr &
+CORBA_TypedefDef_var::inout (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_TypedefDef_ptr &
+CORBA_TypedefDef_var::out (void)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = ::CORBA_TypedefDef::_nil ();
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_TypedefDef_ptr
+CORBA_TypedefDef_var::_retn (void)
+{
+  // yield ownership of managed obj reference
+  ::CORBA_TypedefDef_ptr val = this->ptr_;
+  this->ptr_ = ::CORBA_TypedefDef::_nil ();
+  return val;
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_TYPEDEFDEF___OUT_CI_)
+#define _CORBA_TYPEDEFDEF___OUT_CI_
+
+// *************************************************************
+// Inline operations for class CORBA_TypedefDef_out
+// *************************************************************
+
+ACE_INLINE
+CORBA_TypedefDef_out::CORBA_TypedefDef_out (CORBA_TypedefDef_ptr &p)
+  : ptr_ (p)
+{
+  this->ptr_ = ::CORBA_TypedefDef::_nil ();
+}
+
+ACE_INLINE
+CORBA_TypedefDef_out::CORBA_TypedefDef_out (CORBA_TypedefDef_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = ::CORBA_TypedefDef::_nil ();
+}
+
+ACE_INLINE
+CORBA_TypedefDef_out::CORBA_TypedefDef_out (const ::CORBA_TypedefDef_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (CORBA_TypedefDef_out &, p).ptr_)
+{}
+
+ACE_INLINE ::CORBA_TypedefDef_out &
+CORBA_TypedefDef_out::operator= (const ::CORBA_TypedefDef_out &p)
+{
+  this->ptr_ = ACE_const_cast (CORBA_TypedefDef_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE CORBA_TypedefDef_out &
+CORBA_TypedefDef_out::operator= (const ::CORBA_TypedefDef_var &p)
+{
+  this->ptr_ = ::CORBA_TypedefDef::_duplicate (p.ptr ());
+  return *this;
+}
+
+ACE_INLINE CORBA_TypedefDef_out &
+CORBA_TypedefDef_out::operator= (CORBA_TypedefDef_ptr p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+CORBA_TypedefDef_out::operator ::CORBA_TypedefDef_ptr &() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_TypedefDef_ptr &
+CORBA_TypedefDef_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_TypedefDef_ptr
+CORBA_TypedefDef_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+
+#endif /* end #if !defined */
+
+// *************************************************************
+// Inline operations for class CORBA_TypeDescription_var
+// *************************************************************
+
+ACE_INLINE
+CORBA_TypeDescription_var::CORBA_TypeDescription_var (void) // default constructor
+  : ptr_ (0)
+{}
+
+ACE_INLINE
+CORBA_TypeDescription_var::CORBA_TypeDescription_var (CORBA_TypeDescription *p)
+  : ptr_ (p)
+{}
+
+ACE_INLINE
+CORBA_TypeDescription_var::CORBA_TypeDescription_var (const ::CORBA_TypeDescription_var &p) // copy constructor
+{
+  if (p.ptr_)
+    ACE_NEW (this->ptr_, ::CORBA_TypeDescription (*p.ptr_));
+  else
+    this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA_TypeDescription_var::~CORBA_TypeDescription_var (void) // destructor
+{
+  delete this->ptr_;
+}
+
+ACE_INLINE CORBA_TypeDescription_var &
+CORBA_TypeDescription_var::operator= (CORBA_TypeDescription *p)
+{
+  delete this->ptr_;
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE ::CORBA_TypeDescription_var &
+CORBA_TypeDescription_var::operator= (const ::CORBA_TypeDescription_var &p)
+{
+  if (this != &p)
+    {
+      if (p.ptr_ == 0)
+        {
+          delete this->ptr_;
+          this->ptr_ = 0;
+        }
+      else
+        {
+          CORBA_TypeDescription *deep_copy =
+            new CORBA_TypeDescription (*p.ptr_);
+          
+          if (deep_copy != 0)
+            {
+              CORBA_TypeDescription *tmp = deep_copy;
+              deep_copy = this->ptr_;
+              this->ptr_ = tmp;
+              delete deep_copy;
+            }
+        }
+    }
+  
+  return *this;
+}
+
+ACE_INLINE const ::CORBA_TypeDescription *
+CORBA_TypeDescription_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_TypeDescription *
+CORBA_TypeDescription_var::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+CORBA_TypeDescription_var::operator const ::CORBA_TypeDescription &() const // cast
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE
+CORBA_TypeDescription_var::operator ::CORBA_TypeDescription &() // cast 
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE
+CORBA_TypeDescription_var::operator ::CORBA_TypeDescription &() const // cast 
+{
+  return *this->ptr_;
+}
+
+// variable-size types only
+ACE_INLINE
+CORBA_TypeDescription_var::operator ::CORBA_TypeDescription *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE const ::CORBA_TypeDescription &
+CORBA_TypeDescription_var::in (void) const
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE ::CORBA_TypeDescription &
+CORBA_TypeDescription_var::inout (void)
+{
+  return *this->ptr_;
+}
+
+// mapping for variable size 
+ACE_INLINE ::CORBA_TypeDescription *&
+CORBA_TypeDescription_var::out (void)
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_TypeDescription *
+CORBA_TypeDescription_var::_retn (void)
+{
+  ::CORBA_TypeDescription *tmp = this->ptr_;
+  this->ptr_ = 0;
+  return tmp;
+}
+
+ACE_INLINE ::CORBA_TypeDescription *
+CORBA_TypeDescription_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+// *************************************************************
+// Inline operations for class CORBA_TypeDescription_out
+// *************************************************************
+
+ACE_INLINE
+CORBA_TypeDescription_out::CORBA_TypeDescription_out (::CORBA_TypeDescription *&p)
+  : ptr_ (p)
+{
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA_TypeDescription_out::CORBA_TypeDescription_out (CORBA_TypeDescription_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA_TypeDescription_out::CORBA_TypeDescription_out (const ::CORBA_TypeDescription_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (CORBA_TypeDescription_out&, p).ptr_)
+{}
+
+ACE_INLINE CORBA_TypeDescription_out &
+CORBA_TypeDescription_out::operator= (const ::CORBA_TypeDescription_out &p)
+{
+  this->ptr_ = ACE_const_cast (CORBA_TypeDescription_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE CORBA_TypeDescription_out &
+CORBA_TypeDescription_out::operator= (CORBA_TypeDescription *p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+CORBA_TypeDescription_out::operator ::CORBA_TypeDescription *&() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_TypeDescription *&
+CORBA_TypeDescription_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_TypeDescription *
+CORBA_TypeDescription_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA::DefinitionKind &_tao_enumval)
+{
+  CORBA::ULong _tao_temp = _tao_enumval;
+  return strm << _tao_temp;
+}
+
+ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA::DefinitionKind &_tao_enumval)
+{
+  CORBA::ULong _tao_temp = 0;
+  CORBA::Boolean _tao_result = strm >> _tao_temp;
+  
+  if (_tao_result == 1)
+    {
+      _tao_enumval = ACE_static_cast (CORBA::DefinitionKind, _tao_temp);
+    }
+  
+  return _tao_result;
+}
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &,
+    const CORBA::IRObject_ptr
+  );
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &,
+    CORBA::IRObject_ptr &
+  );
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &strm,
+    const CORBA::IRObject_ptr _tao_objref
+  )
+{
+  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
+  return (strm << _tao_corba_obj);
+}
+
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &strm,
+    CORBA::IRObject_ptr &_tao_objref
+  )
+{
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::Object_var obj;
+    if ((strm >> obj.inout ()) == 0)
+      return 0;
+    // narrow to the right type
+    _tao_objref =
+      CORBA::IRObject::_unchecked_narrow (
+          obj.in (),
+          ACE_TRY_ENV
+        );
+    ACE_TRY_CHECK;
+    return 1;
+  }
+  ACE_CATCHANY
+  {
+    // do nothing
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &,
+    const CORBA::Contained_ptr
+  );
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &,
+    CORBA::Contained_ptr &
+  );
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &,
+    const CORBA::Container_ptr
+  );
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &,
+    CORBA::Container_ptr &
+  );
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &,
+    const CORBA::Contained_ptr
+  );
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &,
+    CORBA::Contained_ptr &
+  );
+
+ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA::Contained::Description &_tao_aggregate)
+{
+  if (
+    (strm << _tao_aggregate.kind) &&
+    (strm << _tao_aggregate.value)
+  )
+    return 1;
+  else
+    return 0;
+  
+}
+
+ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA::Contained::Description &_tao_aggregate)
+{
+  if (
+    (strm >> _tao_aggregate.kind) &&
+    (strm >> _tao_aggregate.value)
+  )
+    return 1;
+  else
+    return 0;
+  
+}
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &strm,
+    const CORBA::Contained_ptr _tao_objref
+  )
+{
+  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
+  return (strm << _tao_corba_obj);
+}
+
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &strm,
+    CORBA::Contained_ptr &_tao_objref
+  )
+{
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::Object_var obj;
+    if ((strm >> obj.inout ()) == 0)
+      return 0;
+    // narrow to the right type
+    _tao_objref =
+      CORBA::Contained::_unchecked_narrow (
+          obj.in (),
+          ACE_TRY_ENV
+        );
+    ACE_TRY_CHECK;
+    return 1;
+  }
+  ACE_CATCHANY
+  {
+    // do nothing
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+
+#if !defined _TAO_CDR_OP_CORBA_ContainedSeq_I_
+#define _TAO_CDR_OP_CORBA_ContainedSeq_I_
+
+CORBA::Boolean TAO_IFR_Client_Export operator<< (
+    TAO_OutputCDR &,
+    const CORBA::ContainedSeq &
+  );
+CORBA::Boolean TAO_IFR_Client_Export operator>> (
+    TAO_InputCDR &,
+    CORBA::ContainedSeq &
+  );
+
+#endif /* _TAO_CDR_OP_CORBA_ContainedSeq_I_ */
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &,
+    const CORBA::IDLType_ptr
+  );
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &,
+    CORBA::IDLType_ptr &
+  );
+ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA::StructMember &_tao_aggregate)
+{
+  if (
+    (strm << _tao_aggregate.name.in ()) &&
+    (strm << _tao_aggregate.type.in ()) &&
+    (strm << _tao_aggregate.type_def.in ())
+  )
+    return 1;
+  else
+    return 0;
+  
+}
+
+ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA::StructMember &_tao_aggregate)
+{
+  if (
+    (strm >> _tao_aggregate.name.out ()) &&
+    (strm >> _tao_aggregate.type.out ()) &&
+    (strm >> _tao_aggregate.type_def.out ())
+  )
+    return 1;
+  else
+    return 0;
+  
+}
+
+
+#if !defined _TAO_CDR_OP_CORBA_StructMemberSeq_I_
+#define _TAO_CDR_OP_CORBA_StructMemberSeq_I_
+
+CORBA::Boolean TAO_IFR_Client_Export operator<< (
+    TAO_OutputCDR &,
+    const CORBA::StructMemberSeq &
+  );
+CORBA::Boolean TAO_IFR_Client_Export operator>> (
+    TAO_InputCDR &,
+    CORBA::StructMemberSeq &
+  );
+
+#endif /* _TAO_CDR_OP_CORBA_StructMemberSeq_I_ */
+
+ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA::Initializer &_tao_aggregate)
+{
+  if (
+    (strm << _tao_aggregate.members) &&
+    (strm << _tao_aggregate.name.in ())
+  )
+    return 1;
+  else
+    return 0;
+  
+}
+
+ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA::Initializer &_tao_aggregate)
+{
+  if (
+    (strm >> _tao_aggregate.members) &&
+    (strm >> _tao_aggregate.name.out ())
+  )
+    return 1;
+  else
+    return 0;
+  
+}
+
+
+#if !defined _TAO_CDR_OP_CORBA_InitializerSeq_I_
+#define _TAO_CDR_OP_CORBA_InitializerSeq_I_
+
+CORBA::Boolean TAO_IFR_Client_Export operator<< (
+    TAO_OutputCDR &,
+    const CORBA::InitializerSeq &
+  );
+CORBA::Boolean TAO_IFR_Client_Export operator>> (
+    TAO_InputCDR &,
+    CORBA::InitializerSeq &
+  );
+
+#endif /* _TAO_CDR_OP_CORBA_InitializerSeq_I_ */
+
+ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA::UnionMember &_tao_aggregate)
+{
+  if (
+    (strm << _tao_aggregate.name.in ()) &&
+    (strm << _tao_aggregate.label) &&
+    (strm << _tao_aggregate.type.in ()) &&
+    (strm << _tao_aggregate.type_def.in ())
+  )
+    return 1;
+  else
+    return 0;
+  
+}
+
+ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA::UnionMember &_tao_aggregate)
+{
+  if (
+    (strm >> _tao_aggregate.name.out ()) &&
+    (strm >> _tao_aggregate.label) &&
+    (strm >> _tao_aggregate.type.out ()) &&
+    (strm >> _tao_aggregate.type_def.out ())
+  )
+    return 1;
+  else
+    return 0;
+  
+}
+
+
+#if !defined _TAO_CDR_OP_CORBA_UnionMemberSeq_I_
+#define _TAO_CDR_OP_CORBA_UnionMemberSeq_I_
+
+CORBA::Boolean TAO_IFR_Client_Export operator<< (
+    TAO_OutputCDR &,
+    const CORBA::UnionMemberSeq &
+  );
+CORBA::Boolean TAO_IFR_Client_Export operator>> (
+    TAO_InputCDR &,
+    CORBA::UnionMemberSeq &
+  );
+
+#endif /* _TAO_CDR_OP_CORBA_UnionMemberSeq_I_ */
+
+
+#if !defined _TAO_CDR_OP_CORBA_EnumMemberSeq_I_
+#define _TAO_CDR_OP_CORBA_EnumMemberSeq_I_
+
+CORBA::Boolean TAO_IFR_Client_Export operator<< (
+    TAO_OutputCDR &,
+    const CORBA::EnumMemberSeq &
+  );
+CORBA::Boolean TAO_IFR_Client_Export operator>> (
+    TAO_InputCDR &,
+    CORBA::EnumMemberSeq &
+  );
+
+#endif /* _TAO_CDR_OP_CORBA_EnumMemberSeq_I_ */
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &,
+    const CORBA::Container_ptr
+  );
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &,
+    CORBA::Container_ptr &
+  );
+
+ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA::Container::Description &_tao_aggregate)
+{
+  if (
+    (strm << _tao_aggregate.contained_object.in ()) &&
+    (strm << _tao_aggregate.kind) &&
+    (strm << _tao_aggregate.value)
+  )
+    return 1;
+  else
+    return 0;
+  
+}
+
+ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA::Container::Description &_tao_aggregate)
+{
+  if (
+    (strm >> _tao_aggregate.contained_object.out ()) &&
+    (strm >> _tao_aggregate.kind) &&
+    (strm >> _tao_aggregate.value)
+  )
+    return 1;
+  else
+    return 0;
+  
+}
+
+
+#if !defined _TAO_CDR_OP_CORBA_Container_DescriptionSeq_I_
+#define _TAO_CDR_OP_CORBA_Container_DescriptionSeq_I_
+
+CORBA::Boolean TAO_IFR_Client_Export operator<< (
+    TAO_OutputCDR &,
+    const CORBA::Container::DescriptionSeq &
+  );
+CORBA::Boolean TAO_IFR_Client_Export operator>> (
+    TAO_InputCDR &,
+    CORBA::Container::DescriptionSeq &
+  );
+
+#endif /* _TAO_CDR_OP_CORBA_Container_DescriptionSeq_I_ */
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &strm,
+    const CORBA::Container_ptr _tao_objref
+  )
+{
+  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
+  return (strm << _tao_corba_obj);
+}
+
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &strm,
+    CORBA::Container_ptr &_tao_objref
+  )
+{
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::Object_var obj;
+    if ((strm >> obj.inout ()) == 0)
+      return 0;
+    // narrow to the right type
+    _tao_objref =
+      CORBA::Container::_unchecked_narrow (
+          obj.in (),
+          ACE_TRY_ENV
+        );
+    ACE_TRY_CHECK;
+    return 1;
+  }
+  ACE_CATCHANY
+  {
+    // do nothing
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &,
+    const CORBA::IDLType_ptr
+  );
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &,
+    CORBA::IDLType_ptr &
+  );
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &strm,
+    const CORBA::IDLType_ptr _tao_objref
+  )
+{
+  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
+  return (strm << _tao_corba_obj);
+}
+
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &strm,
+    CORBA::IDLType_ptr &_tao_objref
+  )
+{
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::Object_var obj;
+    if ((strm >> obj.inout ()) == 0)
+      return 0;
+    // narrow to the right type
+    _tao_objref =
+      CORBA::IDLType::_unchecked_narrow (
+          obj.in (),
+          ACE_TRY_ENV
+        );
+    ACE_TRY_CHECK;
+    return 1;
+  }
+  ACE_CATCHANY
+  {
+    // do nothing
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &,
+    const CORBA::TypedefDef_ptr
+  );
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &,
+    CORBA::TypedefDef_ptr &
+  );
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &strm,
+    const CORBA::TypedefDef_ptr _tao_objref
+  )
+{
+  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
+  return (strm << _tao_corba_obj);
+}
+
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &strm,
+    CORBA::TypedefDef_ptr &_tao_objref
+  )
+{
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::Object_var obj;
+    if ((strm >> obj.inout ()) == 0)
+      return 0;
+    // narrow to the right type
+    _tao_objref =
+      CORBA::TypedefDef::_unchecked_narrow (
+          obj.in (),
+          ACE_TRY_ENV
+        );
+    ACE_TRY_CHECK;
+    return 1;
+  }
+  ACE_CATCHANY
+  {
+    // do nothing
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA::TypeDescription &_tao_aggregate)
+{
+  if (
+    (strm << _tao_aggregate.name.in ()) &&
+    (strm << _tao_aggregate.id.in ()) &&
+    (strm << _tao_aggregate.defined_in.in ()) &&
+    (strm << _tao_aggregate.version.in ()) &&
+    (strm << _tao_aggregate.type.in ())
+  )
+    return 1;
+  else
+    return 0;
+  
+}
+
+ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA::TypeDescription &_tao_aggregate)
+{
+  if (
+    (strm >> _tao_aggregate.name.out ()) &&
+    (strm >> _tao_aggregate.id.out ()) &&
+    (strm >> _tao_aggregate.defined_in.out ()) &&
+    (strm >> _tao_aggregate.version.out ()) &&
+    (strm >> _tao_aggregate.type.out ())
+  )
+    return 1;
+  else
+    return 0;
+  
+}
+
diff --git a/TAO/tao/IFR_Client/IFR_Basic.pidl b/TAO/tao/IFR_Client/IFR_Basic.pidl
new file mode 100644
index 00000000000..2a2c926e533
--- /dev/null
+++ b/TAO/tao/IFR_Client/IFR_Basic.pidl
@@ -0,0 +1,354 @@
+//
+// $Id$
+//
+// ================================================================
+//
+// = LIBRARY
+//   TAO_IFR_Client
+//
+// = FILENAME
+//   IFR_Basic.pidl
+//
+// = DESCRIPTION
+//   This file was used to generate the code in IFR_BasicC.{h,i,cpp}.
+//   The original file Interface.idl was split into four pieces, to
+//   keep the generated files to a manageable size and reduce build
+//   time. This IDL file contains the concrete base interfaces of
+//   the IFR, except for fixed types, valuetypes and CORBA components.
+//
+//   The command used to generate code from this IDL file is:
+//
+//     tao_idl -o orig -Ge 1 \
+//          -Wb,export_macro=TAO_IFR_Client_Export \
+//          -Wb,export_include=ifr_client_export.h \
+//          -Wb,pre_include="ace/pre.h" \
+//          -Wb,post_include="ace/post.h" \
+//          IFR_Basic.pidl
+//
+//   To regenerate the skeleton files IFR_BasicS.{h,i,cpp} and 
+//   IFR_BasicS_T.{h,i.cpp} in ACE_ROOT/TAO/orbsvcs/IFR_Service, use the 
+//   command
+//
+//     tao_idl -o ../../orbsvcs/IFR_Service/orig -Ge 1 \
+//          -Wb,pre_include="ace/pre.h" \
+//          -Wb,post_include="ace/post.h" \
+//          IFR_Basic.pidl
+//
+// ================================================================
+
+#ifndef _IFR_BASIC_IDL_
+#define _IFR_BASIC_IDL_
+
+#include "IFR_Base.pidl"
+
+#pragma prefix "omg.org"
+
+module CORBA 
+{
+  interface PrimitiveDef;
+  interface StringDef;
+  interface SequenceDef;
+  interface ArrayDef;
+  interface WstringDef;
+  interface FixedDef;
+
+  enum PrimitiveKind 
+  {
+    pk_null, 
+    pk_void, 
+    pk_short, 
+    pk_long, 
+    pk_ushort, 
+    pk_ulong,
+    pk_float, 
+    pk_double, 
+    pk_boolean, 
+    pk_char, 
+    pk_octet,
+    pk_any, 
+    pk_TypeCode, 
+    pk_Principal, 
+    pk_string, 
+    pk_objref,
+    pk_longlong, 
+    pk_ulonglong, 
+    pk_longdouble,
+    pk_wchar, 
+    pk_wstring, 
+    pk_value_base
+  };
+
+  interface Repository : Container 
+  {
+    // read interface
+    Contained lookup_id (
+        in RepositoryId search_id
+      );
+    TypeCode get_canonical_typecode (
+        in TypeCode tc
+      );
+    PrimitiveDef get_primitive (
+        in PrimitiveKind kind
+      );
+    // write interface
+    StringDef create_string (
+        in unsigned long bound
+      );
+    WstringDef create_wstring (
+        in unsigned long bound
+      );
+    SequenceDef create_sequence (
+        in unsigned long bound,
+        in IDLType element_type
+      );
+    ArrayDef create_array (
+        in unsigned long length,
+        in IDLType element_type
+      );
+    FixedDef create_fixed (
+        in unsigned short digits,
+        in short scale
+      );
+  };
+
+  interface ModuleDef : Container, Contained 
+  {
+  };
+
+  struct ModuleDescription 
+  {
+    Identifier name;
+    RepositoryId id;
+    RepositoryId defined_in;
+    VersionSpec version;
+  };
+
+  interface ConstantDef : Contained 
+  {
+    readonly attribute TypeCode type;
+    attribute IDLType type_def;
+    attribute any value;
+  };
+
+  struct ConstantDescription 
+  {
+    Identifier name;
+    RepositoryId id;
+    RepositoryId defined_in;
+    VersionSpec version;
+    TypeCode type;
+    any value;
+  };
+
+  interface StructDef : TypedefDef, Container 
+  {
+    attribute StructMemberSeq members;
+  };
+
+  interface UnionDef : TypedefDef, Container 
+  {
+    readonly attribute TypeCode discriminator_type;
+    attribute IDLType discriminator_type_def;
+    attribute UnionMemberSeq members;
+  };
+
+  interface EnumDef : TypedefDef 
+  {
+    attribute EnumMemberSeq members;
+  };
+
+  interface AliasDef : TypedefDef 
+  {
+    attribute IDLType original_type_def;
+  };
+
+  interface NativeDef : TypedefDef 
+  {
+  };
+
+  interface PrimitiveDef: IDLType 
+  {
+    readonly attribute PrimitiveKind kind;
+  };
+
+  interface StringDef : IDLType 
+  {
+    attribute unsigned long bound;
+  };
+
+  interface WstringDef : IDLType 
+  {
+    attribute unsigned long bound;
+  };
+
+  interface SequenceDef : IDLType 
+  {
+    attribute unsigned long bound;
+    readonly attribute TypeCode element_type;
+    attribute IDLType element_type_def;
+  };
+
+  interface ArrayDef : IDLType 
+  {
+  attribute unsigned long length;
+  readonly attribute TypeCode element_type;
+  attribute IDLType element_type_def;
+  };
+
+  interface ExceptionDef : Contained, Container 
+  {
+    readonly attribute TypeCode type;
+    attribute StructMemberSeq members;
+  };
+
+  struct ExceptionDescription 
+  {
+    Identifier name;
+    RepositoryId id;
+    RepositoryId defined_in;
+    VersionSpec version;
+    TypeCode type;
+  };
+
+  typedef sequence <ExceptionDef> ExceptionDefSeq;
+  typedef sequence <ExceptionDescription> ExcDescriptionSeq;
+
+  enum AttributeMode 
+  {
+    ATTR_NORMAL, 
+    ATTR_READONLY
+  };
+
+  interface AttributeDef : Contained 
+  {
+    readonly attribute TypeCode type;
+    attribute IDLType type_def;
+    attribute AttributeMode mode;
+  };
+
+  struct AttributeDescription 
+  {
+    Identifier name;
+    RepositoryId id;
+    RepositoryId defined_in;
+    VersionSpec version;
+    TypeCode type;
+    AttributeMode mode;
+  };
+
+  enum OperationMode 
+  {
+    OP_NORMAL, 
+    OP_ONEWAY
+  };
+
+  enum ParameterMode 
+  {
+    PARAM_IN, 
+    PARAM_OUT, 
+    PARAM_INOUT
+  };
+
+  struct ParameterDescription 
+  {
+    Identifier name;
+    TypeCode type;
+    IDLType type_def;
+    ParameterMode mode;
+  };
+
+  typedef sequence <ParameterDescription> ParDescriptionSeq;
+  typedef Identifier ContextIdentifier;
+  typedef sequence <ContextIdentifier> ContextIdSeq;
+
+  interface OperationDef : Contained 
+  {
+    readonly attribute TypeCode result;
+    attribute IDLType result_def;
+    attribute ParDescriptionSeq params;
+    attribute OperationMode mode;
+    attribute ContextIdSeq contexts;
+    attribute ExceptionDefSeq exceptions;
+  };
+
+  struct OperationDescription 
+  {
+    Identifier name;
+    RepositoryId id;
+    RepositoryId defined_in;
+    VersionSpec version;
+    TypeCode result;
+    OperationMode mode;
+    ContextIdSeq contexts;
+    ParDescriptionSeq parameters;
+    ExcDescriptionSeq exceptions;
+  };
+
+  typedef sequence <RepositoryId> RepositoryIdSeq;
+  typedef sequence <OperationDescription> OpDescriptionSeq;
+  typedef sequence <AttributeDescription> AttrDescriptionSeq;
+
+  interface InterfaceDef : Container, Contained, IDLType 
+  {
+    // read/write interface
+    attribute InterfaceDefSeq base_interfaces;
+    // read interface
+    boolean is_a (
+        in RepositoryId interface_id
+      );
+
+    struct FullInterfaceDescription 
+    {
+      Identifier name;
+      RepositoryId id;
+      RepositoryId defined_in;
+      VersionSpec version;
+      OpDescriptionSeq operations;
+      AttrDescriptionSeq attributes;
+      RepositoryIdSeq base_interfaces;
+      TypeCode type;
+    };
+
+    FullInterfaceDescription describe_interface ();
+
+    // write interface
+    AttributeDef create_attribute (
+        in RepositoryId id,
+        in Identifier name,
+        in VersionSpec version,
+        in IDLType type,
+        in AttributeMode mode
+      );
+    OperationDef create_operation (
+        in RepositoryId id,
+        in Identifier name,
+        in VersionSpec version,
+        in IDLType result,
+        in OperationMode mode,
+        in ParDescriptionSeq params,
+        in ExceptionDefSeq exceptions,
+        in ContextIdSeq contexts
+      );
+  };
+
+  struct InterfaceDescription 
+  {
+    Identifier name;
+    RepositoryId id;
+    RepositoryId defined_in;
+    VersionSpec version;
+    RepositoryIdSeq base_interfaces;
+  };
+
+  interface AbstractInterfaceDef : InterfaceDef 
+  {
+  };
+
+  interface LocalInterfaceDef : InterfaceDef 
+  {
+  };
+};
+
+#pragma prefix ""
+
+#endif /* _IFR_BASIC_IDL_ */
diff --git a/TAO/tao/IFR_Client/IFR_BasicC.cpp b/TAO/tao/IFR_Client/IFR_BasicC.cpp
new file mode 100644
index 00000000000..4a7ffeec116
--- /dev/null
+++ b/TAO/tao/IFR_Client/IFR_BasicC.cpp
@@ -0,0 +1,27435 @@
+// -*- C++ -*-
+//
+// $Id$
+
+// ****  Code generated by the The ACE ORB (TAO) IDL Compiler ****
+// TAO and the TAO IDL Compiler have been developed by:
+//       Center for Distributed Object Computing
+//       Washington University
+//       St. Louis, MO
+//       USA
+//       http://www.cs.wustl.edu/~schmidt/doc-center.html
+// and
+//       Distributed Object Computing Laboratory
+//       University of California at Irvine
+//       Irvine, CA
+//       USA
+//       http://doc.ece.uci.edu/
+//
+// Information about TAO is available at:
+//     http://www.cs.wustl.edu/~schmidt/TAO.html
+
+#include "IFR_BasicC.h"
+
+#if TAO_HAS_INTERCEPTORS == 1
+#include "tao/RequestInfo_Util.h"
+#endif  /* TAO_HAS_INTERCEPTORS == 1 */
+
+#if defined (__BORLANDC__)
+#pragma option -w-rvl -w-rch -w-ccc -w-aus
+#endif /* __BORLANDC__ */
+
+#if !defined (__ACE_INLINE__)
+#include "IFR_BasicC.i"
+#endif /* !defined INLINE */
+
+// *************************************************************
+// Functions moved from IFR_BaseC.cpp
+
+CORBA::Repository_ptr _TAO_Contained_Remote_Proxy_Impl::containing_repository (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::Repository_ptr _tao_retval = CORBA::Repository::_nil ();
+  CORBA::Repository_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_containing_repository",
+      26,
+      0,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::Contained::TAO_ClientRequestInfo_CORBA_Contained_containing_repository_get ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::Repository_ptr _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+CORBA::Any * 
+CORBA::Contained::TAO_ClientRequestInfo_CORBA_Contained_containing_repository_get::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+CORBA::ModuleDef_ptr _TAO_Container_Remote_Proxy_Impl::create_module (
+    CORBA_Object *_collocated_tao_target_,
+    const char * id,
+    const char * name,
+    const char * version,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::ModuleDef_ptr _tao_retval = CORBA::ModuleDef::_nil ();
+  CORBA::ModuleDef_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "create_module",
+      13,
+      1,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_create_module ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        id,
+        name,
+        version,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+          if (!(
+                            (_tao_out << id) &&
+              (_tao_out << name) &&
+              (_tao_out << version)
+            ))
+            TAO_INTERCEPTOR_THROW_RETURN (
+              CORBA::MARSHAL (),
+              0
+            );
+            
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::ModuleDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+CORBA::ConstantDef_ptr _TAO_Container_Remote_Proxy_Impl::create_constant (
+    CORBA_Object *_collocated_tao_target_,
+    const char * id,
+    const char * name,
+    const char * version,
+    CORBA::IDLType_ptr type,
+    const CORBA::Any & value,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::ConstantDef_ptr _tao_retval = CORBA::ConstantDef::_nil ();
+  CORBA::ConstantDef_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "create_constant",
+      15,
+      1,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_create_constant ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        id,
+        name,
+        version,
+        type,
+        value,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+          if (!(
+                            (_tao_out << id) &&
+              (_tao_out << name) &&
+              (_tao_out << version) &&
+              (_tao_out << type) &&
+              (_tao_out << value)
+            ))
+            TAO_INTERCEPTOR_THROW_RETURN (
+              CORBA::MARSHAL (),
+              0
+            );
+            
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::ConstantDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+CORBA::StructDef_ptr _TAO_Container_Remote_Proxy_Impl::create_struct (
+    CORBA_Object *_collocated_tao_target_,
+    const char * id,
+    const char * name,
+    const char * version,
+    const CORBA::StructMemberSeq & members,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::StructDef_ptr _tao_retval = CORBA::StructDef::_nil ();
+  CORBA::StructDef_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "create_struct",
+      13,
+      1,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_create_struct ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        id,
+        name,
+        version,
+        members,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+          if (!(
+                            (_tao_out << id) &&
+              (_tao_out << name) &&
+              (_tao_out << version) &&
+              (_tao_out << members)
+            ))
+            TAO_INTERCEPTOR_THROW_RETURN (
+              CORBA::MARSHAL (),
+              0
+            );
+            
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::StructDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+CORBA::UnionDef_ptr _TAO_Container_Remote_Proxy_Impl::create_union (
+    CORBA_Object *_collocated_tao_target_,
+    const char * id,
+    const char * name,
+    const char * version,
+    CORBA::IDLType_ptr discriminator_type,
+    const CORBA::UnionMemberSeq & members,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::UnionDef_ptr _tao_retval = CORBA::UnionDef::_nil ();
+  CORBA::UnionDef_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "create_union",
+      12,
+      1,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_create_union ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        id,
+        name,
+        version,
+        discriminator_type,
+        members,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+          if (!(
+                            (_tao_out << id) &&
+              (_tao_out << name) &&
+              (_tao_out << version) &&
+              (_tao_out << discriminator_type) &&
+              (_tao_out << members)
+            ))
+            TAO_INTERCEPTOR_THROW_RETURN (
+              CORBA::MARSHAL (),
+              0
+            );
+            
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::UnionDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+CORBA::EnumDef_ptr _TAO_Container_Remote_Proxy_Impl::create_enum (
+    CORBA_Object *_collocated_tao_target_,
+    const char * id,
+    const char * name,
+    const char * version,
+    const CORBA::EnumMemberSeq & members,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::EnumDef_ptr _tao_retval = CORBA::EnumDef::_nil ();
+  CORBA::EnumDef_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "create_enum",
+      11,
+      1,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_create_enum ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        id,
+        name,
+        version,
+        members,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+          if (!(
+                            (_tao_out << id) &&
+              (_tao_out << name) &&
+              (_tao_out << version) &&
+              (_tao_out << members)
+            ))
+            TAO_INTERCEPTOR_THROW_RETURN (
+              CORBA::MARSHAL (),
+              0
+            );
+            
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::EnumDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+CORBA::AliasDef_ptr _TAO_Container_Remote_Proxy_Impl::create_alias (
+    CORBA_Object *_collocated_tao_target_,
+    const char * id,
+    const char * name,
+    const char * version,
+    CORBA::IDLType_ptr original_type,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::AliasDef_ptr _tao_retval = CORBA::AliasDef::_nil ();
+  CORBA::AliasDef_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "create_alias",
+      12,
+      1,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_create_alias ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        id,
+        name,
+        version,
+        original_type,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+          if (!(
+                            (_tao_out << id) &&
+              (_tao_out << name) &&
+              (_tao_out << version) &&
+              (_tao_out << original_type)
+            ))
+            TAO_INTERCEPTOR_THROW_RETURN (
+              CORBA::MARSHAL (),
+              0
+            );
+            
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::AliasDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+CORBA::InterfaceDef_ptr _TAO_Container_Remote_Proxy_Impl::create_interface (
+    CORBA_Object *_collocated_tao_target_,
+    const char * id,
+    const char * name,
+    const char * version,
+    const CORBA::InterfaceDefSeq & base_interfaces,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::InterfaceDef_ptr _tao_retval = CORBA::InterfaceDef::_nil ();
+  CORBA::InterfaceDef_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "create_interface",
+      16,
+      1,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_create_interface ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        id,
+        name,
+        version,
+        base_interfaces,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+          if (!(
+                            (_tao_out << id) &&
+              (_tao_out << name) &&
+              (_tao_out << version) &&
+              (_tao_out << base_interfaces)
+            ))
+            TAO_INTERCEPTOR_THROW_RETURN (
+              CORBA::MARSHAL (),
+              0
+            );
+            
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::InterfaceDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+CORBA::ExceptionDef_ptr _TAO_Container_Remote_Proxy_Impl::create_exception (
+    CORBA_Object *_collocated_tao_target_,
+    const char * id,
+    const char * name,
+    const char * version,
+    const CORBA::StructMemberSeq & members,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::ExceptionDef_ptr _tao_retval = CORBA::ExceptionDef::_nil ();
+  CORBA::ExceptionDef_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "create_exception",
+      16,
+      1,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_create_exception ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        id,
+        name,
+        version,
+        members,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+          if (!(
+                            (_tao_out << id) &&
+              (_tao_out << name) &&
+              (_tao_out << version) &&
+              (_tao_out << members)
+            ))
+            TAO_INTERCEPTOR_THROW_RETURN (
+              CORBA::MARSHAL (),
+              0
+            );
+            
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::ExceptionDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+CORBA::NativeDef_ptr _TAO_Container_Remote_Proxy_Impl::create_native (
+    CORBA_Object *_collocated_tao_target_,
+    const char * id,
+    const char * name,
+    const char * version,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::NativeDef_ptr _tao_retval = CORBA::NativeDef::_nil ();
+  CORBA::NativeDef_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "create_native",
+      13,
+      1,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_create_native ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        id,
+        name,
+        version,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+          if (!(
+                            (_tao_out << id) &&
+              (_tao_out << name) &&
+              (_tao_out << version)
+            ))
+            TAO_INTERCEPTOR_THROW_RETURN (
+              CORBA::MARSHAL (),
+              0
+            );
+            
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::NativeDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+CORBA::AbstractInterfaceDef_ptr _TAO_Container_Remote_Proxy_Impl::create_abstract_interface (
+    CORBA_Object *_collocated_tao_target_,
+    const char * id,
+    const char * name,
+    const char * version,
+    const CORBA::AbstractInterfaceDefSeq & base_interfaces,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::AbstractInterfaceDef_ptr _tao_retval = CORBA::AbstractInterfaceDef::_nil ();
+  CORBA::AbstractInterfaceDef_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "create_abstract_interface",
+      25,
+      1,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_create_abstract_interface ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        id,
+        name,
+        version,
+        base_interfaces,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+          if (!(
+                            (_tao_out << id) &&
+              (_tao_out << name) &&
+              (_tao_out << version) &&
+              (_tao_out << base_interfaces)
+            ))
+            TAO_INTERCEPTOR_THROW_RETURN (
+              CORBA::MARSHAL (),
+              0
+            );
+            
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::AbstractInterfaceDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+CORBA::LocalInterfaceDef_ptr _TAO_Container_Remote_Proxy_Impl::create_local_interface (
+    CORBA_Object *_collocated_tao_target_,
+    const char * id,
+    const char * name,
+    const char * version,
+    const CORBA::InterfaceDefSeq & base_interfaces,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::LocalInterfaceDef_ptr _tao_retval = CORBA::LocalInterfaceDef::_nil ();
+  CORBA::LocalInterfaceDef_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "create_local_interface",
+      22,
+      1,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_create_local_interface ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        id,
+        name,
+        version,
+        base_interfaces,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+          if (!(
+                            (_tao_out << id) &&
+              (_tao_out << name) &&
+              (_tao_out << version) &&
+              (_tao_out << base_interfaces)
+            ))
+            TAO_INTERCEPTOR_THROW_RETURN (
+              CORBA::MARSHAL (),
+              0
+            );
+            
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::LocalInterfaceDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+CORBA::Any * 
+CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_create_module::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+CORBA::Any * 
+CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_create_constant::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+CORBA::Any * 
+CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_create_struct::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+CORBA::Any * 
+CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_create_union::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+CORBA::Any * 
+CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_create_enum::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+CORBA::Any * 
+CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_create_alias::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+Dynamic::ParameterList *
+CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_create_interface::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
+    
+  CORBA::ULong length_id = parameter_list->length ();
+  parameter_list->length (length_id + 1);
+  (*parameter_list)[length_id].argument <<= id_;
+  (*parameter_list)[length_id].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_name = parameter_list->length ();
+  parameter_list->length (length_name + 1);
+  (*parameter_list)[length_name].argument <<= name_;
+  (*parameter_list)[length_name].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_version = parameter_list->length ();
+  parameter_list->length (length_version + 1);
+  (*parameter_list)[length_version].argument <<= version_;
+  (*parameter_list)[length_version].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_base_interfaces = parameter_list->length ();
+  parameter_list->length (length_base_interfaces + 1);
+  (*parameter_list)[length_base_interfaces].argument <<=  this->base_interfaces_;
+  
+  (*parameter_list)[length_base_interfaces].mode = Dynamic::PARAM_IN;
+  
+  return safe_parameter_list._retn ();
+}
+
+CORBA::Any * 
+CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_create_interface::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+CORBA::Any * 
+CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_create_exception::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+CORBA::Any * 
+CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_create_native::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+Dynamic::ParameterList *
+CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_create_abstract_interface::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
+    
+  CORBA::ULong length_id = parameter_list->length ();
+  parameter_list->length (length_id + 1);
+  (*parameter_list)[length_id].argument <<= id_;
+  (*parameter_list)[length_id].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_name = parameter_list->length ();
+  parameter_list->length (length_name + 1);
+  (*parameter_list)[length_name].argument <<= name_;
+  (*parameter_list)[length_name].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_version = parameter_list->length ();
+  parameter_list->length (length_version + 1);
+  (*parameter_list)[length_version].argument <<= version_;
+  (*parameter_list)[length_version].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_base_interfaces = parameter_list->length ();
+  parameter_list->length (length_base_interfaces + 1);
+  (*parameter_list)[length_base_interfaces].argument <<=  this->base_interfaces_;
+  
+  (*parameter_list)[length_base_interfaces].mode = Dynamic::PARAM_IN;
+  
+  return safe_parameter_list._retn ();
+}
+
+CORBA::Any * 
+CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_create_abstract_interface::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+Dynamic::ParameterList *
+CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_create_local_interface::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
+    
+  CORBA::ULong length_id = parameter_list->length ();
+  parameter_list->length (length_id + 1);
+  (*parameter_list)[length_id].argument <<= id_;
+  (*parameter_list)[length_id].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_name = parameter_list->length ();
+  parameter_list->length (length_name + 1);
+  (*parameter_list)[length_name].argument <<= name_;
+  (*parameter_list)[length_name].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_version = parameter_list->length ();
+  parameter_list->length (length_version + 1);
+  (*parameter_list)[length_version].argument <<= version_;
+  (*parameter_list)[length_version].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_base_interfaces = parameter_list->length ();
+  parameter_list->length (length_base_interfaces + 1);
+  (*parameter_list)[length_base_interfaces].argument <<=  this->base_interfaces_;
+  
+  (*parameter_list)[length_base_interfaces].mode = Dynamic::PARAM_IN;
+  
+  return safe_parameter_list._retn ();
+}
+
+CORBA::Any * 
+CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_create_local_interface::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_INTERFACEDEFSEQ_CS_)
+#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_INTERFACEDEFSEQ_CS_
+
+  // The Base_Sequence functions, please see tao/Sequence.h
+  void
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::_allocate_buffer (CORBA::ULong length)
+  {
+    CORBA::InterfaceDef **tmp = 0;
+    tmp = _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::allocbuf (length);
+    
+    if (this->buffer_ != 0)
+    {
+      CORBA::InterfaceDef **old = ACE_reinterpret_cast (CORBA::InterfaceDef**, this->buffer_);
+      for (CORBA::ULong i = 0; i < this->length_; ++i)
+        if (!this->release_)
+          tmp[i] = CORBA::InterfaceDef::_duplicate (old[i]);
+        else
+          tmp[i] = old[i];
+        
+      if (this->release_)
+        delete[] old;
+      
+    }
+    this->buffer_ = tmp;
+  }
+  
+  void
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::_deallocate_buffer (void)
+  {
+    if (this->buffer_ == 0 || this->release_ == 0)
+      return;
+    CORBA::InterfaceDef **tmp = ACE_reinterpret_cast (CORBA::InterfaceDef**, this->buffer_);
+    for (CORBA::ULong i = 0; i < this->length_; ++i)
+    {
+      CORBA::release (tmp[i]);
+      tmp[i] = CORBA::InterfaceDef::_nil ();
+    }
+    _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::freebuf (tmp);
+    this->buffer_ = 0;
+  }
+  
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::~_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq (void)
+  {
+    this->_deallocate_buffer ();
+  }
+  
+  void
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::_shrink_buffer (CORBA::ULong nl, CORBA::ULong ol)
+  {
+    CORBA::InterfaceDef **tmp = ACE_reinterpret_cast (CORBA::InterfaceDef**, this->buffer_);
+    
+    for (CORBA::ULong i = nl; i < ol; ++i)
+    {
+      CORBA::release (tmp[i]);
+      tmp[i] = CORBA::InterfaceDef::_nil ();
+    }
+  }
+  void 
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::_downcast (
+      void* target,
+      CORBA_Object *src,
+      CORBA_Environment &ACE_TRY_ENV
+    )
+  {
+    CORBA::InterfaceDef **tmp = ACE_static_cast (CORBA::InterfaceDef**, target);
+    *tmp = CORBA::InterfaceDef::_narrow (src, ACE_TRY_ENV);
+    ACE_CHECK;
+  }
+
+  CORBA_Object*
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::_upcast (void *src) const
+  {
+    CORBA::InterfaceDef **tmp = ACE_static_cast (CORBA::InterfaceDef**, src);
+    return *tmp;
+  }
+  
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_CORBA_INTERFACEDEFSEQ_CS_)
+#define _CORBA_INTERFACEDEFSEQ_CS_
+
+// *************************************************************
+// CORBA_InterfaceDefSeq
+// *************************************************************
+
+CORBA_InterfaceDefSeq::CORBA_InterfaceDefSeq (void)
+{}
+CORBA_InterfaceDefSeq::CORBA_InterfaceDefSeq (CORBA::ULong max) // uses max size
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<CORBA::InterfaceDef,CORBA::InterfaceDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (max)
+{}
+CORBA_InterfaceDefSeq::CORBA_InterfaceDefSeq (CORBA::ULong max, CORBA::ULong length, CORBA::InterfaceDef_ptr *buffer, CORBA::Boolean release)
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<CORBA::InterfaceDef,CORBA::InterfaceDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (max, length, buffer, release)
+{}
+CORBA_InterfaceDefSeq::CORBA_InterfaceDefSeq (const CORBA_InterfaceDefSeq &seq) // copy ctor
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<CORBA::InterfaceDef,CORBA::InterfaceDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (seq)
+{}
+CORBA_InterfaceDefSeq::~CORBA_InterfaceDefSeq (void) // dtor
+{}
+void CORBA_InterfaceDefSeq::_tao_any_destructor (void *x)
+{
+  CORBA_InterfaceDefSeq *tmp = ACE_static_cast (CORBA_InterfaceDefSeq*,x);
+  delete tmp;
+}
+
+
+#endif /* end #if !defined */
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_ABSTRACTINTERFACEDEFSEQ_CS_)
+#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_ABSTRACTINTERFACEDEFSEQ_CS_
+
+  // The Base_Sequence functions, please see tao/Sequence.h
+  void
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::_allocate_buffer (CORBA::ULong length)
+  {
+    CORBA::AbstractInterfaceDef **tmp = 0;
+    tmp = _TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::allocbuf (length);
+    
+    if (this->buffer_ != 0)
+    {
+      CORBA::AbstractInterfaceDef **old = ACE_reinterpret_cast (CORBA::AbstractInterfaceDef**, this->buffer_);
+      for (CORBA::ULong i = 0; i < this->length_; ++i)
+        if (!this->release_)
+          tmp[i] = CORBA::AbstractInterfaceDef::_duplicate (old[i]);
+        else
+          tmp[i] = old[i];
+        
+      if (this->release_)
+        delete[] old;
+      
+    }
+    this->buffer_ = tmp;
+  }
+  
+  void
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::_deallocate_buffer (void)
+  {
+    if (this->buffer_ == 0 || this->release_ == 0)
+      return;
+    CORBA::AbstractInterfaceDef **tmp = ACE_reinterpret_cast (CORBA::AbstractInterfaceDef**, this->buffer_);
+    for (CORBA::ULong i = 0; i < this->length_; ++i)
+    {
+      CORBA::release (tmp[i]);
+      tmp[i] = CORBA::AbstractInterfaceDef::_nil ();
+    }
+    _TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::freebuf (tmp);
+    this->buffer_ = 0;
+  }
+  
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::~_TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq (void)
+  {
+    this->_deallocate_buffer ();
+  }
+  
+  void
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::_shrink_buffer (CORBA::ULong nl, CORBA::ULong ol)
+  {
+    CORBA::AbstractInterfaceDef **tmp = ACE_reinterpret_cast (CORBA::AbstractInterfaceDef**, this->buffer_);
+    
+    for (CORBA::ULong i = nl; i < ol; ++i)
+    {
+      CORBA::release (tmp[i]);
+      tmp[i] = CORBA::AbstractInterfaceDef::_nil ();
+    }
+  }
+  void 
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::_downcast (
+      void* target,
+      CORBA_Object *src,
+      CORBA_Environment &ACE_TRY_ENV
+    )
+  {
+    CORBA::AbstractInterfaceDef **tmp = ACE_static_cast (CORBA::AbstractInterfaceDef**, target);
+    *tmp = CORBA::AbstractInterfaceDef::_narrow (src, ACE_TRY_ENV);
+    ACE_CHECK;
+  }
+
+  CORBA_Object*
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::_upcast (void *src) const
+  {
+    CORBA::AbstractInterfaceDef **tmp = ACE_static_cast (CORBA::AbstractInterfaceDef**, src);
+    return *tmp;
+  }
+  
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_CORBA_ABSTRACTINTERFACEDEFSEQ_CS_)
+#define _CORBA_ABSTRACTINTERFACEDEFSEQ_CS_
+
+// *************************************************************
+// CORBA_AbstractInterfaceDefSeq
+// *************************************************************
+
+CORBA_AbstractInterfaceDefSeq::CORBA_AbstractInterfaceDefSeq (void)
+{}
+CORBA_AbstractInterfaceDefSeq::CORBA_AbstractInterfaceDefSeq (CORBA::ULong max) // uses max size
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<CORBA::AbstractInterfaceDef,CORBA::AbstractInterfaceDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (max)
+{}
+CORBA_AbstractInterfaceDefSeq::CORBA_AbstractInterfaceDefSeq (CORBA::ULong max, CORBA::ULong length, CORBA::AbstractInterfaceDef_ptr *buffer, CORBA::Boolean release)
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<CORBA::AbstractInterfaceDef,CORBA::AbstractInterfaceDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (max, length, buffer, release)
+{}
+CORBA_AbstractInterfaceDefSeq::CORBA_AbstractInterfaceDefSeq (const CORBA_AbstractInterfaceDefSeq &seq) // copy ctor
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<CORBA::AbstractInterfaceDef,CORBA::AbstractInterfaceDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (seq)
+{}
+CORBA_AbstractInterfaceDefSeq::~CORBA_AbstractInterfaceDefSeq (void) // dtor
+{}
+void CORBA_AbstractInterfaceDefSeq::_tao_any_destructor (void *x)
+{
+  CORBA_AbstractInterfaceDefSeq *tmp = ACE_static_cast (CORBA_AbstractInterfaceDefSeq*,x);
+  delete tmp;
+}
+
+
+#endif /* end #if !defined */
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_LOCALINTERFACEDEFSEQ_CS_)
+#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_LOCALINTERFACEDEFSEQ_CS_
+
+  // The Base_Sequence functions, please see tao/Sequence.h
+  void
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::_allocate_buffer (CORBA::ULong length)
+  {
+    CORBA::LocalInterfaceDef **tmp = 0;
+    tmp = _TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::allocbuf (length);
+    
+    if (this->buffer_ != 0)
+    {
+      CORBA::LocalInterfaceDef **old = ACE_reinterpret_cast (CORBA::LocalInterfaceDef**, this->buffer_);
+      for (CORBA::ULong i = 0; i < this->length_; ++i)
+        if (!this->release_)
+          tmp[i] = CORBA::LocalInterfaceDef::_duplicate (old[i]);
+        else
+          tmp[i] = old[i];
+        
+      if (this->release_)
+        delete[] old;
+      
+    }
+    this->buffer_ = tmp;
+  }
+  
+  void
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::_deallocate_buffer (void)
+  {
+    if (this->buffer_ == 0 || this->release_ == 0)
+      return;
+    CORBA::LocalInterfaceDef **tmp = ACE_reinterpret_cast (CORBA::LocalInterfaceDef**, this->buffer_);
+    for (CORBA::ULong i = 0; i < this->length_; ++i)
+    {
+      CORBA::release (tmp[i]);
+      tmp[i] = CORBA::LocalInterfaceDef::_nil ();
+    }
+    _TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::freebuf (tmp);
+    this->buffer_ = 0;
+  }
+  
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::~_TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq (void)
+  {
+    this->_deallocate_buffer ();
+  }
+  
+  void
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::_shrink_buffer (CORBA::ULong nl, CORBA::ULong ol)
+  {
+    CORBA::LocalInterfaceDef **tmp = ACE_reinterpret_cast (CORBA::LocalInterfaceDef**, this->buffer_);
+    
+    for (CORBA::ULong i = nl; i < ol; ++i)
+    {
+      CORBA::release (tmp[i]);
+      tmp[i] = CORBA::LocalInterfaceDef::_nil ();
+    }
+  }
+  void 
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::_downcast (
+      void* target,
+      CORBA_Object *src,
+      CORBA_Environment &ACE_TRY_ENV
+    )
+  {
+    CORBA::LocalInterfaceDef **tmp = ACE_static_cast (CORBA::LocalInterfaceDef**, target);
+    *tmp = CORBA::LocalInterfaceDef::_narrow (src, ACE_TRY_ENV);
+    ACE_CHECK;
+  }
+
+  CORBA_Object*
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::_upcast (void *src) const
+  {
+    CORBA::LocalInterfaceDef **tmp = ACE_static_cast (CORBA::LocalInterfaceDef**, src);
+    return *tmp;
+  }
+  
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_CORBA_LOCALINTERFACEDEFSEQ_CS_)
+#define _CORBA_LOCALINTERFACEDEFSEQ_CS_
+
+// *************************************************************
+// CORBA_LocalInterfaceDefSeq
+// *************************************************************
+
+CORBA_LocalInterfaceDefSeq::CORBA_LocalInterfaceDefSeq (void)
+{}
+CORBA_LocalInterfaceDefSeq::CORBA_LocalInterfaceDefSeq (CORBA::ULong max) // uses max size
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<CORBA::LocalInterfaceDef,CORBA::LocalInterfaceDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (max)
+{}
+CORBA_LocalInterfaceDefSeq::CORBA_LocalInterfaceDefSeq (CORBA::ULong max, CORBA::ULong length, CORBA::LocalInterfaceDef_ptr *buffer, CORBA::Boolean release)
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<CORBA::LocalInterfaceDef,CORBA::LocalInterfaceDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (max, length, buffer, release)
+{}
+CORBA_LocalInterfaceDefSeq::CORBA_LocalInterfaceDefSeq (const CORBA_LocalInterfaceDefSeq &seq) // copy ctor
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<CORBA::LocalInterfaceDef,CORBA::LocalInterfaceDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (seq)
+{}
+CORBA_LocalInterfaceDefSeq::~CORBA_LocalInterfaceDefSeq (void) // dtor
+{}
+void CORBA_LocalInterfaceDefSeq::_tao_any_destructor (void *x)
+{
+  CORBA_LocalInterfaceDefSeq *tmp = ACE_static_cast (CORBA_LocalInterfaceDefSeq*,x);
+  delete tmp;
+}
+
+
+#endif /* end #if !defined */
+
+// *********************************************************************
+
+///////////////////////////////////////////////////////////////////////
+//                Base & Remote Proxy  Implementation. 
+//
+
+_TAO_Repository_Proxy_Impl::_TAO_Repository_Proxy_Impl (void)
+{}
+
+_TAO_Repository_Remote_Proxy_Impl::_TAO_Repository_Remote_Proxy_Impl (void)
+{}
+
+// Remote Implementation of the IDL interface methods
+
+CORBA::Contained_ptr _TAO_Repository_Remote_Proxy_Impl::lookup_id (
+    CORBA_Object *_collocated_tao_target_,
+    const char * search_id,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::Contained_ptr _tao_retval = CORBA::Contained::_nil ();
+  CORBA::Contained_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "lookup_id",
+      9,
+      1,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::Repository::TAO_ClientRequestInfo_CORBA_Repository_lookup_id ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        search_id,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+          if (!(
+                            (_tao_out << search_id)
+            ))
+            TAO_INTERCEPTOR_THROW_RETURN (
+              CORBA::MARSHAL (),
+              0
+            );
+            
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::Contained_ptr _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+CORBA::TypeCode_ptr _TAO_Repository_Remote_Proxy_Impl::get_canonical_typecode (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::TypeCode_ptr tc,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::TypeCode_ptr _tao_retval = CORBA::TypeCode::_nil ();
+  CORBA::TypeCode_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "get_canonical_typecode",
+      22,
+      1,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::Repository::TAO_ClientRequestInfo_CORBA_Repository_get_canonical_typecode ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        tc,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+          if (!(
+                            (_tao_out << tc)
+            ))
+            TAO_INTERCEPTOR_THROW_RETURN (
+              CORBA::MARSHAL (),
+              0
+            );
+            
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::TypeCode_ptr _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+CORBA::PrimitiveDef_ptr _TAO_Repository_Remote_Proxy_Impl::get_primitive (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::PrimitiveKind kind,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::PrimitiveDef_ptr _tao_retval = CORBA::PrimitiveDef::_nil ();
+  CORBA::PrimitiveDef_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "get_primitive",
+      13,
+      1,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::Repository::TAO_ClientRequestInfo_CORBA_Repository_get_primitive ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        kind,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+          if (!(
+                            (_tao_out << kind)
+            ))
+            TAO_INTERCEPTOR_THROW_RETURN (
+              CORBA::MARSHAL (),
+              0
+            );
+            
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::PrimitiveDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+CORBA::StringDef_ptr _TAO_Repository_Remote_Proxy_Impl::create_string (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::ULong bound,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::StringDef_ptr _tao_retval = CORBA::StringDef::_nil ();
+  CORBA::StringDef_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "create_string",
+      13,
+      1,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::Repository::TAO_ClientRequestInfo_CORBA_Repository_create_string ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        bound,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+          if (!(
+                            (_tao_out << bound)
+            ))
+            TAO_INTERCEPTOR_THROW_RETURN (
+              CORBA::MARSHAL (),
+              0
+            );
+            
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::StringDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+CORBA::WstringDef_ptr _TAO_Repository_Remote_Proxy_Impl::create_wstring (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::ULong bound,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::WstringDef_ptr _tao_retval = CORBA::WstringDef::_nil ();
+  CORBA::WstringDef_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "create_wstring",
+      14,
+      1,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::Repository::TAO_ClientRequestInfo_CORBA_Repository_create_wstring ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        bound,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+          if (!(
+                            (_tao_out << bound)
+            ))
+            TAO_INTERCEPTOR_THROW_RETURN (
+              CORBA::MARSHAL (),
+              0
+            );
+            
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::WstringDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+CORBA::SequenceDef_ptr _TAO_Repository_Remote_Proxy_Impl::create_sequence (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::ULong bound,
+    CORBA::IDLType_ptr element_type,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::SequenceDef_ptr _tao_retval = CORBA::SequenceDef::_nil ();
+  CORBA::SequenceDef_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "create_sequence",
+      15,
+      1,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::Repository::TAO_ClientRequestInfo_CORBA_Repository_create_sequence ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        bound,
+        element_type,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+          if (!(
+                            (_tao_out << bound) &&
+              (_tao_out << element_type)
+            ))
+            TAO_INTERCEPTOR_THROW_RETURN (
+              CORBA::MARSHAL (),
+              0
+            );
+            
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::SequenceDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+CORBA::ArrayDef_ptr _TAO_Repository_Remote_Proxy_Impl::create_array (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::ULong length,
+    CORBA::IDLType_ptr element_type,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::ArrayDef_ptr _tao_retval = CORBA::ArrayDef::_nil ();
+  CORBA::ArrayDef_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "create_array",
+      12,
+      1,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::Repository::TAO_ClientRequestInfo_CORBA_Repository_create_array ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        length,
+        element_type,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+          if (!(
+                            (_tao_out << length) &&
+              (_tao_out << element_type)
+            ))
+            TAO_INTERCEPTOR_THROW_RETURN (
+              CORBA::MARSHAL (),
+              0
+            );
+            
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::ArrayDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+
+//
+//            End  Base & Remote  Proxy Implemeentation. 
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//           Remote & Base  Proxy Broker Implementation
+//
+
+_TAO_Repository_Proxy_Broker::_TAO_Repository_Proxy_Broker (void)
+{
+}
+
+_TAO_Repository_Proxy_Broker::~_TAO_Repository_Proxy_Broker (void)
+{
+}
+
+_TAO_Repository_Proxy_Broker * (*CORBA__TAO_Repository_Proxy_Broker_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  ) = 0;
+
+// Factory Member function Implementation.
+_TAO_Repository_Remote_Proxy_Broker *
+_TAO_Repository_Remote_Proxy_Broker::the_TAO_Repository_Remote_Proxy_Broker (void)
+{
+  static ::_TAO_Repository_Remote_Proxy_Broker remote_proxy_broker;
+  return &remote_proxy_broker;
+}
+
+_TAO_Repository_Remote_Proxy_Broker::_TAO_Repository_Remote_Proxy_Broker (void)
+{
+}
+
+_TAO_Repository_Remote_Proxy_Broker::~_TAO_Repository_Remote_Proxy_Broker (void)
+{
+}
+
+_TAO_Repository_Proxy_Impl&
+_TAO_Repository_Remote_Proxy_Broker::select_proxy (
+  ::CORBA_Repository *,
+  CORBA::Environment &
+)
+{
+  return this->remote_proxy_impl_;
+}
+
+
+//
+//           End Remote & Base Proxy Broker Implementation
+///////////////////////////////////////////////////////////////////////
+
+
+// default constructor
+CORBA::Repository::Repository (int collocated)
+{
+  this->CORBA_Repository_setup_collocation (collocated);
+}
+
+// destructor
+CORBA::Repository::~Repository (void)
+{}
+
+void
+CORBA::Repository::CORBA_Repository_setup_collocation (int collocated)
+{
+  if (collocated)
+    this->the_TAO_Repository_Proxy_Broker_ =
+      ::CORBA__TAO_Repository_Proxy_Broker_Factory_function_pointer (this);
+  else
+    this->the_TAO_Repository_Proxy_Broker_ =
+      ::_TAO_Repository_Remote_Proxy_Broker::the_TAO_Repository_Remote_Proxy_Broker ();
+  
+  this->CORBA_Container_setup_collocation (collocated);
+}
+
+void CORBA::Repository::_tao_any_destructor (void *x)
+{
+  CORBA_Repository *tmp = ACE_static_cast (CORBA_Repository*,x);
+  CORBA::release (tmp);
+}
+
+CORBA::Repository_ptr CORBA::Repository::_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+{
+  if (CORBA::is_nil (obj))
+    return CORBA::Repository::_nil ();
+  if (! obj->_is_local ())
+    {
+      CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/CORBA/Repository:1.0", ACE_TRY_ENV);
+      ACE_CHECK_RETURN (CORBA::Repository::_nil ());
+      if (is_a == 0)
+        return CORBA::Repository::_nil ();
+    }
+  return CORBA::Repository::_unchecked_narrow (obj, ACE_TRY_ENV);
+}
+
+CORBA::Repository_ptr CORBA::Repository::_unchecked_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &
+  )
+{
+  if (CORBA::is_nil (obj))
+    return CORBA::Repository::_nil ();
+  if (! obj->_is_local ())
+    {
+      TAO_Stub* stub = obj->_stubobj ();
+      if (stub)
+        stub->_incr_refcnt ();
+      CORBA::Repository_ptr default_proxy = CORBA::Repository::_nil ();
+
+      if (
+          !CORBA::is_nil (stub->servant_orb_var ().ptr ()) &&
+          stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects () &&
+          obj->_is_collocated () &&CORBA__TAO_Repository_Proxy_Broker_Factory_function_pointer != 0
+        )
+      {
+        ACE_NEW_RETURN (
+          default_proxy,
+          ::CORBA::Repository (
+            stub,
+            1,
+            obj->_servant ()),
+            
+          CORBA::Repository::_nil ());
+        }
+      if (CORBA::is_nil (default_proxy))
+        ACE_NEW_RETURN (default_proxy, ::CORBA::Repository (stub, 0, obj->_servant ()), CORBA::Repository::_nil ());
+        return default_proxy;
+      }
+    else 
+      return
+        ACE_reinterpret_cast
+          (
+            CORBA_Repository_ptr,
+              obj->_tao_QueryInterface
+                (
+                  ACE_reinterpret_cast
+                    (
+                      ptr_arith_t,
+                      &CORBA_Repository::_narrow
+                    )
+                )
+          );
+}
+
+CORBA::Repository_ptr
+CORBA::Repository::_duplicate (CORBA::Repository_ptr obj)
+{
+  if (!CORBA::is_nil (obj))
+    obj->_add_ref ();
+  return obj;
+}
+
+CORBA::Boolean CORBA::Repository::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
+{
+  if (
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Repository:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Container:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
+  return 1; // success using local knowledge
+  else
+    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
+}
+
+void *CORBA::Repository::_tao_QueryInterface (ptr_arith_t type)
+{
+  void *retv = 0;
+  if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      CORBA_Repository::_narrow))
+    retv = ACE_reinterpret_cast (void*, this);
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::Container::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::Container_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::IRObject::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::IRObject_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
+    retv = ACE_reinterpret_cast (void *,
+      ACE_static_cast (CORBA::Object_ptr, this));
+    
+  if (retv)
+    this->_add_ref ();
+  return retv;
+}
+
+const char* CORBA::Repository::_interface_repository_id (void) const
+{
+  return "IDL:omg.org/CORBA/Repository:1.0";
+}
+
+CORBA::Contained_ptr CORBA::Repository::lookup_id (
+    const char * search_id,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_Repository_Proxy_Impl &proxy = 
+    this->the_TAO_Repository_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.lookup_id (
+      this,
+      search_id,
+      ACE_TRY_ENV
+    );
+}
+
+CORBA::TypeCode_ptr CORBA::Repository::get_canonical_typecode (
+    CORBA::TypeCode_ptr tc,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_Repository_Proxy_Impl &proxy = 
+    this->the_TAO_Repository_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.get_canonical_typecode (
+      this,
+      tc,
+      ACE_TRY_ENV
+    );
+}
+
+CORBA::PrimitiveDef_ptr CORBA::Repository::get_primitive (
+    CORBA::PrimitiveKind kind,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_Repository_Proxy_Impl &proxy = 
+    this->the_TAO_Repository_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.get_primitive (
+      this,
+      kind,
+      ACE_TRY_ENV
+    );
+}
+
+CORBA::StringDef_ptr CORBA::Repository::create_string (
+    CORBA::ULong bound,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_Repository_Proxy_Impl &proxy = 
+    this->the_TAO_Repository_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.create_string (
+      this,
+      bound,
+      ACE_TRY_ENV
+    );
+}
+
+CORBA::WstringDef_ptr CORBA::Repository::create_wstring (
+    CORBA::ULong bound,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_Repository_Proxy_Impl &proxy = 
+    this->the_TAO_Repository_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.create_wstring (
+      this,
+      bound,
+      ACE_TRY_ENV
+    );
+}
+
+CORBA::SequenceDef_ptr CORBA::Repository::create_sequence (
+    CORBA::ULong bound,
+    CORBA::IDLType_ptr element_type,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_Repository_Proxy_Impl &proxy = 
+    this->the_TAO_Repository_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.create_sequence (
+      this,
+      bound,
+      element_type,
+      ACE_TRY_ENV
+    );
+}
+
+CORBA::ArrayDef_ptr CORBA::Repository::create_array (
+    CORBA::ULong length,
+    CORBA::IDLType_ptr element_type,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_Repository_Proxy_Impl &proxy = 
+    this->the_TAO_Repository_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.create_array (
+      this,
+      length,
+      element_type,
+      ACE_TRY_ENV
+    );
+}
+
+CORBA::FixedDef_ptr CORBA::Repository::create_fixed (
+    CORBA::UShort digits,
+    CORBA::Short scale,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_Repository_Proxy_Impl &proxy = 
+    this->the_TAO_Repository_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.create_fixed (
+      this,
+      digits,
+      scale,
+      ACE_TRY_ENV
+    );
+}
+
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+CORBA::Repository::TAO_ClientRequestInfo_CORBA_Repository_lookup_id::TAO_ClientRequestInfo_CORBA_Repository_lookup_id (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const char * search_id,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
+    search_id_ (search_id)
+{}
+
+Dynamic::ParameterList *
+CORBA::Repository::TAO_ClientRequestInfo_CORBA_Repository_lookup_id::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
+    
+  CORBA::ULong length_search_id = parameter_list->length ();
+  parameter_list->length (length_search_id + 1);
+  (*parameter_list)[length_search_id].argument <<= search_id_;
+  (*parameter_list)[length_search_id].mode = Dynamic::PARAM_IN;
+  
+  return safe_parameter_list._retn ();
+}
+
+Dynamic::ExceptionList *
+CORBA::Repository::TAO_ClientRequestInfo_CORBA_Repository_lookup_id::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::Repository::TAO_ClientRequestInfo_CORBA_Repository_lookup_id::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+CORBA::Repository::TAO_ClientRequestInfo_CORBA_Repository_lookup_id::result (CORBA::Contained_ptr result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+CORBA::Repository::TAO_ClientRequestInfo_CORBA_Repository_get_canonical_typecode::TAO_ClientRequestInfo_CORBA_Repository_get_canonical_typecode (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::TypeCode_ptr tc,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
+    tc_ (tc)
+{}
+
+Dynamic::ParameterList *
+CORBA::Repository::TAO_ClientRequestInfo_CORBA_Repository_get_canonical_typecode::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
+    
+  CORBA::ULong length_tc = parameter_list->length ();
+  parameter_list->length (length_tc + 1);
+  (*parameter_list)[length_tc].argument <<= tc_;
+  (*parameter_list)[length_tc].mode = Dynamic::PARAM_IN;
+  
+  return safe_parameter_list._retn ();
+}
+
+Dynamic::ExceptionList *
+CORBA::Repository::TAO_ClientRequestInfo_CORBA_Repository_get_canonical_typecode::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::Repository::TAO_ClientRequestInfo_CORBA_Repository_get_canonical_typecode::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+CORBA::Repository::TAO_ClientRequestInfo_CORBA_Repository_get_canonical_typecode::result (CORBA::TypeCode_ptr result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+CORBA::Repository::TAO_ClientRequestInfo_CORBA_Repository_get_primitive::TAO_ClientRequestInfo_CORBA_Repository_get_primitive (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::PrimitiveKind & kind,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
+    kind_ (kind)
+{}
+
+Dynamic::ParameterList *
+CORBA::Repository::TAO_ClientRequestInfo_CORBA_Repository_get_primitive::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
+    
+  CORBA::ULong length_kind = parameter_list->length ();
+  parameter_list->length (length_kind + 1);
+  (*parameter_list)[length_kind].argument <<=  this->kind_;
+  
+  (*parameter_list)[length_kind].mode = Dynamic::PARAM_IN;
+  
+  return safe_parameter_list._retn ();
+}
+
+Dynamic::ExceptionList *
+CORBA::Repository::TAO_ClientRequestInfo_CORBA_Repository_get_primitive::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::Repository::TAO_ClientRequestInfo_CORBA_Repository_get_primitive::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+CORBA::Repository::TAO_ClientRequestInfo_CORBA_Repository_get_primitive::result (CORBA::PrimitiveDef_ptr result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+CORBA::Repository::TAO_ClientRequestInfo_CORBA_Repository_create_string::TAO_ClientRequestInfo_CORBA_Repository_create_string (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const CORBA::ULong & bound,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
+    bound_ (bound)
+{}
+
+Dynamic::ParameterList *
+CORBA::Repository::TAO_ClientRequestInfo_CORBA_Repository_create_string::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
+    
+  CORBA::ULong length_bound = parameter_list->length ();
+  parameter_list->length (length_bound + 1);
+  (*parameter_list)[length_bound].argument <<= bound_;
+  (*parameter_list)[length_bound].mode = Dynamic::PARAM_IN;
+  
+  return safe_parameter_list._retn ();
+}
+
+Dynamic::ExceptionList *
+CORBA::Repository::TAO_ClientRequestInfo_CORBA_Repository_create_string::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::Repository::TAO_ClientRequestInfo_CORBA_Repository_create_string::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+CORBA::Repository::TAO_ClientRequestInfo_CORBA_Repository_create_string::result (CORBA::StringDef_ptr result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+CORBA::Repository::TAO_ClientRequestInfo_CORBA_Repository_create_wstring::TAO_ClientRequestInfo_CORBA_Repository_create_wstring (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const CORBA::ULong & bound,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
+    bound_ (bound)
+{}
+
+Dynamic::ParameterList *
+CORBA::Repository::TAO_ClientRequestInfo_CORBA_Repository_create_wstring::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
+    
+  CORBA::ULong length_bound = parameter_list->length ();
+  parameter_list->length (length_bound + 1);
+  (*parameter_list)[length_bound].argument <<= bound_;
+  (*parameter_list)[length_bound].mode = Dynamic::PARAM_IN;
+  
+  return safe_parameter_list._retn ();
+}
+
+Dynamic::ExceptionList *
+CORBA::Repository::TAO_ClientRequestInfo_CORBA_Repository_create_wstring::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::Repository::TAO_ClientRequestInfo_CORBA_Repository_create_wstring::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+CORBA::Repository::TAO_ClientRequestInfo_CORBA_Repository_create_wstring::result (CORBA::WstringDef_ptr result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+CORBA::Repository::TAO_ClientRequestInfo_CORBA_Repository_create_sequence::TAO_ClientRequestInfo_CORBA_Repository_create_sequence (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const CORBA::ULong & bound,
+    CORBA::IDLType_ptr element_type,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
+    bound_ (bound),
+    element_type_ (element_type)
+{}
+
+Dynamic::ParameterList *
+CORBA::Repository::TAO_ClientRequestInfo_CORBA_Repository_create_sequence::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
+    
+  CORBA::ULong length_bound = parameter_list->length ();
+  parameter_list->length (length_bound + 1);
+  (*parameter_list)[length_bound].argument <<= bound_;
+  (*parameter_list)[length_bound].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_element_type = parameter_list->length ();
+  parameter_list->length (length_element_type + 1);
+  (*parameter_list)[length_element_type].argument <<=  this->element_type_;
+  
+  (*parameter_list)[length_element_type].mode = Dynamic::PARAM_IN;
+  
+  return safe_parameter_list._retn ();
+}
+
+Dynamic::ExceptionList *
+CORBA::Repository::TAO_ClientRequestInfo_CORBA_Repository_create_sequence::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::Repository::TAO_ClientRequestInfo_CORBA_Repository_create_sequence::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+CORBA::Repository::TAO_ClientRequestInfo_CORBA_Repository_create_sequence::result (CORBA::SequenceDef_ptr result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+CORBA::Repository::TAO_ClientRequestInfo_CORBA_Repository_create_array::TAO_ClientRequestInfo_CORBA_Repository_create_array (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const CORBA::ULong & length,
+    CORBA::IDLType_ptr element_type,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
+    length_ (length),
+    element_type_ (element_type)
+{}
+
+Dynamic::ParameterList *
+CORBA::Repository::TAO_ClientRequestInfo_CORBA_Repository_create_array::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
+    
+  CORBA::ULong length_length = parameter_list->length ();
+  parameter_list->length (length_length + 1);
+  (*parameter_list)[length_length].argument <<= length_;
+  (*parameter_list)[length_length].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_element_type = parameter_list->length ();
+  parameter_list->length (length_element_type + 1);
+  (*parameter_list)[length_element_type].argument <<=  this->element_type_;
+  
+  (*parameter_list)[length_element_type].mode = Dynamic::PARAM_IN;
+  
+  return safe_parameter_list._retn ();
+}
+
+Dynamic::ExceptionList *
+CORBA::Repository::TAO_ClientRequestInfo_CORBA_Repository_create_array::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::Repository::TAO_ClientRequestInfo_CORBA_Repository_create_array::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+CORBA::Repository::TAO_ClientRequestInfo_CORBA_Repository_create_array::result (CORBA::ArrayDef_ptr result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+CORBA::Repository::TAO_ClientRequestInfo_CORBA_Repository_create_fixed::TAO_ClientRequestInfo_CORBA_Repository_create_fixed (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const CORBA::UShort & digits,
+    const CORBA::Short & scale,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
+    digits_ (digits),
+    scale_ (scale)
+{}
+
+Dynamic::ParameterList *
+CORBA::Repository::TAO_ClientRequestInfo_CORBA_Repository_create_fixed::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
+    
+  CORBA::ULong length_digits = parameter_list->length ();
+  parameter_list->length (length_digits + 1);
+  (*parameter_list)[length_digits].argument <<= digits_;
+  (*parameter_list)[length_digits].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_scale = parameter_list->length ();
+  parameter_list->length (length_scale + 1);
+  (*parameter_list)[length_scale].argument <<= scale_;
+  (*parameter_list)[length_scale].mode = Dynamic::PARAM_IN;
+  
+  return safe_parameter_list._retn ();
+}
+
+Dynamic::ExceptionList *
+CORBA::Repository::TAO_ClientRequestInfo_CORBA_Repository_create_fixed::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+void 
+CORBA::Repository::TAO_ClientRequestInfo_CORBA_Repository_create_fixed::result (CORBA::FixedDef_ptr result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+#endif /* TAO_HAS_INTERCEPTORS */
+
+///////////////////////////////////////////////////////////////////////
+//                Base & Remote Proxy  Implementation. 
+//
+
+_TAO_ModuleDef_Proxy_Impl::_TAO_ModuleDef_Proxy_Impl (void)
+{}
+
+_TAO_ModuleDef_Remote_Proxy_Impl::_TAO_ModuleDef_Remote_Proxy_Impl (void)
+{}
+
+// Remote Implementation of the IDL interface methods
+
+
+//
+//            End  Base & Remote  Proxy Implemeentation. 
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//           Remote & Base  Proxy Broker Implementation
+//
+
+_TAO_ModuleDef_Proxy_Broker::_TAO_ModuleDef_Proxy_Broker (void)
+{
+}
+
+_TAO_ModuleDef_Proxy_Broker::~_TAO_ModuleDef_Proxy_Broker (void)
+{
+}
+
+_TAO_ModuleDef_Proxy_Broker * (*CORBA__TAO_ModuleDef_Proxy_Broker_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  ) = 0;
+
+// Factory Member function Implementation.
+_TAO_ModuleDef_Remote_Proxy_Broker *
+_TAO_ModuleDef_Remote_Proxy_Broker::the_TAO_ModuleDef_Remote_Proxy_Broker (void)
+{
+  static ::_TAO_ModuleDef_Remote_Proxy_Broker remote_proxy_broker;
+  return &remote_proxy_broker;
+}
+
+_TAO_ModuleDef_Remote_Proxy_Broker::_TAO_ModuleDef_Remote_Proxy_Broker (void)
+{
+}
+
+_TAO_ModuleDef_Remote_Proxy_Broker::~_TAO_ModuleDef_Remote_Proxy_Broker (void)
+{
+}
+
+_TAO_ModuleDef_Proxy_Impl&
+_TAO_ModuleDef_Remote_Proxy_Broker::select_proxy (
+  ::CORBA_ModuleDef *,
+  CORBA::Environment &
+)
+{
+  return this->remote_proxy_impl_;
+}
+
+
+//
+//           End Remote & Base Proxy Broker Implementation
+///////////////////////////////////////////////////////////////////////
+
+
+// default constructor
+CORBA::ModuleDef::ModuleDef (int collocated)
+{
+  this->CORBA_ModuleDef_setup_collocation (collocated);
+}
+
+// destructor
+CORBA::ModuleDef::~ModuleDef (void)
+{}
+
+void
+CORBA::ModuleDef::CORBA_ModuleDef_setup_collocation (int collocated)
+{
+  if (collocated)
+    this->the_TAO_ModuleDef_Proxy_Broker_ =
+      ::CORBA__TAO_ModuleDef_Proxy_Broker_Factory_function_pointer (this);
+  else
+    this->the_TAO_ModuleDef_Proxy_Broker_ =
+      ::_TAO_ModuleDef_Remote_Proxy_Broker::the_TAO_ModuleDef_Remote_Proxy_Broker ();
+  
+  this->CORBA_Container_setup_collocation (collocated);
+  
+  this->CORBA_Contained_setup_collocation (collocated);
+}
+
+void CORBA::ModuleDef::_tao_any_destructor (void *x)
+{
+  CORBA_ModuleDef *tmp = ACE_static_cast (CORBA_ModuleDef*,x);
+  CORBA::release (tmp);
+}
+
+CORBA::ModuleDef_ptr CORBA::ModuleDef::_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+{
+  if (CORBA::is_nil (obj))
+    return CORBA::ModuleDef::_nil ();
+  if (! obj->_is_local ())
+    {
+      CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/CORBA/ModuleDef:1.0", ACE_TRY_ENV);
+      ACE_CHECK_RETURN (CORBA::ModuleDef::_nil ());
+      if (is_a == 0)
+        return CORBA::ModuleDef::_nil ();
+    }
+  return CORBA::ModuleDef::_unchecked_narrow (obj, ACE_TRY_ENV);
+}
+
+CORBA::ModuleDef_ptr CORBA::ModuleDef::_unchecked_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &
+  )
+{
+  if (CORBA::is_nil (obj))
+    return CORBA::ModuleDef::_nil ();
+  if (! obj->_is_local ())
+    {
+      TAO_Stub* stub = obj->_stubobj ();
+      if (stub)
+        stub->_incr_refcnt ();
+      CORBA::ModuleDef_ptr default_proxy = CORBA::ModuleDef::_nil ();
+
+      if (
+          !CORBA::is_nil (stub->servant_orb_var ().ptr ()) &&
+          stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects () &&
+          obj->_is_collocated () &&CORBA__TAO_ModuleDef_Proxy_Broker_Factory_function_pointer != 0
+        )
+      {
+        ACE_NEW_RETURN (
+          default_proxy,
+          ::CORBA::ModuleDef (
+            stub,
+            1,
+            obj->_servant ()),
+            
+          CORBA::ModuleDef::_nil ());
+        }
+      if (CORBA::is_nil (default_proxy))
+        ACE_NEW_RETURN (default_proxy, ::CORBA::ModuleDef (stub, 0, obj->_servant ()), CORBA::ModuleDef::_nil ());
+        return default_proxy;
+      }
+    else 
+      return
+        ACE_reinterpret_cast
+          (
+            CORBA_ModuleDef_ptr,
+              obj->_tao_QueryInterface
+                (
+                  ACE_reinterpret_cast
+                    (
+                      ptr_arith_t,
+                      &CORBA_ModuleDef::_narrow
+                    )
+                )
+          );
+}
+
+CORBA::ModuleDef_ptr
+CORBA::ModuleDef::_duplicate (CORBA::ModuleDef_ptr obj)
+{
+  if (!CORBA::is_nil (obj))
+    obj->_add_ref ();
+  return obj;
+}
+
+CORBA::Boolean CORBA::ModuleDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
+{
+  if (
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/ModuleDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Container:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Contained:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
+  return 1; // success using local knowledge
+  else
+    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
+}
+
+void *CORBA::ModuleDef::_tao_QueryInterface (ptr_arith_t type)
+{
+  void *retv = 0;
+  if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      CORBA_ModuleDef::_narrow))
+    retv = ACE_reinterpret_cast (void*, this);
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::Container::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::Container_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::Contained::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::Contained_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::IRObject::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::IRObject_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
+    retv = ACE_reinterpret_cast (void *,
+      ACE_static_cast (CORBA::Object_ptr, this));
+    
+  if (retv)
+    this->_add_ref ();
+  return retv;
+}
+
+const char* CORBA::ModuleDef::_interface_repository_id (void) const
+{
+  return "IDL:omg.org/CORBA/ModuleDef:1.0";
+}
+
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+#endif /* TAO_HAS_INTERCEPTORS */
+
+void CORBA::ModuleDescription::_tao_any_destructor (void *x)
+{
+  CORBA_ModuleDescription *tmp = ACE_static_cast (CORBA_ModuleDescription*,x);
+  delete tmp;
+}
+
+
+///////////////////////////////////////////////////////////////////////
+//                Base & Remote Proxy  Implementation. 
+//
+
+_TAO_ConstantDef_Proxy_Impl::_TAO_ConstantDef_Proxy_Impl (void)
+{}
+
+_TAO_ConstantDef_Remote_Proxy_Impl::_TAO_ConstantDef_Remote_Proxy_Impl (void)
+{}
+
+// Remote Implementation of the IDL interface methods
+
+CORBA::TypeCode_ptr _TAO_ConstantDef_Remote_Proxy_Impl::type (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::TypeCode_ptr _tao_retval = CORBA::TypeCode::_nil ();
+  CORBA::TypeCode_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_type",
+      9,
+      0,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::ConstantDef::TAO_ClientRequestInfo_CORBA_ConstantDef_type_get ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::TypeCode_ptr _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+CORBA::IDLType_ptr _TAO_ConstantDef_Remote_Proxy_Impl::type_def (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::IDLType_ptr _tao_retval = CORBA::IDLType::_nil ();
+  CORBA::IDLType_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_type_def",
+      13,
+      0,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::ConstantDef::TAO_ClientRequestInfo_CORBA_ConstantDef_type_def_get ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::IDLType_ptr _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+void _TAO_ConstantDef_Remote_Proxy_Impl::type_def (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::IDLType_ptr type_def,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW (CORBA::INTERNAL ());
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_set_type_def",
+      13,
+      1,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::ConstantDef::TAO_ClientRequestInfo_CORBA_ConstantDef_type_def_set ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        type_def,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK;
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK;
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK;
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK;
+          
+          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+          if (!(
+                            (_tao_out << type_def)
+            ))
+            TAO_INTERCEPTOR_THROW (
+              CORBA::MARSHAL ()
+            );
+            
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK;
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)
+              );
+              
+            }
+          
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK;
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK;
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  
+}
+
+CORBA::Any * _TAO_ConstantDef_Remote_Proxy_Impl::value (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::Any *_tao_retval = 0;
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  ACE_NEW_RETURN (_tao_retval, CORBA::Any, _tao_retval);
+  CORBA::Any_var _tao_safe_retval (_tao_retval);
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_value",
+      10,
+      0,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::ConstantDef::TAO_ClientRequestInfo_CORBA_ConstantDef_value_get ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::Any * _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+void _TAO_ConstantDef_Remote_Proxy_Impl::value (
+    CORBA_Object *_collocated_tao_target_,
+    const CORBA::Any & value,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW (CORBA::INTERNAL ());
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_set_value",
+      10,
+      1,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::ConstantDef::TAO_ClientRequestInfo_CORBA_ConstantDef_value_set ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        value,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK;
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK;
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK;
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK;
+          
+          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+          if (!(
+                            (_tao_out << value)
+            ))
+            TAO_INTERCEPTOR_THROW (
+              CORBA::MARSHAL ()
+            );
+            
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK;
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)
+              );
+              
+            }
+          
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK;
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK;
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  
+}
+
+
+//
+//            End  Base & Remote  Proxy Implemeentation. 
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//           Remote & Base  Proxy Broker Implementation
+//
+
+_TAO_ConstantDef_Proxy_Broker::_TAO_ConstantDef_Proxy_Broker (void)
+{
+}
+
+_TAO_ConstantDef_Proxy_Broker::~_TAO_ConstantDef_Proxy_Broker (void)
+{
+}
+
+_TAO_ConstantDef_Proxy_Broker * (*CORBA__TAO_ConstantDef_Proxy_Broker_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  ) = 0;
+
+// Factory Member function Implementation.
+_TAO_ConstantDef_Remote_Proxy_Broker *
+_TAO_ConstantDef_Remote_Proxy_Broker::the_TAO_ConstantDef_Remote_Proxy_Broker (void)
+{
+  static ::_TAO_ConstantDef_Remote_Proxy_Broker remote_proxy_broker;
+  return &remote_proxy_broker;
+}
+
+_TAO_ConstantDef_Remote_Proxy_Broker::_TAO_ConstantDef_Remote_Proxy_Broker (void)
+{
+}
+
+_TAO_ConstantDef_Remote_Proxy_Broker::~_TAO_ConstantDef_Remote_Proxy_Broker (void)
+{
+}
+
+_TAO_ConstantDef_Proxy_Impl&
+_TAO_ConstantDef_Remote_Proxy_Broker::select_proxy (
+  ::CORBA_ConstantDef *,
+  CORBA::Environment &
+)
+{
+  return this->remote_proxy_impl_;
+}
+
+
+//
+//           End Remote & Base Proxy Broker Implementation
+///////////////////////////////////////////////////////////////////////
+
+
+// default constructor
+CORBA::ConstantDef::ConstantDef (int collocated)
+{
+  this->CORBA_ConstantDef_setup_collocation (collocated);
+}
+
+// destructor
+CORBA::ConstantDef::~ConstantDef (void)
+{}
+
+void
+CORBA::ConstantDef::CORBA_ConstantDef_setup_collocation (int collocated)
+{
+  if (collocated)
+    this->the_TAO_ConstantDef_Proxy_Broker_ =
+      ::CORBA__TAO_ConstantDef_Proxy_Broker_Factory_function_pointer (this);
+  else
+    this->the_TAO_ConstantDef_Proxy_Broker_ =
+      ::_TAO_ConstantDef_Remote_Proxy_Broker::the_TAO_ConstantDef_Remote_Proxy_Broker ();
+  
+  this->CORBA_Contained_setup_collocation (collocated);
+}
+
+void CORBA::ConstantDef::_tao_any_destructor (void *x)
+{
+  CORBA_ConstantDef *tmp = ACE_static_cast (CORBA_ConstantDef*,x);
+  CORBA::release (tmp);
+}
+
+CORBA::ConstantDef_ptr CORBA::ConstantDef::_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+{
+  if (CORBA::is_nil (obj))
+    return CORBA::ConstantDef::_nil ();
+  if (! obj->_is_local ())
+    {
+      CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/CORBA/ConstantDef:1.0", ACE_TRY_ENV);
+      ACE_CHECK_RETURN (CORBA::ConstantDef::_nil ());
+      if (is_a == 0)
+        return CORBA::ConstantDef::_nil ();
+    }
+  return CORBA::ConstantDef::_unchecked_narrow (obj, ACE_TRY_ENV);
+}
+
+CORBA::ConstantDef_ptr CORBA::ConstantDef::_unchecked_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &
+  )
+{
+  if (CORBA::is_nil (obj))
+    return CORBA::ConstantDef::_nil ();
+  if (! obj->_is_local ())
+    {
+      TAO_Stub* stub = obj->_stubobj ();
+      if (stub)
+        stub->_incr_refcnt ();
+      CORBA::ConstantDef_ptr default_proxy = CORBA::ConstantDef::_nil ();
+
+      if (
+          !CORBA::is_nil (stub->servant_orb_var ().ptr ()) &&
+          stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects () &&
+          obj->_is_collocated () &&CORBA__TAO_ConstantDef_Proxy_Broker_Factory_function_pointer != 0
+        )
+      {
+        ACE_NEW_RETURN (
+          default_proxy,
+          ::CORBA::ConstantDef (
+            stub,
+            1,
+            obj->_servant ()),
+            
+          CORBA::ConstantDef::_nil ());
+        }
+      if (CORBA::is_nil (default_proxy))
+        ACE_NEW_RETURN (default_proxy, ::CORBA::ConstantDef (stub, 0, obj->_servant ()), CORBA::ConstantDef::_nil ());
+        return default_proxy;
+      }
+    else 
+      return
+        ACE_reinterpret_cast
+          (
+            CORBA_ConstantDef_ptr,
+              obj->_tao_QueryInterface
+                (
+                  ACE_reinterpret_cast
+                    (
+                      ptr_arith_t,
+                      &CORBA_ConstantDef::_narrow
+                    )
+                )
+          );
+}
+
+CORBA::ConstantDef_ptr
+CORBA::ConstantDef::_duplicate (CORBA::ConstantDef_ptr obj)
+{
+  if (!CORBA::is_nil (obj))
+    obj->_add_ref ();
+  return obj;
+}
+
+CORBA::Boolean CORBA::ConstantDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
+{
+  if (
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/ConstantDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Contained:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
+  return 1; // success using local knowledge
+  else
+    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
+}
+
+void *CORBA::ConstantDef::_tao_QueryInterface (ptr_arith_t type)
+{
+  void *retv = 0;
+  if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      CORBA_ConstantDef::_narrow))
+    retv = ACE_reinterpret_cast (void*, this);
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::Contained::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::Contained_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::IRObject::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::IRObject_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
+    retv = ACE_reinterpret_cast (void *,
+      ACE_static_cast (CORBA::Object_ptr, this));
+    
+  if (retv)
+    this->_add_ref ();
+  return retv;
+}
+
+const char* CORBA::ConstantDef::_interface_repository_id (void) const
+{
+  return "IDL:omg.org/CORBA/ConstantDef:1.0";
+}
+
+CORBA::TypeCode_ptr CORBA::ConstantDef::type (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_ConstantDef_Proxy_Impl &proxy = 
+    this->the_TAO_ConstantDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.type (
+      this,
+      ACE_TRY_ENV
+    );
+}
+
+CORBA::IDLType_ptr CORBA::ConstantDef::type_def (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_ConstantDef_Proxy_Impl &proxy = 
+    this->the_TAO_ConstantDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.type_def (
+      this,
+      ACE_TRY_ENV
+    );
+}
+
+void CORBA::ConstantDef::type_def (
+    CORBA::IDLType_ptr type_def,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_ConstantDef_Proxy_Impl &proxy = 
+    this->the_TAO_ConstantDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK;
+  
+  proxy.type_def (
+      this,
+      type_def,
+      ACE_TRY_ENV
+    );
+}
+
+CORBA::Any * CORBA::ConstantDef::value (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_ConstantDef_Proxy_Impl &proxy = 
+    this->the_TAO_ConstantDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.value (
+      this,
+      ACE_TRY_ENV
+    );
+}
+
+void CORBA::ConstantDef::value (
+    const CORBA::Any & value,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_ConstantDef_Proxy_Impl &proxy = 
+    this->the_TAO_ConstantDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK;
+  
+  proxy.value (
+      this,
+      value,
+      ACE_TRY_ENV
+    );
+}
+
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+CORBA::ConstantDef::TAO_ClientRequestInfo_CORBA_ConstantDef_type_get::TAO_ClientRequestInfo_CORBA_ConstantDef_type_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
+{}
+
+Dynamic::ParameterList *
+CORBA::ConstantDef::TAO_ClientRequestInfo_CORBA_ConstantDef_type_get::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return parameter_list;
+}
+
+Dynamic::ExceptionList *
+CORBA::ConstantDef::TAO_ClientRequestInfo_CORBA_ConstantDef_type_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::ConstantDef::TAO_ClientRequestInfo_CORBA_ConstantDef_type_get::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+CORBA::ConstantDef::TAO_ClientRequestInfo_CORBA_ConstantDef_type_get::result (CORBA::TypeCode_ptr result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+CORBA::ConstantDef::TAO_ClientRequestInfo_CORBA_ConstantDef_type_def_get::TAO_ClientRequestInfo_CORBA_ConstantDef_type_def_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
+{}
+
+Dynamic::ParameterList *
+CORBA::ConstantDef::TAO_ClientRequestInfo_CORBA_ConstantDef_type_def_get::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return parameter_list;
+}
+
+Dynamic::ExceptionList *
+CORBA::ConstantDef::TAO_ClientRequestInfo_CORBA_ConstantDef_type_def_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::ConstantDef::TAO_ClientRequestInfo_CORBA_ConstantDef_type_def_get::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+CORBA::ConstantDef::TAO_ClientRequestInfo_CORBA_ConstantDef_type_def_get::result (CORBA::IDLType_ptr result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+CORBA::ConstantDef::TAO_ClientRequestInfo_CORBA_ConstantDef_type_def_set::TAO_ClientRequestInfo_CORBA_ConstantDef_type_def_set (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::IDLType_ptr type_def,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
+    type_def_ (type_def)
+{}
+
+Dynamic::ParameterList *
+CORBA::ConstantDef::TAO_ClientRequestInfo_CORBA_ConstantDef_type_def_set::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
+    
+  CORBA::ULong length_type_def = parameter_list->length ();
+  parameter_list->length (length_type_def + 1);
+  (*parameter_list)[length_type_def].argument <<=  this->type_def_;
+  
+  (*parameter_list)[length_type_def].mode = Dynamic::PARAM_IN;
+  
+  return safe_parameter_list._retn ();
+}
+
+Dynamic::ExceptionList *
+CORBA::ConstantDef::TAO_ClientRequestInfo_CORBA_ConstantDef_type_def_set::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::ConstantDef::TAO_ClientRequestInfo_CORBA_ConstantDef_type_def_set::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 1;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return result_any;
+}
+
+CORBA::ConstantDef::TAO_ClientRequestInfo_CORBA_ConstantDef_value_get::TAO_ClientRequestInfo_CORBA_ConstantDef_value_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
+{}
+
+Dynamic::ParameterList *
+CORBA::ConstantDef::TAO_ClientRequestInfo_CORBA_ConstantDef_value_get::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return parameter_list;
+}
+
+Dynamic::ExceptionList *
+CORBA::ConstantDef::TAO_ClientRequestInfo_CORBA_ConstantDef_value_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::ConstantDef::TAO_ClientRequestInfo_CORBA_ConstantDef_value_get::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+CORBA::ConstantDef::TAO_ClientRequestInfo_CORBA_ConstantDef_value_get::result (CORBA::Any * result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+CORBA::ConstantDef::TAO_ClientRequestInfo_CORBA_ConstantDef_value_set::TAO_ClientRequestInfo_CORBA_ConstantDef_value_set (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const CORBA::Any & value,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
+    value_ (value)
+{}
+
+Dynamic::ParameterList *
+CORBA::ConstantDef::TAO_ClientRequestInfo_CORBA_ConstantDef_value_set::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
+    
+  CORBA::ULong length_value = parameter_list->length ();
+  parameter_list->length (length_value + 1);
+  (*parameter_list)[length_value].argument <<= value_;
+  (*parameter_list)[length_value].mode = Dynamic::PARAM_IN;
+  
+  return safe_parameter_list._retn ();
+}
+
+Dynamic::ExceptionList *
+CORBA::ConstantDef::TAO_ClientRequestInfo_CORBA_ConstantDef_value_set::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::ConstantDef::TAO_ClientRequestInfo_CORBA_ConstantDef_value_set::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 1;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return result_any;
+}
+
+#endif /* TAO_HAS_INTERCEPTORS */
+
+void CORBA::ConstantDescription::_tao_any_destructor (void *x)
+{
+  CORBA_ConstantDescription *tmp = ACE_static_cast (CORBA_ConstantDescription*,x);
+  delete tmp;
+}
+
+
+///////////////////////////////////////////////////////////////////////
+//                Base & Remote Proxy  Implementation. 
+//
+
+_TAO_StructDef_Proxy_Impl::_TAO_StructDef_Proxy_Impl (void)
+{}
+
+_TAO_StructDef_Remote_Proxy_Impl::_TAO_StructDef_Remote_Proxy_Impl (void)
+{}
+
+// Remote Implementation of the IDL interface methods
+
+CORBA::StructMemberSeq * _TAO_StructDef_Remote_Proxy_Impl::members (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::StructMemberSeq *_tao_retval = 0;
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  ACE_NEW_RETURN (_tao_retval, CORBA::StructMemberSeq, _tao_retval);
+  CORBA::StructMemberSeq_var _tao_safe_retval (_tao_retval);
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_members",
+      12,
+      0,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::StructDef::TAO_ClientRequestInfo_CORBA_StructDef_members_get ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::StructMemberSeq * _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+void _TAO_StructDef_Remote_Proxy_Impl::members (
+    CORBA_Object *_collocated_tao_target_,
+    const CORBA::StructMemberSeq & members,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW (CORBA::INTERNAL ());
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_set_members",
+      12,
+      1,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::StructDef::TAO_ClientRequestInfo_CORBA_StructDef_members_set ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        members,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK;
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK;
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK;
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK;
+          
+          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+          if (!(
+                            (_tao_out << members)
+            ))
+            TAO_INTERCEPTOR_THROW (
+              CORBA::MARSHAL ()
+            );
+            
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK;
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)
+              );
+              
+            }
+          
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK;
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK;
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  
+}
+
+
+//
+//            End  Base & Remote  Proxy Implemeentation. 
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//           Remote & Base  Proxy Broker Implementation
+//
+
+_TAO_StructDef_Proxy_Broker::_TAO_StructDef_Proxy_Broker (void)
+{
+}
+
+_TAO_StructDef_Proxy_Broker::~_TAO_StructDef_Proxy_Broker (void)
+{
+}
+
+_TAO_StructDef_Proxy_Broker * (*CORBA__TAO_StructDef_Proxy_Broker_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  ) = 0;
+
+// Factory Member function Implementation.
+_TAO_StructDef_Remote_Proxy_Broker *
+_TAO_StructDef_Remote_Proxy_Broker::the_TAO_StructDef_Remote_Proxy_Broker (void)
+{
+  static ::_TAO_StructDef_Remote_Proxy_Broker remote_proxy_broker;
+  return &remote_proxy_broker;
+}
+
+_TAO_StructDef_Remote_Proxy_Broker::_TAO_StructDef_Remote_Proxy_Broker (void)
+{
+}
+
+_TAO_StructDef_Remote_Proxy_Broker::~_TAO_StructDef_Remote_Proxy_Broker (void)
+{
+}
+
+_TAO_StructDef_Proxy_Impl&
+_TAO_StructDef_Remote_Proxy_Broker::select_proxy (
+  ::CORBA_StructDef *,
+  CORBA::Environment &
+)
+{
+  return this->remote_proxy_impl_;
+}
+
+
+//
+//           End Remote & Base Proxy Broker Implementation
+///////////////////////////////////////////////////////////////////////
+
+
+// default constructor
+CORBA::StructDef::StructDef (int collocated)
+{
+  this->CORBA_StructDef_setup_collocation (collocated);
+}
+
+// destructor
+CORBA::StructDef::~StructDef (void)
+{}
+
+void
+CORBA::StructDef::CORBA_StructDef_setup_collocation (int collocated)
+{
+  if (collocated)
+    this->the_TAO_StructDef_Proxy_Broker_ =
+      ::CORBA__TAO_StructDef_Proxy_Broker_Factory_function_pointer (this);
+  else
+    this->the_TAO_StructDef_Proxy_Broker_ =
+      ::_TAO_StructDef_Remote_Proxy_Broker::the_TAO_StructDef_Remote_Proxy_Broker ();
+  
+  this->CORBA_TypedefDef_setup_collocation (collocated);
+  
+  this->CORBA_Container_setup_collocation (collocated);
+}
+
+void CORBA::StructDef::_tao_any_destructor (void *x)
+{
+  CORBA_StructDef *tmp = ACE_static_cast (CORBA_StructDef*,x);
+  CORBA::release (tmp);
+}
+
+CORBA::StructDef_ptr CORBA::StructDef::_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+{
+  if (CORBA::is_nil (obj))
+    return CORBA::StructDef::_nil ();
+  if (! obj->_is_local ())
+    {
+      CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/CORBA/StructDef:1.0", ACE_TRY_ENV);
+      ACE_CHECK_RETURN (CORBA::StructDef::_nil ());
+      if (is_a == 0)
+        return CORBA::StructDef::_nil ();
+    }
+  return CORBA::StructDef::_unchecked_narrow (obj, ACE_TRY_ENV);
+}
+
+CORBA::StructDef_ptr CORBA::StructDef::_unchecked_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &
+  )
+{
+  if (CORBA::is_nil (obj))
+    return CORBA::StructDef::_nil ();
+  if (! obj->_is_local ())
+    {
+      TAO_Stub* stub = obj->_stubobj ();
+      if (stub)
+        stub->_incr_refcnt ();
+      CORBA::StructDef_ptr default_proxy = CORBA::StructDef::_nil ();
+
+      if (
+          !CORBA::is_nil (stub->servant_orb_var ().ptr ()) &&
+          stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects () &&
+          obj->_is_collocated () &&CORBA__TAO_StructDef_Proxy_Broker_Factory_function_pointer != 0
+        )
+      {
+        ACE_NEW_RETURN (
+          default_proxy,
+          ::CORBA::StructDef (
+            stub,
+            1,
+            obj->_servant ()),
+            
+          CORBA::StructDef::_nil ());
+        }
+      if (CORBA::is_nil (default_proxy))
+        ACE_NEW_RETURN (default_proxy, ::CORBA::StructDef (stub, 0, obj->_servant ()), CORBA::StructDef::_nil ());
+        return default_proxy;
+      }
+    else 
+      return
+        ACE_reinterpret_cast
+          (
+            CORBA_StructDef_ptr,
+              obj->_tao_QueryInterface
+                (
+                  ACE_reinterpret_cast
+                    (
+                      ptr_arith_t,
+                      &CORBA_StructDef::_narrow
+                    )
+                )
+          );
+}
+
+CORBA::StructDef_ptr
+CORBA::StructDef::_duplicate (CORBA::StructDef_ptr obj)
+{
+  if (!CORBA::is_nil (obj))
+    obj->_add_ref ();
+  return obj;
+}
+
+CORBA::Boolean CORBA::StructDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
+{
+  if (
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/StructDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/TypedefDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Container:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Contained:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IDLType:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
+  return 1; // success using local knowledge
+  else
+    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
+}
+
+void *CORBA::StructDef::_tao_QueryInterface (ptr_arith_t type)
+{
+  void *retv = 0;
+  if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      CORBA_StructDef::_narrow))
+    retv = ACE_reinterpret_cast (void*, this);
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::TypedefDef::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::TypedefDef_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::Container::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::Container_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::Contained::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::Contained_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::IDLType::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::IDLType_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::IRObject::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::IRObject_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
+    retv = ACE_reinterpret_cast (void *,
+      ACE_static_cast (CORBA::Object_ptr, this));
+    
+  if (retv)
+    this->_add_ref ();
+  return retv;
+}
+
+const char* CORBA::StructDef::_interface_repository_id (void) const
+{
+  return "IDL:omg.org/CORBA/StructDef:1.0";
+}
+
+CORBA::StructMemberSeq * CORBA::StructDef::members (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_StructDef_Proxy_Impl &proxy = 
+    this->the_TAO_StructDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.members (
+      this,
+      ACE_TRY_ENV
+    );
+}
+
+void CORBA::StructDef::members (
+    const CORBA::StructMemberSeq & members,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_StructDef_Proxy_Impl &proxy = 
+    this->the_TAO_StructDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK;
+  
+  proxy.members (
+      this,
+      members,
+      ACE_TRY_ENV
+    );
+}
+
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+CORBA::StructDef::TAO_ClientRequestInfo_CORBA_StructDef_members_get::TAO_ClientRequestInfo_CORBA_StructDef_members_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
+{}
+
+Dynamic::ParameterList *
+CORBA::StructDef::TAO_ClientRequestInfo_CORBA_StructDef_members_get::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return parameter_list;
+}
+
+Dynamic::ExceptionList *
+CORBA::StructDef::TAO_ClientRequestInfo_CORBA_StructDef_members_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::StructDef::TAO_ClientRequestInfo_CORBA_StructDef_members_get::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+CORBA::StructDef::TAO_ClientRequestInfo_CORBA_StructDef_members_get::result (CORBA::StructMemberSeq * result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+CORBA::StructDef::TAO_ClientRequestInfo_CORBA_StructDef_members_set::TAO_ClientRequestInfo_CORBA_StructDef_members_set (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const CORBA::StructMemberSeq & members,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
+    members_ (members)
+{}
+
+Dynamic::ParameterList *
+CORBA::StructDef::TAO_ClientRequestInfo_CORBA_StructDef_members_set::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
+    
+  CORBA::ULong length_members = parameter_list->length ();
+  parameter_list->length (length_members + 1);
+  (*parameter_list)[length_members].argument <<=  this->members_;
+  
+  (*parameter_list)[length_members].mode = Dynamic::PARAM_IN;
+  
+  return safe_parameter_list._retn ();
+}
+
+Dynamic::ExceptionList *
+CORBA::StructDef::TAO_ClientRequestInfo_CORBA_StructDef_members_set::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::StructDef::TAO_ClientRequestInfo_CORBA_StructDef_members_set::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 1;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return result_any;
+}
+
+#endif /* TAO_HAS_INTERCEPTORS */
+
+///////////////////////////////////////////////////////////////////////
+//                Base & Remote Proxy  Implementation. 
+//
+
+_TAO_UnionDef_Proxy_Impl::_TAO_UnionDef_Proxy_Impl (void)
+{}
+
+_TAO_UnionDef_Remote_Proxy_Impl::_TAO_UnionDef_Remote_Proxy_Impl (void)
+{}
+
+// Remote Implementation of the IDL interface methods
+
+CORBA::TypeCode_ptr _TAO_UnionDef_Remote_Proxy_Impl::discriminator_type (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::TypeCode_ptr _tao_retval = CORBA::TypeCode::_nil ();
+  CORBA::TypeCode_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_discriminator_type",
+      23,
+      0,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::UnionDef::TAO_ClientRequestInfo_CORBA_UnionDef_discriminator_type_get ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::TypeCode_ptr _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+CORBA::IDLType_ptr _TAO_UnionDef_Remote_Proxy_Impl::discriminator_type_def (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::IDLType_ptr _tao_retval = CORBA::IDLType::_nil ();
+  CORBA::IDLType_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_discriminator_type_def",
+      27,
+      0,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::UnionDef::TAO_ClientRequestInfo_CORBA_UnionDef_discriminator_type_def_get ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::IDLType_ptr _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+void _TAO_UnionDef_Remote_Proxy_Impl::discriminator_type_def (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::IDLType_ptr discriminator_type_def,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW (CORBA::INTERNAL ());
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_set_discriminator_type_def",
+      27,
+      1,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::UnionDef::TAO_ClientRequestInfo_CORBA_UnionDef_discriminator_type_def_set ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        discriminator_type_def,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK;
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK;
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK;
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK;
+          
+          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+          if (!(
+                            (_tao_out << discriminator_type_def)
+            ))
+            TAO_INTERCEPTOR_THROW (
+              CORBA::MARSHAL ()
+            );
+            
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK;
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)
+              );
+              
+            }
+          
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK;
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK;
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  
+}
+
+CORBA::UnionMemberSeq * _TAO_UnionDef_Remote_Proxy_Impl::members (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::UnionMemberSeq *_tao_retval = 0;
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  ACE_NEW_RETURN (_tao_retval, CORBA::UnionMemberSeq, _tao_retval);
+  CORBA::UnionMemberSeq_var _tao_safe_retval (_tao_retval);
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_members",
+      12,
+      0,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::UnionDef::TAO_ClientRequestInfo_CORBA_UnionDef_members_get ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::UnionMemberSeq * _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+void _TAO_UnionDef_Remote_Proxy_Impl::members (
+    CORBA_Object *_collocated_tao_target_,
+    const CORBA::UnionMemberSeq & members,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW (CORBA::INTERNAL ());
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_set_members",
+      12,
+      1,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::UnionDef::TAO_ClientRequestInfo_CORBA_UnionDef_members_set ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        members,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK;
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK;
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK;
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK;
+          
+          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+          if (!(
+                            (_tao_out << members)
+            ))
+            TAO_INTERCEPTOR_THROW (
+              CORBA::MARSHAL ()
+            );
+            
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK;
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)
+              );
+              
+            }
+          
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK;
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK;
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  
+}
+
+
+//
+//            End  Base & Remote  Proxy Implemeentation. 
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//           Remote & Base  Proxy Broker Implementation
+//
+
+_TAO_UnionDef_Proxy_Broker::_TAO_UnionDef_Proxy_Broker (void)
+{
+}
+
+_TAO_UnionDef_Proxy_Broker::~_TAO_UnionDef_Proxy_Broker (void)
+{
+}
+
+_TAO_UnionDef_Proxy_Broker * (*CORBA__TAO_UnionDef_Proxy_Broker_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  ) = 0;
+
+// Factory Member function Implementation.
+_TAO_UnionDef_Remote_Proxy_Broker *
+_TAO_UnionDef_Remote_Proxy_Broker::the_TAO_UnionDef_Remote_Proxy_Broker (void)
+{
+  static ::_TAO_UnionDef_Remote_Proxy_Broker remote_proxy_broker;
+  return &remote_proxy_broker;
+}
+
+_TAO_UnionDef_Remote_Proxy_Broker::_TAO_UnionDef_Remote_Proxy_Broker (void)
+{
+}
+
+_TAO_UnionDef_Remote_Proxy_Broker::~_TAO_UnionDef_Remote_Proxy_Broker (void)
+{
+}
+
+_TAO_UnionDef_Proxy_Impl&
+_TAO_UnionDef_Remote_Proxy_Broker::select_proxy (
+  ::CORBA_UnionDef *,
+  CORBA::Environment &
+)
+{
+  return this->remote_proxy_impl_;
+}
+
+
+//
+//           End Remote & Base Proxy Broker Implementation
+///////////////////////////////////////////////////////////////////////
+
+
+// default constructor
+CORBA::UnionDef::UnionDef (int collocated)
+{
+  this->CORBA_UnionDef_setup_collocation (collocated);
+}
+
+// destructor
+CORBA::UnionDef::~UnionDef (void)
+{}
+
+void
+CORBA::UnionDef::CORBA_UnionDef_setup_collocation (int collocated)
+{
+  if (collocated)
+    this->the_TAO_UnionDef_Proxy_Broker_ =
+      ::CORBA__TAO_UnionDef_Proxy_Broker_Factory_function_pointer (this);
+  else
+    this->the_TAO_UnionDef_Proxy_Broker_ =
+      ::_TAO_UnionDef_Remote_Proxy_Broker::the_TAO_UnionDef_Remote_Proxy_Broker ();
+  
+  this->CORBA_TypedefDef_setup_collocation (collocated);
+  
+  this->CORBA_Container_setup_collocation (collocated);
+}
+
+void CORBA::UnionDef::_tao_any_destructor (void *x)
+{
+  CORBA_UnionDef *tmp = ACE_static_cast (CORBA_UnionDef*,x);
+  CORBA::release (tmp);
+}
+
+CORBA::UnionDef_ptr CORBA::UnionDef::_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+{
+  if (CORBA::is_nil (obj))
+    return CORBA::UnionDef::_nil ();
+  if (! obj->_is_local ())
+    {
+      CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/CORBA/UnionDef:1.0", ACE_TRY_ENV);
+      ACE_CHECK_RETURN (CORBA::UnionDef::_nil ());
+      if (is_a == 0)
+        return CORBA::UnionDef::_nil ();
+    }
+  return CORBA::UnionDef::_unchecked_narrow (obj, ACE_TRY_ENV);
+}
+
+CORBA::UnionDef_ptr CORBA::UnionDef::_unchecked_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &
+  )
+{
+  if (CORBA::is_nil (obj))
+    return CORBA::UnionDef::_nil ();
+  if (! obj->_is_local ())
+    {
+      TAO_Stub* stub = obj->_stubobj ();
+      if (stub)
+        stub->_incr_refcnt ();
+      CORBA::UnionDef_ptr default_proxy = CORBA::UnionDef::_nil ();
+
+      if (
+          !CORBA::is_nil (stub->servant_orb_var ().ptr ()) &&
+          stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects () &&
+          obj->_is_collocated () &&CORBA__TAO_UnionDef_Proxy_Broker_Factory_function_pointer != 0
+        )
+      {
+        ACE_NEW_RETURN (
+          default_proxy,
+          ::CORBA::UnionDef (
+            stub,
+            1,
+            obj->_servant ()),
+            
+          CORBA::UnionDef::_nil ());
+        }
+      if (CORBA::is_nil (default_proxy))
+        ACE_NEW_RETURN (default_proxy, ::CORBA::UnionDef (stub, 0, obj->_servant ()), CORBA::UnionDef::_nil ());
+        return default_proxy;
+      }
+    else 
+      return
+        ACE_reinterpret_cast
+          (
+            CORBA_UnionDef_ptr,
+              obj->_tao_QueryInterface
+                (
+                  ACE_reinterpret_cast
+                    (
+                      ptr_arith_t,
+                      &CORBA_UnionDef::_narrow
+                    )
+                )
+          );
+}
+
+CORBA::UnionDef_ptr
+CORBA::UnionDef::_duplicate (CORBA::UnionDef_ptr obj)
+{
+  if (!CORBA::is_nil (obj))
+    obj->_add_ref ();
+  return obj;
+}
+
+CORBA::Boolean CORBA::UnionDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
+{
+  if (
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/UnionDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/TypedefDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Container:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Contained:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IDLType:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
+  return 1; // success using local knowledge
+  else
+    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
+}
+
+void *CORBA::UnionDef::_tao_QueryInterface (ptr_arith_t type)
+{
+  void *retv = 0;
+  if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      CORBA_UnionDef::_narrow))
+    retv = ACE_reinterpret_cast (void*, this);
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::TypedefDef::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::TypedefDef_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::Container::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::Container_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::Contained::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::Contained_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::IDLType::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::IDLType_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::IRObject::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::IRObject_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
+    retv = ACE_reinterpret_cast (void *,
+      ACE_static_cast (CORBA::Object_ptr, this));
+    
+  if (retv)
+    this->_add_ref ();
+  return retv;
+}
+
+const char* CORBA::UnionDef::_interface_repository_id (void) const
+{
+  return "IDL:omg.org/CORBA/UnionDef:1.0";
+}
+
+CORBA::TypeCode_ptr CORBA::UnionDef::discriminator_type (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_UnionDef_Proxy_Impl &proxy = 
+    this->the_TAO_UnionDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.discriminator_type (
+      this,
+      ACE_TRY_ENV
+    );
+}
+
+CORBA::IDLType_ptr CORBA::UnionDef::discriminator_type_def (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_UnionDef_Proxy_Impl &proxy = 
+    this->the_TAO_UnionDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.discriminator_type_def (
+      this,
+      ACE_TRY_ENV
+    );
+}
+
+void CORBA::UnionDef::discriminator_type_def (
+    CORBA::IDLType_ptr discriminator_type_def,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_UnionDef_Proxy_Impl &proxy = 
+    this->the_TAO_UnionDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK;
+  
+  proxy.discriminator_type_def (
+      this,
+      discriminator_type_def,
+      ACE_TRY_ENV
+    );
+}
+
+CORBA::UnionMemberSeq * CORBA::UnionDef::members (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_UnionDef_Proxy_Impl &proxy = 
+    this->the_TAO_UnionDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.members (
+      this,
+      ACE_TRY_ENV
+    );
+}
+
+void CORBA::UnionDef::members (
+    const CORBA::UnionMemberSeq & members,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_UnionDef_Proxy_Impl &proxy = 
+    this->the_TAO_UnionDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK;
+  
+  proxy.members (
+      this,
+      members,
+      ACE_TRY_ENV
+    );
+}
+
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+CORBA::UnionDef::TAO_ClientRequestInfo_CORBA_UnionDef_discriminator_type_get::TAO_ClientRequestInfo_CORBA_UnionDef_discriminator_type_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
+{}
+
+Dynamic::ParameterList *
+CORBA::UnionDef::TAO_ClientRequestInfo_CORBA_UnionDef_discriminator_type_get::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return parameter_list;
+}
+
+Dynamic::ExceptionList *
+CORBA::UnionDef::TAO_ClientRequestInfo_CORBA_UnionDef_discriminator_type_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::UnionDef::TAO_ClientRequestInfo_CORBA_UnionDef_discriminator_type_get::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+CORBA::UnionDef::TAO_ClientRequestInfo_CORBA_UnionDef_discriminator_type_get::result (CORBA::TypeCode_ptr result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+CORBA::UnionDef::TAO_ClientRequestInfo_CORBA_UnionDef_discriminator_type_def_get::TAO_ClientRequestInfo_CORBA_UnionDef_discriminator_type_def_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
+{}
+
+Dynamic::ParameterList *
+CORBA::UnionDef::TAO_ClientRequestInfo_CORBA_UnionDef_discriminator_type_def_get::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return parameter_list;
+}
+
+Dynamic::ExceptionList *
+CORBA::UnionDef::TAO_ClientRequestInfo_CORBA_UnionDef_discriminator_type_def_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::UnionDef::TAO_ClientRequestInfo_CORBA_UnionDef_discriminator_type_def_get::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+CORBA::UnionDef::TAO_ClientRequestInfo_CORBA_UnionDef_discriminator_type_def_get::result (CORBA::IDLType_ptr result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+CORBA::UnionDef::TAO_ClientRequestInfo_CORBA_UnionDef_discriminator_type_def_set::TAO_ClientRequestInfo_CORBA_UnionDef_discriminator_type_def_set (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::IDLType_ptr discriminator_type_def,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
+    discriminator_type_def_ (discriminator_type_def)
+{}
+
+Dynamic::ParameterList *
+CORBA::UnionDef::TAO_ClientRequestInfo_CORBA_UnionDef_discriminator_type_def_set::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
+    
+  CORBA::ULong length_discriminator_type_def = parameter_list->length ();
+  parameter_list->length (length_discriminator_type_def + 1);
+  (*parameter_list)[length_discriminator_type_def].argument <<=  this->discriminator_type_def_;
+  
+  (*parameter_list)[length_discriminator_type_def].mode = Dynamic::PARAM_IN;
+  
+  return safe_parameter_list._retn ();
+}
+
+Dynamic::ExceptionList *
+CORBA::UnionDef::TAO_ClientRequestInfo_CORBA_UnionDef_discriminator_type_def_set::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::UnionDef::TAO_ClientRequestInfo_CORBA_UnionDef_discriminator_type_def_set::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 1;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return result_any;
+}
+
+CORBA::UnionDef::TAO_ClientRequestInfo_CORBA_UnionDef_members_get::TAO_ClientRequestInfo_CORBA_UnionDef_members_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
+{}
+
+Dynamic::ParameterList *
+CORBA::UnionDef::TAO_ClientRequestInfo_CORBA_UnionDef_members_get::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return parameter_list;
+}
+
+Dynamic::ExceptionList *
+CORBA::UnionDef::TAO_ClientRequestInfo_CORBA_UnionDef_members_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::UnionDef::TAO_ClientRequestInfo_CORBA_UnionDef_members_get::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+CORBA::UnionDef::TAO_ClientRequestInfo_CORBA_UnionDef_members_get::result (CORBA::UnionMemberSeq * result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+CORBA::UnionDef::TAO_ClientRequestInfo_CORBA_UnionDef_members_set::TAO_ClientRequestInfo_CORBA_UnionDef_members_set (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const CORBA::UnionMemberSeq & members,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
+    members_ (members)
+{}
+
+Dynamic::ParameterList *
+CORBA::UnionDef::TAO_ClientRequestInfo_CORBA_UnionDef_members_set::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
+    
+  CORBA::ULong length_members = parameter_list->length ();
+  parameter_list->length (length_members + 1);
+  (*parameter_list)[length_members].argument <<=  this->members_;
+  
+  (*parameter_list)[length_members].mode = Dynamic::PARAM_IN;
+  
+  return safe_parameter_list._retn ();
+}
+
+Dynamic::ExceptionList *
+CORBA::UnionDef::TAO_ClientRequestInfo_CORBA_UnionDef_members_set::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::UnionDef::TAO_ClientRequestInfo_CORBA_UnionDef_members_set::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 1;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return result_any;
+}
+
+#endif /* TAO_HAS_INTERCEPTORS */
+
+///////////////////////////////////////////////////////////////////////
+//                Base & Remote Proxy  Implementation. 
+//
+
+_TAO_EnumDef_Proxy_Impl::_TAO_EnumDef_Proxy_Impl (void)
+{}
+
+_TAO_EnumDef_Remote_Proxy_Impl::_TAO_EnumDef_Remote_Proxy_Impl (void)
+{}
+
+// Remote Implementation of the IDL interface methods
+
+CORBA::EnumMemberSeq * _TAO_EnumDef_Remote_Proxy_Impl::members (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::EnumMemberSeq *_tao_retval = 0;
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  ACE_NEW_RETURN (_tao_retval, CORBA::EnumMemberSeq, _tao_retval);
+  CORBA::EnumMemberSeq_var _tao_safe_retval (_tao_retval);
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_members",
+      12,
+      0,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::EnumDef::TAO_ClientRequestInfo_CORBA_EnumDef_members_get ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::EnumMemberSeq * _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+void _TAO_EnumDef_Remote_Proxy_Impl::members (
+    CORBA_Object *_collocated_tao_target_,
+    const CORBA::EnumMemberSeq & members,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW (CORBA::INTERNAL ());
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_set_members",
+      12,
+      1,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::EnumDef::TAO_ClientRequestInfo_CORBA_EnumDef_members_set ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        members,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK;
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK;
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK;
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK;
+          
+          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+          if (!(
+                            (_tao_out << members)
+            ))
+            TAO_INTERCEPTOR_THROW (
+              CORBA::MARSHAL ()
+            );
+            
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK;
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)
+              );
+              
+            }
+          
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK;
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK;
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  
+}
+
+
+//
+//            End  Base & Remote  Proxy Implemeentation. 
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//           Remote & Base  Proxy Broker Implementation
+//
+
+_TAO_EnumDef_Proxy_Broker::_TAO_EnumDef_Proxy_Broker (void)
+{
+}
+
+_TAO_EnumDef_Proxy_Broker::~_TAO_EnumDef_Proxy_Broker (void)
+{
+}
+
+_TAO_EnumDef_Proxy_Broker * (*CORBA__TAO_EnumDef_Proxy_Broker_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  ) = 0;
+
+// Factory Member function Implementation.
+_TAO_EnumDef_Remote_Proxy_Broker *
+_TAO_EnumDef_Remote_Proxy_Broker::the_TAO_EnumDef_Remote_Proxy_Broker (void)
+{
+  static ::_TAO_EnumDef_Remote_Proxy_Broker remote_proxy_broker;
+  return &remote_proxy_broker;
+}
+
+_TAO_EnumDef_Remote_Proxy_Broker::_TAO_EnumDef_Remote_Proxy_Broker (void)
+{
+}
+
+_TAO_EnumDef_Remote_Proxy_Broker::~_TAO_EnumDef_Remote_Proxy_Broker (void)
+{
+}
+
+_TAO_EnumDef_Proxy_Impl&
+_TAO_EnumDef_Remote_Proxy_Broker::select_proxy (
+  ::CORBA_EnumDef *,
+  CORBA::Environment &
+)
+{
+  return this->remote_proxy_impl_;
+}
+
+
+//
+//           End Remote & Base Proxy Broker Implementation
+///////////////////////////////////////////////////////////////////////
+
+
+// default constructor
+CORBA::EnumDef::EnumDef (int collocated)
+{
+  this->CORBA_EnumDef_setup_collocation (collocated);
+}
+
+// destructor
+CORBA::EnumDef::~EnumDef (void)
+{}
+
+void
+CORBA::EnumDef::CORBA_EnumDef_setup_collocation (int collocated)
+{
+  if (collocated)
+    this->the_TAO_EnumDef_Proxy_Broker_ =
+      ::CORBA__TAO_EnumDef_Proxy_Broker_Factory_function_pointer (this);
+  else
+    this->the_TAO_EnumDef_Proxy_Broker_ =
+      ::_TAO_EnumDef_Remote_Proxy_Broker::the_TAO_EnumDef_Remote_Proxy_Broker ();
+  
+  this->CORBA_TypedefDef_setup_collocation (collocated);
+}
+
+void CORBA::EnumDef::_tao_any_destructor (void *x)
+{
+  CORBA_EnumDef *tmp = ACE_static_cast (CORBA_EnumDef*,x);
+  CORBA::release (tmp);
+}
+
+CORBA::EnumDef_ptr CORBA::EnumDef::_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+{
+  if (CORBA::is_nil (obj))
+    return CORBA::EnumDef::_nil ();
+  if (! obj->_is_local ())
+    {
+      CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/CORBA/EnumDef:1.0", ACE_TRY_ENV);
+      ACE_CHECK_RETURN (CORBA::EnumDef::_nil ());
+      if (is_a == 0)
+        return CORBA::EnumDef::_nil ();
+    }
+  return CORBA::EnumDef::_unchecked_narrow (obj, ACE_TRY_ENV);
+}
+
+CORBA::EnumDef_ptr CORBA::EnumDef::_unchecked_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &
+  )
+{
+  if (CORBA::is_nil (obj))
+    return CORBA::EnumDef::_nil ();
+  if (! obj->_is_local ())
+    {
+      TAO_Stub* stub = obj->_stubobj ();
+      if (stub)
+        stub->_incr_refcnt ();
+      CORBA::EnumDef_ptr default_proxy = CORBA::EnumDef::_nil ();
+
+      if (
+          !CORBA::is_nil (stub->servant_orb_var ().ptr ()) &&
+          stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects () &&
+          obj->_is_collocated () &&CORBA__TAO_EnumDef_Proxy_Broker_Factory_function_pointer != 0
+        )
+      {
+        ACE_NEW_RETURN (
+          default_proxy,
+          ::CORBA::EnumDef (
+            stub,
+            1,
+            obj->_servant ()),
+            
+          CORBA::EnumDef::_nil ());
+        }
+      if (CORBA::is_nil (default_proxy))
+        ACE_NEW_RETURN (default_proxy, ::CORBA::EnumDef (stub, 0, obj->_servant ()), CORBA::EnumDef::_nil ());
+        return default_proxy;
+      }
+    else 
+      return
+        ACE_reinterpret_cast
+          (
+            CORBA_EnumDef_ptr,
+              obj->_tao_QueryInterface
+                (
+                  ACE_reinterpret_cast
+                    (
+                      ptr_arith_t,
+                      &CORBA_EnumDef::_narrow
+                    )
+                )
+          );
+}
+
+CORBA::EnumDef_ptr
+CORBA::EnumDef::_duplicate (CORBA::EnumDef_ptr obj)
+{
+  if (!CORBA::is_nil (obj))
+    obj->_add_ref ();
+  return obj;
+}
+
+CORBA::Boolean CORBA::EnumDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
+{
+  if (
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/EnumDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/TypedefDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Contained:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IDLType:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
+  return 1; // success using local knowledge
+  else
+    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
+}
+
+void *CORBA::EnumDef::_tao_QueryInterface (ptr_arith_t type)
+{
+  void *retv = 0;
+  if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      CORBA_EnumDef::_narrow))
+    retv = ACE_reinterpret_cast (void*, this);
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::TypedefDef::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::TypedefDef_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::Contained::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::Contained_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::IDLType::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::IDLType_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::IRObject::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::IRObject_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
+    retv = ACE_reinterpret_cast (void *,
+      ACE_static_cast (CORBA::Object_ptr, this));
+    
+  if (retv)
+    this->_add_ref ();
+  return retv;
+}
+
+const char* CORBA::EnumDef::_interface_repository_id (void) const
+{
+  return "IDL:omg.org/CORBA/EnumDef:1.0";
+}
+
+CORBA::EnumMemberSeq * CORBA::EnumDef::members (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_EnumDef_Proxy_Impl &proxy = 
+    this->the_TAO_EnumDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.members (
+      this,
+      ACE_TRY_ENV
+    );
+}
+
+void CORBA::EnumDef::members (
+    const CORBA::EnumMemberSeq & members,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_EnumDef_Proxy_Impl &proxy = 
+    this->the_TAO_EnumDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK;
+  
+  proxy.members (
+      this,
+      members,
+      ACE_TRY_ENV
+    );
+}
+
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+CORBA::EnumDef::TAO_ClientRequestInfo_CORBA_EnumDef_members_get::TAO_ClientRequestInfo_CORBA_EnumDef_members_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
+{}
+
+Dynamic::ParameterList *
+CORBA::EnumDef::TAO_ClientRequestInfo_CORBA_EnumDef_members_get::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return parameter_list;
+}
+
+Dynamic::ExceptionList *
+CORBA::EnumDef::TAO_ClientRequestInfo_CORBA_EnumDef_members_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::EnumDef::TAO_ClientRequestInfo_CORBA_EnumDef_members_get::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+CORBA::EnumDef::TAO_ClientRequestInfo_CORBA_EnumDef_members_get::result (CORBA::EnumMemberSeq * result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+CORBA::EnumDef::TAO_ClientRequestInfo_CORBA_EnumDef_members_set::TAO_ClientRequestInfo_CORBA_EnumDef_members_set (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const CORBA::EnumMemberSeq & members,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
+    members_ (members)
+{}
+
+Dynamic::ParameterList *
+CORBA::EnumDef::TAO_ClientRequestInfo_CORBA_EnumDef_members_set::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
+    
+  CORBA::ULong length_members = parameter_list->length ();
+  parameter_list->length (length_members + 1);
+  (*parameter_list)[length_members].argument <<=  this->members_;
+  
+  (*parameter_list)[length_members].mode = Dynamic::PARAM_IN;
+  
+  return safe_parameter_list._retn ();
+}
+
+Dynamic::ExceptionList *
+CORBA::EnumDef::TAO_ClientRequestInfo_CORBA_EnumDef_members_set::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::EnumDef::TAO_ClientRequestInfo_CORBA_EnumDef_members_set::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 1;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return result_any;
+}
+
+#endif /* TAO_HAS_INTERCEPTORS */
+
+///////////////////////////////////////////////////////////////////////
+//                Base & Remote Proxy  Implementation. 
+//
+
+_TAO_AliasDef_Proxy_Impl::_TAO_AliasDef_Proxy_Impl (void)
+{}
+
+_TAO_AliasDef_Remote_Proxy_Impl::_TAO_AliasDef_Remote_Proxy_Impl (void)
+{}
+
+// Remote Implementation of the IDL interface methods
+
+CORBA::IDLType_ptr _TAO_AliasDef_Remote_Proxy_Impl::original_type_def (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::IDLType_ptr _tao_retval = CORBA::IDLType::_nil ();
+  CORBA::IDLType_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_original_type_def",
+      22,
+      0,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::AliasDef::TAO_ClientRequestInfo_CORBA_AliasDef_original_type_def_get ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::IDLType_ptr _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+void _TAO_AliasDef_Remote_Proxy_Impl::original_type_def (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::IDLType_ptr original_type_def,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW (CORBA::INTERNAL ());
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_set_original_type_def",
+      22,
+      1,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::AliasDef::TAO_ClientRequestInfo_CORBA_AliasDef_original_type_def_set ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        original_type_def,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK;
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK;
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK;
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK;
+          
+          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+          if (!(
+                            (_tao_out << original_type_def)
+            ))
+            TAO_INTERCEPTOR_THROW (
+              CORBA::MARSHAL ()
+            );
+            
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK;
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)
+              );
+              
+            }
+          
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK;
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK;
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  
+}
+
+
+//
+//            End  Base & Remote  Proxy Implemeentation. 
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//           Remote & Base  Proxy Broker Implementation
+//
+
+_TAO_AliasDef_Proxy_Broker::_TAO_AliasDef_Proxy_Broker (void)
+{
+}
+
+_TAO_AliasDef_Proxy_Broker::~_TAO_AliasDef_Proxy_Broker (void)
+{
+}
+
+_TAO_AliasDef_Proxy_Broker * (*CORBA__TAO_AliasDef_Proxy_Broker_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  ) = 0;
+
+// Factory Member function Implementation.
+_TAO_AliasDef_Remote_Proxy_Broker *
+_TAO_AliasDef_Remote_Proxy_Broker::the_TAO_AliasDef_Remote_Proxy_Broker (void)
+{
+  static ::_TAO_AliasDef_Remote_Proxy_Broker remote_proxy_broker;
+  return &remote_proxy_broker;
+}
+
+_TAO_AliasDef_Remote_Proxy_Broker::_TAO_AliasDef_Remote_Proxy_Broker (void)
+{
+}
+
+_TAO_AliasDef_Remote_Proxy_Broker::~_TAO_AliasDef_Remote_Proxy_Broker (void)
+{
+}
+
+_TAO_AliasDef_Proxy_Impl&
+_TAO_AliasDef_Remote_Proxy_Broker::select_proxy (
+  ::CORBA_AliasDef *,
+  CORBA::Environment &
+)
+{
+  return this->remote_proxy_impl_;
+}
+
+
+//
+//           End Remote & Base Proxy Broker Implementation
+///////////////////////////////////////////////////////////////////////
+
+
+// default constructor
+CORBA::AliasDef::AliasDef (int collocated)
+{
+  this->CORBA_AliasDef_setup_collocation (collocated);
+}
+
+// destructor
+CORBA::AliasDef::~AliasDef (void)
+{}
+
+void
+CORBA::AliasDef::CORBA_AliasDef_setup_collocation (int collocated)
+{
+  if (collocated)
+    this->the_TAO_AliasDef_Proxy_Broker_ =
+      ::CORBA__TAO_AliasDef_Proxy_Broker_Factory_function_pointer (this);
+  else
+    this->the_TAO_AliasDef_Proxy_Broker_ =
+      ::_TAO_AliasDef_Remote_Proxy_Broker::the_TAO_AliasDef_Remote_Proxy_Broker ();
+  
+  this->CORBA_TypedefDef_setup_collocation (collocated);
+}
+
+void CORBA::AliasDef::_tao_any_destructor (void *x)
+{
+  CORBA_AliasDef *tmp = ACE_static_cast (CORBA_AliasDef*,x);
+  CORBA::release (tmp);
+}
+
+CORBA::AliasDef_ptr CORBA::AliasDef::_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+{
+  if (CORBA::is_nil (obj))
+    return CORBA::AliasDef::_nil ();
+  if (! obj->_is_local ())
+    {
+      CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/CORBA/AliasDef:1.0", ACE_TRY_ENV);
+      ACE_CHECK_RETURN (CORBA::AliasDef::_nil ());
+      if (is_a == 0)
+        return CORBA::AliasDef::_nil ();
+    }
+  return CORBA::AliasDef::_unchecked_narrow (obj, ACE_TRY_ENV);
+}
+
+CORBA::AliasDef_ptr CORBA::AliasDef::_unchecked_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &
+  )
+{
+  if (CORBA::is_nil (obj))
+    return CORBA::AliasDef::_nil ();
+  if (! obj->_is_local ())
+    {
+      TAO_Stub* stub = obj->_stubobj ();
+      if (stub)
+        stub->_incr_refcnt ();
+      CORBA::AliasDef_ptr default_proxy = CORBA::AliasDef::_nil ();
+
+      if (
+          !CORBA::is_nil (stub->servant_orb_var ().ptr ()) &&
+          stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects () &&
+          obj->_is_collocated () &&CORBA__TAO_AliasDef_Proxy_Broker_Factory_function_pointer != 0
+        )
+      {
+        ACE_NEW_RETURN (
+          default_proxy,
+          ::CORBA::AliasDef (
+            stub,
+            1,
+            obj->_servant ()),
+            
+          CORBA::AliasDef::_nil ());
+        }
+      if (CORBA::is_nil (default_proxy))
+        ACE_NEW_RETURN (default_proxy, ::CORBA::AliasDef (stub, 0, obj->_servant ()), CORBA::AliasDef::_nil ());
+        return default_proxy;
+      }
+    else 
+      return
+        ACE_reinterpret_cast
+          (
+            CORBA_AliasDef_ptr,
+              obj->_tao_QueryInterface
+                (
+                  ACE_reinterpret_cast
+                    (
+                      ptr_arith_t,
+                      &CORBA_AliasDef::_narrow
+                    )
+                )
+          );
+}
+
+CORBA::AliasDef_ptr
+CORBA::AliasDef::_duplicate (CORBA::AliasDef_ptr obj)
+{
+  if (!CORBA::is_nil (obj))
+    obj->_add_ref ();
+  return obj;
+}
+
+CORBA::Boolean CORBA::AliasDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
+{
+  if (
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/AliasDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/TypedefDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Contained:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IDLType:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
+  return 1; // success using local knowledge
+  else
+    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
+}
+
+void *CORBA::AliasDef::_tao_QueryInterface (ptr_arith_t type)
+{
+  void *retv = 0;
+  if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      CORBA_AliasDef::_narrow))
+    retv = ACE_reinterpret_cast (void*, this);
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::TypedefDef::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::TypedefDef_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::Contained::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::Contained_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::IDLType::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::IDLType_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::IRObject::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::IRObject_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
+    retv = ACE_reinterpret_cast (void *,
+      ACE_static_cast (CORBA::Object_ptr, this));
+    
+  if (retv)
+    this->_add_ref ();
+  return retv;
+}
+
+const char* CORBA::AliasDef::_interface_repository_id (void) const
+{
+  return "IDL:omg.org/CORBA/AliasDef:1.0";
+}
+
+CORBA::IDLType_ptr CORBA::AliasDef::original_type_def (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_AliasDef_Proxy_Impl &proxy = 
+    this->the_TAO_AliasDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.original_type_def (
+      this,
+      ACE_TRY_ENV
+    );
+}
+
+void CORBA::AliasDef::original_type_def (
+    CORBA::IDLType_ptr original_type_def,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_AliasDef_Proxy_Impl &proxy = 
+    this->the_TAO_AliasDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK;
+  
+  proxy.original_type_def (
+      this,
+      original_type_def,
+      ACE_TRY_ENV
+    );
+}
+
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+CORBA::AliasDef::TAO_ClientRequestInfo_CORBA_AliasDef_original_type_def_get::TAO_ClientRequestInfo_CORBA_AliasDef_original_type_def_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
+{}
+
+Dynamic::ParameterList *
+CORBA::AliasDef::TAO_ClientRequestInfo_CORBA_AliasDef_original_type_def_get::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return parameter_list;
+}
+
+Dynamic::ExceptionList *
+CORBA::AliasDef::TAO_ClientRequestInfo_CORBA_AliasDef_original_type_def_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::AliasDef::TAO_ClientRequestInfo_CORBA_AliasDef_original_type_def_get::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+CORBA::AliasDef::TAO_ClientRequestInfo_CORBA_AliasDef_original_type_def_get::result (CORBA::IDLType_ptr result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+CORBA::AliasDef::TAO_ClientRequestInfo_CORBA_AliasDef_original_type_def_set::TAO_ClientRequestInfo_CORBA_AliasDef_original_type_def_set (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::IDLType_ptr original_type_def,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
+    original_type_def_ (original_type_def)
+{}
+
+Dynamic::ParameterList *
+CORBA::AliasDef::TAO_ClientRequestInfo_CORBA_AliasDef_original_type_def_set::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
+    
+  CORBA::ULong length_original_type_def = parameter_list->length ();
+  parameter_list->length (length_original_type_def + 1);
+  (*parameter_list)[length_original_type_def].argument <<=  this->original_type_def_;
+  
+  (*parameter_list)[length_original_type_def].mode = Dynamic::PARAM_IN;
+  
+  return safe_parameter_list._retn ();
+}
+
+Dynamic::ExceptionList *
+CORBA::AliasDef::TAO_ClientRequestInfo_CORBA_AliasDef_original_type_def_set::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::AliasDef::TAO_ClientRequestInfo_CORBA_AliasDef_original_type_def_set::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 1;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return result_any;
+}
+
+#endif /* TAO_HAS_INTERCEPTORS */
+
+///////////////////////////////////////////////////////////////////////
+//                Base & Remote Proxy  Implementation. 
+//
+
+_TAO_NativeDef_Proxy_Impl::_TAO_NativeDef_Proxy_Impl (void)
+{}
+
+_TAO_NativeDef_Remote_Proxy_Impl::_TAO_NativeDef_Remote_Proxy_Impl (void)
+{}
+
+// Remote Implementation of the IDL interface methods
+
+
+//
+//            End  Base & Remote  Proxy Implemeentation. 
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//           Remote & Base  Proxy Broker Implementation
+//
+
+_TAO_NativeDef_Proxy_Broker::_TAO_NativeDef_Proxy_Broker (void)
+{
+}
+
+_TAO_NativeDef_Proxy_Broker::~_TAO_NativeDef_Proxy_Broker (void)
+{
+}
+
+_TAO_NativeDef_Proxy_Broker * (*CORBA__TAO_NativeDef_Proxy_Broker_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  ) = 0;
+
+// Factory Member function Implementation.
+_TAO_NativeDef_Remote_Proxy_Broker *
+_TAO_NativeDef_Remote_Proxy_Broker::the_TAO_NativeDef_Remote_Proxy_Broker (void)
+{
+  static ::_TAO_NativeDef_Remote_Proxy_Broker remote_proxy_broker;
+  return &remote_proxy_broker;
+}
+
+_TAO_NativeDef_Remote_Proxy_Broker::_TAO_NativeDef_Remote_Proxy_Broker (void)
+{
+}
+
+_TAO_NativeDef_Remote_Proxy_Broker::~_TAO_NativeDef_Remote_Proxy_Broker (void)
+{
+}
+
+_TAO_NativeDef_Proxy_Impl&
+_TAO_NativeDef_Remote_Proxy_Broker::select_proxy (
+  ::CORBA_NativeDef *,
+  CORBA::Environment &
+)
+{
+  return this->remote_proxy_impl_;
+}
+
+
+//
+//           End Remote & Base Proxy Broker Implementation
+///////////////////////////////////////////////////////////////////////
+
+
+// default constructor
+CORBA::NativeDef::NativeDef (int collocated)
+{
+  this->CORBA_NativeDef_setup_collocation (collocated);
+}
+
+// destructor
+CORBA::NativeDef::~NativeDef (void)
+{}
+
+void
+CORBA::NativeDef::CORBA_NativeDef_setup_collocation (int collocated)
+{
+  if (collocated)
+    this->the_TAO_NativeDef_Proxy_Broker_ =
+      ::CORBA__TAO_NativeDef_Proxy_Broker_Factory_function_pointer (this);
+  else
+    this->the_TAO_NativeDef_Proxy_Broker_ =
+      ::_TAO_NativeDef_Remote_Proxy_Broker::the_TAO_NativeDef_Remote_Proxy_Broker ();
+  
+  this->CORBA_TypedefDef_setup_collocation (collocated);
+}
+
+void CORBA::NativeDef::_tao_any_destructor (void *x)
+{
+  CORBA_NativeDef *tmp = ACE_static_cast (CORBA_NativeDef*,x);
+  CORBA::release (tmp);
+}
+
+CORBA::NativeDef_ptr CORBA::NativeDef::_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+{
+  if (CORBA::is_nil (obj))
+    return CORBA::NativeDef::_nil ();
+  if (! obj->_is_local ())
+    {
+      CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/CORBA/NativeDef:1.0", ACE_TRY_ENV);
+      ACE_CHECK_RETURN (CORBA::NativeDef::_nil ());
+      if (is_a == 0)
+        return CORBA::NativeDef::_nil ();
+    }
+  return CORBA::NativeDef::_unchecked_narrow (obj, ACE_TRY_ENV);
+}
+
+CORBA::NativeDef_ptr CORBA::NativeDef::_unchecked_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &
+  )
+{
+  if (CORBA::is_nil (obj))
+    return CORBA::NativeDef::_nil ();
+  if (! obj->_is_local ())
+    {
+      TAO_Stub* stub = obj->_stubobj ();
+      if (stub)
+        stub->_incr_refcnt ();
+      CORBA::NativeDef_ptr default_proxy = CORBA::NativeDef::_nil ();
+
+      if (
+          !CORBA::is_nil (stub->servant_orb_var ().ptr ()) &&
+          stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects () &&
+          obj->_is_collocated () &&CORBA__TAO_NativeDef_Proxy_Broker_Factory_function_pointer != 0
+        )
+      {
+        ACE_NEW_RETURN (
+          default_proxy,
+          ::CORBA::NativeDef (
+            stub,
+            1,
+            obj->_servant ()),
+            
+          CORBA::NativeDef::_nil ());
+        }
+      if (CORBA::is_nil (default_proxy))
+        ACE_NEW_RETURN (default_proxy, ::CORBA::NativeDef (stub, 0, obj->_servant ()), CORBA::NativeDef::_nil ());
+        return default_proxy;
+      }
+    else 
+      return
+        ACE_reinterpret_cast
+          (
+            CORBA_NativeDef_ptr,
+              obj->_tao_QueryInterface
+                (
+                  ACE_reinterpret_cast
+                    (
+                      ptr_arith_t,
+                      &CORBA_NativeDef::_narrow
+                    )
+                )
+          );
+}
+
+CORBA::NativeDef_ptr
+CORBA::NativeDef::_duplicate (CORBA::NativeDef_ptr obj)
+{
+  if (!CORBA::is_nil (obj))
+    obj->_add_ref ();
+  return obj;
+}
+
+CORBA::Boolean CORBA::NativeDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
+{
+  if (
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/NativeDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/TypedefDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Contained:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IDLType:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
+  return 1; // success using local knowledge
+  else
+    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
+}
+
+void *CORBA::NativeDef::_tao_QueryInterface (ptr_arith_t type)
+{
+  void *retv = 0;
+  if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      CORBA_NativeDef::_narrow))
+    retv = ACE_reinterpret_cast (void*, this);
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::TypedefDef::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::TypedefDef_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::Contained::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::Contained_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::IDLType::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::IDLType_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::IRObject::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::IRObject_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
+    retv = ACE_reinterpret_cast (void *,
+      ACE_static_cast (CORBA::Object_ptr, this));
+    
+  if (retv)
+    this->_add_ref ();
+  return retv;
+}
+
+const char* CORBA::NativeDef::_interface_repository_id (void) const
+{
+  return "IDL:omg.org/CORBA/NativeDef:1.0";
+}
+
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+#endif /* TAO_HAS_INTERCEPTORS */
+
+///////////////////////////////////////////////////////////////////////
+//                Base & Remote Proxy  Implementation. 
+//
+
+_TAO_PrimitiveDef_Proxy_Impl::_TAO_PrimitiveDef_Proxy_Impl (void)
+{}
+
+_TAO_PrimitiveDef_Remote_Proxy_Impl::_TAO_PrimitiveDef_Remote_Proxy_Impl (void)
+{}
+
+// Remote Implementation of the IDL interface methods
+
+CORBA::PrimitiveKind _TAO_PrimitiveDef_Remote_Proxy_Impl::kind (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::PrimitiveKind _tao_retval = (CORBA::PrimitiveKind)0;
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), _tao_retval);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_kind",
+      9,
+      0,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::PrimitiveDef::TAO_ClientRequestInfo_CORBA_PrimitiveDef_kind_get ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN  (_tao_retval);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                _tao_retval
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_retval)
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                _tao_retval
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::PrimitiveKind  _tao_retval_info = _tao_retval;
+               ri.result (_tao_retval_info);
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN  (_tao_retval);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_retval;
+}
+
+
+//
+//            End  Base & Remote  Proxy Implemeentation. 
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//           Remote & Base  Proxy Broker Implementation
+//
+
+_TAO_PrimitiveDef_Proxy_Broker::_TAO_PrimitiveDef_Proxy_Broker (void)
+{
+}
+
+_TAO_PrimitiveDef_Proxy_Broker::~_TAO_PrimitiveDef_Proxy_Broker (void)
+{
+}
+
+_TAO_PrimitiveDef_Proxy_Broker * (*CORBA__TAO_PrimitiveDef_Proxy_Broker_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  ) = 0;
+
+// Factory Member function Implementation.
+_TAO_PrimitiveDef_Remote_Proxy_Broker *
+_TAO_PrimitiveDef_Remote_Proxy_Broker::the_TAO_PrimitiveDef_Remote_Proxy_Broker (void)
+{
+  static ::_TAO_PrimitiveDef_Remote_Proxy_Broker remote_proxy_broker;
+  return &remote_proxy_broker;
+}
+
+_TAO_PrimitiveDef_Remote_Proxy_Broker::_TAO_PrimitiveDef_Remote_Proxy_Broker (void)
+{
+}
+
+_TAO_PrimitiveDef_Remote_Proxy_Broker::~_TAO_PrimitiveDef_Remote_Proxy_Broker (void)
+{
+}
+
+_TAO_PrimitiveDef_Proxy_Impl&
+_TAO_PrimitiveDef_Remote_Proxy_Broker::select_proxy (
+  ::CORBA_PrimitiveDef *,
+  CORBA::Environment &
+)
+{
+  return this->remote_proxy_impl_;
+}
+
+
+//
+//           End Remote & Base Proxy Broker Implementation
+///////////////////////////////////////////////////////////////////////
+
+
+// default constructor
+CORBA::PrimitiveDef::PrimitiveDef (int collocated)
+{
+  this->CORBA_PrimitiveDef_setup_collocation (collocated);
+}
+
+// destructor
+CORBA::PrimitiveDef::~PrimitiveDef (void)
+{}
+
+void
+CORBA::PrimitiveDef::CORBA_PrimitiveDef_setup_collocation (int collocated)
+{
+  if (collocated)
+    this->the_TAO_PrimitiveDef_Proxy_Broker_ =
+      ::CORBA__TAO_PrimitiveDef_Proxy_Broker_Factory_function_pointer (this);
+  else
+    this->the_TAO_PrimitiveDef_Proxy_Broker_ =
+      ::_TAO_PrimitiveDef_Remote_Proxy_Broker::the_TAO_PrimitiveDef_Remote_Proxy_Broker ();
+  
+  this->CORBA_IDLType_setup_collocation (collocated);
+}
+
+void CORBA::PrimitiveDef::_tao_any_destructor (void *x)
+{
+  CORBA_PrimitiveDef *tmp = ACE_static_cast (CORBA_PrimitiveDef*,x);
+  CORBA::release (tmp);
+}
+
+CORBA::PrimitiveDef_ptr CORBA::PrimitiveDef::_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+{
+  if (CORBA::is_nil (obj))
+    return CORBA::PrimitiveDef::_nil ();
+  if (! obj->_is_local ())
+    {
+      CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/CORBA/PrimitiveDef:1.0", ACE_TRY_ENV);
+      ACE_CHECK_RETURN (CORBA::PrimitiveDef::_nil ());
+      if (is_a == 0)
+        return CORBA::PrimitiveDef::_nil ();
+    }
+  return CORBA::PrimitiveDef::_unchecked_narrow (obj, ACE_TRY_ENV);
+}
+
+CORBA::PrimitiveDef_ptr CORBA::PrimitiveDef::_unchecked_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &
+  )
+{
+  if (CORBA::is_nil (obj))
+    return CORBA::PrimitiveDef::_nil ();
+  if (! obj->_is_local ())
+    {
+      TAO_Stub* stub = obj->_stubobj ();
+      if (stub)
+        stub->_incr_refcnt ();
+      CORBA::PrimitiveDef_ptr default_proxy = CORBA::PrimitiveDef::_nil ();
+
+      if (
+          !CORBA::is_nil (stub->servant_orb_var ().ptr ()) &&
+          stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects () &&
+          obj->_is_collocated () &&CORBA__TAO_PrimitiveDef_Proxy_Broker_Factory_function_pointer != 0
+        )
+      {
+        ACE_NEW_RETURN (
+          default_proxy,
+          ::CORBA::PrimitiveDef (
+            stub,
+            1,
+            obj->_servant ()),
+            
+          CORBA::PrimitiveDef::_nil ());
+        }
+      if (CORBA::is_nil (default_proxy))
+        ACE_NEW_RETURN (default_proxy, ::CORBA::PrimitiveDef (stub, 0, obj->_servant ()), CORBA::PrimitiveDef::_nil ());
+        return default_proxy;
+      }
+    else 
+      return
+        ACE_reinterpret_cast
+          (
+            CORBA_PrimitiveDef_ptr,
+              obj->_tao_QueryInterface
+                (
+                  ACE_reinterpret_cast
+                    (
+                      ptr_arith_t,
+                      &CORBA_PrimitiveDef::_narrow
+                    )
+                )
+          );
+}
+
+CORBA::PrimitiveDef_ptr
+CORBA::PrimitiveDef::_duplicate (CORBA::PrimitiveDef_ptr obj)
+{
+  if (!CORBA::is_nil (obj))
+    obj->_add_ref ();
+  return obj;
+}
+
+CORBA::Boolean CORBA::PrimitiveDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
+{
+  if (
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/PrimitiveDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IDLType:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
+  return 1; // success using local knowledge
+  else
+    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
+}
+
+void *CORBA::PrimitiveDef::_tao_QueryInterface (ptr_arith_t type)
+{
+  void *retv = 0;
+  if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      CORBA_PrimitiveDef::_narrow))
+    retv = ACE_reinterpret_cast (void*, this);
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::IDLType::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::IDLType_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::IRObject::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::IRObject_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
+    retv = ACE_reinterpret_cast (void *,
+      ACE_static_cast (CORBA::Object_ptr, this));
+    
+  if (retv)
+    this->_add_ref ();
+  return retv;
+}
+
+const char* CORBA::PrimitiveDef::_interface_repository_id (void) const
+{
+  return "IDL:omg.org/CORBA/PrimitiveDef:1.0";
+}
+
+CORBA::PrimitiveKind CORBA::PrimitiveDef::kind (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_PrimitiveDef_Proxy_Impl &proxy = 
+    this->the_TAO_PrimitiveDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN ((CORBA::PrimitiveKind)0);
+  
+  return proxy.kind (
+      this,
+      ACE_TRY_ENV
+    );
+}
+
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+CORBA::PrimitiveDef::TAO_ClientRequestInfo_CORBA_PrimitiveDef_kind_get::TAO_ClientRequestInfo_CORBA_PrimitiveDef_kind_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
+{}
+
+Dynamic::ParameterList *
+CORBA::PrimitiveDef::TAO_ClientRequestInfo_CORBA_PrimitiveDef_kind_get::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return parameter_list;
+}
+
+Dynamic::ExceptionList *
+CORBA::PrimitiveDef::TAO_ClientRequestInfo_CORBA_PrimitiveDef_kind_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::PrimitiveDef::TAO_ClientRequestInfo_CORBA_PrimitiveDef_kind_get::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+CORBA::PrimitiveDef::TAO_ClientRequestInfo_CORBA_PrimitiveDef_kind_get::result (CORBA::PrimitiveKind result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+#endif /* TAO_HAS_INTERCEPTORS */
+
+///////////////////////////////////////////////////////////////////////
+//                Base & Remote Proxy  Implementation. 
+//
+
+_TAO_StringDef_Proxy_Impl::_TAO_StringDef_Proxy_Impl (void)
+{}
+
+_TAO_StringDef_Remote_Proxy_Impl::_TAO_StringDef_Remote_Proxy_Impl (void)
+{}
+
+// Remote Implementation of the IDL interface methods
+
+CORBA::ULong _TAO_StringDef_Remote_Proxy_Impl::bound (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::ULong _tao_retval = 0;
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), _tao_retval);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_bound",
+      10,
+      0,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::StringDef::TAO_ClientRequestInfo_CORBA_StringDef_bound_get ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN  (_tao_retval);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                _tao_retval
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_retval)
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                _tao_retval
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::ULong  _tao_retval_info = _tao_retval;
+               ri.result (_tao_retval_info);
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN  (_tao_retval);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_retval;
+}
+
+void _TAO_StringDef_Remote_Proxy_Impl::bound (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::ULong bound,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW (CORBA::INTERNAL ());
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_set_bound",
+      10,
+      1,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::StringDef::TAO_ClientRequestInfo_CORBA_StringDef_bound_set ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        bound,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK;
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK;
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK;
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK;
+          
+          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+          if (!(
+                            (_tao_out << bound)
+            ))
+            TAO_INTERCEPTOR_THROW (
+              CORBA::MARSHAL ()
+            );
+            
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK;
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)
+              );
+              
+            }
+          
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK;
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK;
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  
+}
+
+
+//
+//            End  Base & Remote  Proxy Implemeentation. 
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//           Remote & Base  Proxy Broker Implementation
+//
+
+_TAO_StringDef_Proxy_Broker::_TAO_StringDef_Proxy_Broker (void)
+{
+}
+
+_TAO_StringDef_Proxy_Broker::~_TAO_StringDef_Proxy_Broker (void)
+{
+}
+
+_TAO_StringDef_Proxy_Broker * (*CORBA__TAO_StringDef_Proxy_Broker_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  ) = 0;
+
+// Factory Member function Implementation.
+_TAO_StringDef_Remote_Proxy_Broker *
+_TAO_StringDef_Remote_Proxy_Broker::the_TAO_StringDef_Remote_Proxy_Broker (void)
+{
+  static ::_TAO_StringDef_Remote_Proxy_Broker remote_proxy_broker;
+  return &remote_proxy_broker;
+}
+
+_TAO_StringDef_Remote_Proxy_Broker::_TAO_StringDef_Remote_Proxy_Broker (void)
+{
+}
+
+_TAO_StringDef_Remote_Proxy_Broker::~_TAO_StringDef_Remote_Proxy_Broker (void)
+{
+}
+
+_TAO_StringDef_Proxy_Impl&
+_TAO_StringDef_Remote_Proxy_Broker::select_proxy (
+  ::CORBA_StringDef *,
+  CORBA::Environment &
+)
+{
+  return this->remote_proxy_impl_;
+}
+
+
+//
+//           End Remote & Base Proxy Broker Implementation
+///////////////////////////////////////////////////////////////////////
+
+
+// default constructor
+CORBA::StringDef::StringDef (int collocated)
+{
+  this->CORBA_StringDef_setup_collocation (collocated);
+}
+
+// destructor
+CORBA::StringDef::~StringDef (void)
+{}
+
+void
+CORBA::StringDef::CORBA_StringDef_setup_collocation (int collocated)
+{
+  if (collocated)
+    this->the_TAO_StringDef_Proxy_Broker_ =
+      ::CORBA__TAO_StringDef_Proxy_Broker_Factory_function_pointer (this);
+  else
+    this->the_TAO_StringDef_Proxy_Broker_ =
+      ::_TAO_StringDef_Remote_Proxy_Broker::the_TAO_StringDef_Remote_Proxy_Broker ();
+  
+  this->CORBA_IDLType_setup_collocation (collocated);
+}
+
+void CORBA::StringDef::_tao_any_destructor (void *x)
+{
+  CORBA_StringDef *tmp = ACE_static_cast (CORBA_StringDef*,x);
+  CORBA::release (tmp);
+}
+
+CORBA::StringDef_ptr CORBA::StringDef::_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+{
+  if (CORBA::is_nil (obj))
+    return CORBA::StringDef::_nil ();
+  if (! obj->_is_local ())
+    {
+      CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/CORBA/StringDef:1.0", ACE_TRY_ENV);
+      ACE_CHECK_RETURN (CORBA::StringDef::_nil ());
+      if (is_a == 0)
+        return CORBA::StringDef::_nil ();
+    }
+  return CORBA::StringDef::_unchecked_narrow (obj, ACE_TRY_ENV);
+}
+
+CORBA::StringDef_ptr CORBA::StringDef::_unchecked_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &
+  )
+{
+  if (CORBA::is_nil (obj))
+    return CORBA::StringDef::_nil ();
+  if (! obj->_is_local ())
+    {
+      TAO_Stub* stub = obj->_stubobj ();
+      if (stub)
+        stub->_incr_refcnt ();
+      CORBA::StringDef_ptr default_proxy = CORBA::StringDef::_nil ();
+
+      if (
+          !CORBA::is_nil (stub->servant_orb_var ().ptr ()) &&
+          stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects () &&
+          obj->_is_collocated () &&CORBA__TAO_StringDef_Proxy_Broker_Factory_function_pointer != 0
+        )
+      {
+        ACE_NEW_RETURN (
+          default_proxy,
+          ::CORBA::StringDef (
+            stub,
+            1,
+            obj->_servant ()),
+            
+          CORBA::StringDef::_nil ());
+        }
+      if (CORBA::is_nil (default_proxy))
+        ACE_NEW_RETURN (default_proxy, ::CORBA::StringDef (stub, 0, obj->_servant ()), CORBA::StringDef::_nil ());
+        return default_proxy;
+      }
+    else 
+      return
+        ACE_reinterpret_cast
+          (
+            CORBA_StringDef_ptr,
+              obj->_tao_QueryInterface
+                (
+                  ACE_reinterpret_cast
+                    (
+                      ptr_arith_t,
+                      &CORBA_StringDef::_narrow
+                    )
+                )
+          );
+}
+
+CORBA::StringDef_ptr
+CORBA::StringDef::_duplicate (CORBA::StringDef_ptr obj)
+{
+  if (!CORBA::is_nil (obj))
+    obj->_add_ref ();
+  return obj;
+}
+
+CORBA::Boolean CORBA::StringDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
+{
+  if (
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/StringDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IDLType:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
+  return 1; // success using local knowledge
+  else
+    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
+}
+
+void *CORBA::StringDef::_tao_QueryInterface (ptr_arith_t type)
+{
+  void *retv = 0;
+  if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      CORBA_StringDef::_narrow))
+    retv = ACE_reinterpret_cast (void*, this);
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::IDLType::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::IDLType_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::IRObject::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::IRObject_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
+    retv = ACE_reinterpret_cast (void *,
+      ACE_static_cast (CORBA::Object_ptr, this));
+    
+  if (retv)
+    this->_add_ref ();
+  return retv;
+}
+
+const char* CORBA::StringDef::_interface_repository_id (void) const
+{
+  return "IDL:omg.org/CORBA/StringDef:1.0";
+}
+
+CORBA::ULong CORBA::StringDef::bound (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_StringDef_Proxy_Impl &proxy = 
+    this->the_TAO_StringDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.bound (
+      this,
+      ACE_TRY_ENV
+    );
+}
+
+void CORBA::StringDef::bound (
+    CORBA::ULong bound,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_StringDef_Proxy_Impl &proxy = 
+    this->the_TAO_StringDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK;
+  
+  proxy.bound (
+      this,
+      bound,
+      ACE_TRY_ENV
+    );
+}
+
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+CORBA::StringDef::TAO_ClientRequestInfo_CORBA_StringDef_bound_get::TAO_ClientRequestInfo_CORBA_StringDef_bound_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
+{}
+
+Dynamic::ParameterList *
+CORBA::StringDef::TAO_ClientRequestInfo_CORBA_StringDef_bound_get::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return parameter_list;
+}
+
+Dynamic::ExceptionList *
+CORBA::StringDef::TAO_ClientRequestInfo_CORBA_StringDef_bound_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::StringDef::TAO_ClientRequestInfo_CORBA_StringDef_bound_get::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+CORBA::StringDef::TAO_ClientRequestInfo_CORBA_StringDef_bound_get::result (CORBA::ULong result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+CORBA::StringDef::TAO_ClientRequestInfo_CORBA_StringDef_bound_set::TAO_ClientRequestInfo_CORBA_StringDef_bound_set (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const CORBA::ULong & bound,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
+    bound_ (bound)
+{}
+
+Dynamic::ParameterList *
+CORBA::StringDef::TAO_ClientRequestInfo_CORBA_StringDef_bound_set::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
+    
+  CORBA::ULong length_bound = parameter_list->length ();
+  parameter_list->length (length_bound + 1);
+  (*parameter_list)[length_bound].argument <<= bound_;
+  (*parameter_list)[length_bound].mode = Dynamic::PARAM_IN;
+  
+  return safe_parameter_list._retn ();
+}
+
+Dynamic::ExceptionList *
+CORBA::StringDef::TAO_ClientRequestInfo_CORBA_StringDef_bound_set::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::StringDef::TAO_ClientRequestInfo_CORBA_StringDef_bound_set::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 1;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return result_any;
+}
+
+#endif /* TAO_HAS_INTERCEPTORS */
+
+///////////////////////////////////////////////////////////////////////
+//                Base & Remote Proxy  Implementation. 
+//
+
+_TAO_WstringDef_Proxy_Impl::_TAO_WstringDef_Proxy_Impl (void)
+{}
+
+_TAO_WstringDef_Remote_Proxy_Impl::_TAO_WstringDef_Remote_Proxy_Impl (void)
+{}
+
+// Remote Implementation of the IDL interface methods
+
+CORBA::ULong _TAO_WstringDef_Remote_Proxy_Impl::bound (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::ULong _tao_retval = 0;
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), _tao_retval);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_bound",
+      10,
+      0,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::WstringDef::TAO_ClientRequestInfo_CORBA_WstringDef_bound_get ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN  (_tao_retval);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                _tao_retval
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_retval)
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                _tao_retval
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::ULong  _tao_retval_info = _tao_retval;
+               ri.result (_tao_retval_info);
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN  (_tao_retval);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_retval;
+}
+
+void _TAO_WstringDef_Remote_Proxy_Impl::bound (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::ULong bound,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW (CORBA::INTERNAL ());
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_set_bound",
+      10,
+      1,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::WstringDef::TAO_ClientRequestInfo_CORBA_WstringDef_bound_set ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        bound,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK;
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK;
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK;
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK;
+          
+          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+          if (!(
+                            (_tao_out << bound)
+            ))
+            TAO_INTERCEPTOR_THROW (
+              CORBA::MARSHAL ()
+            );
+            
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK;
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)
+              );
+              
+            }
+          
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK;
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK;
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  
+}
+
+
+//
+//            End  Base & Remote  Proxy Implemeentation. 
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//           Remote & Base  Proxy Broker Implementation
+//
+
+_TAO_WstringDef_Proxy_Broker::_TAO_WstringDef_Proxy_Broker (void)
+{
+}
+
+_TAO_WstringDef_Proxy_Broker::~_TAO_WstringDef_Proxy_Broker (void)
+{
+}
+
+_TAO_WstringDef_Proxy_Broker * (*CORBA__TAO_WstringDef_Proxy_Broker_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  ) = 0;
+
+// Factory Member function Implementation.
+_TAO_WstringDef_Remote_Proxy_Broker *
+_TAO_WstringDef_Remote_Proxy_Broker::the_TAO_WstringDef_Remote_Proxy_Broker (void)
+{
+  static ::_TAO_WstringDef_Remote_Proxy_Broker remote_proxy_broker;
+  return &remote_proxy_broker;
+}
+
+_TAO_WstringDef_Remote_Proxy_Broker::_TAO_WstringDef_Remote_Proxy_Broker (void)
+{
+}
+
+_TAO_WstringDef_Remote_Proxy_Broker::~_TAO_WstringDef_Remote_Proxy_Broker (void)
+{
+}
+
+_TAO_WstringDef_Proxy_Impl&
+_TAO_WstringDef_Remote_Proxy_Broker::select_proxy (
+  ::CORBA_WstringDef *,
+  CORBA::Environment &
+)
+{
+  return this->remote_proxy_impl_;
+}
+
+
+//
+//           End Remote & Base Proxy Broker Implementation
+///////////////////////////////////////////////////////////////////////
+
+
+// default constructor
+CORBA::WstringDef::WstringDef (int collocated)
+{
+  this->CORBA_WstringDef_setup_collocation (collocated);
+}
+
+// destructor
+CORBA::WstringDef::~WstringDef (void)
+{}
+
+void
+CORBA::WstringDef::CORBA_WstringDef_setup_collocation (int collocated)
+{
+  if (collocated)
+    this->the_TAO_WstringDef_Proxy_Broker_ =
+      ::CORBA__TAO_WstringDef_Proxy_Broker_Factory_function_pointer (this);
+  else
+    this->the_TAO_WstringDef_Proxy_Broker_ =
+      ::_TAO_WstringDef_Remote_Proxy_Broker::the_TAO_WstringDef_Remote_Proxy_Broker ();
+  
+  this->CORBA_IDLType_setup_collocation (collocated);
+}
+
+void CORBA::WstringDef::_tao_any_destructor (void *x)
+{
+  CORBA_WstringDef *tmp = ACE_static_cast (CORBA_WstringDef*,x);
+  CORBA::release (tmp);
+}
+
+CORBA::WstringDef_ptr CORBA::WstringDef::_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+{
+  if (CORBA::is_nil (obj))
+    return CORBA::WstringDef::_nil ();
+  if (! obj->_is_local ())
+    {
+      CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/CORBA/WstringDef:1.0", ACE_TRY_ENV);
+      ACE_CHECK_RETURN (CORBA::WstringDef::_nil ());
+      if (is_a == 0)
+        return CORBA::WstringDef::_nil ();
+    }
+  return CORBA::WstringDef::_unchecked_narrow (obj, ACE_TRY_ENV);
+}
+
+CORBA::WstringDef_ptr CORBA::WstringDef::_unchecked_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &
+  )
+{
+  if (CORBA::is_nil (obj))
+    return CORBA::WstringDef::_nil ();
+  if (! obj->_is_local ())
+    {
+      TAO_Stub* stub = obj->_stubobj ();
+      if (stub)
+        stub->_incr_refcnt ();
+      CORBA::WstringDef_ptr default_proxy = CORBA::WstringDef::_nil ();
+
+      if (
+          !CORBA::is_nil (stub->servant_orb_var ().ptr ()) &&
+          stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects () &&
+          obj->_is_collocated () &&CORBA__TAO_WstringDef_Proxy_Broker_Factory_function_pointer != 0
+        )
+      {
+        ACE_NEW_RETURN (
+          default_proxy,
+          ::CORBA::WstringDef (
+            stub,
+            1,
+            obj->_servant ()),
+            
+          CORBA::WstringDef::_nil ());
+        }
+      if (CORBA::is_nil (default_proxy))
+        ACE_NEW_RETURN (default_proxy, ::CORBA::WstringDef (stub, 0, obj->_servant ()), CORBA::WstringDef::_nil ());
+        return default_proxy;
+      }
+    else 
+      return
+        ACE_reinterpret_cast
+          (
+            CORBA_WstringDef_ptr,
+              obj->_tao_QueryInterface
+                (
+                  ACE_reinterpret_cast
+                    (
+                      ptr_arith_t,
+                      &CORBA_WstringDef::_narrow
+                    )
+                )
+          );
+}
+
+CORBA::WstringDef_ptr
+CORBA::WstringDef::_duplicate (CORBA::WstringDef_ptr obj)
+{
+  if (!CORBA::is_nil (obj))
+    obj->_add_ref ();
+  return obj;
+}
+
+CORBA::Boolean CORBA::WstringDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
+{
+  if (
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/WstringDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IDLType:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
+  return 1; // success using local knowledge
+  else
+    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
+}
+
+void *CORBA::WstringDef::_tao_QueryInterface (ptr_arith_t type)
+{
+  void *retv = 0;
+  if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      CORBA_WstringDef::_narrow))
+    retv = ACE_reinterpret_cast (void*, this);
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::IDLType::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::IDLType_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::IRObject::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::IRObject_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
+    retv = ACE_reinterpret_cast (void *,
+      ACE_static_cast (CORBA::Object_ptr, this));
+    
+  if (retv)
+    this->_add_ref ();
+  return retv;
+}
+
+const char* CORBA::WstringDef::_interface_repository_id (void) const
+{
+  return "IDL:omg.org/CORBA/WstringDef:1.0";
+}
+
+CORBA::ULong CORBA::WstringDef::bound (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_WstringDef_Proxy_Impl &proxy = 
+    this->the_TAO_WstringDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.bound (
+      this,
+      ACE_TRY_ENV
+    );
+}
+
+void CORBA::WstringDef::bound (
+    CORBA::ULong bound,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_WstringDef_Proxy_Impl &proxy = 
+    this->the_TAO_WstringDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK;
+  
+  proxy.bound (
+      this,
+      bound,
+      ACE_TRY_ENV
+    );
+}
+
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+CORBA::WstringDef::TAO_ClientRequestInfo_CORBA_WstringDef_bound_get::TAO_ClientRequestInfo_CORBA_WstringDef_bound_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
+{}
+
+Dynamic::ParameterList *
+CORBA::WstringDef::TAO_ClientRequestInfo_CORBA_WstringDef_bound_get::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return parameter_list;
+}
+
+Dynamic::ExceptionList *
+CORBA::WstringDef::TAO_ClientRequestInfo_CORBA_WstringDef_bound_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::WstringDef::TAO_ClientRequestInfo_CORBA_WstringDef_bound_get::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+CORBA::WstringDef::TAO_ClientRequestInfo_CORBA_WstringDef_bound_get::result (CORBA::ULong result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+CORBA::WstringDef::TAO_ClientRequestInfo_CORBA_WstringDef_bound_set::TAO_ClientRequestInfo_CORBA_WstringDef_bound_set (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const CORBA::ULong & bound,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
+    bound_ (bound)
+{}
+
+Dynamic::ParameterList *
+CORBA::WstringDef::TAO_ClientRequestInfo_CORBA_WstringDef_bound_set::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
+    
+  CORBA::ULong length_bound = parameter_list->length ();
+  parameter_list->length (length_bound + 1);
+  (*parameter_list)[length_bound].argument <<= bound_;
+  (*parameter_list)[length_bound].mode = Dynamic::PARAM_IN;
+  
+  return safe_parameter_list._retn ();
+}
+
+Dynamic::ExceptionList *
+CORBA::WstringDef::TAO_ClientRequestInfo_CORBA_WstringDef_bound_set::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::WstringDef::TAO_ClientRequestInfo_CORBA_WstringDef_bound_set::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 1;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return result_any;
+}
+
+#endif /* TAO_HAS_INTERCEPTORS */
+
+///////////////////////////////////////////////////////////////////////
+//                Base & Remote Proxy  Implementation. 
+//
+
+_TAO_SequenceDef_Proxy_Impl::_TAO_SequenceDef_Proxy_Impl (void)
+{}
+
+_TAO_SequenceDef_Remote_Proxy_Impl::_TAO_SequenceDef_Remote_Proxy_Impl (void)
+{}
+
+// Remote Implementation of the IDL interface methods
+
+CORBA::ULong _TAO_SequenceDef_Remote_Proxy_Impl::bound (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::ULong _tao_retval = 0;
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), _tao_retval);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_bound",
+      10,
+      0,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::SequenceDef::TAO_ClientRequestInfo_CORBA_SequenceDef_bound_get ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN  (_tao_retval);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                _tao_retval
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_retval)
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                _tao_retval
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::ULong  _tao_retval_info = _tao_retval;
+               ri.result (_tao_retval_info);
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN  (_tao_retval);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_retval;
+}
+
+void _TAO_SequenceDef_Remote_Proxy_Impl::bound (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::ULong bound,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW (CORBA::INTERNAL ());
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_set_bound",
+      10,
+      1,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::SequenceDef::TAO_ClientRequestInfo_CORBA_SequenceDef_bound_set ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        bound,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK;
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK;
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK;
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK;
+          
+          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+          if (!(
+                            (_tao_out << bound)
+            ))
+            TAO_INTERCEPTOR_THROW (
+              CORBA::MARSHAL ()
+            );
+            
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK;
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)
+              );
+              
+            }
+          
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK;
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK;
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  
+}
+
+CORBA::TypeCode_ptr _TAO_SequenceDef_Remote_Proxy_Impl::element_type (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::TypeCode_ptr _tao_retval = CORBA::TypeCode::_nil ();
+  CORBA::TypeCode_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_element_type",
+      17,
+      0,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::SequenceDef::TAO_ClientRequestInfo_CORBA_SequenceDef_element_type_get ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::TypeCode_ptr _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+CORBA::IDLType_ptr _TAO_SequenceDef_Remote_Proxy_Impl::element_type_def (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::IDLType_ptr _tao_retval = CORBA::IDLType::_nil ();
+  CORBA::IDLType_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_element_type_def",
+      21,
+      0,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::SequenceDef::TAO_ClientRequestInfo_CORBA_SequenceDef_element_type_def_get ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::IDLType_ptr _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+void _TAO_SequenceDef_Remote_Proxy_Impl::element_type_def (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::IDLType_ptr element_type_def,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW (CORBA::INTERNAL ());
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_set_element_type_def",
+      21,
+      1,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::SequenceDef::TAO_ClientRequestInfo_CORBA_SequenceDef_element_type_def_set ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        element_type_def,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK;
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK;
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK;
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK;
+          
+          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+          if (!(
+                            (_tao_out << element_type_def)
+            ))
+            TAO_INTERCEPTOR_THROW (
+              CORBA::MARSHAL ()
+            );
+            
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK;
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)
+              );
+              
+            }
+          
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK;
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK;
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  
+}
+
+
+//
+//            End  Base & Remote  Proxy Implemeentation. 
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//           Remote & Base  Proxy Broker Implementation
+//
+
+_TAO_SequenceDef_Proxy_Broker::_TAO_SequenceDef_Proxy_Broker (void)
+{
+}
+
+_TAO_SequenceDef_Proxy_Broker::~_TAO_SequenceDef_Proxy_Broker (void)
+{
+}
+
+_TAO_SequenceDef_Proxy_Broker * (*CORBA__TAO_SequenceDef_Proxy_Broker_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  ) = 0;
+
+// Factory Member function Implementation.
+_TAO_SequenceDef_Remote_Proxy_Broker *
+_TAO_SequenceDef_Remote_Proxy_Broker::the_TAO_SequenceDef_Remote_Proxy_Broker (void)
+{
+  static ::_TAO_SequenceDef_Remote_Proxy_Broker remote_proxy_broker;
+  return &remote_proxy_broker;
+}
+
+_TAO_SequenceDef_Remote_Proxy_Broker::_TAO_SequenceDef_Remote_Proxy_Broker (void)
+{
+}
+
+_TAO_SequenceDef_Remote_Proxy_Broker::~_TAO_SequenceDef_Remote_Proxy_Broker (void)
+{
+}
+
+_TAO_SequenceDef_Proxy_Impl&
+_TAO_SequenceDef_Remote_Proxy_Broker::select_proxy (
+  ::CORBA_SequenceDef *,
+  CORBA::Environment &
+)
+{
+  return this->remote_proxy_impl_;
+}
+
+
+//
+//           End Remote & Base Proxy Broker Implementation
+///////////////////////////////////////////////////////////////////////
+
+
+// default constructor
+CORBA::SequenceDef::SequenceDef (int collocated)
+{
+  this->CORBA_SequenceDef_setup_collocation (collocated);
+}
+
+// destructor
+CORBA::SequenceDef::~SequenceDef (void)
+{}
+
+void
+CORBA::SequenceDef::CORBA_SequenceDef_setup_collocation (int collocated)
+{
+  if (collocated)
+    this->the_TAO_SequenceDef_Proxy_Broker_ =
+      ::CORBA__TAO_SequenceDef_Proxy_Broker_Factory_function_pointer (this);
+  else
+    this->the_TAO_SequenceDef_Proxy_Broker_ =
+      ::_TAO_SequenceDef_Remote_Proxy_Broker::the_TAO_SequenceDef_Remote_Proxy_Broker ();
+  
+  this->CORBA_IDLType_setup_collocation (collocated);
+}
+
+void CORBA::SequenceDef::_tao_any_destructor (void *x)
+{
+  CORBA_SequenceDef *tmp = ACE_static_cast (CORBA_SequenceDef*,x);
+  CORBA::release (tmp);
+}
+
+CORBA::SequenceDef_ptr CORBA::SequenceDef::_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+{
+  if (CORBA::is_nil (obj))
+    return CORBA::SequenceDef::_nil ();
+  if (! obj->_is_local ())
+    {
+      CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/CORBA/SequenceDef:1.0", ACE_TRY_ENV);
+      ACE_CHECK_RETURN (CORBA::SequenceDef::_nil ());
+      if (is_a == 0)
+        return CORBA::SequenceDef::_nil ();
+    }
+  return CORBA::SequenceDef::_unchecked_narrow (obj, ACE_TRY_ENV);
+}
+
+CORBA::SequenceDef_ptr CORBA::SequenceDef::_unchecked_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &
+  )
+{
+  if (CORBA::is_nil (obj))
+    return CORBA::SequenceDef::_nil ();
+  if (! obj->_is_local ())
+    {
+      TAO_Stub* stub = obj->_stubobj ();
+      if (stub)
+        stub->_incr_refcnt ();
+      CORBA::SequenceDef_ptr default_proxy = CORBA::SequenceDef::_nil ();
+
+      if (
+          !CORBA::is_nil (stub->servant_orb_var ().ptr ()) &&
+          stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects () &&
+          obj->_is_collocated () &&CORBA__TAO_SequenceDef_Proxy_Broker_Factory_function_pointer != 0
+        )
+      {
+        ACE_NEW_RETURN (
+          default_proxy,
+          ::CORBA::SequenceDef (
+            stub,
+            1,
+            obj->_servant ()),
+            
+          CORBA::SequenceDef::_nil ());
+        }
+      if (CORBA::is_nil (default_proxy))
+        ACE_NEW_RETURN (default_proxy, ::CORBA::SequenceDef (stub, 0, obj->_servant ()), CORBA::SequenceDef::_nil ());
+        return default_proxy;
+      }
+    else 
+      return
+        ACE_reinterpret_cast
+          (
+            CORBA_SequenceDef_ptr,
+              obj->_tao_QueryInterface
+                (
+                  ACE_reinterpret_cast
+                    (
+                      ptr_arith_t,
+                      &CORBA_SequenceDef::_narrow
+                    )
+                )
+          );
+}
+
+CORBA::SequenceDef_ptr
+CORBA::SequenceDef::_duplicate (CORBA::SequenceDef_ptr obj)
+{
+  if (!CORBA::is_nil (obj))
+    obj->_add_ref ();
+  return obj;
+}
+
+CORBA::Boolean CORBA::SequenceDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
+{
+  if (
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/SequenceDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IDLType:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
+  return 1; // success using local knowledge
+  else
+    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
+}
+
+void *CORBA::SequenceDef::_tao_QueryInterface (ptr_arith_t type)
+{
+  void *retv = 0;
+  if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      CORBA_SequenceDef::_narrow))
+    retv = ACE_reinterpret_cast (void*, this);
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::IDLType::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::IDLType_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::IRObject::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::IRObject_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
+    retv = ACE_reinterpret_cast (void *,
+      ACE_static_cast (CORBA::Object_ptr, this));
+    
+  if (retv)
+    this->_add_ref ();
+  return retv;
+}
+
+const char* CORBA::SequenceDef::_interface_repository_id (void) const
+{
+  return "IDL:omg.org/CORBA/SequenceDef:1.0";
+}
+
+CORBA::ULong CORBA::SequenceDef::bound (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_SequenceDef_Proxy_Impl &proxy = 
+    this->the_TAO_SequenceDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.bound (
+      this,
+      ACE_TRY_ENV
+    );
+}
+
+void CORBA::SequenceDef::bound (
+    CORBA::ULong bound,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_SequenceDef_Proxy_Impl &proxy = 
+    this->the_TAO_SequenceDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK;
+  
+  proxy.bound (
+      this,
+      bound,
+      ACE_TRY_ENV
+    );
+}
+
+CORBA::TypeCode_ptr CORBA::SequenceDef::element_type (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_SequenceDef_Proxy_Impl &proxy = 
+    this->the_TAO_SequenceDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.element_type (
+      this,
+      ACE_TRY_ENV
+    );
+}
+
+CORBA::IDLType_ptr CORBA::SequenceDef::element_type_def (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_SequenceDef_Proxy_Impl &proxy = 
+    this->the_TAO_SequenceDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.element_type_def (
+      this,
+      ACE_TRY_ENV
+    );
+}
+
+void CORBA::SequenceDef::element_type_def (
+    CORBA::IDLType_ptr element_type_def,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_SequenceDef_Proxy_Impl &proxy = 
+    this->the_TAO_SequenceDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK;
+  
+  proxy.element_type_def (
+      this,
+      element_type_def,
+      ACE_TRY_ENV
+    );
+}
+
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+CORBA::SequenceDef::TAO_ClientRequestInfo_CORBA_SequenceDef_bound_get::TAO_ClientRequestInfo_CORBA_SequenceDef_bound_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
+{}
+
+Dynamic::ParameterList *
+CORBA::SequenceDef::TAO_ClientRequestInfo_CORBA_SequenceDef_bound_get::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return parameter_list;
+}
+
+Dynamic::ExceptionList *
+CORBA::SequenceDef::TAO_ClientRequestInfo_CORBA_SequenceDef_bound_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::SequenceDef::TAO_ClientRequestInfo_CORBA_SequenceDef_bound_get::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+CORBA::SequenceDef::TAO_ClientRequestInfo_CORBA_SequenceDef_bound_get::result (CORBA::ULong result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+CORBA::SequenceDef::TAO_ClientRequestInfo_CORBA_SequenceDef_bound_set::TAO_ClientRequestInfo_CORBA_SequenceDef_bound_set (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const CORBA::ULong & bound,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
+    bound_ (bound)
+{}
+
+Dynamic::ParameterList *
+CORBA::SequenceDef::TAO_ClientRequestInfo_CORBA_SequenceDef_bound_set::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
+    
+  CORBA::ULong length_bound = parameter_list->length ();
+  parameter_list->length (length_bound + 1);
+  (*parameter_list)[length_bound].argument <<= bound_;
+  (*parameter_list)[length_bound].mode = Dynamic::PARAM_IN;
+  
+  return safe_parameter_list._retn ();
+}
+
+Dynamic::ExceptionList *
+CORBA::SequenceDef::TAO_ClientRequestInfo_CORBA_SequenceDef_bound_set::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::SequenceDef::TAO_ClientRequestInfo_CORBA_SequenceDef_bound_set::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 1;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return result_any;
+}
+
+CORBA::SequenceDef::TAO_ClientRequestInfo_CORBA_SequenceDef_element_type_get::TAO_ClientRequestInfo_CORBA_SequenceDef_element_type_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
+{}
+
+Dynamic::ParameterList *
+CORBA::SequenceDef::TAO_ClientRequestInfo_CORBA_SequenceDef_element_type_get::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return parameter_list;
+}
+
+Dynamic::ExceptionList *
+CORBA::SequenceDef::TAO_ClientRequestInfo_CORBA_SequenceDef_element_type_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::SequenceDef::TAO_ClientRequestInfo_CORBA_SequenceDef_element_type_get::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+CORBA::SequenceDef::TAO_ClientRequestInfo_CORBA_SequenceDef_element_type_get::result (CORBA::TypeCode_ptr result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+CORBA::SequenceDef::TAO_ClientRequestInfo_CORBA_SequenceDef_element_type_def_get::TAO_ClientRequestInfo_CORBA_SequenceDef_element_type_def_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
+{}
+
+Dynamic::ParameterList *
+CORBA::SequenceDef::TAO_ClientRequestInfo_CORBA_SequenceDef_element_type_def_get::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return parameter_list;
+}
+
+Dynamic::ExceptionList *
+CORBA::SequenceDef::TAO_ClientRequestInfo_CORBA_SequenceDef_element_type_def_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::SequenceDef::TAO_ClientRequestInfo_CORBA_SequenceDef_element_type_def_get::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+CORBA::SequenceDef::TAO_ClientRequestInfo_CORBA_SequenceDef_element_type_def_get::result (CORBA::IDLType_ptr result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+CORBA::SequenceDef::TAO_ClientRequestInfo_CORBA_SequenceDef_element_type_def_set::TAO_ClientRequestInfo_CORBA_SequenceDef_element_type_def_set (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::IDLType_ptr element_type_def,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
+    element_type_def_ (element_type_def)
+{}
+
+Dynamic::ParameterList *
+CORBA::SequenceDef::TAO_ClientRequestInfo_CORBA_SequenceDef_element_type_def_set::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
+    
+  CORBA::ULong length_element_type_def = parameter_list->length ();
+  parameter_list->length (length_element_type_def + 1);
+  (*parameter_list)[length_element_type_def].argument <<=  this->element_type_def_;
+  
+  (*parameter_list)[length_element_type_def].mode = Dynamic::PARAM_IN;
+  
+  return safe_parameter_list._retn ();
+}
+
+Dynamic::ExceptionList *
+CORBA::SequenceDef::TAO_ClientRequestInfo_CORBA_SequenceDef_element_type_def_set::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::SequenceDef::TAO_ClientRequestInfo_CORBA_SequenceDef_element_type_def_set::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 1;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return result_any;
+}
+
+#endif /* TAO_HAS_INTERCEPTORS */
+
+///////////////////////////////////////////////////////////////////////
+//                Base & Remote Proxy  Implementation. 
+//
+
+_TAO_ArrayDef_Proxy_Impl::_TAO_ArrayDef_Proxy_Impl (void)
+{}
+
+_TAO_ArrayDef_Remote_Proxy_Impl::_TAO_ArrayDef_Remote_Proxy_Impl (void)
+{}
+
+// Remote Implementation of the IDL interface methods
+
+CORBA::ULong _TAO_ArrayDef_Remote_Proxy_Impl::length (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::ULong _tao_retval = 0;
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), _tao_retval);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_length",
+      11,
+      0,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::ArrayDef::TAO_ClientRequestInfo_CORBA_ArrayDef_length_get ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN  (_tao_retval);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                _tao_retval
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_retval)
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                _tao_retval
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::ULong  _tao_retval_info = _tao_retval;
+               ri.result (_tao_retval_info);
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN  (_tao_retval);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_retval;
+}
+
+void _TAO_ArrayDef_Remote_Proxy_Impl::length (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::ULong length,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW (CORBA::INTERNAL ());
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_set_length",
+      11,
+      1,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::ArrayDef::TAO_ClientRequestInfo_CORBA_ArrayDef_length_set ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        length,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK;
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK;
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK;
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK;
+          
+          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+          if (!(
+                            (_tao_out << length)
+            ))
+            TAO_INTERCEPTOR_THROW (
+              CORBA::MARSHAL ()
+            );
+            
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK;
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)
+              );
+              
+            }
+          
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK;
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK;
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  
+}
+
+CORBA::TypeCode_ptr _TAO_ArrayDef_Remote_Proxy_Impl::element_type (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::TypeCode_ptr _tao_retval = CORBA::TypeCode::_nil ();
+  CORBA::TypeCode_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_element_type",
+      17,
+      0,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::ArrayDef::TAO_ClientRequestInfo_CORBA_ArrayDef_element_type_get ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::TypeCode_ptr _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+CORBA::IDLType_ptr _TAO_ArrayDef_Remote_Proxy_Impl::element_type_def (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::IDLType_ptr _tao_retval = CORBA::IDLType::_nil ();
+  CORBA::IDLType_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_element_type_def",
+      21,
+      0,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::ArrayDef::TAO_ClientRequestInfo_CORBA_ArrayDef_element_type_def_get ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::IDLType_ptr _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+void _TAO_ArrayDef_Remote_Proxy_Impl::element_type_def (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::IDLType_ptr element_type_def,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW (CORBA::INTERNAL ());
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_set_element_type_def",
+      21,
+      1,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::ArrayDef::TAO_ClientRequestInfo_CORBA_ArrayDef_element_type_def_set ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        element_type_def,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK;
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK;
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK;
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK;
+          
+          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+          if (!(
+                            (_tao_out << element_type_def)
+            ))
+            TAO_INTERCEPTOR_THROW (
+              CORBA::MARSHAL ()
+            );
+            
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK;
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)
+              );
+              
+            }
+          
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK;
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK;
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  
+}
+
+
+//
+//            End  Base & Remote  Proxy Implemeentation. 
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//           Remote & Base  Proxy Broker Implementation
+//
+
+_TAO_ArrayDef_Proxy_Broker::_TAO_ArrayDef_Proxy_Broker (void)
+{
+}
+
+_TAO_ArrayDef_Proxy_Broker::~_TAO_ArrayDef_Proxy_Broker (void)
+{
+}
+
+_TAO_ArrayDef_Proxy_Broker * (*CORBA__TAO_ArrayDef_Proxy_Broker_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  ) = 0;
+
+// Factory Member function Implementation.
+_TAO_ArrayDef_Remote_Proxy_Broker *
+_TAO_ArrayDef_Remote_Proxy_Broker::the_TAO_ArrayDef_Remote_Proxy_Broker (void)
+{
+  static ::_TAO_ArrayDef_Remote_Proxy_Broker remote_proxy_broker;
+  return &remote_proxy_broker;
+}
+
+_TAO_ArrayDef_Remote_Proxy_Broker::_TAO_ArrayDef_Remote_Proxy_Broker (void)
+{
+}
+
+_TAO_ArrayDef_Remote_Proxy_Broker::~_TAO_ArrayDef_Remote_Proxy_Broker (void)
+{
+}
+
+_TAO_ArrayDef_Proxy_Impl&
+_TAO_ArrayDef_Remote_Proxy_Broker::select_proxy (
+  ::CORBA_ArrayDef *,
+  CORBA::Environment &
+)
+{
+  return this->remote_proxy_impl_;
+}
+
+
+//
+//           End Remote & Base Proxy Broker Implementation
+///////////////////////////////////////////////////////////////////////
+
+
+// default constructor
+CORBA::ArrayDef::ArrayDef (int collocated)
+{
+  this->CORBA_ArrayDef_setup_collocation (collocated);
+}
+
+// destructor
+CORBA::ArrayDef::~ArrayDef (void)
+{}
+
+void
+CORBA::ArrayDef::CORBA_ArrayDef_setup_collocation (int collocated)
+{
+  if (collocated)
+    this->the_TAO_ArrayDef_Proxy_Broker_ =
+      ::CORBA__TAO_ArrayDef_Proxy_Broker_Factory_function_pointer (this);
+  else
+    this->the_TAO_ArrayDef_Proxy_Broker_ =
+      ::_TAO_ArrayDef_Remote_Proxy_Broker::the_TAO_ArrayDef_Remote_Proxy_Broker ();
+  
+  this->CORBA_IDLType_setup_collocation (collocated);
+}
+
+void CORBA::ArrayDef::_tao_any_destructor (void *x)
+{
+  CORBA_ArrayDef *tmp = ACE_static_cast (CORBA_ArrayDef*,x);
+  CORBA::release (tmp);
+}
+
+CORBA::ArrayDef_ptr CORBA::ArrayDef::_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+{
+  if (CORBA::is_nil (obj))
+    return CORBA::ArrayDef::_nil ();
+  if (! obj->_is_local ())
+    {
+      CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/CORBA/ArrayDef:1.0", ACE_TRY_ENV);
+      ACE_CHECK_RETURN (CORBA::ArrayDef::_nil ());
+      if (is_a == 0)
+        return CORBA::ArrayDef::_nil ();
+    }
+  return CORBA::ArrayDef::_unchecked_narrow (obj, ACE_TRY_ENV);
+}
+
+CORBA::ArrayDef_ptr CORBA::ArrayDef::_unchecked_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &
+  )
+{
+  if (CORBA::is_nil (obj))
+    return CORBA::ArrayDef::_nil ();
+  if (! obj->_is_local ())
+    {
+      TAO_Stub* stub = obj->_stubobj ();
+      if (stub)
+        stub->_incr_refcnt ();
+      CORBA::ArrayDef_ptr default_proxy = CORBA::ArrayDef::_nil ();
+
+      if (
+          !CORBA::is_nil (stub->servant_orb_var ().ptr ()) &&
+          stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects () &&
+          obj->_is_collocated () &&CORBA__TAO_ArrayDef_Proxy_Broker_Factory_function_pointer != 0
+        )
+      {
+        ACE_NEW_RETURN (
+          default_proxy,
+          ::CORBA::ArrayDef (
+            stub,
+            1,
+            obj->_servant ()),
+            
+          CORBA::ArrayDef::_nil ());
+        }
+      if (CORBA::is_nil (default_proxy))
+        ACE_NEW_RETURN (default_proxy, ::CORBA::ArrayDef (stub, 0, obj->_servant ()), CORBA::ArrayDef::_nil ());
+        return default_proxy;
+      }
+    else 
+      return
+        ACE_reinterpret_cast
+          (
+            CORBA_ArrayDef_ptr,
+              obj->_tao_QueryInterface
+                (
+                  ACE_reinterpret_cast
+                    (
+                      ptr_arith_t,
+                      &CORBA_ArrayDef::_narrow
+                    )
+                )
+          );
+}
+
+CORBA::ArrayDef_ptr
+CORBA::ArrayDef::_duplicate (CORBA::ArrayDef_ptr obj)
+{
+  if (!CORBA::is_nil (obj))
+    obj->_add_ref ();
+  return obj;
+}
+
+CORBA::Boolean CORBA::ArrayDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
+{
+  if (
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/ArrayDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IDLType:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
+  return 1; // success using local knowledge
+  else
+    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
+}
+
+void *CORBA::ArrayDef::_tao_QueryInterface (ptr_arith_t type)
+{
+  void *retv = 0;
+  if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      CORBA_ArrayDef::_narrow))
+    retv = ACE_reinterpret_cast (void*, this);
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::IDLType::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::IDLType_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::IRObject::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::IRObject_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
+    retv = ACE_reinterpret_cast (void *,
+      ACE_static_cast (CORBA::Object_ptr, this));
+    
+  if (retv)
+    this->_add_ref ();
+  return retv;
+}
+
+const char* CORBA::ArrayDef::_interface_repository_id (void) const
+{
+  return "IDL:omg.org/CORBA/ArrayDef:1.0";
+}
+
+CORBA::ULong CORBA::ArrayDef::length (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_ArrayDef_Proxy_Impl &proxy = 
+    this->the_TAO_ArrayDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.length (
+      this,
+      ACE_TRY_ENV
+    );
+}
+
+void CORBA::ArrayDef::length (
+    CORBA::ULong length,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_ArrayDef_Proxy_Impl &proxy = 
+    this->the_TAO_ArrayDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK;
+  
+  proxy.length (
+      this,
+      length,
+      ACE_TRY_ENV
+    );
+}
+
+CORBA::TypeCode_ptr CORBA::ArrayDef::element_type (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_ArrayDef_Proxy_Impl &proxy = 
+    this->the_TAO_ArrayDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.element_type (
+      this,
+      ACE_TRY_ENV
+    );
+}
+
+CORBA::IDLType_ptr CORBA::ArrayDef::element_type_def (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_ArrayDef_Proxy_Impl &proxy = 
+    this->the_TAO_ArrayDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.element_type_def (
+      this,
+      ACE_TRY_ENV
+    );
+}
+
+void CORBA::ArrayDef::element_type_def (
+    CORBA::IDLType_ptr element_type_def,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_ArrayDef_Proxy_Impl &proxy = 
+    this->the_TAO_ArrayDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK;
+  
+  proxy.element_type_def (
+      this,
+      element_type_def,
+      ACE_TRY_ENV
+    );
+}
+
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+CORBA::ArrayDef::TAO_ClientRequestInfo_CORBA_ArrayDef_length_get::TAO_ClientRequestInfo_CORBA_ArrayDef_length_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
+{}
+
+Dynamic::ParameterList *
+CORBA::ArrayDef::TAO_ClientRequestInfo_CORBA_ArrayDef_length_get::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return parameter_list;
+}
+
+Dynamic::ExceptionList *
+CORBA::ArrayDef::TAO_ClientRequestInfo_CORBA_ArrayDef_length_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::ArrayDef::TAO_ClientRequestInfo_CORBA_ArrayDef_length_get::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+CORBA::ArrayDef::TAO_ClientRequestInfo_CORBA_ArrayDef_length_get::result (CORBA::ULong result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+CORBA::ArrayDef::TAO_ClientRequestInfo_CORBA_ArrayDef_length_set::TAO_ClientRequestInfo_CORBA_ArrayDef_length_set (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const CORBA::ULong & length,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
+    length_ (length)
+{}
+
+Dynamic::ParameterList *
+CORBA::ArrayDef::TAO_ClientRequestInfo_CORBA_ArrayDef_length_set::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
+    
+  CORBA::ULong length_length = parameter_list->length ();
+  parameter_list->length (length_length + 1);
+  (*parameter_list)[length_length].argument <<= length_;
+  (*parameter_list)[length_length].mode = Dynamic::PARAM_IN;
+  
+  return safe_parameter_list._retn ();
+}
+
+Dynamic::ExceptionList *
+CORBA::ArrayDef::TAO_ClientRequestInfo_CORBA_ArrayDef_length_set::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::ArrayDef::TAO_ClientRequestInfo_CORBA_ArrayDef_length_set::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 1;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return result_any;
+}
+
+CORBA::ArrayDef::TAO_ClientRequestInfo_CORBA_ArrayDef_element_type_get::TAO_ClientRequestInfo_CORBA_ArrayDef_element_type_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
+{}
+
+Dynamic::ParameterList *
+CORBA::ArrayDef::TAO_ClientRequestInfo_CORBA_ArrayDef_element_type_get::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return parameter_list;
+}
+
+Dynamic::ExceptionList *
+CORBA::ArrayDef::TAO_ClientRequestInfo_CORBA_ArrayDef_element_type_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::ArrayDef::TAO_ClientRequestInfo_CORBA_ArrayDef_element_type_get::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+CORBA::ArrayDef::TAO_ClientRequestInfo_CORBA_ArrayDef_element_type_get::result (CORBA::TypeCode_ptr result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+CORBA::ArrayDef::TAO_ClientRequestInfo_CORBA_ArrayDef_element_type_def_get::TAO_ClientRequestInfo_CORBA_ArrayDef_element_type_def_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
+{}
+
+Dynamic::ParameterList *
+CORBA::ArrayDef::TAO_ClientRequestInfo_CORBA_ArrayDef_element_type_def_get::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return parameter_list;
+}
+
+Dynamic::ExceptionList *
+CORBA::ArrayDef::TAO_ClientRequestInfo_CORBA_ArrayDef_element_type_def_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::ArrayDef::TAO_ClientRequestInfo_CORBA_ArrayDef_element_type_def_get::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+CORBA::ArrayDef::TAO_ClientRequestInfo_CORBA_ArrayDef_element_type_def_get::result (CORBA::IDLType_ptr result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+CORBA::ArrayDef::TAO_ClientRequestInfo_CORBA_ArrayDef_element_type_def_set::TAO_ClientRequestInfo_CORBA_ArrayDef_element_type_def_set (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::IDLType_ptr element_type_def,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
+    element_type_def_ (element_type_def)
+{}
+
+Dynamic::ParameterList *
+CORBA::ArrayDef::TAO_ClientRequestInfo_CORBA_ArrayDef_element_type_def_set::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
+    
+  CORBA::ULong length_element_type_def = parameter_list->length ();
+  parameter_list->length (length_element_type_def + 1);
+  (*parameter_list)[length_element_type_def].argument <<=  this->element_type_def_;
+  
+  (*parameter_list)[length_element_type_def].mode = Dynamic::PARAM_IN;
+  
+  return safe_parameter_list._retn ();
+}
+
+Dynamic::ExceptionList *
+CORBA::ArrayDef::TAO_ClientRequestInfo_CORBA_ArrayDef_element_type_def_set::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::ArrayDef::TAO_ClientRequestInfo_CORBA_ArrayDef_element_type_def_set::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 1;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return result_any;
+}
+
+#endif /* TAO_HAS_INTERCEPTORS */
+
+///////////////////////////////////////////////////////////////////////
+//                Base & Remote Proxy  Implementation. 
+//
+
+_TAO_ExceptionDef_Proxy_Impl::_TAO_ExceptionDef_Proxy_Impl (void)
+{}
+
+_TAO_ExceptionDef_Remote_Proxy_Impl::_TAO_ExceptionDef_Remote_Proxy_Impl (void)
+{}
+
+// Remote Implementation of the IDL interface methods
+
+CORBA::TypeCode_ptr _TAO_ExceptionDef_Remote_Proxy_Impl::type (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::TypeCode_ptr _tao_retval = CORBA::TypeCode::_nil ();
+  CORBA::TypeCode_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_type",
+      9,
+      0,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::ExceptionDef::TAO_ClientRequestInfo_CORBA_ExceptionDef_type_get ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::TypeCode_ptr _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+CORBA::StructMemberSeq * _TAO_ExceptionDef_Remote_Proxy_Impl::members (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::StructMemberSeq *_tao_retval = 0;
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  ACE_NEW_RETURN (_tao_retval, CORBA::StructMemberSeq, _tao_retval);
+  CORBA::StructMemberSeq_var _tao_safe_retval (_tao_retval);
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_members",
+      12,
+      0,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::ExceptionDef::TAO_ClientRequestInfo_CORBA_ExceptionDef_members_get ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::StructMemberSeq * _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+void _TAO_ExceptionDef_Remote_Proxy_Impl::members (
+    CORBA_Object *_collocated_tao_target_,
+    const CORBA::StructMemberSeq & members,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW (CORBA::INTERNAL ());
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_set_members",
+      12,
+      1,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::ExceptionDef::TAO_ClientRequestInfo_CORBA_ExceptionDef_members_set ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        members,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK;
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK;
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK;
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK;
+          
+          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+          if (!(
+                            (_tao_out << members)
+            ))
+            TAO_INTERCEPTOR_THROW (
+              CORBA::MARSHAL ()
+            );
+            
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK;
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)
+              );
+              
+            }
+          
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK;
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK;
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  
+}
+
+
+//
+//            End  Base & Remote  Proxy Implemeentation. 
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//           Remote & Base  Proxy Broker Implementation
+//
+
+_TAO_ExceptionDef_Proxy_Broker::_TAO_ExceptionDef_Proxy_Broker (void)
+{
+}
+
+_TAO_ExceptionDef_Proxy_Broker::~_TAO_ExceptionDef_Proxy_Broker (void)
+{
+}
+
+_TAO_ExceptionDef_Proxy_Broker * (*CORBA__TAO_ExceptionDef_Proxy_Broker_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  ) = 0;
+
+// Factory Member function Implementation.
+_TAO_ExceptionDef_Remote_Proxy_Broker *
+_TAO_ExceptionDef_Remote_Proxy_Broker::the_TAO_ExceptionDef_Remote_Proxy_Broker (void)
+{
+  static ::_TAO_ExceptionDef_Remote_Proxy_Broker remote_proxy_broker;
+  return &remote_proxy_broker;
+}
+
+_TAO_ExceptionDef_Remote_Proxy_Broker::_TAO_ExceptionDef_Remote_Proxy_Broker (void)
+{
+}
+
+_TAO_ExceptionDef_Remote_Proxy_Broker::~_TAO_ExceptionDef_Remote_Proxy_Broker (void)
+{
+}
+
+_TAO_ExceptionDef_Proxy_Impl&
+_TAO_ExceptionDef_Remote_Proxy_Broker::select_proxy (
+  ::CORBA_ExceptionDef *,
+  CORBA::Environment &
+)
+{
+  return this->remote_proxy_impl_;
+}
+
+
+//
+//           End Remote & Base Proxy Broker Implementation
+///////////////////////////////////////////////////////////////////////
+
+
+// default constructor
+CORBA::ExceptionDef::ExceptionDef (int collocated)
+{
+  this->CORBA_ExceptionDef_setup_collocation (collocated);
+}
+
+// destructor
+CORBA::ExceptionDef::~ExceptionDef (void)
+{}
+
+void
+CORBA::ExceptionDef::CORBA_ExceptionDef_setup_collocation (int collocated)
+{
+  if (collocated)
+    this->the_TAO_ExceptionDef_Proxy_Broker_ =
+      ::CORBA__TAO_ExceptionDef_Proxy_Broker_Factory_function_pointer (this);
+  else
+    this->the_TAO_ExceptionDef_Proxy_Broker_ =
+      ::_TAO_ExceptionDef_Remote_Proxy_Broker::the_TAO_ExceptionDef_Remote_Proxy_Broker ();
+  
+  this->CORBA_Contained_setup_collocation (collocated);
+  
+  this->CORBA_Container_setup_collocation (collocated);
+}
+
+void CORBA::ExceptionDef::_tao_any_destructor (void *x)
+{
+  CORBA_ExceptionDef *tmp = ACE_static_cast (CORBA_ExceptionDef*,x);
+  CORBA::release (tmp);
+}
+
+CORBA::ExceptionDef_ptr CORBA::ExceptionDef::_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+{
+  if (CORBA::is_nil (obj))
+    return CORBA::ExceptionDef::_nil ();
+  if (! obj->_is_local ())
+    {
+      CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/CORBA/ExceptionDef:1.0", ACE_TRY_ENV);
+      ACE_CHECK_RETURN (CORBA::ExceptionDef::_nil ());
+      if (is_a == 0)
+        return CORBA::ExceptionDef::_nil ();
+    }
+  return CORBA::ExceptionDef::_unchecked_narrow (obj, ACE_TRY_ENV);
+}
+
+CORBA::ExceptionDef_ptr CORBA::ExceptionDef::_unchecked_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &
+  )
+{
+  if (CORBA::is_nil (obj))
+    return CORBA::ExceptionDef::_nil ();
+  if (! obj->_is_local ())
+    {
+      TAO_Stub* stub = obj->_stubobj ();
+      if (stub)
+        stub->_incr_refcnt ();
+      CORBA::ExceptionDef_ptr default_proxy = CORBA::ExceptionDef::_nil ();
+
+      if (
+          !CORBA::is_nil (stub->servant_orb_var ().ptr ()) &&
+          stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects () &&
+          obj->_is_collocated () &&CORBA__TAO_ExceptionDef_Proxy_Broker_Factory_function_pointer != 0
+        )
+      {
+        ACE_NEW_RETURN (
+          default_proxy,
+          ::CORBA::ExceptionDef (
+            stub,
+            1,
+            obj->_servant ()),
+            
+          CORBA::ExceptionDef::_nil ());
+        }
+      if (CORBA::is_nil (default_proxy))
+        ACE_NEW_RETURN (default_proxy, ::CORBA::ExceptionDef (stub, 0, obj->_servant ()), CORBA::ExceptionDef::_nil ());
+        return default_proxy;
+      }
+    else 
+      return
+        ACE_reinterpret_cast
+          (
+            CORBA_ExceptionDef_ptr,
+              obj->_tao_QueryInterface
+                (
+                  ACE_reinterpret_cast
+                    (
+                      ptr_arith_t,
+                      &CORBA_ExceptionDef::_narrow
+                    )
+                )
+          );
+}
+
+CORBA::ExceptionDef_ptr
+CORBA::ExceptionDef::_duplicate (CORBA::ExceptionDef_ptr obj)
+{
+  if (!CORBA::is_nil (obj))
+    obj->_add_ref ();
+  return obj;
+}
+
+CORBA::Boolean CORBA::ExceptionDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
+{
+  if (
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/ExceptionDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Contained:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Container:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
+  return 1; // success using local knowledge
+  else
+    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
+}
+
+void *CORBA::ExceptionDef::_tao_QueryInterface (ptr_arith_t type)
+{
+  void *retv = 0;
+  if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      CORBA_ExceptionDef::_narrow))
+    retv = ACE_reinterpret_cast (void*, this);
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::Contained::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::Contained_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::Container::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::Container_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::IRObject::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::IRObject_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
+    retv = ACE_reinterpret_cast (void *,
+      ACE_static_cast (CORBA::Object_ptr, this));
+    
+  if (retv)
+    this->_add_ref ();
+  return retv;
+}
+
+const char* CORBA::ExceptionDef::_interface_repository_id (void) const
+{
+  return "IDL:omg.org/CORBA/ExceptionDef:1.0";
+}
+
+CORBA::TypeCode_ptr CORBA::ExceptionDef::type (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_ExceptionDef_Proxy_Impl &proxy = 
+    this->the_TAO_ExceptionDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.type (
+      this,
+      ACE_TRY_ENV
+    );
+}
+
+CORBA::StructMemberSeq * CORBA::ExceptionDef::members (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_ExceptionDef_Proxy_Impl &proxy = 
+    this->the_TAO_ExceptionDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.members (
+      this,
+      ACE_TRY_ENV
+    );
+}
+
+void CORBA::ExceptionDef::members (
+    const CORBA::StructMemberSeq & members,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_ExceptionDef_Proxy_Impl &proxy = 
+    this->the_TAO_ExceptionDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK;
+  
+  proxy.members (
+      this,
+      members,
+      ACE_TRY_ENV
+    );
+}
+
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+CORBA::ExceptionDef::TAO_ClientRequestInfo_CORBA_ExceptionDef_type_get::TAO_ClientRequestInfo_CORBA_ExceptionDef_type_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
+{}
+
+Dynamic::ParameterList *
+CORBA::ExceptionDef::TAO_ClientRequestInfo_CORBA_ExceptionDef_type_get::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return parameter_list;
+}
+
+Dynamic::ExceptionList *
+CORBA::ExceptionDef::TAO_ClientRequestInfo_CORBA_ExceptionDef_type_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::ExceptionDef::TAO_ClientRequestInfo_CORBA_ExceptionDef_type_get::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+CORBA::ExceptionDef::TAO_ClientRequestInfo_CORBA_ExceptionDef_type_get::result (CORBA::TypeCode_ptr result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+CORBA::ExceptionDef::TAO_ClientRequestInfo_CORBA_ExceptionDef_members_get::TAO_ClientRequestInfo_CORBA_ExceptionDef_members_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
+{}
+
+Dynamic::ParameterList *
+CORBA::ExceptionDef::TAO_ClientRequestInfo_CORBA_ExceptionDef_members_get::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return parameter_list;
+}
+
+Dynamic::ExceptionList *
+CORBA::ExceptionDef::TAO_ClientRequestInfo_CORBA_ExceptionDef_members_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::ExceptionDef::TAO_ClientRequestInfo_CORBA_ExceptionDef_members_get::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+CORBA::ExceptionDef::TAO_ClientRequestInfo_CORBA_ExceptionDef_members_get::result (CORBA::StructMemberSeq * result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+CORBA::ExceptionDef::TAO_ClientRequestInfo_CORBA_ExceptionDef_members_set::TAO_ClientRequestInfo_CORBA_ExceptionDef_members_set (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const CORBA::StructMemberSeq & members,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
+    members_ (members)
+{}
+
+Dynamic::ParameterList *
+CORBA::ExceptionDef::TAO_ClientRequestInfo_CORBA_ExceptionDef_members_set::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
+    
+  CORBA::ULong length_members = parameter_list->length ();
+  parameter_list->length (length_members + 1);
+  (*parameter_list)[length_members].argument <<=  this->members_;
+  
+  (*parameter_list)[length_members].mode = Dynamic::PARAM_IN;
+  
+  return safe_parameter_list._retn ();
+}
+
+Dynamic::ExceptionList *
+CORBA::ExceptionDef::TAO_ClientRequestInfo_CORBA_ExceptionDef_members_set::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::ExceptionDef::TAO_ClientRequestInfo_CORBA_ExceptionDef_members_set::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 1;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return result_any;
+}
+
+#endif /* TAO_HAS_INTERCEPTORS */
+
+void CORBA::ExceptionDescription::_tao_any_destructor (void *x)
+{
+  CORBA_ExceptionDescription *tmp = ACE_static_cast (CORBA_ExceptionDescription*,x);
+  delete tmp;
+}
+
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_EXCEPTIONDEFSEQ_CS_)
+#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_EXCEPTIONDEFSEQ_CS_
+
+  // The Base_Sequence functions, please see tao/Sequence.h
+  void
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::_allocate_buffer (CORBA::ULong length)
+  {
+    CORBA::ExceptionDef **tmp = 0;
+    tmp = _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::allocbuf (length);
+    
+    if (this->buffer_ != 0)
+    {
+      CORBA::ExceptionDef **old = ACE_reinterpret_cast (CORBA::ExceptionDef**, this->buffer_);
+      for (CORBA::ULong i = 0; i < this->length_; ++i)
+        if (!this->release_)
+          tmp[i] = CORBA::ExceptionDef::_duplicate (old[i]);
+        else
+          tmp[i] = old[i];
+        
+      if (this->release_)
+        delete[] old;
+      
+    }
+    this->buffer_ = tmp;
+  }
+  
+  void
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::_deallocate_buffer (void)
+  {
+    if (this->buffer_ == 0 || this->release_ == 0)
+      return;
+    CORBA::ExceptionDef **tmp = ACE_reinterpret_cast (CORBA::ExceptionDef**, this->buffer_);
+    for (CORBA::ULong i = 0; i < this->length_; ++i)
+    {
+      CORBA::release (tmp[i]);
+      tmp[i] = CORBA::ExceptionDef::_nil ();
+    }
+    _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::freebuf (tmp);
+    this->buffer_ = 0;
+  }
+  
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::~_TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq (void)
+  {
+    this->_deallocate_buffer ();
+  }
+  
+  void
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::_shrink_buffer (CORBA::ULong nl, CORBA::ULong ol)
+  {
+    CORBA::ExceptionDef **tmp = ACE_reinterpret_cast (CORBA::ExceptionDef**, this->buffer_);
+    
+    for (CORBA::ULong i = nl; i < ol; ++i)
+    {
+      CORBA::release (tmp[i]);
+      tmp[i] = CORBA::ExceptionDef::_nil ();
+    }
+  }
+  void 
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::_downcast (
+      void* target,
+      CORBA_Object *src,
+      CORBA_Environment &ACE_TRY_ENV
+    )
+  {
+    CORBA::ExceptionDef **tmp = ACE_static_cast (CORBA::ExceptionDef**, target);
+    *tmp = CORBA::ExceptionDef::_narrow (src, ACE_TRY_ENV);
+    ACE_CHECK;
+  }
+
+  CORBA_Object*
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::_upcast (void *src) const
+  {
+    CORBA::ExceptionDef **tmp = ACE_static_cast (CORBA::ExceptionDef**, src);
+    return *tmp;
+  }
+  
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_CORBA_EXCEPTIONDEFSEQ_CS_)
+#define _CORBA_EXCEPTIONDEFSEQ_CS_
+
+// *************************************************************
+// CORBA_ExceptionDefSeq
+// *************************************************************
+
+CORBA_ExceptionDefSeq::CORBA_ExceptionDefSeq (void)
+{}
+CORBA_ExceptionDefSeq::CORBA_ExceptionDefSeq (CORBA::ULong max) // uses max size
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<CORBA::ExceptionDef,CORBA::ExceptionDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (max)
+{}
+CORBA_ExceptionDefSeq::CORBA_ExceptionDefSeq (CORBA::ULong max, CORBA::ULong length, CORBA::ExceptionDef_ptr *buffer, CORBA::Boolean release)
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<CORBA::ExceptionDef,CORBA::ExceptionDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (max, length, buffer, release)
+{}
+CORBA_ExceptionDefSeq::CORBA_ExceptionDefSeq (const CORBA_ExceptionDefSeq &seq) // copy ctor
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<CORBA::ExceptionDef,CORBA::ExceptionDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (seq)
+{}
+CORBA_ExceptionDefSeq::~CORBA_ExceptionDefSeq (void) // dtor
+{}
+void CORBA_ExceptionDefSeq::_tao_any_destructor (void *x)
+{
+  CORBA_ExceptionDefSeq *tmp = ACE_static_cast (CORBA_ExceptionDefSeq*,x);
+  delete tmp;
+}
+
+
+#endif /* end #if !defined */
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_SEQUENCE_CORBA_EXCDESCRIPTIONSEQ_CS_)
+#define __TAO_UNBOUNDED_SEQUENCE_CORBA_EXCDESCRIPTIONSEQ_CS_
+
+  void
+  CORBA::_TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::_allocate_buffer (CORBA::ULong length)
+  {
+    CORBA::ExceptionDescription* tmp = 0;
+    tmp = _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::allocbuf (length);
+    
+    if (this->buffer_ != 0)
+    {
+      CORBA::ExceptionDescription *old = ACE_reinterpret_cast (CORBA::ExceptionDescription *,this->buffer_);
+      
+      for (CORBA::ULong i = 0; i < this->length_; ++i)
+        tmp[i] = old[i];
+      
+      if (this->release_)
+        _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::freebuf (old);
+      
+    }
+    this->buffer_ = tmp;
+  }
+  
+  void
+  CORBA::_TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::_deallocate_buffer (void)
+  {
+    if (this->buffer_ == 0 || this->release_ == 0)
+      return;
+    
+    CORBA::ExceptionDescription *tmp = ACE_reinterpret_cast (CORBA::ExceptionDescription *,this->buffer_);
+    
+    _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::freebuf (tmp);
+    this->buffer_ = 0;
+  } 
+  
+  CORBA::_TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::~_TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq (void) // Dtor.
+  {
+    this->_deallocate_buffer ();
+  }
+  
+  
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_CORBA_EXCDESCRIPTIONSEQ_CS_)
+#define _CORBA_EXCDESCRIPTIONSEQ_CS_
+
+// *************************************************************
+// CORBA_ExcDescriptionSeq
+// *************************************************************
+
+CORBA_ExcDescriptionSeq::CORBA_ExcDescriptionSeq (void)
+{}
+CORBA_ExcDescriptionSeq::CORBA_ExcDescriptionSeq (CORBA::ULong max) // uses max size
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<CORBA::ExceptionDescription>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (max)
+{}
+CORBA_ExcDescriptionSeq::CORBA_ExcDescriptionSeq (CORBA::ULong max, CORBA::ULong length, CORBA::ExceptionDescription *buffer, CORBA::Boolean release)
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<CORBA::ExceptionDescription>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (max, length, buffer, release)
+{}
+CORBA_ExcDescriptionSeq::CORBA_ExcDescriptionSeq (const CORBA_ExcDescriptionSeq &seq) // copy ctor
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<CORBA::ExceptionDescription>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (seq)
+{}
+CORBA_ExcDescriptionSeq::~CORBA_ExcDescriptionSeq (void) // dtor
+{}
+void CORBA_ExcDescriptionSeq::_tao_any_destructor (void *x)
+{
+  CORBA_ExcDescriptionSeq *tmp = ACE_static_cast (CORBA_ExcDescriptionSeq*,x);
+  delete tmp;
+}
+
+
+#endif /* end #if !defined */
+
+///////////////////////////////////////////////////////////////////////
+//                Base & Remote Proxy  Implementation. 
+//
+
+_TAO_AttributeDef_Proxy_Impl::_TAO_AttributeDef_Proxy_Impl (void)
+{}
+
+_TAO_AttributeDef_Remote_Proxy_Impl::_TAO_AttributeDef_Remote_Proxy_Impl (void)
+{}
+
+// Remote Implementation of the IDL interface methods
+
+CORBA::TypeCode_ptr _TAO_AttributeDef_Remote_Proxy_Impl::type (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::TypeCode_ptr _tao_retval = CORBA::TypeCode::_nil ();
+  CORBA::TypeCode_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_type",
+      9,
+      0,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::AttributeDef::TAO_ClientRequestInfo_CORBA_AttributeDef_type_get ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::TypeCode_ptr _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+CORBA::IDLType_ptr _TAO_AttributeDef_Remote_Proxy_Impl::type_def (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::IDLType_ptr _tao_retval = CORBA::IDLType::_nil ();
+  CORBA::IDLType_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_type_def",
+      13,
+      0,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::AttributeDef::TAO_ClientRequestInfo_CORBA_AttributeDef_type_def_get ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::IDLType_ptr _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+void _TAO_AttributeDef_Remote_Proxy_Impl::type_def (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::IDLType_ptr type_def,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW (CORBA::INTERNAL ());
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_set_type_def",
+      13,
+      1,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::AttributeDef::TAO_ClientRequestInfo_CORBA_AttributeDef_type_def_set ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        type_def,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK;
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK;
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK;
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK;
+          
+          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+          if (!(
+                            (_tao_out << type_def)
+            ))
+            TAO_INTERCEPTOR_THROW (
+              CORBA::MARSHAL ()
+            );
+            
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK;
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)
+              );
+              
+            }
+          
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK;
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK;
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  
+}
+
+CORBA::AttributeMode _TAO_AttributeDef_Remote_Proxy_Impl::mode (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::AttributeMode _tao_retval = (CORBA::AttributeMode)0;
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), _tao_retval);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_mode",
+      9,
+      0,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::AttributeDef::TAO_ClientRequestInfo_CORBA_AttributeDef_mode_get ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN  (_tao_retval);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                _tao_retval
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_retval)
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                _tao_retval
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::AttributeMode  _tao_retval_info = _tao_retval;
+               ri.result (_tao_retval_info);
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN  (_tao_retval);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_retval;
+}
+
+void _TAO_AttributeDef_Remote_Proxy_Impl::mode (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::AttributeMode mode,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW (CORBA::INTERNAL ());
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_set_mode",
+      9,
+      1,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::AttributeDef::TAO_ClientRequestInfo_CORBA_AttributeDef_mode_set ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        mode,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK;
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK;
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK;
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK;
+          
+          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+          if (!(
+                            (_tao_out << mode)
+            ))
+            TAO_INTERCEPTOR_THROW (
+              CORBA::MARSHAL ()
+            );
+            
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK;
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)
+              );
+              
+            }
+          
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK;
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK;
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  
+}
+
+
+//
+//            End  Base & Remote  Proxy Implemeentation. 
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//           Remote & Base  Proxy Broker Implementation
+//
+
+_TAO_AttributeDef_Proxy_Broker::_TAO_AttributeDef_Proxy_Broker (void)
+{
+}
+
+_TAO_AttributeDef_Proxy_Broker::~_TAO_AttributeDef_Proxy_Broker (void)
+{
+}
+
+_TAO_AttributeDef_Proxy_Broker * (*CORBA__TAO_AttributeDef_Proxy_Broker_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  ) = 0;
+
+// Factory Member function Implementation.
+_TAO_AttributeDef_Remote_Proxy_Broker *
+_TAO_AttributeDef_Remote_Proxy_Broker::the_TAO_AttributeDef_Remote_Proxy_Broker (void)
+{
+  static ::_TAO_AttributeDef_Remote_Proxy_Broker remote_proxy_broker;
+  return &remote_proxy_broker;
+}
+
+_TAO_AttributeDef_Remote_Proxy_Broker::_TAO_AttributeDef_Remote_Proxy_Broker (void)
+{
+}
+
+_TAO_AttributeDef_Remote_Proxy_Broker::~_TAO_AttributeDef_Remote_Proxy_Broker (void)
+{
+}
+
+_TAO_AttributeDef_Proxy_Impl&
+_TAO_AttributeDef_Remote_Proxy_Broker::select_proxy (
+  ::CORBA_AttributeDef *,
+  CORBA::Environment &
+)
+{
+  return this->remote_proxy_impl_;
+}
+
+
+//
+//           End Remote & Base Proxy Broker Implementation
+///////////////////////////////////////////////////////////////////////
+
+
+// default constructor
+CORBA::AttributeDef::AttributeDef (int collocated)
+{
+  this->CORBA_AttributeDef_setup_collocation (collocated);
+}
+
+// destructor
+CORBA::AttributeDef::~AttributeDef (void)
+{}
+
+void
+CORBA::AttributeDef::CORBA_AttributeDef_setup_collocation (int collocated)
+{
+  if (collocated)
+    this->the_TAO_AttributeDef_Proxy_Broker_ =
+      ::CORBA__TAO_AttributeDef_Proxy_Broker_Factory_function_pointer (this);
+  else
+    this->the_TAO_AttributeDef_Proxy_Broker_ =
+      ::_TAO_AttributeDef_Remote_Proxy_Broker::the_TAO_AttributeDef_Remote_Proxy_Broker ();
+  
+  this->CORBA_Contained_setup_collocation (collocated);
+}
+
+void CORBA::AttributeDef::_tao_any_destructor (void *x)
+{
+  CORBA_AttributeDef *tmp = ACE_static_cast (CORBA_AttributeDef*,x);
+  CORBA::release (tmp);
+}
+
+CORBA::AttributeDef_ptr CORBA::AttributeDef::_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+{
+  if (CORBA::is_nil (obj))
+    return CORBA::AttributeDef::_nil ();
+  if (! obj->_is_local ())
+    {
+      CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/CORBA/AttributeDef:1.0", ACE_TRY_ENV);
+      ACE_CHECK_RETURN (CORBA::AttributeDef::_nil ());
+      if (is_a == 0)
+        return CORBA::AttributeDef::_nil ();
+    }
+  return CORBA::AttributeDef::_unchecked_narrow (obj, ACE_TRY_ENV);
+}
+
+CORBA::AttributeDef_ptr CORBA::AttributeDef::_unchecked_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &
+  )
+{
+  if (CORBA::is_nil (obj))
+    return CORBA::AttributeDef::_nil ();
+  if (! obj->_is_local ())
+    {
+      TAO_Stub* stub = obj->_stubobj ();
+      if (stub)
+        stub->_incr_refcnt ();
+      CORBA::AttributeDef_ptr default_proxy = CORBA::AttributeDef::_nil ();
+
+      if (
+          !CORBA::is_nil (stub->servant_orb_var ().ptr ()) &&
+          stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects () &&
+          obj->_is_collocated () &&CORBA__TAO_AttributeDef_Proxy_Broker_Factory_function_pointer != 0
+        )
+      {
+        ACE_NEW_RETURN (
+          default_proxy,
+          ::CORBA::AttributeDef (
+            stub,
+            1,
+            obj->_servant ()),
+            
+          CORBA::AttributeDef::_nil ());
+        }
+      if (CORBA::is_nil (default_proxy))
+        ACE_NEW_RETURN (default_proxy, ::CORBA::AttributeDef (stub, 0, obj->_servant ()), CORBA::AttributeDef::_nil ());
+        return default_proxy;
+      }
+    else 
+      return
+        ACE_reinterpret_cast
+          (
+            CORBA_AttributeDef_ptr,
+              obj->_tao_QueryInterface
+                (
+                  ACE_reinterpret_cast
+                    (
+                      ptr_arith_t,
+                      &CORBA_AttributeDef::_narrow
+                    )
+                )
+          );
+}
+
+CORBA::AttributeDef_ptr
+CORBA::AttributeDef::_duplicate (CORBA::AttributeDef_ptr obj)
+{
+  if (!CORBA::is_nil (obj))
+    obj->_add_ref ();
+  return obj;
+}
+
+CORBA::Boolean CORBA::AttributeDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
+{
+  if (
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/AttributeDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Contained:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
+  return 1; // success using local knowledge
+  else
+    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
+}
+
+void *CORBA::AttributeDef::_tao_QueryInterface (ptr_arith_t type)
+{
+  void *retv = 0;
+  if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      CORBA_AttributeDef::_narrow))
+    retv = ACE_reinterpret_cast (void*, this);
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::Contained::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::Contained_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::IRObject::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::IRObject_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
+    retv = ACE_reinterpret_cast (void *,
+      ACE_static_cast (CORBA::Object_ptr, this));
+    
+  if (retv)
+    this->_add_ref ();
+  return retv;
+}
+
+const char* CORBA::AttributeDef::_interface_repository_id (void) const
+{
+  return "IDL:omg.org/CORBA/AttributeDef:1.0";
+}
+
+CORBA::TypeCode_ptr CORBA::AttributeDef::type (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_AttributeDef_Proxy_Impl &proxy = 
+    this->the_TAO_AttributeDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.type (
+      this,
+      ACE_TRY_ENV
+    );
+}
+
+CORBA::IDLType_ptr CORBA::AttributeDef::type_def (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_AttributeDef_Proxy_Impl &proxy = 
+    this->the_TAO_AttributeDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.type_def (
+      this,
+      ACE_TRY_ENV
+    );
+}
+
+void CORBA::AttributeDef::type_def (
+    CORBA::IDLType_ptr type_def,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_AttributeDef_Proxy_Impl &proxy = 
+    this->the_TAO_AttributeDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK;
+  
+  proxy.type_def (
+      this,
+      type_def,
+      ACE_TRY_ENV
+    );
+}
+
+CORBA::AttributeMode CORBA::AttributeDef::mode (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_AttributeDef_Proxy_Impl &proxy = 
+    this->the_TAO_AttributeDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN ((CORBA::AttributeMode)0);
+  
+  return proxy.mode (
+      this,
+      ACE_TRY_ENV
+    );
+}
+
+void CORBA::AttributeDef::mode (
+    CORBA::AttributeMode mode,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_AttributeDef_Proxy_Impl &proxy = 
+    this->the_TAO_AttributeDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK;
+  
+  proxy.mode (
+      this,
+      mode,
+      ACE_TRY_ENV
+    );
+}
+
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+CORBA::AttributeDef::TAO_ClientRequestInfo_CORBA_AttributeDef_type_get::TAO_ClientRequestInfo_CORBA_AttributeDef_type_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
+{}
+
+Dynamic::ParameterList *
+CORBA::AttributeDef::TAO_ClientRequestInfo_CORBA_AttributeDef_type_get::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return parameter_list;
+}
+
+Dynamic::ExceptionList *
+CORBA::AttributeDef::TAO_ClientRequestInfo_CORBA_AttributeDef_type_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::AttributeDef::TAO_ClientRequestInfo_CORBA_AttributeDef_type_get::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+CORBA::AttributeDef::TAO_ClientRequestInfo_CORBA_AttributeDef_type_get::result (CORBA::TypeCode_ptr result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+CORBA::AttributeDef::TAO_ClientRequestInfo_CORBA_AttributeDef_type_def_get::TAO_ClientRequestInfo_CORBA_AttributeDef_type_def_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
+{}
+
+Dynamic::ParameterList *
+CORBA::AttributeDef::TAO_ClientRequestInfo_CORBA_AttributeDef_type_def_get::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return parameter_list;
+}
+
+Dynamic::ExceptionList *
+CORBA::AttributeDef::TAO_ClientRequestInfo_CORBA_AttributeDef_type_def_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::AttributeDef::TAO_ClientRequestInfo_CORBA_AttributeDef_type_def_get::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+CORBA::AttributeDef::TAO_ClientRequestInfo_CORBA_AttributeDef_type_def_get::result (CORBA::IDLType_ptr result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+CORBA::AttributeDef::TAO_ClientRequestInfo_CORBA_AttributeDef_type_def_set::TAO_ClientRequestInfo_CORBA_AttributeDef_type_def_set (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::IDLType_ptr type_def,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
+    type_def_ (type_def)
+{}
+
+Dynamic::ParameterList *
+CORBA::AttributeDef::TAO_ClientRequestInfo_CORBA_AttributeDef_type_def_set::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
+    
+  CORBA::ULong length_type_def = parameter_list->length ();
+  parameter_list->length (length_type_def + 1);
+  (*parameter_list)[length_type_def].argument <<=  this->type_def_;
+  
+  (*parameter_list)[length_type_def].mode = Dynamic::PARAM_IN;
+  
+  return safe_parameter_list._retn ();
+}
+
+Dynamic::ExceptionList *
+CORBA::AttributeDef::TAO_ClientRequestInfo_CORBA_AttributeDef_type_def_set::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::AttributeDef::TAO_ClientRequestInfo_CORBA_AttributeDef_type_def_set::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 1;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return result_any;
+}
+
+CORBA::AttributeDef::TAO_ClientRequestInfo_CORBA_AttributeDef_mode_get::TAO_ClientRequestInfo_CORBA_AttributeDef_mode_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
+{}
+
+Dynamic::ParameterList *
+CORBA::AttributeDef::TAO_ClientRequestInfo_CORBA_AttributeDef_mode_get::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return parameter_list;
+}
+
+Dynamic::ExceptionList *
+CORBA::AttributeDef::TAO_ClientRequestInfo_CORBA_AttributeDef_mode_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::AttributeDef::TAO_ClientRequestInfo_CORBA_AttributeDef_mode_get::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+CORBA::AttributeDef::TAO_ClientRequestInfo_CORBA_AttributeDef_mode_get::result (CORBA::AttributeMode result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+CORBA::AttributeDef::TAO_ClientRequestInfo_CORBA_AttributeDef_mode_set::TAO_ClientRequestInfo_CORBA_AttributeDef_mode_set (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::AttributeMode & mode,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
+    mode_ (mode)
+{}
+
+Dynamic::ParameterList *
+CORBA::AttributeDef::TAO_ClientRequestInfo_CORBA_AttributeDef_mode_set::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
+    
+  CORBA::ULong length_mode = parameter_list->length ();
+  parameter_list->length (length_mode + 1);
+  (*parameter_list)[length_mode].argument <<=  this->mode_;
+  
+  (*parameter_list)[length_mode].mode = Dynamic::PARAM_IN;
+  
+  return safe_parameter_list._retn ();
+}
+
+Dynamic::ExceptionList *
+CORBA::AttributeDef::TAO_ClientRequestInfo_CORBA_AttributeDef_mode_set::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::AttributeDef::TAO_ClientRequestInfo_CORBA_AttributeDef_mode_set::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 1;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return result_any;
+}
+
+#endif /* TAO_HAS_INTERCEPTORS */
+
+void CORBA::AttributeDescription::_tao_any_destructor (void *x)
+{
+  CORBA_AttributeDescription *tmp = ACE_static_cast (CORBA_AttributeDescription*,x);
+  delete tmp;
+}
+
+void CORBA::ParameterDescription::_tao_any_destructor (void *x)
+{
+  CORBA_ParameterDescription *tmp = ACE_static_cast (CORBA_ParameterDescription*,x);
+  delete tmp;
+}
+
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_SEQUENCE_CORBA_PARDESCRIPTIONSEQ_CS_)
+#define __TAO_UNBOUNDED_SEQUENCE_CORBA_PARDESCRIPTIONSEQ_CS_
+
+  void
+  CORBA::_TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::_allocate_buffer (CORBA::ULong length)
+  {
+    CORBA::ParameterDescription* tmp = 0;
+    tmp = _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::allocbuf (length);
+    
+    if (this->buffer_ != 0)
+    {
+      CORBA::ParameterDescription *old = ACE_reinterpret_cast (CORBA::ParameterDescription *,this->buffer_);
+      
+      for (CORBA::ULong i = 0; i < this->length_; ++i)
+        tmp[i] = old[i];
+      
+      if (this->release_)
+        _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::freebuf (old);
+      
+    }
+    this->buffer_ = tmp;
+  }
+  
+  void
+  CORBA::_TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::_deallocate_buffer (void)
+  {
+    if (this->buffer_ == 0 || this->release_ == 0)
+      return;
+    
+    CORBA::ParameterDescription *tmp = ACE_reinterpret_cast (CORBA::ParameterDescription *,this->buffer_);
+    
+    _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::freebuf (tmp);
+    this->buffer_ = 0;
+  } 
+  
+  CORBA::_TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::~_TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq (void) // Dtor.
+  {
+    this->_deallocate_buffer ();
+  }
+  
+  
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_CORBA_PARDESCRIPTIONSEQ_CS_)
+#define _CORBA_PARDESCRIPTIONSEQ_CS_
+
+// *************************************************************
+// CORBA_ParDescriptionSeq
+// *************************************************************
+
+CORBA_ParDescriptionSeq::CORBA_ParDescriptionSeq (void)
+{}
+CORBA_ParDescriptionSeq::CORBA_ParDescriptionSeq (CORBA::ULong max) // uses max size
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<CORBA::ParameterDescription>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (max)
+{}
+CORBA_ParDescriptionSeq::CORBA_ParDescriptionSeq (CORBA::ULong max, CORBA::ULong length, CORBA::ParameterDescription *buffer, CORBA::Boolean release)
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<CORBA::ParameterDescription>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (max, length, buffer, release)
+{}
+CORBA_ParDescriptionSeq::CORBA_ParDescriptionSeq (const CORBA_ParDescriptionSeq &seq) // copy ctor
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<CORBA::ParameterDescription>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (seq)
+{}
+CORBA_ParDescriptionSeq::~CORBA_ParDescriptionSeq (void) // dtor
+{}
+void CORBA_ParDescriptionSeq::_tao_any_destructor (void *x)
+{
+  CORBA_ParDescriptionSeq *tmp = ACE_static_cast (CORBA_ParDescriptionSeq*,x);
+  delete tmp;
+}
+
+
+#endif /* end #if !defined */
+
+#if !defined (_CORBA_CONTEXTIDSEQ_CS_)
+#define _CORBA_CONTEXTIDSEQ_CS_
+
+// *************************************************************
+// CORBA_ContextIdSeq
+// *************************************************************
+
+CORBA_ContextIdSeq::CORBA_ContextIdSeq (void)
+{}
+CORBA_ContextIdSeq::CORBA_ContextIdSeq (CORBA::ULong max) // uses max size
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  TAO_Unbounded_String_Sequence
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_String_Sequence
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (max)
+{}
+CORBA_ContextIdSeq::CORBA_ContextIdSeq (CORBA::ULong max, CORBA::ULong length, char * *buffer, CORBA::Boolean release)
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  TAO_Unbounded_String_Sequence
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_String_Sequence
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (max, length, buffer, release)
+{}
+CORBA_ContextIdSeq::CORBA_ContextIdSeq (const CORBA_ContextIdSeq &seq) // copy ctor
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  TAO_Unbounded_String_Sequence
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_String_Sequence
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (seq)
+{}
+CORBA_ContextIdSeq::~CORBA_ContextIdSeq (void) // dtor
+{}
+void CORBA_ContextIdSeq::_tao_any_destructor (void *x)
+{
+  CORBA_ContextIdSeq *tmp = ACE_static_cast (CORBA_ContextIdSeq*,x);
+  delete tmp;
+}
+
+
+#endif /* end #if !defined */
+
+///////////////////////////////////////////////////////////////////////
+//                Base & Remote Proxy  Implementation. 
+//
+
+_TAO_OperationDef_Proxy_Impl::_TAO_OperationDef_Proxy_Impl (void)
+{}
+
+_TAO_OperationDef_Remote_Proxy_Impl::_TAO_OperationDef_Remote_Proxy_Impl (void)
+{}
+
+// Remote Implementation of the IDL interface methods
+
+CORBA::TypeCode_ptr _TAO_OperationDef_Remote_Proxy_Impl::result (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::TypeCode_ptr _tao_retval = CORBA::TypeCode::_nil ();
+  CORBA::TypeCode_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_result",
+      11,
+      0,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::OperationDef::TAO_ClientRequestInfo_CORBA_OperationDef_result_get ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::TypeCode_ptr _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+CORBA::IDLType_ptr _TAO_OperationDef_Remote_Proxy_Impl::result_def (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::IDLType_ptr _tao_retval = CORBA::IDLType::_nil ();
+  CORBA::IDLType_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_result_def",
+      15,
+      0,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::OperationDef::TAO_ClientRequestInfo_CORBA_OperationDef_result_def_get ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::IDLType_ptr _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+void _TAO_OperationDef_Remote_Proxy_Impl::result_def (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::IDLType_ptr result_def,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW (CORBA::INTERNAL ());
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_set_result_def",
+      15,
+      1,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::OperationDef::TAO_ClientRequestInfo_CORBA_OperationDef_result_def_set ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        result_def,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK;
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK;
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK;
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK;
+          
+          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+          if (!(
+                            (_tao_out << result_def)
+            ))
+            TAO_INTERCEPTOR_THROW (
+              CORBA::MARSHAL ()
+            );
+            
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK;
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)
+              );
+              
+            }
+          
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK;
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK;
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  
+}
+
+CORBA::ParDescriptionSeq * _TAO_OperationDef_Remote_Proxy_Impl::params (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::ParDescriptionSeq *_tao_retval = 0;
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  ACE_NEW_RETURN (_tao_retval, CORBA::ParDescriptionSeq, _tao_retval);
+  CORBA::ParDescriptionSeq_var _tao_safe_retval (_tao_retval);
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_params",
+      11,
+      0,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::OperationDef::TAO_ClientRequestInfo_CORBA_OperationDef_params_get ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::ParDescriptionSeq * _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+void _TAO_OperationDef_Remote_Proxy_Impl::params (
+    CORBA_Object *_collocated_tao_target_,
+    const CORBA::ParDescriptionSeq & params,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW (CORBA::INTERNAL ());
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_set_params",
+      11,
+      1,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::OperationDef::TAO_ClientRequestInfo_CORBA_OperationDef_params_set ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        params,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK;
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK;
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK;
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK;
+          
+          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+          if (!(
+                            (_tao_out << params)
+            ))
+            TAO_INTERCEPTOR_THROW (
+              CORBA::MARSHAL ()
+            );
+            
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK;
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)
+              );
+              
+            }
+          
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK;
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK;
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  
+}
+
+CORBA::OperationMode _TAO_OperationDef_Remote_Proxy_Impl::mode (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::OperationMode _tao_retval = (CORBA::OperationMode)0;
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), _tao_retval);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_mode",
+      9,
+      0,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::OperationDef::TAO_ClientRequestInfo_CORBA_OperationDef_mode_get ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN  (_tao_retval);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                _tao_retval
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_retval)
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                _tao_retval
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::OperationMode  _tao_retval_info = _tao_retval;
+               ri.result (_tao_retval_info);
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN  (_tao_retval);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_retval;
+}
+
+void _TAO_OperationDef_Remote_Proxy_Impl::mode (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::OperationMode mode,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW (CORBA::INTERNAL ());
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_set_mode",
+      9,
+      1,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::OperationDef::TAO_ClientRequestInfo_CORBA_OperationDef_mode_set ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        mode,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK;
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK;
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK;
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK;
+          
+          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+          if (!(
+                            (_tao_out << mode)
+            ))
+            TAO_INTERCEPTOR_THROW (
+              CORBA::MARSHAL ()
+            );
+            
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK;
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)
+              );
+              
+            }
+          
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK;
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK;
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  
+}
+
+CORBA::ContextIdSeq * _TAO_OperationDef_Remote_Proxy_Impl::contexts (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::ContextIdSeq *_tao_retval = 0;
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  ACE_NEW_RETURN (_tao_retval, CORBA::ContextIdSeq, _tao_retval);
+  CORBA::ContextIdSeq_var _tao_safe_retval (_tao_retval);
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_contexts",
+      13,
+      0,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::OperationDef::TAO_ClientRequestInfo_CORBA_OperationDef_contexts_get ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::ContextIdSeq * _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+void _TAO_OperationDef_Remote_Proxy_Impl::contexts (
+    CORBA_Object *_collocated_tao_target_,
+    const CORBA::ContextIdSeq & contexts,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW (CORBA::INTERNAL ());
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_set_contexts",
+      13,
+      1,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::OperationDef::TAO_ClientRequestInfo_CORBA_OperationDef_contexts_set ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        contexts,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK;
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK;
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK;
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK;
+          
+          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+          if (!(
+                            (_tao_out << contexts)
+            ))
+            TAO_INTERCEPTOR_THROW (
+              CORBA::MARSHAL ()
+            );
+            
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK;
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)
+              );
+              
+            }
+          
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK;
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK;
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  
+}
+
+CORBA::ExceptionDefSeq * _TAO_OperationDef_Remote_Proxy_Impl::exceptions (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::ExceptionDefSeq *_tao_retval = 0;
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  ACE_NEW_RETURN (_tao_retval, CORBA::ExceptionDefSeq, _tao_retval);
+  CORBA::ExceptionDefSeq_var _tao_safe_retval (_tao_retval);
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_exceptions",
+      15,
+      0,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::OperationDef::TAO_ClientRequestInfo_CORBA_OperationDef_exceptions_get ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::ExceptionDefSeq * _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+void _TAO_OperationDef_Remote_Proxy_Impl::exceptions (
+    CORBA_Object *_collocated_tao_target_,
+    const CORBA::ExceptionDefSeq & exceptions,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW (CORBA::INTERNAL ());
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_set_exceptions",
+      15,
+      1,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::OperationDef::TAO_ClientRequestInfo_CORBA_OperationDef_exceptions_set ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        exceptions,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK;
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK;
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK;
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK;
+          
+          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+          if (!(
+                            (_tao_out << exceptions)
+            ))
+            TAO_INTERCEPTOR_THROW (
+              CORBA::MARSHAL ()
+            );
+            
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK;
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)
+              );
+              
+            }
+          
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK;
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK;
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  
+}
+
+
+//
+//            End  Base & Remote  Proxy Implemeentation. 
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//           Remote & Base  Proxy Broker Implementation
+//
+
+_TAO_OperationDef_Proxy_Broker::_TAO_OperationDef_Proxy_Broker (void)
+{
+}
+
+_TAO_OperationDef_Proxy_Broker::~_TAO_OperationDef_Proxy_Broker (void)
+{
+}
+
+_TAO_OperationDef_Proxy_Broker * (*CORBA__TAO_OperationDef_Proxy_Broker_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  ) = 0;
+
+// Factory Member function Implementation.
+_TAO_OperationDef_Remote_Proxy_Broker *
+_TAO_OperationDef_Remote_Proxy_Broker::the_TAO_OperationDef_Remote_Proxy_Broker (void)
+{
+  static ::_TAO_OperationDef_Remote_Proxy_Broker remote_proxy_broker;
+  return &remote_proxy_broker;
+}
+
+_TAO_OperationDef_Remote_Proxy_Broker::_TAO_OperationDef_Remote_Proxy_Broker (void)
+{
+}
+
+_TAO_OperationDef_Remote_Proxy_Broker::~_TAO_OperationDef_Remote_Proxy_Broker (void)
+{
+}
+
+_TAO_OperationDef_Proxy_Impl&
+_TAO_OperationDef_Remote_Proxy_Broker::select_proxy (
+  ::CORBA_OperationDef *,
+  CORBA::Environment &
+)
+{
+  return this->remote_proxy_impl_;
+}
+
+
+//
+//           End Remote & Base Proxy Broker Implementation
+///////////////////////////////////////////////////////////////////////
+
+
+// default constructor
+CORBA::OperationDef::OperationDef (int collocated)
+{
+  this->CORBA_OperationDef_setup_collocation (collocated);
+}
+
+// destructor
+CORBA::OperationDef::~OperationDef (void)
+{}
+
+void
+CORBA::OperationDef::CORBA_OperationDef_setup_collocation (int collocated)
+{
+  if (collocated)
+    this->the_TAO_OperationDef_Proxy_Broker_ =
+      ::CORBA__TAO_OperationDef_Proxy_Broker_Factory_function_pointer (this);
+  else
+    this->the_TAO_OperationDef_Proxy_Broker_ =
+      ::_TAO_OperationDef_Remote_Proxy_Broker::the_TAO_OperationDef_Remote_Proxy_Broker ();
+  
+  this->CORBA_Contained_setup_collocation (collocated);
+}
+
+void CORBA::OperationDef::_tao_any_destructor (void *x)
+{
+  CORBA_OperationDef *tmp = ACE_static_cast (CORBA_OperationDef*,x);
+  CORBA::release (tmp);
+}
+
+CORBA::OperationDef_ptr CORBA::OperationDef::_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+{
+  if (CORBA::is_nil (obj))
+    return CORBA::OperationDef::_nil ();
+  if (! obj->_is_local ())
+    {
+      CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/CORBA/OperationDef:1.0", ACE_TRY_ENV);
+      ACE_CHECK_RETURN (CORBA::OperationDef::_nil ());
+      if (is_a == 0)
+        return CORBA::OperationDef::_nil ();
+    }
+  return CORBA::OperationDef::_unchecked_narrow (obj, ACE_TRY_ENV);
+}
+
+CORBA::OperationDef_ptr CORBA::OperationDef::_unchecked_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &
+  )
+{
+  if (CORBA::is_nil (obj))
+    return CORBA::OperationDef::_nil ();
+  if (! obj->_is_local ())
+    {
+      TAO_Stub* stub = obj->_stubobj ();
+      if (stub)
+        stub->_incr_refcnt ();
+      CORBA::OperationDef_ptr default_proxy = CORBA::OperationDef::_nil ();
+
+      if (
+          !CORBA::is_nil (stub->servant_orb_var ().ptr ()) &&
+          stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects () &&
+          obj->_is_collocated () &&CORBA__TAO_OperationDef_Proxy_Broker_Factory_function_pointer != 0
+        )
+      {
+        ACE_NEW_RETURN (
+          default_proxy,
+          ::CORBA::OperationDef (
+            stub,
+            1,
+            obj->_servant ()),
+            
+          CORBA::OperationDef::_nil ());
+        }
+      if (CORBA::is_nil (default_proxy))
+        ACE_NEW_RETURN (default_proxy, ::CORBA::OperationDef (stub, 0, obj->_servant ()), CORBA::OperationDef::_nil ());
+        return default_proxy;
+      }
+    else 
+      return
+        ACE_reinterpret_cast
+          (
+            CORBA_OperationDef_ptr,
+              obj->_tao_QueryInterface
+                (
+                  ACE_reinterpret_cast
+                    (
+                      ptr_arith_t,
+                      &CORBA_OperationDef::_narrow
+                    )
+                )
+          );
+}
+
+CORBA::OperationDef_ptr
+CORBA::OperationDef::_duplicate (CORBA::OperationDef_ptr obj)
+{
+  if (!CORBA::is_nil (obj))
+    obj->_add_ref ();
+  return obj;
+}
+
+CORBA::Boolean CORBA::OperationDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
+{
+  if (
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/OperationDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Contained:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
+  return 1; // success using local knowledge
+  else
+    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
+}
+
+void *CORBA::OperationDef::_tao_QueryInterface (ptr_arith_t type)
+{
+  void *retv = 0;
+  if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      CORBA_OperationDef::_narrow))
+    retv = ACE_reinterpret_cast (void*, this);
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::Contained::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::Contained_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::IRObject::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::IRObject_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
+    retv = ACE_reinterpret_cast (void *,
+      ACE_static_cast (CORBA::Object_ptr, this));
+    
+  if (retv)
+    this->_add_ref ();
+  return retv;
+}
+
+const char* CORBA::OperationDef::_interface_repository_id (void) const
+{
+  return "IDL:omg.org/CORBA/OperationDef:1.0";
+}
+
+CORBA::TypeCode_ptr CORBA::OperationDef::result (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_OperationDef_Proxy_Impl &proxy = 
+    this->the_TAO_OperationDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.result (
+      this,
+      ACE_TRY_ENV
+    );
+}
+
+CORBA::IDLType_ptr CORBA::OperationDef::result_def (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_OperationDef_Proxy_Impl &proxy = 
+    this->the_TAO_OperationDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.result_def (
+      this,
+      ACE_TRY_ENV
+    );
+}
+
+void CORBA::OperationDef::result_def (
+    CORBA::IDLType_ptr result_def,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_OperationDef_Proxy_Impl &proxy = 
+    this->the_TAO_OperationDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK;
+  
+  proxy.result_def (
+      this,
+      result_def,
+      ACE_TRY_ENV
+    );
+}
+
+CORBA::ParDescriptionSeq * CORBA::OperationDef::params (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_OperationDef_Proxy_Impl &proxy = 
+    this->the_TAO_OperationDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.params (
+      this,
+      ACE_TRY_ENV
+    );
+}
+
+void CORBA::OperationDef::params (
+    const CORBA::ParDescriptionSeq & params,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_OperationDef_Proxy_Impl &proxy = 
+    this->the_TAO_OperationDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK;
+  
+  proxy.params (
+      this,
+      params,
+      ACE_TRY_ENV
+    );
+}
+
+CORBA::OperationMode CORBA::OperationDef::mode (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_OperationDef_Proxy_Impl &proxy = 
+    this->the_TAO_OperationDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN ((CORBA::OperationMode)0);
+  
+  return proxy.mode (
+      this,
+      ACE_TRY_ENV
+    );
+}
+
+void CORBA::OperationDef::mode (
+    CORBA::OperationMode mode,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_OperationDef_Proxy_Impl &proxy = 
+    this->the_TAO_OperationDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK;
+  
+  proxy.mode (
+      this,
+      mode,
+      ACE_TRY_ENV
+    );
+}
+
+CORBA::ContextIdSeq * CORBA::OperationDef::contexts (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_OperationDef_Proxy_Impl &proxy = 
+    this->the_TAO_OperationDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.contexts (
+      this,
+      ACE_TRY_ENV
+    );
+}
+
+void CORBA::OperationDef::contexts (
+    const CORBA::ContextIdSeq & contexts,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_OperationDef_Proxy_Impl &proxy = 
+    this->the_TAO_OperationDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK;
+  
+  proxy.contexts (
+      this,
+      contexts,
+      ACE_TRY_ENV
+    );
+}
+
+CORBA::ExceptionDefSeq * CORBA::OperationDef::exceptions (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_OperationDef_Proxy_Impl &proxy = 
+    this->the_TAO_OperationDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.exceptions (
+      this,
+      ACE_TRY_ENV
+    );
+}
+
+void CORBA::OperationDef::exceptions (
+    const CORBA::ExceptionDefSeq & exceptions,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_OperationDef_Proxy_Impl &proxy = 
+    this->the_TAO_OperationDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK;
+  
+  proxy.exceptions (
+      this,
+      exceptions,
+      ACE_TRY_ENV
+    );
+}
+
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+CORBA::OperationDef::TAO_ClientRequestInfo_CORBA_OperationDef_result_get::TAO_ClientRequestInfo_CORBA_OperationDef_result_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
+{}
+
+Dynamic::ParameterList *
+CORBA::OperationDef::TAO_ClientRequestInfo_CORBA_OperationDef_result_get::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return parameter_list;
+}
+
+Dynamic::ExceptionList *
+CORBA::OperationDef::TAO_ClientRequestInfo_CORBA_OperationDef_result_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::OperationDef::TAO_ClientRequestInfo_CORBA_OperationDef_result_get::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+CORBA::OperationDef::TAO_ClientRequestInfo_CORBA_OperationDef_result_get::result (CORBA::TypeCode_ptr result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+CORBA::OperationDef::TAO_ClientRequestInfo_CORBA_OperationDef_result_def_get::TAO_ClientRequestInfo_CORBA_OperationDef_result_def_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
+{}
+
+Dynamic::ParameterList *
+CORBA::OperationDef::TAO_ClientRequestInfo_CORBA_OperationDef_result_def_get::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return parameter_list;
+}
+
+Dynamic::ExceptionList *
+CORBA::OperationDef::TAO_ClientRequestInfo_CORBA_OperationDef_result_def_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::OperationDef::TAO_ClientRequestInfo_CORBA_OperationDef_result_def_get::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+CORBA::OperationDef::TAO_ClientRequestInfo_CORBA_OperationDef_result_def_get::result (CORBA::IDLType_ptr result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+CORBA::OperationDef::TAO_ClientRequestInfo_CORBA_OperationDef_result_def_set::TAO_ClientRequestInfo_CORBA_OperationDef_result_def_set (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::IDLType_ptr result_def,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
+    result_def_ (result_def)
+{}
+
+Dynamic::ParameterList *
+CORBA::OperationDef::TAO_ClientRequestInfo_CORBA_OperationDef_result_def_set::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
+    
+  CORBA::ULong length_result_def = parameter_list->length ();
+  parameter_list->length (length_result_def + 1);
+  (*parameter_list)[length_result_def].argument <<=  this->result_def_;
+  
+  (*parameter_list)[length_result_def].mode = Dynamic::PARAM_IN;
+  
+  return safe_parameter_list._retn ();
+}
+
+Dynamic::ExceptionList *
+CORBA::OperationDef::TAO_ClientRequestInfo_CORBA_OperationDef_result_def_set::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::OperationDef::TAO_ClientRequestInfo_CORBA_OperationDef_result_def_set::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 1;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return result_any;
+}
+
+CORBA::OperationDef::TAO_ClientRequestInfo_CORBA_OperationDef_params_get::TAO_ClientRequestInfo_CORBA_OperationDef_params_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
+{}
+
+Dynamic::ParameterList *
+CORBA::OperationDef::TAO_ClientRequestInfo_CORBA_OperationDef_params_get::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return parameter_list;
+}
+
+Dynamic::ExceptionList *
+CORBA::OperationDef::TAO_ClientRequestInfo_CORBA_OperationDef_params_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::OperationDef::TAO_ClientRequestInfo_CORBA_OperationDef_params_get::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+CORBA::OperationDef::TAO_ClientRequestInfo_CORBA_OperationDef_params_get::result (CORBA::ParDescriptionSeq * result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+CORBA::OperationDef::TAO_ClientRequestInfo_CORBA_OperationDef_params_set::TAO_ClientRequestInfo_CORBA_OperationDef_params_set (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const CORBA::ParDescriptionSeq & params,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
+    params_ (params)
+{}
+
+Dynamic::ParameterList *
+CORBA::OperationDef::TAO_ClientRequestInfo_CORBA_OperationDef_params_set::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
+    
+  CORBA::ULong length_params = parameter_list->length ();
+  parameter_list->length (length_params + 1);
+  (*parameter_list)[length_params].argument <<=  this->params_;
+  
+  (*parameter_list)[length_params].mode = Dynamic::PARAM_IN;
+  
+  return safe_parameter_list._retn ();
+}
+
+Dynamic::ExceptionList *
+CORBA::OperationDef::TAO_ClientRequestInfo_CORBA_OperationDef_params_set::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::OperationDef::TAO_ClientRequestInfo_CORBA_OperationDef_params_set::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 1;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return result_any;
+}
+
+CORBA::OperationDef::TAO_ClientRequestInfo_CORBA_OperationDef_mode_get::TAO_ClientRequestInfo_CORBA_OperationDef_mode_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
+{}
+
+Dynamic::ParameterList *
+CORBA::OperationDef::TAO_ClientRequestInfo_CORBA_OperationDef_mode_get::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return parameter_list;
+}
+
+Dynamic::ExceptionList *
+CORBA::OperationDef::TAO_ClientRequestInfo_CORBA_OperationDef_mode_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::OperationDef::TAO_ClientRequestInfo_CORBA_OperationDef_mode_get::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+CORBA::OperationDef::TAO_ClientRequestInfo_CORBA_OperationDef_mode_get::result (CORBA::OperationMode result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+CORBA::OperationDef::TAO_ClientRequestInfo_CORBA_OperationDef_mode_set::TAO_ClientRequestInfo_CORBA_OperationDef_mode_set (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::OperationMode & mode,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
+    mode_ (mode)
+{}
+
+Dynamic::ParameterList *
+CORBA::OperationDef::TAO_ClientRequestInfo_CORBA_OperationDef_mode_set::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
+    
+  CORBA::ULong length_mode = parameter_list->length ();
+  parameter_list->length (length_mode + 1);
+  (*parameter_list)[length_mode].argument <<=  this->mode_;
+  
+  (*parameter_list)[length_mode].mode = Dynamic::PARAM_IN;
+  
+  return safe_parameter_list._retn ();
+}
+
+Dynamic::ExceptionList *
+CORBA::OperationDef::TAO_ClientRequestInfo_CORBA_OperationDef_mode_set::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::OperationDef::TAO_ClientRequestInfo_CORBA_OperationDef_mode_set::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 1;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return result_any;
+}
+
+CORBA::OperationDef::TAO_ClientRequestInfo_CORBA_OperationDef_contexts_get::TAO_ClientRequestInfo_CORBA_OperationDef_contexts_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
+{}
+
+Dynamic::ParameterList *
+CORBA::OperationDef::TAO_ClientRequestInfo_CORBA_OperationDef_contexts_get::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return parameter_list;
+}
+
+Dynamic::ExceptionList *
+CORBA::OperationDef::TAO_ClientRequestInfo_CORBA_OperationDef_contexts_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::OperationDef::TAO_ClientRequestInfo_CORBA_OperationDef_contexts_get::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+CORBA::OperationDef::TAO_ClientRequestInfo_CORBA_OperationDef_contexts_get::result (CORBA::ContextIdSeq * result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+CORBA::OperationDef::TAO_ClientRequestInfo_CORBA_OperationDef_contexts_set::TAO_ClientRequestInfo_CORBA_OperationDef_contexts_set (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const CORBA::ContextIdSeq & contexts,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
+    contexts_ (contexts)
+{}
+
+Dynamic::ParameterList *
+CORBA::OperationDef::TAO_ClientRequestInfo_CORBA_OperationDef_contexts_set::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
+    
+  CORBA::ULong length_contexts = parameter_list->length ();
+  parameter_list->length (length_contexts + 1);
+  (*parameter_list)[length_contexts].argument <<=  this->contexts_;
+  
+  (*parameter_list)[length_contexts].mode = Dynamic::PARAM_IN;
+  
+  return safe_parameter_list._retn ();
+}
+
+Dynamic::ExceptionList *
+CORBA::OperationDef::TAO_ClientRequestInfo_CORBA_OperationDef_contexts_set::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::OperationDef::TAO_ClientRequestInfo_CORBA_OperationDef_contexts_set::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 1;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return result_any;
+}
+
+CORBA::OperationDef::TAO_ClientRequestInfo_CORBA_OperationDef_exceptions_get::TAO_ClientRequestInfo_CORBA_OperationDef_exceptions_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
+{}
+
+Dynamic::ParameterList *
+CORBA::OperationDef::TAO_ClientRequestInfo_CORBA_OperationDef_exceptions_get::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return parameter_list;
+}
+
+Dynamic::ExceptionList *
+CORBA::OperationDef::TAO_ClientRequestInfo_CORBA_OperationDef_exceptions_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::OperationDef::TAO_ClientRequestInfo_CORBA_OperationDef_exceptions_get::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+CORBA::OperationDef::TAO_ClientRequestInfo_CORBA_OperationDef_exceptions_get::result (CORBA::ExceptionDefSeq * result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+CORBA::OperationDef::TAO_ClientRequestInfo_CORBA_OperationDef_exceptions_set::TAO_ClientRequestInfo_CORBA_OperationDef_exceptions_set (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const CORBA::ExceptionDefSeq & exceptions,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
+    exceptions_ (exceptions)
+{}
+
+Dynamic::ParameterList *
+CORBA::OperationDef::TAO_ClientRequestInfo_CORBA_OperationDef_exceptions_set::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
+    
+  CORBA::ULong length_exceptions = parameter_list->length ();
+  parameter_list->length (length_exceptions + 1);
+  (*parameter_list)[length_exceptions].argument <<=  this->exceptions_;
+  
+  (*parameter_list)[length_exceptions].mode = Dynamic::PARAM_IN;
+  
+  return safe_parameter_list._retn ();
+}
+
+Dynamic::ExceptionList *
+CORBA::OperationDef::TAO_ClientRequestInfo_CORBA_OperationDef_exceptions_set::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::OperationDef::TAO_ClientRequestInfo_CORBA_OperationDef_exceptions_set::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 1;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return result_any;
+}
+
+#endif /* TAO_HAS_INTERCEPTORS */
+
+void CORBA::OperationDescription::_tao_any_destructor (void *x)
+{
+  CORBA_OperationDescription *tmp = ACE_static_cast (CORBA_OperationDescription*,x);
+  delete tmp;
+}
+
+
+#if !defined (_CORBA_REPOSITORYIDSEQ_CS_)
+#define _CORBA_REPOSITORYIDSEQ_CS_
+
+// *************************************************************
+// CORBA_RepositoryIdSeq
+// *************************************************************
+
+CORBA_RepositoryIdSeq::CORBA_RepositoryIdSeq (void)
+{}
+CORBA_RepositoryIdSeq::CORBA_RepositoryIdSeq (CORBA::ULong max) // uses max size
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  TAO_Unbounded_String_Sequence
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_String_Sequence
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (max)
+{}
+CORBA_RepositoryIdSeq::CORBA_RepositoryIdSeq (CORBA::ULong max, CORBA::ULong length, char * *buffer, CORBA::Boolean release)
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  TAO_Unbounded_String_Sequence
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_String_Sequence
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (max, length, buffer, release)
+{}
+CORBA_RepositoryIdSeq::CORBA_RepositoryIdSeq (const CORBA_RepositoryIdSeq &seq) // copy ctor
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  TAO_Unbounded_String_Sequence
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_String_Sequence
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (seq)
+{}
+CORBA_RepositoryIdSeq::~CORBA_RepositoryIdSeq (void) // dtor
+{}
+void CORBA_RepositoryIdSeq::_tao_any_destructor (void *x)
+{
+  CORBA_RepositoryIdSeq *tmp = ACE_static_cast (CORBA_RepositoryIdSeq*,x);
+  delete tmp;
+}
+
+
+#endif /* end #if !defined */
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_SEQUENCE_CORBA_OPDESCRIPTIONSEQ_CS_)
+#define __TAO_UNBOUNDED_SEQUENCE_CORBA_OPDESCRIPTIONSEQ_CS_
+
+  void
+  CORBA::_TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::_allocate_buffer (CORBA::ULong length)
+  {
+    CORBA::OperationDescription* tmp = 0;
+    tmp = _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::allocbuf (length);
+    
+    if (this->buffer_ != 0)
+    {
+      CORBA::OperationDescription *old = ACE_reinterpret_cast (CORBA::OperationDescription *,this->buffer_);
+      
+      for (CORBA::ULong i = 0; i < this->length_; ++i)
+        tmp[i] = old[i];
+      
+      if (this->release_)
+        _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::freebuf (old);
+      
+    }
+    this->buffer_ = tmp;
+  }
+  
+  void
+  CORBA::_TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::_deallocate_buffer (void)
+  {
+    if (this->buffer_ == 0 || this->release_ == 0)
+      return;
+    
+    CORBA::OperationDescription *tmp = ACE_reinterpret_cast (CORBA::OperationDescription *,this->buffer_);
+    
+    _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::freebuf (tmp);
+    this->buffer_ = 0;
+  } 
+  
+  CORBA::_TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::~_TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq (void) // Dtor.
+  {
+    this->_deallocate_buffer ();
+  }
+  
+  
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_CORBA_OPDESCRIPTIONSEQ_CS_)
+#define _CORBA_OPDESCRIPTIONSEQ_CS_
+
+// *************************************************************
+// CORBA_OpDescriptionSeq
+// *************************************************************
+
+CORBA_OpDescriptionSeq::CORBA_OpDescriptionSeq (void)
+{}
+CORBA_OpDescriptionSeq::CORBA_OpDescriptionSeq (CORBA::ULong max) // uses max size
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<CORBA::OperationDescription>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (max)
+{}
+CORBA_OpDescriptionSeq::CORBA_OpDescriptionSeq (CORBA::ULong max, CORBA::ULong length, CORBA::OperationDescription *buffer, CORBA::Boolean release)
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<CORBA::OperationDescription>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (max, length, buffer, release)
+{}
+CORBA_OpDescriptionSeq::CORBA_OpDescriptionSeq (const CORBA_OpDescriptionSeq &seq) // copy ctor
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<CORBA::OperationDescription>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (seq)
+{}
+CORBA_OpDescriptionSeq::~CORBA_OpDescriptionSeq (void) // dtor
+{}
+void CORBA_OpDescriptionSeq::_tao_any_destructor (void *x)
+{
+  CORBA_OpDescriptionSeq *tmp = ACE_static_cast (CORBA_OpDescriptionSeq*,x);
+  delete tmp;
+}
+
+
+#endif /* end #if !defined */
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_SEQUENCE_CORBA_ATTRDESCRIPTIONSEQ_CS_)
+#define __TAO_UNBOUNDED_SEQUENCE_CORBA_ATTRDESCRIPTIONSEQ_CS_
+
+  void
+  CORBA::_TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::_allocate_buffer (CORBA::ULong length)
+  {
+    CORBA::AttributeDescription* tmp = 0;
+    tmp = _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::allocbuf (length);
+    
+    if (this->buffer_ != 0)
+    {
+      CORBA::AttributeDescription *old = ACE_reinterpret_cast (CORBA::AttributeDescription *,this->buffer_);
+      
+      for (CORBA::ULong i = 0; i < this->length_; ++i)
+        tmp[i] = old[i];
+      
+      if (this->release_)
+        _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::freebuf (old);
+      
+    }
+    this->buffer_ = tmp;
+  }
+  
+  void
+  CORBA::_TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::_deallocate_buffer (void)
+  {
+    if (this->buffer_ == 0 || this->release_ == 0)
+      return;
+    
+    CORBA::AttributeDescription *tmp = ACE_reinterpret_cast (CORBA::AttributeDescription *,this->buffer_);
+    
+    _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::freebuf (tmp);
+    this->buffer_ = 0;
+  } 
+  
+  CORBA::_TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::~_TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq (void) // Dtor.
+  {
+    this->_deallocate_buffer ();
+  }
+  
+  
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_CORBA_ATTRDESCRIPTIONSEQ_CS_)
+#define _CORBA_ATTRDESCRIPTIONSEQ_CS_
+
+// *************************************************************
+// CORBA_AttrDescriptionSeq
+// *************************************************************
+
+CORBA_AttrDescriptionSeq::CORBA_AttrDescriptionSeq (void)
+{}
+CORBA_AttrDescriptionSeq::CORBA_AttrDescriptionSeq (CORBA::ULong max) // uses max size
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<CORBA::AttributeDescription>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (max)
+{}
+CORBA_AttrDescriptionSeq::CORBA_AttrDescriptionSeq (CORBA::ULong max, CORBA::ULong length, CORBA::AttributeDescription *buffer, CORBA::Boolean release)
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<CORBA::AttributeDescription>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (max, length, buffer, release)
+{}
+CORBA_AttrDescriptionSeq::CORBA_AttrDescriptionSeq (const CORBA_AttrDescriptionSeq &seq) // copy ctor
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<CORBA::AttributeDescription>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (seq)
+{}
+CORBA_AttrDescriptionSeq::~CORBA_AttrDescriptionSeq (void) // dtor
+{}
+void CORBA_AttrDescriptionSeq::_tao_any_destructor (void *x)
+{
+  CORBA_AttrDescriptionSeq *tmp = ACE_static_cast (CORBA_AttrDescriptionSeq*,x);
+  delete tmp;
+}
+
+
+#endif /* end #if !defined */
+
+///////////////////////////////////////////////////////////////////////
+//                Base & Remote Proxy  Implementation. 
+//
+
+_TAO_InterfaceDef_Proxy_Impl::_TAO_InterfaceDef_Proxy_Impl (void)
+{}
+
+_TAO_InterfaceDef_Remote_Proxy_Impl::_TAO_InterfaceDef_Remote_Proxy_Impl (void)
+{}
+
+// Remote Implementation of the IDL interface methods
+
+CORBA::InterfaceDefSeq * _TAO_InterfaceDef_Remote_Proxy_Impl::base_interfaces (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::InterfaceDefSeq *_tao_retval = 0;
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  ACE_NEW_RETURN (_tao_retval, CORBA::InterfaceDefSeq, _tao_retval);
+  CORBA::InterfaceDefSeq_var _tao_safe_retval (_tao_retval);
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_base_interfaces",
+      20,
+      0,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::InterfaceDef::TAO_ClientRequestInfo_CORBA_InterfaceDef_base_interfaces_get ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::InterfaceDefSeq * _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+void _TAO_InterfaceDef_Remote_Proxy_Impl::base_interfaces (
+    CORBA_Object *_collocated_tao_target_,
+    const CORBA::InterfaceDefSeq & base_interfaces,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW (CORBA::INTERNAL ());
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_set_base_interfaces",
+      20,
+      1,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::InterfaceDef::TAO_ClientRequestInfo_CORBA_InterfaceDef_base_interfaces_set ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        base_interfaces,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK;
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK;
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK;
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK;
+          
+          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+          if (!(
+                            (_tao_out << base_interfaces)
+            ))
+            TAO_INTERCEPTOR_THROW (
+              CORBA::MARSHAL ()
+            );
+            
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK;
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)
+              );
+              
+            }
+          
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK;
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK;
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  
+}
+
+CORBA::Boolean _TAO_InterfaceDef_Remote_Proxy_Impl::is_a (
+    CORBA_Object *_collocated_tao_target_,
+    const char * interface_id,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::Boolean _tao_retval = 0;
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), _tao_retval);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "is_a",
+      4,
+      1,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::InterfaceDef::TAO_ClientRequestInfo_CORBA_InterfaceDef_is_a ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        interface_id,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN  (_tao_retval);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          
+          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+          if (!(
+                            (_tao_out << interface_id)
+            ))
+            TAO_INTERCEPTOR_THROW_RETURN (
+              CORBA::MARSHAL (),
+              _tao_retval
+            );
+            
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                _tao_retval
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> CORBA::Any::to_boolean (_tao_retval))
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                _tao_retval
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::Boolean  _tao_retval_info = _tao_retval;
+               ri.result (_tao_retval_info);
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN  (_tao_retval);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_retval;
+}
+
+CORBA::InterfaceDef::FullInterfaceDescription * _TAO_InterfaceDef_Remote_Proxy_Impl::describe_interface (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::InterfaceDef::FullInterfaceDescription *_tao_retval = 0;
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  ACE_NEW_RETURN (_tao_retval, CORBA::InterfaceDef::FullInterfaceDescription, _tao_retval);
+  CORBA::InterfaceDef::FullInterfaceDescription_var _tao_safe_retval (_tao_retval);
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "describe_interface",
+      18,
+      0,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::InterfaceDef::TAO_ClientRequestInfo_CORBA_InterfaceDef_describe_interface ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::InterfaceDef::FullInterfaceDescription * _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+CORBA::AttributeDef_ptr _TAO_InterfaceDef_Remote_Proxy_Impl::create_attribute (
+    CORBA_Object *_collocated_tao_target_,
+    const char * id,
+    const char * name,
+    const char * version,
+    CORBA::IDLType_ptr type,
+    CORBA::AttributeMode mode,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::AttributeDef_ptr _tao_retval = CORBA::AttributeDef::_nil ();
+  CORBA::AttributeDef_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "create_attribute",
+      16,
+      1,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::InterfaceDef::TAO_ClientRequestInfo_CORBA_InterfaceDef_create_attribute ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        id,
+        name,
+        version,
+        type,
+        mode,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+          if (!(
+                            (_tao_out << id) &&
+              (_tao_out << name) &&
+              (_tao_out << version) &&
+              (_tao_out << type) &&
+              (_tao_out << mode)
+            ))
+            TAO_INTERCEPTOR_THROW_RETURN (
+              CORBA::MARSHAL (),
+              0
+            );
+            
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::AttributeDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+CORBA::OperationDef_ptr _TAO_InterfaceDef_Remote_Proxy_Impl::create_operation (
+    CORBA_Object *_collocated_tao_target_,
+    const char * id,
+    const char * name,
+    const char * version,
+    CORBA::IDLType_ptr result,
+    CORBA::OperationMode mode,
+    const CORBA::ParDescriptionSeq & params,
+    const CORBA::ExceptionDefSeq & exceptions,
+    const CORBA::ContextIdSeq & contexts,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::OperationDef_ptr _tao_retval = CORBA::OperationDef::_nil ();
+  CORBA::OperationDef_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "create_operation",
+      16,
+      1,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::InterfaceDef::TAO_ClientRequestInfo_CORBA_InterfaceDef_create_operation ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        id,
+        name,
+        version,
+        result,
+        mode,
+        params,
+        exceptions,
+        contexts,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+          if (!(
+                            (_tao_out << id) &&
+              (_tao_out << name) &&
+              (_tao_out << version) &&
+              (_tao_out << result) &&
+              (_tao_out << mode) &&
+              (_tao_out << params) &&
+              (_tao_out << exceptions) &&
+              (_tao_out << contexts)
+            ))
+            TAO_INTERCEPTOR_THROW_RETURN (
+              CORBA::MARSHAL (),
+              0
+            );
+            
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::OperationDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+
+//
+//            End  Base & Remote  Proxy Implemeentation. 
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//           Remote & Base  Proxy Broker Implementation
+//
+
+_TAO_InterfaceDef_Proxy_Broker::_TAO_InterfaceDef_Proxy_Broker (void)
+{
+}
+
+_TAO_InterfaceDef_Proxy_Broker::~_TAO_InterfaceDef_Proxy_Broker (void)
+{
+}
+
+_TAO_InterfaceDef_Proxy_Broker * (*CORBA__TAO_InterfaceDef_Proxy_Broker_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  ) = 0;
+
+// Factory Member function Implementation.
+_TAO_InterfaceDef_Remote_Proxy_Broker *
+_TAO_InterfaceDef_Remote_Proxy_Broker::the_TAO_InterfaceDef_Remote_Proxy_Broker (void)
+{
+  static ::_TAO_InterfaceDef_Remote_Proxy_Broker remote_proxy_broker;
+  return &remote_proxy_broker;
+}
+
+_TAO_InterfaceDef_Remote_Proxy_Broker::_TAO_InterfaceDef_Remote_Proxy_Broker (void)
+{
+}
+
+_TAO_InterfaceDef_Remote_Proxy_Broker::~_TAO_InterfaceDef_Remote_Proxy_Broker (void)
+{
+}
+
+_TAO_InterfaceDef_Proxy_Impl&
+_TAO_InterfaceDef_Remote_Proxy_Broker::select_proxy (
+  ::CORBA_InterfaceDef *,
+  CORBA::Environment &
+)
+{
+  return this->remote_proxy_impl_;
+}
+
+
+//
+//           End Remote & Base Proxy Broker Implementation
+///////////////////////////////////////////////////////////////////////
+
+
+// default constructor
+CORBA::InterfaceDef::InterfaceDef (int collocated)
+{
+  this->CORBA_InterfaceDef_setup_collocation (collocated);
+}
+
+// destructor
+CORBA::InterfaceDef::~InterfaceDef (void)
+{}
+
+void
+CORBA::InterfaceDef::CORBA_InterfaceDef_setup_collocation (int collocated)
+{
+  if (collocated)
+    this->the_TAO_InterfaceDef_Proxy_Broker_ =
+      ::CORBA__TAO_InterfaceDef_Proxy_Broker_Factory_function_pointer (this);
+  else
+    this->the_TAO_InterfaceDef_Proxy_Broker_ =
+      ::_TAO_InterfaceDef_Remote_Proxy_Broker::the_TAO_InterfaceDef_Remote_Proxy_Broker ();
+  
+  this->CORBA_Container_setup_collocation (collocated);
+  
+  this->CORBA_Contained_setup_collocation (collocated);
+  
+  this->CORBA_IDLType_setup_collocation (collocated);
+}
+
+void CORBA::InterfaceDef::_tao_any_destructor (void *x)
+{
+  CORBA_InterfaceDef *tmp = ACE_static_cast (CORBA_InterfaceDef*,x);
+  CORBA::release (tmp);
+}
+
+CORBA::InterfaceDef_ptr CORBA::InterfaceDef::_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+{
+  if (CORBA::is_nil (obj))
+    return CORBA::InterfaceDef::_nil ();
+  if (! obj->_is_local ())
+    {
+      CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/CORBA/InterfaceDef:1.0", ACE_TRY_ENV);
+      ACE_CHECK_RETURN (CORBA::InterfaceDef::_nil ());
+      if (is_a == 0)
+        return CORBA::InterfaceDef::_nil ();
+    }
+  return CORBA::InterfaceDef::_unchecked_narrow (obj, ACE_TRY_ENV);
+}
+
+CORBA::InterfaceDef_ptr CORBA::InterfaceDef::_unchecked_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &
+  )
+{
+  if (CORBA::is_nil (obj))
+    return CORBA::InterfaceDef::_nil ();
+  if (! obj->_is_local ())
+    {
+      TAO_Stub* stub = obj->_stubobj ();
+      if (stub)
+        stub->_incr_refcnt ();
+      CORBA::InterfaceDef_ptr default_proxy = CORBA::InterfaceDef::_nil ();
+
+      if (
+          !CORBA::is_nil (stub->servant_orb_var ().ptr ()) &&
+          stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects () &&
+          obj->_is_collocated () &&CORBA__TAO_InterfaceDef_Proxy_Broker_Factory_function_pointer != 0
+        )
+      {
+        ACE_NEW_RETURN (
+          default_proxy,
+          ::CORBA::InterfaceDef (
+            stub,
+            1,
+            obj->_servant ()),
+            
+          CORBA::InterfaceDef::_nil ());
+        }
+      if (CORBA::is_nil (default_proxy))
+        ACE_NEW_RETURN (default_proxy, ::CORBA::InterfaceDef (stub, 0, obj->_servant ()), CORBA::InterfaceDef::_nil ());
+        return default_proxy;
+      }
+    else 
+      return
+        ACE_reinterpret_cast
+          (
+            CORBA_InterfaceDef_ptr,
+              obj->_tao_QueryInterface
+                (
+                  ACE_reinterpret_cast
+                    (
+                      ptr_arith_t,
+                      &CORBA_InterfaceDef::_narrow
+                    )
+                )
+          );
+}
+
+CORBA::InterfaceDef_ptr
+CORBA::InterfaceDef::_duplicate (CORBA::InterfaceDef_ptr obj)
+{
+  if (!CORBA::is_nil (obj))
+    obj->_add_ref ();
+  return obj;
+}
+
+CORBA::Boolean CORBA::InterfaceDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
+{
+  if (
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/InterfaceDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Container:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Contained:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IDLType:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
+  return 1; // success using local knowledge
+  else
+    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
+}
+
+void *CORBA::InterfaceDef::_tao_QueryInterface (ptr_arith_t type)
+{
+  void *retv = 0;
+  if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      CORBA_InterfaceDef::_narrow))
+    retv = ACE_reinterpret_cast (void*, this);
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::Container::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::Container_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::Contained::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::Contained_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::IDLType::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::IDLType_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::IRObject::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::IRObject_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
+    retv = ACE_reinterpret_cast (void *,
+      ACE_static_cast (CORBA::Object_ptr, this));
+    
+  if (retv)
+    this->_add_ref ();
+  return retv;
+}
+
+const char* CORBA::InterfaceDef::_interface_repository_id (void) const
+{
+  return "IDL:omg.org/CORBA/InterfaceDef:1.0";
+}
+
+CORBA::InterfaceDefSeq * CORBA::InterfaceDef::base_interfaces (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_InterfaceDef_Proxy_Impl &proxy = 
+    this->the_TAO_InterfaceDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.base_interfaces (
+      this,
+      ACE_TRY_ENV
+    );
+}
+
+void CORBA::InterfaceDef::base_interfaces (
+    const CORBA::InterfaceDefSeq & base_interfaces,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_InterfaceDef_Proxy_Impl &proxy = 
+    this->the_TAO_InterfaceDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK;
+  
+  proxy.base_interfaces (
+      this,
+      base_interfaces,
+      ACE_TRY_ENV
+    );
+}
+
+CORBA::Boolean CORBA::InterfaceDef::is_a (
+    const char * interface_id,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_InterfaceDef_Proxy_Impl &proxy = 
+    this->the_TAO_InterfaceDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.is_a (
+      this,
+      interface_id,
+      ACE_TRY_ENV
+    );
+}
+
+static const CORBA::Long _oc_CORBA_InterfaceDef_FullInterfaceDescription[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  60,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x434f5242), 
+  ACE_NTOHL (0x412f496e), 
+  ACE_NTOHL (0x74657266), 
+  ACE_NTOHL (0x61636544), 
+  ACE_NTOHL (0x65662f46), 
+  ACE_NTOHL (0x756c6c49), 
+  ACE_NTOHL (0x6e746572), 
+  ACE_NTOHL (0x66616365), 
+  ACE_NTOHL (0x44657363), 
+  ACE_NTOHL (0x72697074), 
+  ACE_NTOHL (0x696f6e3a), 
+  ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/InterfaceDef/FullInterfaceDescription:1.0
+  25,
+  ACE_NTOHL (0x46756c6c), 
+  ACE_NTOHL (0x496e7465), 
+  ACE_NTOHL (0x72666163), 
+  ACE_NTOHL (0x65446573), 
+  ACE_NTOHL (0x63726970), 
+  ACE_NTOHL (0x74696f6e), 
+  ACE_NTOHL (0x0),  // name = FullInterfaceDescription
+  8, // member count
+  5,
+  ACE_NTOHL (0x6e616d65), 
+  ACE_NTOHL (0x0),  // name = name
+  CORBA::tk_alias, // typecode kind for typedefs
+  68, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    33,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x434f5242), 
+    ACE_NTOHL (0x412f4964), 
+    ACE_NTOHL (0x656e7469), 
+    ACE_NTOHL (0x66696572), 
+    ACE_NTOHL (0x3a312e30), 
+    ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+    11,
+    ACE_NTOHL (0x4964656e), 
+    ACE_NTOHL (0x74696669), 
+    ACE_NTOHL (0x65720000),  // name = Identifier
+    CORBA::tk_string, 
+    0U, // string length
+
+  3,
+  ACE_NTOHL (0x69640000),  // name = id
+  CORBA::tk_alias, // typecode kind for typedefs
+  72, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    35,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x434f5242), 
+    ACE_NTOHL (0x412f5265), 
+    ACE_NTOHL (0x706f7369), 
+    ACE_NTOHL (0x746f7279), 
+    ACE_NTOHL (0x49643a31), 
+    ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+    13,
+    ACE_NTOHL (0x5265706f), 
+    ACE_NTOHL (0x7369746f), 
+    ACE_NTOHL (0x72794964), 
+    ACE_NTOHL (0x0),  // name = RepositoryId
+    CORBA::tk_string, 
+    0U, // string length
+
+  11,
+  ACE_NTOHL (0x64656669), 
+  ACE_NTOHL (0x6e65645f), 
+  ACE_NTOHL (0x696e0000),  // name = defined_in
+  CORBA::tk_alias, // typecode kind for typedefs
+  72, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    35,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x434f5242), 
+    ACE_NTOHL (0x412f5265), 
+    ACE_NTOHL (0x706f7369), 
+    ACE_NTOHL (0x746f7279), 
+    ACE_NTOHL (0x49643a31), 
+    ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+    13,
+    ACE_NTOHL (0x5265706f), 
+    ACE_NTOHL (0x7369746f), 
+    ACE_NTOHL (0x72794964), 
+    ACE_NTOHL (0x0),  // name = RepositoryId
+    CORBA::tk_string, 
+    0U, // string length
+
+  8,
+  ACE_NTOHL (0x76657273), 
+  ACE_NTOHL (0x696f6e00),  // name = version
+  CORBA::tk_alias, // typecode kind for typedefs
+  68, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    34,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x434f5242), 
+    ACE_NTOHL (0x412f5665), 
+    ACE_NTOHL (0x7273696f), 
+    ACE_NTOHL (0x6e537065), 
+    ACE_NTOHL (0x633a312e), 
+    ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/VersionSpec:1.0
+    12,
+    ACE_NTOHL (0x56657273), 
+    ACE_NTOHL (0x696f6e53), 
+    ACE_NTOHL (0x70656300),  // name = VersionSpec
+    CORBA::tk_string, 
+    0U, // string length
+
+  11,
+  ACE_NTOHL (0x6f706572), 
+  ACE_NTOHL (0x6174696f), 
+  ACE_NTOHL (0x6e730000),  // name = operations
+  CORBA::tk_alias, // typecode kind for typedefs
+  2036, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    39,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x434f5242), 
+    ACE_NTOHL (0x412f4f70), 
+    ACE_NTOHL (0x44657363), 
+    ACE_NTOHL (0x72697074), 
+    ACE_NTOHL (0x696f6e53), 
+    ACE_NTOHL (0x65713a31), 
+    ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/OpDescriptionSeq:1.0
+    17,
+    ACE_NTOHL (0x4f704465), 
+    ACE_NTOHL (0x73637269), 
+    ACE_NTOHL (0x7074696f), 
+    ACE_NTOHL (0x6e536571), 
+    ACE_NTOHL (0x0),  // name = OpDescriptionSeq
+    CORBA::tk_sequence, // typecode kind
+    1956, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      CORBA::tk_struct, // typecode kind
+      1940, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        43,
+        ACE_NTOHL (0x49444c3a), 
+        ACE_NTOHL (0x6f6d672e), 
+        ACE_NTOHL (0x6f72672f), 
+        ACE_NTOHL (0x434f5242), 
+        ACE_NTOHL (0x412f4f70), 
+        ACE_NTOHL (0x65726174), 
+        ACE_NTOHL (0x696f6e44), 
+        ACE_NTOHL (0x65736372), 
+        ACE_NTOHL (0x69707469), 
+        ACE_NTOHL (0x6f6e3a31), 
+        ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/OperationDescription:1.0
+        21,
+        ACE_NTOHL (0x4f706572), 
+        ACE_NTOHL (0x6174696f), 
+        ACE_NTOHL (0x6e446573), 
+        ACE_NTOHL (0x63726970), 
+        ACE_NTOHL (0x74696f6e), 
+        ACE_NTOHL (0x0),  // name = OperationDescription
+        9, // member count
+        5,
+        ACE_NTOHL (0x6e616d65), 
+        ACE_NTOHL (0x0),  // name = name
+        CORBA::tk_alias, // typecode kind for typedefs
+        68, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          33,
+          ACE_NTOHL (0x49444c3a), 
+          ACE_NTOHL (0x6f6d672e), 
+          ACE_NTOHL (0x6f72672f), 
+          ACE_NTOHL (0x434f5242), 
+          ACE_NTOHL (0x412f4964), 
+          ACE_NTOHL (0x656e7469), 
+          ACE_NTOHL (0x66696572), 
+          ACE_NTOHL (0x3a312e30), 
+          ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+          11,
+          ACE_NTOHL (0x4964656e), 
+          ACE_NTOHL (0x74696669), 
+          ACE_NTOHL (0x65720000),  // name = Identifier
+          CORBA::tk_string, 
+          0U, // string length
+
+        3,
+        ACE_NTOHL (0x69640000),  // name = id
+        CORBA::tk_alias, // typecode kind for typedefs
+        72, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          35,
+          ACE_NTOHL (0x49444c3a), 
+          ACE_NTOHL (0x6f6d672e), 
+          ACE_NTOHL (0x6f72672f), 
+          ACE_NTOHL (0x434f5242), 
+          ACE_NTOHL (0x412f5265), 
+          ACE_NTOHL (0x706f7369), 
+          ACE_NTOHL (0x746f7279), 
+          ACE_NTOHL (0x49643a31), 
+          ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+          13,
+          ACE_NTOHL (0x5265706f), 
+          ACE_NTOHL (0x7369746f), 
+          ACE_NTOHL (0x72794964), 
+          ACE_NTOHL (0x0),  // name = RepositoryId
+          CORBA::tk_string, 
+          0U, // string length
+
+        11,
+        ACE_NTOHL (0x64656669), 
+        ACE_NTOHL (0x6e65645f), 
+        ACE_NTOHL (0x696e0000),  // name = defined_in
+        CORBA::tk_alias, // typecode kind for typedefs
+        72, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          35,
+          ACE_NTOHL (0x49444c3a), 
+          ACE_NTOHL (0x6f6d672e), 
+          ACE_NTOHL (0x6f72672f), 
+          ACE_NTOHL (0x434f5242), 
+          ACE_NTOHL (0x412f5265), 
+          ACE_NTOHL (0x706f7369), 
+          ACE_NTOHL (0x746f7279), 
+          ACE_NTOHL (0x49643a31), 
+          ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+          13,
+          ACE_NTOHL (0x5265706f), 
+          ACE_NTOHL (0x7369746f), 
+          ACE_NTOHL (0x72794964), 
+          ACE_NTOHL (0x0),  // name = RepositoryId
+          CORBA::tk_string, 
+          0U, // string length
+
+        8,
+        ACE_NTOHL (0x76657273), 
+        ACE_NTOHL (0x696f6e00),  // name = version
+        CORBA::tk_alias, // typecode kind for typedefs
+        68, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          34,
+          ACE_NTOHL (0x49444c3a), 
+          ACE_NTOHL (0x6f6d672e), 
+          ACE_NTOHL (0x6f72672f), 
+          ACE_NTOHL (0x434f5242), 
+          ACE_NTOHL (0x412f5665), 
+          ACE_NTOHL (0x7273696f), 
+          ACE_NTOHL (0x6e537065), 
+          ACE_NTOHL (0x633a312e), 
+          ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/VersionSpec:1.0
+          12,
+          ACE_NTOHL (0x56657273), 
+          ACE_NTOHL (0x696f6e53), 
+          ACE_NTOHL (0x70656300),  // name = VersionSpec
+          CORBA::tk_string, 
+          0U, // string length
+
+        7,
+        ACE_NTOHL (0x72657375), 
+        ACE_NTOHL (0x6c740000),  // name = result
+        CORBA::tk_TypeCode,
+
+        5,
+        ACE_NTOHL (0x6d6f6465), 
+        ACE_NTOHL (0x0),  // name = mode
+        CORBA::tk_enum, // typecode kind
+        100, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          36,
+          ACE_NTOHL (0x49444c3a), 
+          ACE_NTOHL (0x6f6d672e), 
+          ACE_NTOHL (0x6f72672f), 
+          ACE_NTOHL (0x434f5242), 
+          ACE_NTOHL (0x412f4f70), 
+          ACE_NTOHL (0x65726174), 
+          ACE_NTOHL (0x696f6e4d), 
+          ACE_NTOHL (0x6f64653a), 
+          ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/OperationMode:1.0
+          14,
+          ACE_NTOHL (0x4f706572), 
+          ACE_NTOHL (0x6174696f), 
+          ACE_NTOHL (0x6e4d6f64), 
+          ACE_NTOHL (0x65000000),  // name = OperationMode
+          2, // member count
+          10,
+          ACE_NTOHL (0x4f505f4e), 
+          ACE_NTOHL (0x4f524d41), 
+          ACE_NTOHL (0x4c000000),  // name = OP_NORMAL
+          10,
+          ACE_NTOHL (0x4f505f4f), 
+          ACE_NTOHL (0x4e455741), 
+          ACE_NTOHL (0x59000000),  // name = OP_ONEWAY
+
+        9,
+        ACE_NTOHL (0x636f6e74), 
+        ACE_NTOHL (0x65787473), 
+        ACE_NTOHL (0x0),  // name = contexts
+        CORBA::tk_alias, // typecode kind for typedefs
+        236, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          35,
+          ACE_NTOHL (0x49444c3a), 
+          ACE_NTOHL (0x6f6d672e), 
+          ACE_NTOHL (0x6f72672f), 
+          ACE_NTOHL (0x434f5242), 
+          ACE_NTOHL (0x412f436f), 
+          ACE_NTOHL (0x6e746578), 
+          ACE_NTOHL (0x74496453), 
+          ACE_NTOHL (0x65713a31), 
+          ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/ContextIdSeq:1.0
+          13,
+          ACE_NTOHL (0x436f6e74), 
+          ACE_NTOHL (0x65787449), 
+          ACE_NTOHL (0x64536571), 
+          ACE_NTOHL (0x0),  // name = ContextIdSeq
+          CORBA::tk_sequence, // typecode kind
+          164, // encapsulation length
+            TAO_ENCAP_BYTE_ORDER, // byte order
+            CORBA::tk_alias, // typecode kind for typedefs
+            148, // encapsulation length
+              TAO_ENCAP_BYTE_ORDER, // byte order
+              40,
+              ACE_NTOHL (0x49444c3a), 
+              ACE_NTOHL (0x6f6d672e), 
+              ACE_NTOHL (0x6f72672f), 
+              ACE_NTOHL (0x434f5242), 
+              ACE_NTOHL (0x412f436f), 
+              ACE_NTOHL (0x6e746578), 
+              ACE_NTOHL (0x74496465), 
+              ACE_NTOHL (0x6e746966), 
+              ACE_NTOHL (0x6965723a), 
+              ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/ContextIdentifier:1.0
+              18,
+              ACE_NTOHL (0x436f6e74), 
+              ACE_NTOHL (0x65787449), 
+              ACE_NTOHL (0x64656e74), 
+              ACE_NTOHL (0x69666965), 
+              ACE_NTOHL (0x72000000),  // name = ContextIdentifier
+              CORBA::tk_alias, // typecode kind for typedefs
+              68, // encapsulation length
+                TAO_ENCAP_BYTE_ORDER, // byte order
+                33,
+                ACE_NTOHL (0x49444c3a), 
+                ACE_NTOHL (0x6f6d672e), 
+                ACE_NTOHL (0x6f72672f), 
+                ACE_NTOHL (0x434f5242), 
+                ACE_NTOHL (0x412f4964), 
+                ACE_NTOHL (0x656e7469), 
+                ACE_NTOHL (0x66696572), 
+                ACE_NTOHL (0x3a312e30), 
+                ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+                11,
+                ACE_NTOHL (0x4964656e), 
+                ACE_NTOHL (0x74696669), 
+                ACE_NTOHL (0x65720000),  // name = Identifier
+                CORBA::tk_string, 
+                0U, // string length
+
+
+            0U,
+
+
+        11,
+        ACE_NTOHL (0x70617261), 
+        ACE_NTOHL (0x6d657465), 
+        ACE_NTOHL (0x72730000),  // name = parameters
+        CORBA::tk_alias, // typecode kind for typedefs
+        496, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          40,
+          ACE_NTOHL (0x49444c3a), 
+          ACE_NTOHL (0x6f6d672e), 
+          ACE_NTOHL (0x6f72672f), 
+          ACE_NTOHL (0x434f5242), 
+          ACE_NTOHL (0x412f5061), 
+          ACE_NTOHL (0x72446573), 
+          ACE_NTOHL (0x63726970), 
+          ACE_NTOHL (0x74696f6e), 
+          ACE_NTOHL (0x5365713a), 
+          ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/ParDescriptionSeq:1.0
+          18,
+          ACE_NTOHL (0x50617244), 
+          ACE_NTOHL (0x65736372), 
+          ACE_NTOHL (0x69707469), 
+          ACE_NTOHL (0x6f6e5365), 
+          ACE_NTOHL (0x71000000),  // name = ParDescriptionSeq
+          CORBA::tk_sequence, // typecode kind
+          416, // encapsulation length
+            TAO_ENCAP_BYTE_ORDER, // byte order
+            CORBA::tk_struct, // typecode kind
+            400, // encapsulation length
+              TAO_ENCAP_BYTE_ORDER, // byte order
+              43,
+              ACE_NTOHL (0x49444c3a), 
+              ACE_NTOHL (0x6f6d672e), 
+              ACE_NTOHL (0x6f72672f), 
+              ACE_NTOHL (0x434f5242), 
+              ACE_NTOHL (0x412f5061), 
+              ACE_NTOHL (0x72616d65), 
+              ACE_NTOHL (0x74657244), 
+              ACE_NTOHL (0x65736372), 
+              ACE_NTOHL (0x69707469), 
+              ACE_NTOHL (0x6f6e3a31), 
+              ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/ParameterDescription:1.0
+              21,
+              ACE_NTOHL (0x50617261), 
+              ACE_NTOHL (0x6d657465), 
+              ACE_NTOHL (0x72446573), 
+              ACE_NTOHL (0x63726970), 
+              ACE_NTOHL (0x74696f6e), 
+              ACE_NTOHL (0x0),  // name = ParameterDescription
+              4, // member count
+              5,
+              ACE_NTOHL (0x6e616d65), 
+              ACE_NTOHL (0x0),  // name = name
+              CORBA::tk_alias, // typecode kind for typedefs
+              68, // encapsulation length
+                TAO_ENCAP_BYTE_ORDER, // byte order
+                33,
+                ACE_NTOHL (0x49444c3a), 
+                ACE_NTOHL (0x6f6d672e), 
+                ACE_NTOHL (0x6f72672f), 
+                ACE_NTOHL (0x434f5242), 
+                ACE_NTOHL (0x412f4964), 
+                ACE_NTOHL (0x656e7469), 
+                ACE_NTOHL (0x66696572), 
+                ACE_NTOHL (0x3a312e30), 
+                ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+                11,
+                ACE_NTOHL (0x4964656e), 
+                ACE_NTOHL (0x74696669), 
+                ACE_NTOHL (0x65720000),  // name = Identifier
+                CORBA::tk_string, 
+                0U, // string length
+
+              5,
+              ACE_NTOHL (0x74797065), 
+              ACE_NTOHL (0x0),  // name = type
+              CORBA::tk_TypeCode,
+
+              9,
+              ACE_NTOHL (0x74797065), 
+              ACE_NTOHL (0x5f646566), 
+              ACE_NTOHL (0x0),  // name = type_def
+              CORBA::tk_objref, // typecode kind
+              52, // encapsulation length
+                TAO_ENCAP_BYTE_ORDER, // byte order
+                30,
+                ACE_NTOHL (0x49444c3a), 
+                ACE_NTOHL (0x6f6d672e), 
+                ACE_NTOHL (0x6f72672f), 
+                ACE_NTOHL (0x434f5242), 
+                ACE_NTOHL (0x412f4944), 
+                ACE_NTOHL (0x4c547970), 
+                ACE_NTOHL (0x653a312e), 
+                ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/IDLType:1.0
+                8,
+                ACE_NTOHL (0x49444c54), 
+                ACE_NTOHL (0x79706500),  // name = IDLType
+
+              5,
+              ACE_NTOHL (0x6d6f6465), 
+              ACE_NTOHL (0x0),  // name = mode
+              CORBA::tk_enum, // typecode kind
+              116, // encapsulation length
+                TAO_ENCAP_BYTE_ORDER, // byte order
+                36,
+                ACE_NTOHL (0x49444c3a), 
+                ACE_NTOHL (0x6f6d672e), 
+                ACE_NTOHL (0x6f72672f), 
+                ACE_NTOHL (0x434f5242), 
+                ACE_NTOHL (0x412f5061), 
+                ACE_NTOHL (0x72616d65), 
+                ACE_NTOHL (0x7465724d), 
+                ACE_NTOHL (0x6f64653a), 
+                ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/ParameterMode:1.0
+                14,
+                ACE_NTOHL (0x50617261), 
+                ACE_NTOHL (0x6d657465), 
+                ACE_NTOHL (0x724d6f64), 
+                ACE_NTOHL (0x65000000),  // name = ParameterMode
+                3, // member count
+                9,
+                ACE_NTOHL (0x50415241), 
+                ACE_NTOHL (0x4d5f494e), 
+                ACE_NTOHL (0x0),  // name = PARAM_IN
+                10,
+                ACE_NTOHL (0x50415241), 
+                ACE_NTOHL (0x4d5f4f55), 
+                ACE_NTOHL (0x54000000),  // name = PARAM_OUT
+                12,
+                ACE_NTOHL (0x50415241), 
+                ACE_NTOHL (0x4d5f494e), 
+                ACE_NTOHL (0x4f555400),  // name = PARAM_INOUT
+
+
+            0U,
+
+
+        11,
+        ACE_NTOHL (0x65786365), 
+        ACE_NTOHL (0x7074696f), 
+        ACE_NTOHL (0x6e730000),  // name = exceptions
+        CORBA::tk_alias, // typecode kind for typedefs
+        556, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          40,
+          ACE_NTOHL (0x49444c3a), 
+          ACE_NTOHL (0x6f6d672e), 
+          ACE_NTOHL (0x6f72672f), 
+          ACE_NTOHL (0x434f5242), 
+          ACE_NTOHL (0x412f4578), 
+          ACE_NTOHL (0x63446573), 
+          ACE_NTOHL (0x63726970), 
+          ACE_NTOHL (0x74696f6e), 
+          ACE_NTOHL (0x5365713a), 
+          ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/ExcDescriptionSeq:1.0
+          18,
+          ACE_NTOHL (0x45786344), 
+          ACE_NTOHL (0x65736372), 
+          ACE_NTOHL (0x69707469), 
+          ACE_NTOHL (0x6f6e5365), 
+          ACE_NTOHL (0x71000000),  // name = ExcDescriptionSeq
+          CORBA::tk_sequence, // typecode kind
+          476, // encapsulation length
+            TAO_ENCAP_BYTE_ORDER, // byte order
+            CORBA::tk_struct, // typecode kind
+            460, // encapsulation length
+              TAO_ENCAP_BYTE_ORDER, // byte order
+              43,
+              ACE_NTOHL (0x49444c3a), 
+              ACE_NTOHL (0x6f6d672e), 
+              ACE_NTOHL (0x6f72672f), 
+              ACE_NTOHL (0x434f5242), 
+              ACE_NTOHL (0x412f4578), 
+              ACE_NTOHL (0x63657074), 
+              ACE_NTOHL (0x696f6e44), 
+              ACE_NTOHL (0x65736372), 
+              ACE_NTOHL (0x69707469), 
+              ACE_NTOHL (0x6f6e3a31), 
+              ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/ExceptionDescription:1.0
+              21,
+              ACE_NTOHL (0x45786365), 
+              ACE_NTOHL (0x7074696f), 
+              ACE_NTOHL (0x6e446573), 
+              ACE_NTOHL (0x63726970), 
+              ACE_NTOHL (0x74696f6e), 
+              ACE_NTOHL (0x0),  // name = ExceptionDescription
+              5, // member count
+              5,
+              ACE_NTOHL (0x6e616d65), 
+              ACE_NTOHL (0x0),  // name = name
+              CORBA::tk_alias, // typecode kind for typedefs
+              68, // encapsulation length
+                TAO_ENCAP_BYTE_ORDER, // byte order
+                33,
+                ACE_NTOHL (0x49444c3a), 
+                ACE_NTOHL (0x6f6d672e), 
+                ACE_NTOHL (0x6f72672f), 
+                ACE_NTOHL (0x434f5242), 
+                ACE_NTOHL (0x412f4964), 
+                ACE_NTOHL (0x656e7469), 
+                ACE_NTOHL (0x66696572), 
+                ACE_NTOHL (0x3a312e30), 
+                ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+                11,
+                ACE_NTOHL (0x4964656e), 
+                ACE_NTOHL (0x74696669), 
+                ACE_NTOHL (0x65720000),  // name = Identifier
+                CORBA::tk_string, 
+                0U, // string length
+
+              3,
+              ACE_NTOHL (0x69640000),  // name = id
+              CORBA::tk_alias, // typecode kind for typedefs
+              72, // encapsulation length
+                TAO_ENCAP_BYTE_ORDER, // byte order
+                35,
+                ACE_NTOHL (0x49444c3a), 
+                ACE_NTOHL (0x6f6d672e), 
+                ACE_NTOHL (0x6f72672f), 
+                ACE_NTOHL (0x434f5242), 
+                ACE_NTOHL (0x412f5265), 
+                ACE_NTOHL (0x706f7369), 
+                ACE_NTOHL (0x746f7279), 
+                ACE_NTOHL (0x49643a31), 
+                ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+                13,
+                ACE_NTOHL (0x5265706f), 
+                ACE_NTOHL (0x7369746f), 
+                ACE_NTOHL (0x72794964), 
+                ACE_NTOHL (0x0),  // name = RepositoryId
+                CORBA::tk_string, 
+                0U, // string length
+
+              11,
+              ACE_NTOHL (0x64656669), 
+              ACE_NTOHL (0x6e65645f), 
+              ACE_NTOHL (0x696e0000),  // name = defined_in
+              CORBA::tk_alias, // typecode kind for typedefs
+              72, // encapsulation length
+                TAO_ENCAP_BYTE_ORDER, // byte order
+                35,
+                ACE_NTOHL (0x49444c3a), 
+                ACE_NTOHL (0x6f6d672e), 
+                ACE_NTOHL (0x6f72672f), 
+                ACE_NTOHL (0x434f5242), 
+                ACE_NTOHL (0x412f5265), 
+                ACE_NTOHL (0x706f7369), 
+                ACE_NTOHL (0x746f7279), 
+                ACE_NTOHL (0x49643a31), 
+                ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+                13,
+                ACE_NTOHL (0x5265706f), 
+                ACE_NTOHL (0x7369746f), 
+                ACE_NTOHL (0x72794964), 
+                ACE_NTOHL (0x0),  // name = RepositoryId
+                CORBA::tk_string, 
+                0U, // string length
+
+              8,
+              ACE_NTOHL (0x76657273), 
+              ACE_NTOHL (0x696f6e00),  // name = version
+              CORBA::tk_alias, // typecode kind for typedefs
+              68, // encapsulation length
+                TAO_ENCAP_BYTE_ORDER, // byte order
+                34,
+                ACE_NTOHL (0x49444c3a), 
+                ACE_NTOHL (0x6f6d672e), 
+                ACE_NTOHL (0x6f72672f), 
+                ACE_NTOHL (0x434f5242), 
+                ACE_NTOHL (0x412f5665), 
+                ACE_NTOHL (0x7273696f), 
+                ACE_NTOHL (0x6e537065), 
+                ACE_NTOHL (0x633a312e), 
+                ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/VersionSpec:1.0
+                12,
+                ACE_NTOHL (0x56657273), 
+                ACE_NTOHL (0x696f6e53), 
+                ACE_NTOHL (0x70656300),  // name = VersionSpec
+                CORBA::tk_string, 
+                0U, // string length
+
+              5,
+              ACE_NTOHL (0x74797065), 
+              ACE_NTOHL (0x0),  // name = type
+              CORBA::tk_TypeCode,
+
+
+            0U,
+
+
+
+      0U,
+
+
+  11,
+  ACE_NTOHL (0x61747472), 
+  ACE_NTOHL (0x69627574), 
+  ACE_NTOHL (0x65730000),  // name = attributes
+  CORBA::tk_alias, // typecode kind for typedefs
+  684, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    41,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x434f5242), 
+    ACE_NTOHL (0x412f4174), 
+    ACE_NTOHL (0x74724465), 
+    ACE_NTOHL (0x73637269), 
+    ACE_NTOHL (0x7074696f), 
+    ACE_NTOHL (0x6e536571), 
+    ACE_NTOHL (0x3a312e30), 
+    ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/AttrDescriptionSeq:1.0
+    19,
+    ACE_NTOHL (0x41747472), 
+    ACE_NTOHL (0x44657363), 
+    ACE_NTOHL (0x72697074), 
+    ACE_NTOHL (0x696f6e53), 
+    ACE_NTOHL (0x65710000),  // name = AttrDescriptionSeq
+    CORBA::tk_sequence, // typecode kind
+    600, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      CORBA::tk_struct, // typecode kind
+      584, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        43,
+        ACE_NTOHL (0x49444c3a), 
+        ACE_NTOHL (0x6f6d672e), 
+        ACE_NTOHL (0x6f72672f), 
+        ACE_NTOHL (0x434f5242), 
+        ACE_NTOHL (0x412f4174), 
+        ACE_NTOHL (0x74726962), 
+        ACE_NTOHL (0x75746544), 
+        ACE_NTOHL (0x65736372), 
+        ACE_NTOHL (0x69707469), 
+        ACE_NTOHL (0x6f6e3a31), 
+        ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/AttributeDescription:1.0
+        21,
+        ACE_NTOHL (0x41747472), 
+        ACE_NTOHL (0x69627574), 
+        ACE_NTOHL (0x65446573), 
+        ACE_NTOHL (0x63726970), 
+        ACE_NTOHL (0x74696f6e), 
+        ACE_NTOHL (0x0),  // name = AttributeDescription
+        6, // member count
+        5,
+        ACE_NTOHL (0x6e616d65), 
+        ACE_NTOHL (0x0),  // name = name
+        CORBA::tk_alias, // typecode kind for typedefs
+        68, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          33,
+          ACE_NTOHL (0x49444c3a), 
+          ACE_NTOHL (0x6f6d672e), 
+          ACE_NTOHL (0x6f72672f), 
+          ACE_NTOHL (0x434f5242), 
+          ACE_NTOHL (0x412f4964), 
+          ACE_NTOHL (0x656e7469), 
+          ACE_NTOHL (0x66696572), 
+          ACE_NTOHL (0x3a312e30), 
+          ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+          11,
+          ACE_NTOHL (0x4964656e), 
+          ACE_NTOHL (0x74696669), 
+          ACE_NTOHL (0x65720000),  // name = Identifier
+          CORBA::tk_string, 
+          0U, // string length
+
+        3,
+        ACE_NTOHL (0x69640000),  // name = id
+        CORBA::tk_alias, // typecode kind for typedefs
+        72, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          35,
+          ACE_NTOHL (0x49444c3a), 
+          ACE_NTOHL (0x6f6d672e), 
+          ACE_NTOHL (0x6f72672f), 
+          ACE_NTOHL (0x434f5242), 
+          ACE_NTOHL (0x412f5265), 
+          ACE_NTOHL (0x706f7369), 
+          ACE_NTOHL (0x746f7279), 
+          ACE_NTOHL (0x49643a31), 
+          ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+          13,
+          ACE_NTOHL (0x5265706f), 
+          ACE_NTOHL (0x7369746f), 
+          ACE_NTOHL (0x72794964), 
+          ACE_NTOHL (0x0),  // name = RepositoryId
+          CORBA::tk_string, 
+          0U, // string length
+
+        11,
+        ACE_NTOHL (0x64656669), 
+        ACE_NTOHL (0x6e65645f), 
+        ACE_NTOHL (0x696e0000),  // name = defined_in
+        CORBA::tk_alias, // typecode kind for typedefs
+        72, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          35,
+          ACE_NTOHL (0x49444c3a), 
+          ACE_NTOHL (0x6f6d672e), 
+          ACE_NTOHL (0x6f72672f), 
+          ACE_NTOHL (0x434f5242), 
+          ACE_NTOHL (0x412f5265), 
+          ACE_NTOHL (0x706f7369), 
+          ACE_NTOHL (0x746f7279), 
+          ACE_NTOHL (0x49643a31), 
+          ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+          13,
+          ACE_NTOHL (0x5265706f), 
+          ACE_NTOHL (0x7369746f), 
+          ACE_NTOHL (0x72794964), 
+          ACE_NTOHL (0x0),  // name = RepositoryId
+          CORBA::tk_string, 
+          0U, // string length
+
+        8,
+        ACE_NTOHL (0x76657273), 
+        ACE_NTOHL (0x696f6e00),  // name = version
+        CORBA::tk_alias, // typecode kind for typedefs
+        68, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          34,
+          ACE_NTOHL (0x49444c3a), 
+          ACE_NTOHL (0x6f6d672e), 
+          ACE_NTOHL (0x6f72672f), 
+          ACE_NTOHL (0x434f5242), 
+          ACE_NTOHL (0x412f5665), 
+          ACE_NTOHL (0x7273696f), 
+          ACE_NTOHL (0x6e537065), 
+          ACE_NTOHL (0x633a312e), 
+          ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/VersionSpec:1.0
+          12,
+          ACE_NTOHL (0x56657273), 
+          ACE_NTOHL (0x696f6e53), 
+          ACE_NTOHL (0x70656300),  // name = VersionSpec
+          CORBA::tk_string, 
+          0U, // string length
+
+        5,
+        ACE_NTOHL (0x74797065), 
+        ACE_NTOHL (0x0),  // name = type
+        CORBA::tk_TypeCode,
+
+        5,
+        ACE_NTOHL (0x6d6f6465), 
+        ACE_NTOHL (0x0),  // name = mode
+        CORBA::tk_enum, // typecode kind
+        104, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          36,
+          ACE_NTOHL (0x49444c3a), 
+          ACE_NTOHL (0x6f6d672e), 
+          ACE_NTOHL (0x6f72672f), 
+          ACE_NTOHL (0x434f5242), 
+          ACE_NTOHL (0x412f4174), 
+          ACE_NTOHL (0x74726962), 
+          ACE_NTOHL (0x7574654d), 
+          ACE_NTOHL (0x6f64653a), 
+          ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/AttributeMode:1.0
+          14,
+          ACE_NTOHL (0x41747472), 
+          ACE_NTOHL (0x69627574), 
+          ACE_NTOHL (0x654d6f64), 
+          ACE_NTOHL (0x65000000),  // name = AttributeMode
+          2, // member count
+          12,
+          ACE_NTOHL (0x41545452), 
+          ACE_NTOHL (0x5f4e4f52), 
+          ACE_NTOHL (0x4d414c00),  // name = ATTR_NORMAL
+          14,
+          ACE_NTOHL (0x41545452), 
+          ACE_NTOHL (0x5f524541), 
+          ACE_NTOHL (0x444f4e4c), 
+          ACE_NTOHL (0x59000000),  // name = ATTR_READONLY
+
+
+      0U,
+
+
+  16,
+  ACE_NTOHL (0x62617365), 
+  ACE_NTOHL (0x5f696e74), 
+  ACE_NTOHL (0x65726661), 
+  ACE_NTOHL (0x63657300),  // name = base_interfaces
+  CORBA::tk_alias, // typecode kind for typedefs
+  164, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    38,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x434f5242), 
+    ACE_NTOHL (0x412f5265), 
+    ACE_NTOHL (0x706f7369), 
+    ACE_NTOHL (0x746f7279), 
+    ACE_NTOHL (0x49645365), 
+    ACE_NTOHL (0x713a312e), 
+    ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/RepositoryIdSeq:1.0
+    16,
+    ACE_NTOHL (0x5265706f), 
+    ACE_NTOHL (0x7369746f), 
+    ACE_NTOHL (0x72794964), 
+    ACE_NTOHL (0x53657100),  // name = RepositoryIdSeq
+    CORBA::tk_sequence, // typecode kind
+    88, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      CORBA::tk_alias, // typecode kind for typedefs
+      72, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        35,
+        ACE_NTOHL (0x49444c3a), 
+        ACE_NTOHL (0x6f6d672e), 
+        ACE_NTOHL (0x6f72672f), 
+        ACE_NTOHL (0x434f5242), 
+        ACE_NTOHL (0x412f5265), 
+        ACE_NTOHL (0x706f7369), 
+        ACE_NTOHL (0x746f7279), 
+        ACE_NTOHL (0x49643a31), 
+        ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+        13,
+        ACE_NTOHL (0x5265706f), 
+        ACE_NTOHL (0x7369746f), 
+        ACE_NTOHL (0x72794964), 
+        ACE_NTOHL (0x0),  // name = RepositoryId
+        CORBA::tk_string, 
+        0U, // string length
+
+      0U,
+
+
+  5,
+  ACE_NTOHL (0x74797065), 
+  ACE_NTOHL (0x0),  // name = type
+  CORBA::tk_TypeCode,
+
+};
+
+static CORBA::TypeCode _tc_TAO_tc_CORBA_InterfaceDef_FullInterfaceDescription (
+    CORBA::tk_struct,
+    sizeof (_oc_CORBA_InterfaceDef_FullInterfaceDescription),
+    (char *) &_oc_CORBA_InterfaceDef_FullInterfaceDescription,
+    0,
+    sizeof (CORBA::InterfaceDef::FullInterfaceDescription)
+  );
+
+CORBA::TypeCode_ptr CORBA::InterfaceDef::_tc_FullInterfaceDescription =
+  &_tc_TAO_tc_CORBA_InterfaceDef_FullInterfaceDescription;
+
+void CORBA::InterfaceDef::FullInterfaceDescription::_tao_any_destructor (void *x)
+{
+  FullInterfaceDescription *tmp = ACE_static_cast (FullInterfaceDescription*,x);
+  delete tmp;
+}
+
+CORBA::InterfaceDef::FullInterfaceDescription * CORBA::InterfaceDef::describe_interface (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_InterfaceDef_Proxy_Impl &proxy = 
+    this->the_TAO_InterfaceDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.describe_interface (
+      this,
+      ACE_TRY_ENV
+    );
+}
+
+CORBA::AttributeDef_ptr CORBA::InterfaceDef::create_attribute (
+    const char * id,
+    const char * name,
+    const char * version,
+    CORBA::IDLType_ptr type,
+    CORBA::AttributeMode mode,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_InterfaceDef_Proxy_Impl &proxy = 
+    this->the_TAO_InterfaceDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.create_attribute (
+      this,
+      id,
+      name,
+      version,
+      type,
+      mode,
+      ACE_TRY_ENV
+    );
+}
+
+CORBA::OperationDef_ptr CORBA::InterfaceDef::create_operation (
+    const char * id,
+    const char * name,
+    const char * version,
+    CORBA::IDLType_ptr result,
+    CORBA::OperationMode mode,
+    const CORBA::ParDescriptionSeq & params,
+    const CORBA::ExceptionDefSeq & exceptions,
+    const CORBA::ContextIdSeq & contexts,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_InterfaceDef_Proxy_Impl &proxy = 
+    this->the_TAO_InterfaceDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.create_operation (
+      this,
+      id,
+      name,
+      version,
+      result,
+      mode,
+      params,
+      exceptions,
+      contexts,
+      ACE_TRY_ENV
+    );
+}
+
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+CORBA::InterfaceDef::TAO_ClientRequestInfo_CORBA_InterfaceDef_base_interfaces_get::TAO_ClientRequestInfo_CORBA_InterfaceDef_base_interfaces_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
+{}
+
+Dynamic::ParameterList *
+CORBA::InterfaceDef::TAO_ClientRequestInfo_CORBA_InterfaceDef_base_interfaces_get::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return parameter_list;
+}
+
+Dynamic::ExceptionList *
+CORBA::InterfaceDef::TAO_ClientRequestInfo_CORBA_InterfaceDef_base_interfaces_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::InterfaceDef::TAO_ClientRequestInfo_CORBA_InterfaceDef_base_interfaces_get::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+CORBA::InterfaceDef::TAO_ClientRequestInfo_CORBA_InterfaceDef_base_interfaces_get::result (CORBA::InterfaceDefSeq * result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+CORBA::InterfaceDef::TAO_ClientRequestInfo_CORBA_InterfaceDef_base_interfaces_set::TAO_ClientRequestInfo_CORBA_InterfaceDef_base_interfaces_set (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const CORBA::InterfaceDefSeq & base_interfaces,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
+    base_interfaces_ (base_interfaces)
+{}
+
+Dynamic::ParameterList *
+CORBA::InterfaceDef::TAO_ClientRequestInfo_CORBA_InterfaceDef_base_interfaces_set::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
+    
+  CORBA::ULong length_base_interfaces = parameter_list->length ();
+  parameter_list->length (length_base_interfaces + 1);
+  (*parameter_list)[length_base_interfaces].argument <<=  this->base_interfaces_;
+  
+  (*parameter_list)[length_base_interfaces].mode = Dynamic::PARAM_IN;
+  
+  return safe_parameter_list._retn ();
+}
+
+Dynamic::ExceptionList *
+CORBA::InterfaceDef::TAO_ClientRequestInfo_CORBA_InterfaceDef_base_interfaces_set::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::InterfaceDef::TAO_ClientRequestInfo_CORBA_InterfaceDef_base_interfaces_set::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 1;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return result_any;
+}
+
+CORBA::InterfaceDef::TAO_ClientRequestInfo_CORBA_InterfaceDef_is_a::TAO_ClientRequestInfo_CORBA_InterfaceDef_is_a (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const char * interface_id,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
+    interface_id_ (interface_id)
+{}
+
+Dynamic::ParameterList *
+CORBA::InterfaceDef::TAO_ClientRequestInfo_CORBA_InterfaceDef_is_a::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
+    
+  CORBA::ULong length_interface_id = parameter_list->length ();
+  parameter_list->length (length_interface_id + 1);
+  (*parameter_list)[length_interface_id].argument <<= interface_id_;
+  (*parameter_list)[length_interface_id].mode = Dynamic::PARAM_IN;
+  
+  return safe_parameter_list._retn ();
+}
+
+Dynamic::ExceptionList *
+CORBA::InterfaceDef::TAO_ClientRequestInfo_CORBA_InterfaceDef_is_a::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::InterfaceDef::TAO_ClientRequestInfo_CORBA_InterfaceDef_is_a::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= CORBA::Any::from_boolean (this->_result);
+  return safe_result_any._retn ();
+}
+
+void 
+CORBA::InterfaceDef::TAO_ClientRequestInfo_CORBA_InterfaceDef_is_a::result (CORBA::Boolean result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+CORBA::InterfaceDef::TAO_ClientRequestInfo_CORBA_InterfaceDef_describe_interface::TAO_ClientRequestInfo_CORBA_InterfaceDef_describe_interface (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
+{}
+
+Dynamic::ParameterList *
+CORBA::InterfaceDef::TAO_ClientRequestInfo_CORBA_InterfaceDef_describe_interface::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return parameter_list;
+}
+
+Dynamic::ExceptionList *
+CORBA::InterfaceDef::TAO_ClientRequestInfo_CORBA_InterfaceDef_describe_interface::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::InterfaceDef::TAO_ClientRequestInfo_CORBA_InterfaceDef_describe_interface::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+CORBA::InterfaceDef::TAO_ClientRequestInfo_CORBA_InterfaceDef_describe_interface::result (ACE_NESTED_CLASS (CORBA::InterfaceDef,FullInterfaceDescription) * result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+CORBA::InterfaceDef::TAO_ClientRequestInfo_CORBA_InterfaceDef_create_attribute::TAO_ClientRequestInfo_CORBA_InterfaceDef_create_attribute (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const char * id,
+    const char * name,
+    const char * version,
+    CORBA::IDLType_ptr type,
+    CORBA::AttributeMode & mode,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
+    id_ (id),
+    name_ (name),
+    version_ (version),
+    type_ (type),
+    mode_ (mode)
+{}
+
+Dynamic::ParameterList *
+CORBA::InterfaceDef::TAO_ClientRequestInfo_CORBA_InterfaceDef_create_attribute::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
+    
+  CORBA::ULong length_id = parameter_list->length ();
+  parameter_list->length (length_id + 1);
+  (*parameter_list)[length_id].argument <<= id_;
+  (*parameter_list)[length_id].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_name = parameter_list->length ();
+  parameter_list->length (length_name + 1);
+  (*parameter_list)[length_name].argument <<= name_;
+  (*parameter_list)[length_name].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_version = parameter_list->length ();
+  parameter_list->length (length_version + 1);
+  (*parameter_list)[length_version].argument <<= version_;
+  (*parameter_list)[length_version].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_type = parameter_list->length ();
+  parameter_list->length (length_type + 1);
+  (*parameter_list)[length_type].argument <<=  this->type_;
+  
+  (*parameter_list)[length_type].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_mode = parameter_list->length ();
+  parameter_list->length (length_mode + 1);
+  (*parameter_list)[length_mode].argument <<=  this->mode_;
+  
+  (*parameter_list)[length_mode].mode = Dynamic::PARAM_IN;
+  
+  return safe_parameter_list._retn ();
+}
+
+Dynamic::ExceptionList *
+CORBA::InterfaceDef::TAO_ClientRequestInfo_CORBA_InterfaceDef_create_attribute::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::InterfaceDef::TAO_ClientRequestInfo_CORBA_InterfaceDef_create_attribute::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+CORBA::InterfaceDef::TAO_ClientRequestInfo_CORBA_InterfaceDef_create_attribute::result (CORBA::AttributeDef_ptr result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+CORBA::InterfaceDef::TAO_ClientRequestInfo_CORBA_InterfaceDef_create_operation::TAO_ClientRequestInfo_CORBA_InterfaceDef_create_operation (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const char * id,
+    const char * name,
+    const char * version,
+    CORBA::IDLType_ptr result,
+    CORBA::OperationMode & mode,
+    const CORBA::ParDescriptionSeq & params,
+    const CORBA::ExceptionDefSeq & exceptions,
+    const CORBA::ContextIdSeq & contexts,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
+    id_ (id),
+    name_ (name),
+    version_ (version),
+    result_ (result),
+    mode_ (mode),
+    params_ (params),
+    exceptions_ (exceptions),
+    contexts_ (contexts)
+{}
+
+Dynamic::ParameterList *
+CORBA::InterfaceDef::TAO_ClientRequestInfo_CORBA_InterfaceDef_create_operation::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
+    
+  CORBA::ULong length_id = parameter_list->length ();
+  parameter_list->length (length_id + 1);
+  (*parameter_list)[length_id].argument <<= id_;
+  (*parameter_list)[length_id].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_name = parameter_list->length ();
+  parameter_list->length (length_name + 1);
+  (*parameter_list)[length_name].argument <<= name_;
+  (*parameter_list)[length_name].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_version = parameter_list->length ();
+  parameter_list->length (length_version + 1);
+  (*parameter_list)[length_version].argument <<= version_;
+  (*parameter_list)[length_version].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_result = parameter_list->length ();
+  parameter_list->length (length_result + 1);
+  (*parameter_list)[length_result].argument <<=  this->result_;
+  
+  (*parameter_list)[length_result].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_mode = parameter_list->length ();
+  parameter_list->length (length_mode + 1);
+  (*parameter_list)[length_mode].argument <<=  this->mode_;
+  
+  (*parameter_list)[length_mode].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_params = parameter_list->length ();
+  parameter_list->length (length_params + 1);
+  (*parameter_list)[length_params].argument <<=  this->params_;
+  
+  (*parameter_list)[length_params].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_exceptions = parameter_list->length ();
+  parameter_list->length (length_exceptions + 1);
+  (*parameter_list)[length_exceptions].argument <<=  this->exceptions_;
+  
+  (*parameter_list)[length_exceptions].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_contexts = parameter_list->length ();
+  parameter_list->length (length_contexts + 1);
+  (*parameter_list)[length_contexts].argument <<=  this->contexts_;
+  
+  (*parameter_list)[length_contexts].mode = Dynamic::PARAM_IN;
+  
+  return safe_parameter_list._retn ();
+}
+
+Dynamic::ExceptionList *
+CORBA::InterfaceDef::TAO_ClientRequestInfo_CORBA_InterfaceDef_create_operation::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::InterfaceDef::TAO_ClientRequestInfo_CORBA_InterfaceDef_create_operation::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+CORBA::InterfaceDef::TAO_ClientRequestInfo_CORBA_InterfaceDef_create_operation::result (CORBA::OperationDef_ptr result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+#endif /* TAO_HAS_INTERCEPTORS */
+
+void CORBA::InterfaceDescription::_tao_any_destructor (void *x)
+{
+  CORBA_InterfaceDescription *tmp = ACE_static_cast (CORBA_InterfaceDescription*,x);
+  delete tmp;
+}
+
+
+///////////////////////////////////////////////////////////////////////
+//                Base & Remote Proxy  Implementation. 
+//
+
+_TAO_AbstractInterfaceDef_Proxy_Impl::_TAO_AbstractInterfaceDef_Proxy_Impl (void)
+{}
+
+_TAO_AbstractInterfaceDef_Remote_Proxy_Impl::_TAO_AbstractInterfaceDef_Remote_Proxy_Impl (void)
+{}
+
+// Remote Implementation of the IDL interface methods
+
+
+//
+//            End  Base & Remote  Proxy Implemeentation. 
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//           Remote & Base  Proxy Broker Implementation
+//
+
+_TAO_AbstractInterfaceDef_Proxy_Broker::_TAO_AbstractInterfaceDef_Proxy_Broker (void)
+{
+}
+
+_TAO_AbstractInterfaceDef_Proxy_Broker::~_TAO_AbstractInterfaceDef_Proxy_Broker (void)
+{
+}
+
+_TAO_AbstractInterfaceDef_Proxy_Broker * (*CORBA__TAO_AbstractInterfaceDef_Proxy_Broker_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  ) = 0;
+
+// Factory Member function Implementation.
+_TAO_AbstractInterfaceDef_Remote_Proxy_Broker *
+_TAO_AbstractInterfaceDef_Remote_Proxy_Broker::the_TAO_AbstractInterfaceDef_Remote_Proxy_Broker (void)
+{
+  static ::_TAO_AbstractInterfaceDef_Remote_Proxy_Broker remote_proxy_broker;
+  return &remote_proxy_broker;
+}
+
+_TAO_AbstractInterfaceDef_Remote_Proxy_Broker::_TAO_AbstractInterfaceDef_Remote_Proxy_Broker (void)
+{
+}
+
+_TAO_AbstractInterfaceDef_Remote_Proxy_Broker::~_TAO_AbstractInterfaceDef_Remote_Proxy_Broker (void)
+{
+}
+
+_TAO_AbstractInterfaceDef_Proxy_Impl&
+_TAO_AbstractInterfaceDef_Remote_Proxy_Broker::select_proxy (
+  ::CORBA_AbstractInterfaceDef *,
+  CORBA::Environment &
+)
+{
+  return this->remote_proxy_impl_;
+}
+
+
+//
+//           End Remote & Base Proxy Broker Implementation
+///////////////////////////////////////////////////////////////////////
+
+
+// default constructor
+CORBA::AbstractInterfaceDef::AbstractInterfaceDef (int collocated)
+{
+  this->CORBA_AbstractInterfaceDef_setup_collocation (collocated);
+}
+
+// destructor
+CORBA::AbstractInterfaceDef::~AbstractInterfaceDef (void)
+{}
+
+void
+CORBA::AbstractInterfaceDef::CORBA_AbstractInterfaceDef_setup_collocation (int collocated)
+{
+  if (collocated)
+    this->the_TAO_AbstractInterfaceDef_Proxy_Broker_ =
+      ::CORBA__TAO_AbstractInterfaceDef_Proxy_Broker_Factory_function_pointer (this);
+  else
+    this->the_TAO_AbstractInterfaceDef_Proxy_Broker_ =
+      ::_TAO_AbstractInterfaceDef_Remote_Proxy_Broker::the_TAO_AbstractInterfaceDef_Remote_Proxy_Broker ();
+  
+  this->CORBA_InterfaceDef_setup_collocation (collocated);
+}
+
+void CORBA::AbstractInterfaceDef::_tao_any_destructor (void *x)
+{
+  CORBA_AbstractInterfaceDef *tmp = ACE_static_cast (CORBA_AbstractInterfaceDef*,x);
+  CORBA::release (tmp);
+}
+
+CORBA::AbstractInterfaceDef_ptr CORBA::AbstractInterfaceDef::_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+{
+  if (CORBA::is_nil (obj))
+    return CORBA::AbstractInterfaceDef::_nil ();
+  if (! obj->_is_local ())
+    {
+      CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/CORBA/AbstractInterfaceDef:1.0", ACE_TRY_ENV);
+      ACE_CHECK_RETURN (CORBA::AbstractInterfaceDef::_nil ());
+      if (is_a == 0)
+        return CORBA::AbstractInterfaceDef::_nil ();
+    }
+  return CORBA::AbstractInterfaceDef::_unchecked_narrow (obj, ACE_TRY_ENV);
+}
+
+CORBA::AbstractInterfaceDef_ptr CORBA::AbstractInterfaceDef::_unchecked_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &
+  )
+{
+  if (CORBA::is_nil (obj))
+    return CORBA::AbstractInterfaceDef::_nil ();
+  if (! obj->_is_local ())
+    {
+      TAO_Stub* stub = obj->_stubobj ();
+      if (stub)
+        stub->_incr_refcnt ();
+      CORBA::AbstractInterfaceDef_ptr default_proxy = CORBA::AbstractInterfaceDef::_nil ();
+
+      if (
+          !CORBA::is_nil (stub->servant_orb_var ().ptr ()) &&
+          stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects () &&
+          obj->_is_collocated () &&CORBA__TAO_AbstractInterfaceDef_Proxy_Broker_Factory_function_pointer != 0
+        )
+      {
+        ACE_NEW_RETURN (
+          default_proxy,
+          ::CORBA::AbstractInterfaceDef (
+            stub,
+            1,
+            obj->_servant ()),
+            
+          CORBA::AbstractInterfaceDef::_nil ());
+        }
+      if (CORBA::is_nil (default_proxy))
+        ACE_NEW_RETURN (default_proxy, ::CORBA::AbstractInterfaceDef (stub, 0, obj->_servant ()), CORBA::AbstractInterfaceDef::_nil ());
+        return default_proxy;
+      }
+    else 
+      return
+        ACE_reinterpret_cast
+          (
+            CORBA_AbstractInterfaceDef_ptr,
+              obj->_tao_QueryInterface
+                (
+                  ACE_reinterpret_cast
+                    (
+                      ptr_arith_t,
+                      &CORBA_AbstractInterfaceDef::_narrow
+                    )
+                )
+          );
+}
+
+CORBA::AbstractInterfaceDef_ptr
+CORBA::AbstractInterfaceDef::_duplicate (CORBA::AbstractInterfaceDef_ptr obj)
+{
+  if (!CORBA::is_nil (obj))
+    obj->_add_ref ();
+  return obj;
+}
+
+CORBA::Boolean CORBA::AbstractInterfaceDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
+{
+  if (
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/AbstractInterfaceDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/InterfaceDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Container:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Contained:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IDLType:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
+  return 1; // success using local knowledge
+  else
+    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
+}
+
+void *CORBA::AbstractInterfaceDef::_tao_QueryInterface (ptr_arith_t type)
+{
+  void *retv = 0;
+  if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      CORBA_AbstractInterfaceDef::_narrow))
+    retv = ACE_reinterpret_cast (void*, this);
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      CORBA_InterfaceDef::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::InterfaceDef_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::Container::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::Container_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::Contained::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::Contained_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::IDLType::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::IDLType_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::IRObject::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::IRObject_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
+    retv = ACE_reinterpret_cast (void *,
+      ACE_static_cast (CORBA::Object_ptr, this));
+    
+  if (retv)
+    this->_add_ref ();
+  return retv;
+}
+
+const char* CORBA::AbstractInterfaceDef::_interface_repository_id (void) const
+{
+  return "IDL:omg.org/CORBA/AbstractInterfaceDef:1.0";
+}
+
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+#endif /* TAO_HAS_INTERCEPTORS */
+
+///////////////////////////////////////////////////////////////////////
+//                Base & Remote Proxy  Implementation. 
+//
+
+_TAO_LocalInterfaceDef_Proxy_Impl::_TAO_LocalInterfaceDef_Proxy_Impl (void)
+{}
+
+_TAO_LocalInterfaceDef_Remote_Proxy_Impl::_TAO_LocalInterfaceDef_Remote_Proxy_Impl (void)
+{}
+
+// Remote Implementation of the IDL interface methods
+
+
+//
+//            End  Base & Remote  Proxy Implemeentation. 
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//           Remote & Base  Proxy Broker Implementation
+//
+
+_TAO_LocalInterfaceDef_Proxy_Broker::_TAO_LocalInterfaceDef_Proxy_Broker (void)
+{
+}
+
+_TAO_LocalInterfaceDef_Proxy_Broker::~_TAO_LocalInterfaceDef_Proxy_Broker (void)
+{
+}
+
+_TAO_LocalInterfaceDef_Proxy_Broker * (*CORBA__TAO_LocalInterfaceDef_Proxy_Broker_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  ) = 0;
+
+// Factory Member function Implementation.
+_TAO_LocalInterfaceDef_Remote_Proxy_Broker *
+_TAO_LocalInterfaceDef_Remote_Proxy_Broker::the_TAO_LocalInterfaceDef_Remote_Proxy_Broker (void)
+{
+  static ::_TAO_LocalInterfaceDef_Remote_Proxy_Broker remote_proxy_broker;
+  return &remote_proxy_broker;
+}
+
+_TAO_LocalInterfaceDef_Remote_Proxy_Broker::_TAO_LocalInterfaceDef_Remote_Proxy_Broker (void)
+{
+}
+
+_TAO_LocalInterfaceDef_Remote_Proxy_Broker::~_TAO_LocalInterfaceDef_Remote_Proxy_Broker (void)
+{
+}
+
+_TAO_LocalInterfaceDef_Proxy_Impl&
+_TAO_LocalInterfaceDef_Remote_Proxy_Broker::select_proxy (
+  ::CORBA_LocalInterfaceDef *,
+  CORBA::Environment &
+)
+{
+  return this->remote_proxy_impl_;
+}
+
+
+//
+//           End Remote & Base Proxy Broker Implementation
+///////////////////////////////////////////////////////////////////////
+
+
+// default constructor
+CORBA::LocalInterfaceDef::LocalInterfaceDef (int collocated)
+{
+  this->CORBA_LocalInterfaceDef_setup_collocation (collocated);
+}
+
+// destructor
+CORBA::LocalInterfaceDef::~LocalInterfaceDef (void)
+{}
+
+void
+CORBA::LocalInterfaceDef::CORBA_LocalInterfaceDef_setup_collocation (int collocated)
+{
+  if (collocated)
+    this->the_TAO_LocalInterfaceDef_Proxy_Broker_ =
+      ::CORBA__TAO_LocalInterfaceDef_Proxy_Broker_Factory_function_pointer (this);
+  else
+    this->the_TAO_LocalInterfaceDef_Proxy_Broker_ =
+      ::_TAO_LocalInterfaceDef_Remote_Proxy_Broker::the_TAO_LocalInterfaceDef_Remote_Proxy_Broker ();
+  
+  this->CORBA_InterfaceDef_setup_collocation (collocated);
+}
+
+void CORBA::LocalInterfaceDef::_tao_any_destructor (void *x)
+{
+  CORBA_LocalInterfaceDef *tmp = ACE_static_cast (CORBA_LocalInterfaceDef*,x);
+  CORBA::release (tmp);
+}
+
+CORBA::LocalInterfaceDef_ptr CORBA::LocalInterfaceDef::_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+{
+  if (CORBA::is_nil (obj))
+    return CORBA::LocalInterfaceDef::_nil ();
+  if (! obj->_is_local ())
+    {
+      CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/CORBA/LocalInterfaceDef:1.0", ACE_TRY_ENV);
+      ACE_CHECK_RETURN (CORBA::LocalInterfaceDef::_nil ());
+      if (is_a == 0)
+        return CORBA::LocalInterfaceDef::_nil ();
+    }
+  return CORBA::LocalInterfaceDef::_unchecked_narrow (obj, ACE_TRY_ENV);
+}
+
+CORBA::LocalInterfaceDef_ptr CORBA::LocalInterfaceDef::_unchecked_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &
+  )
+{
+  if (CORBA::is_nil (obj))
+    return CORBA::LocalInterfaceDef::_nil ();
+  if (! obj->_is_local ())
+    {
+      TAO_Stub* stub = obj->_stubobj ();
+      if (stub)
+        stub->_incr_refcnt ();
+      CORBA::LocalInterfaceDef_ptr default_proxy = CORBA::LocalInterfaceDef::_nil ();
+
+      if (
+          !CORBA::is_nil (stub->servant_orb_var ().ptr ()) &&
+          stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects () &&
+          obj->_is_collocated () &&CORBA__TAO_LocalInterfaceDef_Proxy_Broker_Factory_function_pointer != 0
+        )
+      {
+        ACE_NEW_RETURN (
+          default_proxy,
+          ::CORBA::LocalInterfaceDef (
+            stub,
+            1,
+            obj->_servant ()),
+            
+          CORBA::LocalInterfaceDef::_nil ());
+        }
+      if (CORBA::is_nil (default_proxy))
+        ACE_NEW_RETURN (default_proxy, ::CORBA::LocalInterfaceDef (stub, 0, obj->_servant ()), CORBA::LocalInterfaceDef::_nil ());
+        return default_proxy;
+      }
+    else 
+      return
+        ACE_reinterpret_cast
+          (
+            CORBA_LocalInterfaceDef_ptr,
+              obj->_tao_QueryInterface
+                (
+                  ACE_reinterpret_cast
+                    (
+                      ptr_arith_t,
+                      &CORBA_LocalInterfaceDef::_narrow
+                    )
+                )
+          );
+}
+
+CORBA::LocalInterfaceDef_ptr
+CORBA::LocalInterfaceDef::_duplicate (CORBA::LocalInterfaceDef_ptr obj)
+{
+  if (!CORBA::is_nil (obj))
+    obj->_add_ref ();
+  return obj;
+}
+
+CORBA::Boolean CORBA::LocalInterfaceDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
+{
+  if (
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/LocalInterfaceDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/InterfaceDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Container:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Contained:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IDLType:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
+  return 1; // success using local knowledge
+  else
+    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
+}
+
+void *CORBA::LocalInterfaceDef::_tao_QueryInterface (ptr_arith_t type)
+{
+  void *retv = 0;
+  if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      CORBA_LocalInterfaceDef::_narrow))
+    retv = ACE_reinterpret_cast (void*, this);
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      CORBA_InterfaceDef::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::InterfaceDef_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::Container::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::Container_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::Contained::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::Contained_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::IDLType::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::IDLType_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::IRObject::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::IRObject_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
+    retv = ACE_reinterpret_cast (void *,
+      ACE_static_cast (CORBA::Object_ptr, this));
+    
+  if (retv)
+    this->_add_ref ();
+  return retv;
+}
+
+const char* CORBA::LocalInterfaceDef::_interface_repository_id (void) const
+{
+  return "IDL:omg.org/CORBA/LocalInterfaceDef:1.0";
+}
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+#endif /* TAO_HAS_INTERCEPTORS */
+
+// ************************************************************
+// Any operators for classes moved from IFR_BaseC.cpp
+
+void operator<<= (
+    CORBA::Any &_tao_any,
+    const CORBA::InterfaceDefSeq &_tao_elem
+  ) // copying
+{
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        CORBA::_tc_InterfaceDefSeq,
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin ()
+      );
+  }
+}
+
+void operator<<= (CORBA::Any &_tao_any, CORBA::InterfaceDefSeq *_tao_elem) // non copying
+{
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      CORBA::_tc_InterfaceDefSeq,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      CORBA::InterfaceDefSeq::_tao_any_destructor
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::InterfaceDefSeq *&_tao_elem)
+{
+  return _tao_any >>= ACE_const_cast(
+      const CORBA::InterfaceDefSeq*&,
+      _tao_elem
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::InterfaceDefSeq *&_tao_elem)
+{
+  _tao_elem = 0;
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (CORBA::_tc_InterfaceDefSeq, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    if (_tao_any.any_owns_data ())
+    {
+      _tao_elem = ACE_static_cast(
+          const CORBA::InterfaceDefSeq*,
+          _tao_any.value ()
+        );
+      return 1;
+    }
+    else
+    {
+      CORBA::InterfaceDefSeq *tmp;
+      ACE_NEW_RETURN (tmp, CORBA::InterfaceDefSeq, 0);
+      TAO_InputCDR stream (
+          _tao_any._tao_get_cdr (),
+          _tao_any._tao_byte_order ()
+        );
+      if (stream >> *tmp)
+      {
+        ((CORBA::Any *)&_tao_any)->_tao_replace (
+            CORBA::_tc_InterfaceDefSeq,
+            1,
+            ACE_static_cast (void *, tmp),
+            CORBA::InterfaceDefSeq::_tao_any_destructor
+          );
+        _tao_elem = tmp;
+        return 1;
+      }
+      else
+      {
+        delete tmp;
+      }
+    }
+  }
+  ACE_CATCHANY
+  {
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+void operator<<= (
+    CORBA::Any &_tao_any,
+    const CORBA::AbstractInterfaceDefSeq &_tao_elem
+  ) // copying
+{
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        CORBA::_tc_AbstractInterfaceDefSeq,
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin ()
+      );
+  }
+}
+
+void operator<<= (CORBA::Any &_tao_any, CORBA::AbstractInterfaceDefSeq *_tao_elem) // non copying
+{
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      CORBA::_tc_AbstractInterfaceDefSeq,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      CORBA::AbstractInterfaceDefSeq::_tao_any_destructor
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::AbstractInterfaceDefSeq *&_tao_elem)
+{
+  return _tao_any >>= ACE_const_cast(
+      const CORBA::AbstractInterfaceDefSeq*&,
+      _tao_elem
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::AbstractInterfaceDefSeq *&_tao_elem)
+{
+  _tao_elem = 0;
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (CORBA::_tc_AbstractInterfaceDefSeq, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    if (_tao_any.any_owns_data ())
+    {
+      _tao_elem = ACE_static_cast(
+          const CORBA::AbstractInterfaceDefSeq*,
+          _tao_any.value ()
+        );
+      return 1;
+    }
+    else
+    {
+      CORBA::AbstractInterfaceDefSeq *tmp;
+      ACE_NEW_RETURN (tmp, CORBA::AbstractInterfaceDefSeq, 0);
+      TAO_InputCDR stream (
+          _tao_any._tao_get_cdr (),
+          _tao_any._tao_byte_order ()
+        );
+      if (stream >> *tmp)
+      {
+        ((CORBA::Any *)&_tao_any)->_tao_replace (
+            CORBA::_tc_AbstractInterfaceDefSeq,
+            1,
+            ACE_static_cast (void *, tmp),
+            CORBA::AbstractInterfaceDefSeq::_tao_any_destructor
+          );
+        _tao_elem = tmp;
+        return 1;
+      }
+      else
+      {
+        delete tmp;
+      }
+    }
+  }
+  ACE_CATCHANY
+  {
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+void operator<<= (
+    CORBA::Any &_tao_any,
+    const CORBA::LocalInterfaceDefSeq &_tao_elem
+  ) // copying
+{
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        CORBA::_tc_LocalInterfaceDefSeq,
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin ()
+      );
+  }
+}
+
+void operator<<= (CORBA::Any &_tao_any, CORBA::LocalInterfaceDefSeq *_tao_elem) // non copying
+{
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      CORBA::_tc_LocalInterfaceDefSeq,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      CORBA::LocalInterfaceDefSeq::_tao_any_destructor
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::LocalInterfaceDefSeq *&_tao_elem)
+{
+  return _tao_any >>= ACE_const_cast(
+      const CORBA::LocalInterfaceDefSeq*&,
+      _tao_elem
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::LocalInterfaceDefSeq *&_tao_elem)
+{
+  _tao_elem = 0;
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (CORBA::_tc_LocalInterfaceDefSeq, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    if (_tao_any.any_owns_data ())
+    {
+      _tao_elem = ACE_static_cast(
+          const CORBA::LocalInterfaceDefSeq*,
+          _tao_any.value ()
+        );
+      return 1;
+    }
+    else
+    {
+      CORBA::LocalInterfaceDefSeq *tmp;
+      ACE_NEW_RETURN (tmp, CORBA::LocalInterfaceDefSeq, 0);
+      TAO_InputCDR stream (
+          _tao_any._tao_get_cdr (),
+          _tao_any._tao_byte_order ()
+        );
+      if (stream >> *tmp)
+      {
+        ((CORBA::Any *)&_tao_any)->_tao_replace (
+            CORBA::_tc_LocalInterfaceDefSeq,
+            1,
+            ACE_static_cast (void *, tmp),
+            CORBA::LocalInterfaceDefSeq::_tao_any_destructor
+          );
+        _tao_elem = tmp;
+        return 1;
+      }
+      else
+      {
+        delete tmp;
+      }
+    }
+  }
+  ACE_CATCHANY
+  {
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+// ******************************************************************
+
+void operator<<= (CORBA::Any &_tao_any, CORBA::PrimitiveKind _tao_elem)
+{
+  TAO_OutputCDR stream;
+  stream << _tao_elem;
+  _tao_any._tao_replace (
+      CORBA::_tc_PrimitiveKind,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin ()
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::PrimitiveKind &_tao_elem)
+{
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (CORBA::_tc_PrimitiveKind, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    TAO_InputCDR stream (
+        _tao_any._tao_get_cdr (),
+        _tao_any._tao_byte_order ()
+      );
+    if (stream >> _tao_elem)
+    {
+      return 1;
+    }
+  }
+  ACE_CATCHANY
+  {
+    return 0;
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+void operator<<= (CORBA::Any &_tao_any, CORBA::Repository_ptr _tao_elem)
+{
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        CORBA::_tc_Repository, 
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin (),
+        1,
+        CORBA::Repository::_duplicate (_tao_elem),
+        CORBA::Repository::_tao_any_destructor
+      );
+  }
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::Repository_ptr &_tao_elem)
+{
+  ACE_TRY_NEW_ENV
+  {
+    _tao_elem = CORBA::Repository::_nil ();
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (CORBA::_tc_Repository, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    TAO_InputCDR stream (
+        _tao_any._tao_get_cdr (),
+        _tao_any._tao_byte_order ()
+      );
+    if (stream >> _tao_elem)
+    {
+      ((CORBA::Any *)&_tao_any)->_tao_replace (
+          CORBA::_tc_Repository,
+          1,
+          _tao_elem,
+          CORBA::Repository::_tao_any_destructor
+        );
+      return 1;
+    }
+  }
+  ACE_CATCHANY
+  {
+    _tao_elem = CORBA::Repository::_nil ();
+    return 0;
+  }
+  ACE_ENDTRY;
+  _tao_elem = CORBA::Repository::_nil ();
+  return 0;
+}
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
+    defined (ACE_HAS_GNU_REPO)
+    template class TAO_Object_Manager<CORBA::Repository,CORBA::Repository_var>;
+  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+  #  pragma instantiate TAO_Object_Manager<CORBA::Repository,CORBA::Repository_var>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+void operator<<= (CORBA::Any &_tao_any, CORBA::ModuleDef_ptr _tao_elem)
+{
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        CORBA::_tc_ModuleDef, 
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin (),
+        1,
+        CORBA::ModuleDef::_duplicate (_tao_elem),
+        CORBA::ModuleDef::_tao_any_destructor
+      );
+  }
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ModuleDef_ptr &_tao_elem)
+{
+  ACE_TRY_NEW_ENV
+  {
+    _tao_elem = CORBA::ModuleDef::_nil ();
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (CORBA::_tc_ModuleDef, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    TAO_InputCDR stream (
+        _tao_any._tao_get_cdr (),
+        _tao_any._tao_byte_order ()
+      );
+    if (stream >> _tao_elem)
+    {
+      ((CORBA::Any *)&_tao_any)->_tao_replace (
+          CORBA::_tc_ModuleDef,
+          1,
+          _tao_elem,
+          CORBA::ModuleDef::_tao_any_destructor
+        );
+      return 1;
+    }
+  }
+  ACE_CATCHANY
+  {
+    _tao_elem = CORBA::ModuleDef::_nil ();
+    return 0;
+  }
+  ACE_ENDTRY;
+  _tao_elem = CORBA::ModuleDef::_nil ();
+  return 0;
+}
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
+    defined (ACE_HAS_GNU_REPO)
+    template class TAO_Object_Manager<CORBA::ModuleDef,CORBA::ModuleDef_var>;
+  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+  #  pragma instantiate TAO_Object_Manager<CORBA::ModuleDef,CORBA::ModuleDef_var>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+void operator<<= (CORBA::Any &_tao_any, const CORBA::ModuleDescription &_tao_elem) // copying
+{
+  TAO_OutputCDR stream;
+  stream << _tao_elem;
+  _tao_any._tao_replace (
+      CORBA::_tc_ModuleDescription,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin ()
+    );
+}
+
+void operator<<= (CORBA::Any &_tao_any, CORBA::ModuleDescription *_tao_elem) // non copying
+{
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      CORBA::_tc_ModuleDescription,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      CORBA::ModuleDescription::_tao_any_destructor
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ModuleDescription *&_tao_elem)
+{
+  return _tao_any >>= ACE_const_cast(const CORBA::ModuleDescription*&,_tao_elem);
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::ModuleDescription *&_tao_elem)
+{
+  _tao_elem = 0;
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (CORBA::_tc_ModuleDescription, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    if (_tao_any.any_owns_data ())
+    {
+      _tao_elem = ACE_static_cast(
+          const CORBA::ModuleDescription*,
+          _tao_any.value ()
+        );
+      return 1;
+    }
+    else
+    {
+      CORBA::ModuleDescription *tmp;
+      ACE_NEW_RETURN (tmp, CORBA::ModuleDescription, 0);
+      TAO_InputCDR stream (
+          _tao_any._tao_get_cdr (),
+          _tao_any._tao_byte_order ()
+        );
+      if (stream >> *tmp)
+      {
+        ((CORBA::Any *)&_tao_any)->_tao_replace (
+            CORBA::_tc_ModuleDescription,
+            1,
+            ACE_static_cast (void *, tmp),
+            CORBA::ModuleDescription::_tao_any_destructor
+          );
+        _tao_elem = tmp;
+        return 1;
+      }
+      else
+      {
+        delete tmp;
+      }
+    }
+  }
+  ACE_CATCHANY
+  {
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+void operator<<= (CORBA::Any &_tao_any, CORBA::ConstantDef_ptr _tao_elem)
+{
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        CORBA::_tc_ConstantDef, 
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin (),
+        1,
+        CORBA::ConstantDef::_duplicate (_tao_elem),
+        CORBA::ConstantDef::_tao_any_destructor
+      );
+  }
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ConstantDef_ptr &_tao_elem)
+{
+  ACE_TRY_NEW_ENV
+  {
+    _tao_elem = CORBA::ConstantDef::_nil ();
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (CORBA::_tc_ConstantDef, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    TAO_InputCDR stream (
+        _tao_any._tao_get_cdr (),
+        _tao_any._tao_byte_order ()
+      );
+    if (stream >> _tao_elem)
+    {
+      ((CORBA::Any *)&_tao_any)->_tao_replace (
+          CORBA::_tc_ConstantDef,
+          1,
+          _tao_elem,
+          CORBA::ConstantDef::_tao_any_destructor
+        );
+      return 1;
+    }
+  }
+  ACE_CATCHANY
+  {
+    _tao_elem = CORBA::ConstantDef::_nil ();
+    return 0;
+  }
+  ACE_ENDTRY;
+  _tao_elem = CORBA::ConstantDef::_nil ();
+  return 0;
+}
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
+    defined (ACE_HAS_GNU_REPO)
+    template class TAO_Object_Manager<CORBA::ConstantDef,CORBA::ConstantDef_var>;
+  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+  #  pragma instantiate TAO_Object_Manager<CORBA::ConstantDef,CORBA::ConstantDef_var>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+void operator<<= (CORBA::Any &_tao_any, const CORBA::ConstantDescription &_tao_elem) // copying
+{
+  TAO_OutputCDR stream;
+  stream << _tao_elem;
+  _tao_any._tao_replace (
+      CORBA::_tc_ConstantDescription,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin ()
+    );
+}
+
+void operator<<= (CORBA::Any &_tao_any, CORBA::ConstantDescription *_tao_elem) // non copying
+{
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      CORBA::_tc_ConstantDescription,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      CORBA::ConstantDescription::_tao_any_destructor
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ConstantDescription *&_tao_elem)
+{
+  return _tao_any >>= ACE_const_cast(const CORBA::ConstantDescription*&,_tao_elem);
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::ConstantDescription *&_tao_elem)
+{
+  _tao_elem = 0;
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (CORBA::_tc_ConstantDescription, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    if (_tao_any.any_owns_data ())
+    {
+      _tao_elem = ACE_static_cast(
+          const CORBA::ConstantDescription*,
+          _tao_any.value ()
+        );
+      return 1;
+    }
+    else
+    {
+      CORBA::ConstantDescription *tmp;
+      ACE_NEW_RETURN (tmp, CORBA::ConstantDescription, 0);
+      TAO_InputCDR stream (
+          _tao_any._tao_get_cdr (),
+          _tao_any._tao_byte_order ()
+        );
+      if (stream >> *tmp)
+      {
+        ((CORBA::Any *)&_tao_any)->_tao_replace (
+            CORBA::_tc_ConstantDescription,
+            1,
+            ACE_static_cast (void *, tmp),
+            CORBA::ConstantDescription::_tao_any_destructor
+          );
+        _tao_elem = tmp;
+        return 1;
+      }
+      else
+      {
+        delete tmp;
+      }
+    }
+  }
+  ACE_CATCHANY
+  {
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+void operator<<= (CORBA::Any &_tao_any, CORBA::StructDef_ptr _tao_elem)
+{
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        CORBA::_tc_StructDef, 
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin (),
+        1,
+        CORBA::StructDef::_duplicate (_tao_elem),
+        CORBA::StructDef::_tao_any_destructor
+      );
+  }
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::StructDef_ptr &_tao_elem)
+{
+  ACE_TRY_NEW_ENV
+  {
+    _tao_elem = CORBA::StructDef::_nil ();
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (CORBA::_tc_StructDef, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    TAO_InputCDR stream (
+        _tao_any._tao_get_cdr (),
+        _tao_any._tao_byte_order ()
+      );
+    if (stream >> _tao_elem)
+    {
+      ((CORBA::Any *)&_tao_any)->_tao_replace (
+          CORBA::_tc_StructDef,
+          1,
+          _tao_elem,
+          CORBA::StructDef::_tao_any_destructor
+        );
+      return 1;
+    }
+  }
+  ACE_CATCHANY
+  {
+    _tao_elem = CORBA::StructDef::_nil ();
+    return 0;
+  }
+  ACE_ENDTRY;
+  _tao_elem = CORBA::StructDef::_nil ();
+  return 0;
+}
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
+    defined (ACE_HAS_GNU_REPO)
+    template class TAO_Object_Manager<CORBA::StructDef,CORBA::StructDef_var>;
+  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+  #  pragma instantiate TAO_Object_Manager<CORBA::StructDef,CORBA::StructDef_var>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+void operator<<= (CORBA::Any &_tao_any, CORBA::UnionDef_ptr _tao_elem)
+{
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        CORBA::_tc_UnionDef, 
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin (),
+        1,
+        CORBA::UnionDef::_duplicate (_tao_elem),
+        CORBA::UnionDef::_tao_any_destructor
+      );
+  }
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::UnionDef_ptr &_tao_elem)
+{
+  ACE_TRY_NEW_ENV
+  {
+    _tao_elem = CORBA::UnionDef::_nil ();
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (CORBA::_tc_UnionDef, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    TAO_InputCDR stream (
+        _tao_any._tao_get_cdr (),
+        _tao_any._tao_byte_order ()
+      );
+    if (stream >> _tao_elem)
+    {
+      ((CORBA::Any *)&_tao_any)->_tao_replace (
+          CORBA::_tc_UnionDef,
+          1,
+          _tao_elem,
+          CORBA::UnionDef::_tao_any_destructor
+        );
+      return 1;
+    }
+  }
+  ACE_CATCHANY
+  {
+    _tao_elem = CORBA::UnionDef::_nil ();
+    return 0;
+  }
+  ACE_ENDTRY;
+  _tao_elem = CORBA::UnionDef::_nil ();
+  return 0;
+}
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
+    defined (ACE_HAS_GNU_REPO)
+    template class TAO_Object_Manager<CORBA::UnionDef,CORBA::UnionDef_var>;
+  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+  #  pragma instantiate TAO_Object_Manager<CORBA::UnionDef,CORBA::UnionDef_var>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+void operator<<= (CORBA::Any &_tao_any, CORBA::EnumDef_ptr _tao_elem)
+{
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        CORBA::_tc_EnumDef, 
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin (),
+        1,
+        CORBA::EnumDef::_duplicate (_tao_elem),
+        CORBA::EnumDef::_tao_any_destructor
+      );
+  }
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::EnumDef_ptr &_tao_elem)
+{
+  ACE_TRY_NEW_ENV
+  {
+    _tao_elem = CORBA::EnumDef::_nil ();
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (CORBA::_tc_EnumDef, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    TAO_InputCDR stream (
+        _tao_any._tao_get_cdr (),
+        _tao_any._tao_byte_order ()
+      );
+    if (stream >> _tao_elem)
+    {
+      ((CORBA::Any *)&_tao_any)->_tao_replace (
+          CORBA::_tc_EnumDef,
+          1,
+          _tao_elem,
+          CORBA::EnumDef::_tao_any_destructor
+        );
+      return 1;
+    }
+  }
+  ACE_CATCHANY
+  {
+    _tao_elem = CORBA::EnumDef::_nil ();
+    return 0;
+  }
+  ACE_ENDTRY;
+  _tao_elem = CORBA::EnumDef::_nil ();
+  return 0;
+}
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
+    defined (ACE_HAS_GNU_REPO)
+    template class TAO_Object_Manager<CORBA::EnumDef,CORBA::EnumDef_var>;
+  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+  #  pragma instantiate TAO_Object_Manager<CORBA::EnumDef,CORBA::EnumDef_var>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+void operator<<= (CORBA::Any &_tao_any, CORBA::AliasDef_ptr _tao_elem)
+{
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        CORBA::_tc_AliasDef, 
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin (),
+        1,
+        CORBA::AliasDef::_duplicate (_tao_elem),
+        CORBA::AliasDef::_tao_any_destructor
+      );
+  }
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::AliasDef_ptr &_tao_elem)
+{
+  ACE_TRY_NEW_ENV
+  {
+    _tao_elem = CORBA::AliasDef::_nil ();
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (CORBA::_tc_AliasDef, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    TAO_InputCDR stream (
+        _tao_any._tao_get_cdr (),
+        _tao_any._tao_byte_order ()
+      );
+    if (stream >> _tao_elem)
+    {
+      ((CORBA::Any *)&_tao_any)->_tao_replace (
+          CORBA::_tc_AliasDef,
+          1,
+          _tao_elem,
+          CORBA::AliasDef::_tao_any_destructor
+        );
+      return 1;
+    }
+  }
+  ACE_CATCHANY
+  {
+    _tao_elem = CORBA::AliasDef::_nil ();
+    return 0;
+  }
+  ACE_ENDTRY;
+  _tao_elem = CORBA::AliasDef::_nil ();
+  return 0;
+}
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
+    defined (ACE_HAS_GNU_REPO)
+    template class TAO_Object_Manager<CORBA::AliasDef,CORBA::AliasDef_var>;
+  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+  #  pragma instantiate TAO_Object_Manager<CORBA::AliasDef,CORBA::AliasDef_var>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+void operator<<= (CORBA::Any &_tao_any, CORBA::NativeDef_ptr _tao_elem)
+{
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        CORBA::_tc_NativeDef, 
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin (),
+        1,
+        CORBA::NativeDef::_duplicate (_tao_elem),
+        CORBA::NativeDef::_tao_any_destructor
+      );
+  }
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::NativeDef_ptr &_tao_elem)
+{
+  ACE_TRY_NEW_ENV
+  {
+    _tao_elem = CORBA::NativeDef::_nil ();
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (CORBA::_tc_NativeDef, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    TAO_InputCDR stream (
+        _tao_any._tao_get_cdr (),
+        _tao_any._tao_byte_order ()
+      );
+    if (stream >> _tao_elem)
+    {
+      ((CORBA::Any *)&_tao_any)->_tao_replace (
+          CORBA::_tc_NativeDef,
+          1,
+          _tao_elem,
+          CORBA::NativeDef::_tao_any_destructor
+        );
+      return 1;
+    }
+  }
+  ACE_CATCHANY
+  {
+    _tao_elem = CORBA::NativeDef::_nil ();
+    return 0;
+  }
+  ACE_ENDTRY;
+  _tao_elem = CORBA::NativeDef::_nil ();
+  return 0;
+}
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
+    defined (ACE_HAS_GNU_REPO)
+    template class TAO_Object_Manager<CORBA::NativeDef,CORBA::NativeDef_var>;
+  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+  #  pragma instantiate TAO_Object_Manager<CORBA::NativeDef,CORBA::NativeDef_var>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+void operator<<= (CORBA::Any &_tao_any, CORBA::PrimitiveDef_ptr _tao_elem)
+{
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        CORBA::_tc_PrimitiveDef, 
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin (),
+        1,
+        CORBA::PrimitiveDef::_duplicate (_tao_elem),
+        CORBA::PrimitiveDef::_tao_any_destructor
+      );
+  }
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::PrimitiveDef_ptr &_tao_elem)
+{
+  ACE_TRY_NEW_ENV
+  {
+    _tao_elem = CORBA::PrimitiveDef::_nil ();
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (CORBA::_tc_PrimitiveDef, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    TAO_InputCDR stream (
+        _tao_any._tao_get_cdr (),
+        _tao_any._tao_byte_order ()
+      );
+    if (stream >> _tao_elem)
+    {
+      ((CORBA::Any *)&_tao_any)->_tao_replace (
+          CORBA::_tc_PrimitiveDef,
+          1,
+          _tao_elem,
+          CORBA::PrimitiveDef::_tao_any_destructor
+        );
+      return 1;
+    }
+  }
+  ACE_CATCHANY
+  {
+    _tao_elem = CORBA::PrimitiveDef::_nil ();
+    return 0;
+  }
+  ACE_ENDTRY;
+  _tao_elem = CORBA::PrimitiveDef::_nil ();
+  return 0;
+}
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
+    defined (ACE_HAS_GNU_REPO)
+    template class TAO_Object_Manager<CORBA::PrimitiveDef,CORBA::PrimitiveDef_var>;
+  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+  #  pragma instantiate TAO_Object_Manager<CORBA::PrimitiveDef,CORBA::PrimitiveDef_var>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+void operator<<= (CORBA::Any &_tao_any, CORBA::StringDef_ptr _tao_elem)
+{
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        CORBA::_tc_StringDef, 
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin (),
+        1,
+        CORBA::StringDef::_duplicate (_tao_elem),
+        CORBA::StringDef::_tao_any_destructor
+      );
+  }
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::StringDef_ptr &_tao_elem)
+{
+  ACE_TRY_NEW_ENV
+  {
+    _tao_elem = CORBA::StringDef::_nil ();
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (CORBA::_tc_StringDef, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    TAO_InputCDR stream (
+        _tao_any._tao_get_cdr (),
+        _tao_any._tao_byte_order ()
+      );
+    if (stream >> _tao_elem)
+    {
+      ((CORBA::Any *)&_tao_any)->_tao_replace (
+          CORBA::_tc_StringDef,
+          1,
+          _tao_elem,
+          CORBA::StringDef::_tao_any_destructor
+        );
+      return 1;
+    }
+  }
+  ACE_CATCHANY
+  {
+    _tao_elem = CORBA::StringDef::_nil ();
+    return 0;
+  }
+  ACE_ENDTRY;
+  _tao_elem = CORBA::StringDef::_nil ();
+  return 0;
+}
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
+    defined (ACE_HAS_GNU_REPO)
+    template class TAO_Object_Manager<CORBA::StringDef,CORBA::StringDef_var>;
+  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+  #  pragma instantiate TAO_Object_Manager<CORBA::StringDef,CORBA::StringDef_var>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+void operator<<= (CORBA::Any &_tao_any, CORBA::WstringDef_ptr _tao_elem)
+{
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        CORBA::_tc_WstringDef, 
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin (),
+        1,
+        CORBA::WstringDef::_duplicate (_tao_elem),
+        CORBA::WstringDef::_tao_any_destructor
+      );
+  }
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::WstringDef_ptr &_tao_elem)
+{
+  ACE_TRY_NEW_ENV
+  {
+    _tao_elem = CORBA::WstringDef::_nil ();
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (CORBA::_tc_WstringDef, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    TAO_InputCDR stream (
+        _tao_any._tao_get_cdr (),
+        _tao_any._tao_byte_order ()
+      );
+    if (stream >> _tao_elem)
+    {
+      ((CORBA::Any *)&_tao_any)->_tao_replace (
+          CORBA::_tc_WstringDef,
+          1,
+          _tao_elem,
+          CORBA::WstringDef::_tao_any_destructor
+        );
+      return 1;
+    }
+  }
+  ACE_CATCHANY
+  {
+    _tao_elem = CORBA::WstringDef::_nil ();
+    return 0;
+  }
+  ACE_ENDTRY;
+  _tao_elem = CORBA::WstringDef::_nil ();
+  return 0;
+}
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
+    defined (ACE_HAS_GNU_REPO)
+    template class TAO_Object_Manager<CORBA::WstringDef,CORBA::WstringDef_var>;
+  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+  #  pragma instantiate TAO_Object_Manager<CORBA::WstringDef,CORBA::WstringDef_var>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+void operator<<= (CORBA::Any &_tao_any, CORBA::SequenceDef_ptr _tao_elem)
+{
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        CORBA::_tc_SequenceDef, 
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin (),
+        1,
+        CORBA::SequenceDef::_duplicate (_tao_elem),
+        CORBA::SequenceDef::_tao_any_destructor
+      );
+  }
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::SequenceDef_ptr &_tao_elem)
+{
+  ACE_TRY_NEW_ENV
+  {
+    _tao_elem = CORBA::SequenceDef::_nil ();
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (CORBA::_tc_SequenceDef, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    TAO_InputCDR stream (
+        _tao_any._tao_get_cdr (),
+        _tao_any._tao_byte_order ()
+      );
+    if (stream >> _tao_elem)
+    {
+      ((CORBA::Any *)&_tao_any)->_tao_replace (
+          CORBA::_tc_SequenceDef,
+          1,
+          _tao_elem,
+          CORBA::SequenceDef::_tao_any_destructor
+        );
+      return 1;
+    }
+  }
+  ACE_CATCHANY
+  {
+    _tao_elem = CORBA::SequenceDef::_nil ();
+    return 0;
+  }
+  ACE_ENDTRY;
+  _tao_elem = CORBA::SequenceDef::_nil ();
+  return 0;
+}
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
+    defined (ACE_HAS_GNU_REPO)
+    template class TAO_Object_Manager<CORBA::SequenceDef,CORBA::SequenceDef_var>;
+  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+  #  pragma instantiate TAO_Object_Manager<CORBA::SequenceDef,CORBA::SequenceDef_var>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+void operator<<= (CORBA::Any &_tao_any, CORBA::ArrayDef_ptr _tao_elem)
+{
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        CORBA::_tc_ArrayDef, 
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin (),
+        1,
+        CORBA::ArrayDef::_duplicate (_tao_elem),
+        CORBA::ArrayDef::_tao_any_destructor
+      );
+  }
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ArrayDef_ptr &_tao_elem)
+{
+  ACE_TRY_NEW_ENV
+  {
+    _tao_elem = CORBA::ArrayDef::_nil ();
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (CORBA::_tc_ArrayDef, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    TAO_InputCDR stream (
+        _tao_any._tao_get_cdr (),
+        _tao_any._tao_byte_order ()
+      );
+    if (stream >> _tao_elem)
+    {
+      ((CORBA::Any *)&_tao_any)->_tao_replace (
+          CORBA::_tc_ArrayDef,
+          1,
+          _tao_elem,
+          CORBA::ArrayDef::_tao_any_destructor
+        );
+      return 1;
+    }
+  }
+  ACE_CATCHANY
+  {
+    _tao_elem = CORBA::ArrayDef::_nil ();
+    return 0;
+  }
+  ACE_ENDTRY;
+  _tao_elem = CORBA::ArrayDef::_nil ();
+  return 0;
+}
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
+    defined (ACE_HAS_GNU_REPO)
+    template class TAO_Object_Manager<CORBA::ArrayDef,CORBA::ArrayDef_var>;
+  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+  #  pragma instantiate TAO_Object_Manager<CORBA::ArrayDef,CORBA::ArrayDef_var>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+void operator<<= (CORBA::Any &_tao_any, CORBA::ExceptionDef_ptr _tao_elem)
+{
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        CORBA::_tc_ExceptionDef, 
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin (),
+        1,
+        CORBA::ExceptionDef::_duplicate (_tao_elem),
+        CORBA::ExceptionDef::_tao_any_destructor
+      );
+  }
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ExceptionDef_ptr &_tao_elem)
+{
+  ACE_TRY_NEW_ENV
+  {
+    _tao_elem = CORBA::ExceptionDef::_nil ();
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (CORBA::_tc_ExceptionDef, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    TAO_InputCDR stream (
+        _tao_any._tao_get_cdr (),
+        _tao_any._tao_byte_order ()
+      );
+    if (stream >> _tao_elem)
+    {
+      ((CORBA::Any *)&_tao_any)->_tao_replace (
+          CORBA::_tc_ExceptionDef,
+          1,
+          _tao_elem,
+          CORBA::ExceptionDef::_tao_any_destructor
+        );
+      return 1;
+    }
+  }
+  ACE_CATCHANY
+  {
+    _tao_elem = CORBA::ExceptionDef::_nil ();
+    return 0;
+  }
+  ACE_ENDTRY;
+  _tao_elem = CORBA::ExceptionDef::_nil ();
+  return 0;
+}
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
+    defined (ACE_HAS_GNU_REPO)
+    template class TAO_Object_Manager<CORBA::ExceptionDef,CORBA::ExceptionDef_var>;
+  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+  #  pragma instantiate TAO_Object_Manager<CORBA::ExceptionDef,CORBA::ExceptionDef_var>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+void operator<<= (CORBA::Any &_tao_any, const CORBA::ExceptionDescription &_tao_elem) // copying
+{
+  TAO_OutputCDR stream;
+  stream << _tao_elem;
+  _tao_any._tao_replace (
+      CORBA::_tc_ExceptionDescription,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin ()
+    );
+}
+
+void operator<<= (CORBA::Any &_tao_any, CORBA::ExceptionDescription *_tao_elem) // non copying
+{
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      CORBA::_tc_ExceptionDescription,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      CORBA::ExceptionDescription::_tao_any_destructor
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ExceptionDescription *&_tao_elem)
+{
+  return _tao_any >>= ACE_const_cast(const CORBA::ExceptionDescription*&,_tao_elem);
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::ExceptionDescription *&_tao_elem)
+{
+  _tao_elem = 0;
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (CORBA::_tc_ExceptionDescription, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    if (_tao_any.any_owns_data ())
+    {
+      _tao_elem = ACE_static_cast(
+          const CORBA::ExceptionDescription*,
+          _tao_any.value ()
+        );
+      return 1;
+    }
+    else
+    {
+      CORBA::ExceptionDescription *tmp;
+      ACE_NEW_RETURN (tmp, CORBA::ExceptionDescription, 0);
+      TAO_InputCDR stream (
+          _tao_any._tao_get_cdr (),
+          _tao_any._tao_byte_order ()
+        );
+      if (stream >> *tmp)
+      {
+        ((CORBA::Any *)&_tao_any)->_tao_replace (
+            CORBA::_tc_ExceptionDescription,
+            1,
+            ACE_static_cast (void *, tmp),
+            CORBA::ExceptionDescription::_tao_any_destructor
+          );
+        _tao_elem = tmp;
+        return 1;
+      }
+      else
+      {
+        delete tmp;
+      }
+    }
+  }
+  ACE_CATCHANY
+  {
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+void operator<<= (
+    CORBA::Any &_tao_any,
+    const CORBA::ExceptionDefSeq &_tao_elem
+  ) // copying
+{
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        CORBA::_tc_ExceptionDefSeq,
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin ()
+      );
+  }
+}
+
+void operator<<= (CORBA::Any &_tao_any, CORBA::ExceptionDefSeq *_tao_elem) // non copying
+{
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      CORBA::_tc_ExceptionDefSeq,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      CORBA::ExceptionDefSeq::_tao_any_destructor
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ExceptionDefSeq *&_tao_elem)
+{
+  return _tao_any >>= ACE_const_cast(
+      const CORBA::ExceptionDefSeq*&,
+      _tao_elem
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::ExceptionDefSeq *&_tao_elem)
+{
+  _tao_elem = 0;
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (CORBA::_tc_ExceptionDefSeq, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    if (_tao_any.any_owns_data ())
+    {
+      _tao_elem = ACE_static_cast(
+          const CORBA::ExceptionDefSeq*,
+          _tao_any.value ()
+        );
+      return 1;
+    }
+    else
+    {
+      CORBA::ExceptionDefSeq *tmp;
+      ACE_NEW_RETURN (tmp, CORBA::ExceptionDefSeq, 0);
+      TAO_InputCDR stream (
+          _tao_any._tao_get_cdr (),
+          _tao_any._tao_byte_order ()
+        );
+      if (stream >> *tmp)
+      {
+        ((CORBA::Any *)&_tao_any)->_tao_replace (
+            CORBA::_tc_ExceptionDefSeq,
+            1,
+            ACE_static_cast (void *, tmp),
+            CORBA::ExceptionDefSeq::_tao_any_destructor
+          );
+        _tao_elem = tmp;
+        return 1;
+      }
+      else
+      {
+        delete tmp;
+      }
+    }
+  }
+  ACE_CATCHANY
+  {
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+void operator<<= (
+    CORBA::Any &_tao_any,
+    const CORBA::ExcDescriptionSeq &_tao_elem
+  ) // copying
+{
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        CORBA::_tc_ExcDescriptionSeq,
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin ()
+      );
+  }
+}
+
+void operator<<= (CORBA::Any &_tao_any, CORBA::ExcDescriptionSeq *_tao_elem) // non copying
+{
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      CORBA::_tc_ExcDescriptionSeq,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      CORBA::ExcDescriptionSeq::_tao_any_destructor
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ExcDescriptionSeq *&_tao_elem)
+{
+  return _tao_any >>= ACE_const_cast(
+      const CORBA::ExcDescriptionSeq*&,
+      _tao_elem
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::ExcDescriptionSeq *&_tao_elem)
+{
+  _tao_elem = 0;
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (CORBA::_tc_ExcDescriptionSeq, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    if (_tao_any.any_owns_data ())
+    {
+      _tao_elem = ACE_static_cast(
+          const CORBA::ExcDescriptionSeq*,
+          _tao_any.value ()
+        );
+      return 1;
+    }
+    else
+    {
+      CORBA::ExcDescriptionSeq *tmp;
+      ACE_NEW_RETURN (tmp, CORBA::ExcDescriptionSeq, 0);
+      TAO_InputCDR stream (
+          _tao_any._tao_get_cdr (),
+          _tao_any._tao_byte_order ()
+        );
+      if (stream >> *tmp)
+      {
+        ((CORBA::Any *)&_tao_any)->_tao_replace (
+            CORBA::_tc_ExcDescriptionSeq,
+            1,
+            ACE_static_cast (void *, tmp),
+            CORBA::ExcDescriptionSeq::_tao_any_destructor
+          );
+        _tao_elem = tmp;
+        return 1;
+      }
+      else
+      {
+        delete tmp;
+      }
+    }
+  }
+  ACE_CATCHANY
+  {
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+void operator<<= (CORBA::Any &_tao_any, CORBA::AttributeMode _tao_elem)
+{
+  TAO_OutputCDR stream;
+  stream << _tao_elem;
+  _tao_any._tao_replace (
+      CORBA::_tc_AttributeMode,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin ()
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::AttributeMode &_tao_elem)
+{
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (CORBA::_tc_AttributeMode, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    TAO_InputCDR stream (
+        _tao_any._tao_get_cdr (),
+        _tao_any._tao_byte_order ()
+      );
+    if (stream >> _tao_elem)
+    {
+      return 1;
+    }
+  }
+  ACE_CATCHANY
+  {
+    return 0;
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+void operator<<= (CORBA::Any &_tao_any, CORBA::AttributeDef_ptr _tao_elem)
+{
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        CORBA::_tc_AttributeDef, 
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin (),
+        1,
+        CORBA::AttributeDef::_duplicate (_tao_elem),
+        CORBA::AttributeDef::_tao_any_destructor
+      );
+  }
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::AttributeDef_ptr &_tao_elem)
+{
+  ACE_TRY_NEW_ENV
+  {
+    _tao_elem = CORBA::AttributeDef::_nil ();
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (CORBA::_tc_AttributeDef, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    TAO_InputCDR stream (
+        _tao_any._tao_get_cdr (),
+        _tao_any._tao_byte_order ()
+      );
+    if (stream >> _tao_elem)
+    {
+      ((CORBA::Any *)&_tao_any)->_tao_replace (
+          CORBA::_tc_AttributeDef,
+          1,
+          _tao_elem,
+          CORBA::AttributeDef::_tao_any_destructor
+        );
+      return 1;
+    }
+  }
+  ACE_CATCHANY
+  {
+    _tao_elem = CORBA::AttributeDef::_nil ();
+    return 0;
+  }
+  ACE_ENDTRY;
+  _tao_elem = CORBA::AttributeDef::_nil ();
+  return 0;
+}
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
+    defined (ACE_HAS_GNU_REPO)
+    template class TAO_Object_Manager<CORBA::AttributeDef,CORBA::AttributeDef_var>;
+  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+  #  pragma instantiate TAO_Object_Manager<CORBA::AttributeDef,CORBA::AttributeDef_var>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+void operator<<= (CORBA::Any &_tao_any, const CORBA::AttributeDescription &_tao_elem) // copying
+{
+  TAO_OutputCDR stream;
+  stream << _tao_elem;
+  _tao_any._tao_replace (
+      CORBA::_tc_AttributeDescription,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin ()
+    );
+}
+
+void operator<<= (CORBA::Any &_tao_any, CORBA::AttributeDescription *_tao_elem) // non copying
+{
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      CORBA::_tc_AttributeDescription,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      CORBA::AttributeDescription::_tao_any_destructor
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::AttributeDescription *&_tao_elem)
+{
+  return _tao_any >>= ACE_const_cast(const CORBA::AttributeDescription*&,_tao_elem);
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::AttributeDescription *&_tao_elem)
+{
+  _tao_elem = 0;
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (CORBA::_tc_AttributeDescription, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    if (_tao_any.any_owns_data ())
+    {
+      _tao_elem = ACE_static_cast(
+          const CORBA::AttributeDescription*,
+          _tao_any.value ()
+        );
+      return 1;
+    }
+    else
+    {
+      CORBA::AttributeDescription *tmp;
+      ACE_NEW_RETURN (tmp, CORBA::AttributeDescription, 0);
+      TAO_InputCDR stream (
+          _tao_any._tao_get_cdr (),
+          _tao_any._tao_byte_order ()
+        );
+      if (stream >> *tmp)
+      {
+        ((CORBA::Any *)&_tao_any)->_tao_replace (
+            CORBA::_tc_AttributeDescription,
+            1,
+            ACE_static_cast (void *, tmp),
+            CORBA::AttributeDescription::_tao_any_destructor
+          );
+        _tao_elem = tmp;
+        return 1;
+      }
+      else
+      {
+        delete tmp;
+      }
+    }
+  }
+  ACE_CATCHANY
+  {
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+void operator<<= (CORBA::Any &_tao_any, CORBA::OperationMode _tao_elem)
+{
+  TAO_OutputCDR stream;
+  stream << _tao_elem;
+  _tao_any._tao_replace (
+      CORBA::_tc_OperationMode,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin ()
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::OperationMode &_tao_elem)
+{
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (CORBA::_tc_OperationMode, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    TAO_InputCDR stream (
+        _tao_any._tao_get_cdr (),
+        _tao_any._tao_byte_order ()
+      );
+    if (stream >> _tao_elem)
+    {
+      return 1;
+    }
+  }
+  ACE_CATCHANY
+  {
+    return 0;
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+void operator<<= (CORBA::Any &_tao_any, CORBA::ParameterMode _tao_elem)
+{
+  TAO_OutputCDR stream;
+  stream << _tao_elem;
+  _tao_any._tao_replace (
+      CORBA::_tc_ParameterMode,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin ()
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ParameterMode &_tao_elem)
+{
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (CORBA::_tc_ParameterMode, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    TAO_InputCDR stream (
+        _tao_any._tao_get_cdr (),
+        _tao_any._tao_byte_order ()
+      );
+    if (stream >> _tao_elem)
+    {
+      return 1;
+    }
+  }
+  ACE_CATCHANY
+  {
+    return 0;
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+void operator<<= (CORBA::Any &_tao_any, const CORBA::ParameterDescription &_tao_elem) // copying
+{
+  TAO_OutputCDR stream;
+  stream << _tao_elem;
+  _tao_any._tao_replace (
+      CORBA::_tc_ParameterDescription,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin ()
+    );
+}
+
+void operator<<= (CORBA::Any &_tao_any, CORBA::ParameterDescription *_tao_elem) // non copying
+{
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      CORBA::_tc_ParameterDescription,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      CORBA::ParameterDescription::_tao_any_destructor
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ParameterDescription *&_tao_elem)
+{
+  return _tao_any >>= ACE_const_cast(const CORBA::ParameterDescription*&,_tao_elem);
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::ParameterDescription *&_tao_elem)
+{
+  _tao_elem = 0;
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (CORBA::_tc_ParameterDescription, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    if (_tao_any.any_owns_data ())
+    {
+      _tao_elem = ACE_static_cast(
+          const CORBA::ParameterDescription*,
+          _tao_any.value ()
+        );
+      return 1;
+    }
+    else
+    {
+      CORBA::ParameterDescription *tmp;
+      ACE_NEW_RETURN (tmp, CORBA::ParameterDescription, 0);
+      TAO_InputCDR stream (
+          _tao_any._tao_get_cdr (),
+          _tao_any._tao_byte_order ()
+        );
+      if (stream >> *tmp)
+      {
+        ((CORBA::Any *)&_tao_any)->_tao_replace (
+            CORBA::_tc_ParameterDescription,
+            1,
+            ACE_static_cast (void *, tmp),
+            CORBA::ParameterDescription::_tao_any_destructor
+          );
+        _tao_elem = tmp;
+        return 1;
+      }
+      else
+      {
+        delete tmp;
+      }
+    }
+  }
+  ACE_CATCHANY
+  {
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+void operator<<= (
+    CORBA::Any &_tao_any,
+    const CORBA::ParDescriptionSeq &_tao_elem
+  ) // copying
+{
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        CORBA::_tc_ParDescriptionSeq,
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin ()
+      );
+  }
+}
+
+void operator<<= (CORBA::Any &_tao_any, CORBA::ParDescriptionSeq *_tao_elem) // non copying
+{
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      CORBA::_tc_ParDescriptionSeq,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      CORBA::ParDescriptionSeq::_tao_any_destructor
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ParDescriptionSeq *&_tao_elem)
+{
+  return _tao_any >>= ACE_const_cast(
+      const CORBA::ParDescriptionSeq*&,
+      _tao_elem
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::ParDescriptionSeq *&_tao_elem)
+{
+  _tao_elem = 0;
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (CORBA::_tc_ParDescriptionSeq, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    if (_tao_any.any_owns_data ())
+    {
+      _tao_elem = ACE_static_cast(
+          const CORBA::ParDescriptionSeq*,
+          _tao_any.value ()
+        );
+      return 1;
+    }
+    else
+    {
+      CORBA::ParDescriptionSeq *tmp;
+      ACE_NEW_RETURN (tmp, CORBA::ParDescriptionSeq, 0);
+      TAO_InputCDR stream (
+          _tao_any._tao_get_cdr (),
+          _tao_any._tao_byte_order ()
+        );
+      if (stream >> *tmp)
+      {
+        ((CORBA::Any *)&_tao_any)->_tao_replace (
+            CORBA::_tc_ParDescriptionSeq,
+            1,
+            ACE_static_cast (void *, tmp),
+            CORBA::ParDescriptionSeq::_tao_any_destructor
+          );
+        _tao_elem = tmp;
+        return 1;
+      }
+      else
+      {
+        delete tmp;
+      }
+    }
+  }
+  ACE_CATCHANY
+  {
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+void operator<<= (
+    CORBA::Any &_tao_any,
+    const CORBA::ContextIdSeq &_tao_elem
+  ) // copying
+{
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        CORBA::_tc_ContextIdSeq,
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin ()
+      );
+  }
+}
+
+void operator<<= (CORBA::Any &_tao_any, CORBA::ContextIdSeq *_tao_elem) // non copying
+{
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      CORBA::_tc_ContextIdSeq,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      CORBA::ContextIdSeq::_tao_any_destructor
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ContextIdSeq *&_tao_elem)
+{
+  return _tao_any >>= ACE_const_cast(
+      const CORBA::ContextIdSeq*&,
+      _tao_elem
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::ContextIdSeq *&_tao_elem)
+{
+  _tao_elem = 0;
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (CORBA::_tc_ContextIdSeq, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    if (_tao_any.any_owns_data ())
+    {
+      _tao_elem = ACE_static_cast(
+          const CORBA::ContextIdSeq*,
+          _tao_any.value ()
+        );
+      return 1;
+    }
+    else
+    {
+      CORBA::ContextIdSeq *tmp;
+      ACE_NEW_RETURN (tmp, CORBA::ContextIdSeq, 0);
+      TAO_InputCDR stream (
+          _tao_any._tao_get_cdr (),
+          _tao_any._tao_byte_order ()
+        );
+      if (stream >> *tmp)
+      {
+        ((CORBA::Any *)&_tao_any)->_tao_replace (
+            CORBA::_tc_ContextIdSeq,
+            1,
+            ACE_static_cast (void *, tmp),
+            CORBA::ContextIdSeq::_tao_any_destructor
+          );
+        _tao_elem = tmp;
+        return 1;
+      }
+      else
+      {
+        delete tmp;
+      }
+    }
+  }
+  ACE_CATCHANY
+  {
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+void operator<<= (CORBA::Any &_tao_any, CORBA::OperationDef_ptr _tao_elem)
+{
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        CORBA::_tc_OperationDef, 
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin (),
+        1,
+        CORBA::OperationDef::_duplicate (_tao_elem),
+        CORBA::OperationDef::_tao_any_destructor
+      );
+  }
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::OperationDef_ptr &_tao_elem)
+{
+  ACE_TRY_NEW_ENV
+  {
+    _tao_elem = CORBA::OperationDef::_nil ();
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (CORBA::_tc_OperationDef, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    TAO_InputCDR stream (
+        _tao_any._tao_get_cdr (),
+        _tao_any._tao_byte_order ()
+      );
+    if (stream >> _tao_elem)
+    {
+      ((CORBA::Any *)&_tao_any)->_tao_replace (
+          CORBA::_tc_OperationDef,
+          1,
+          _tao_elem,
+          CORBA::OperationDef::_tao_any_destructor
+        );
+      return 1;
+    }
+  }
+  ACE_CATCHANY
+  {
+    _tao_elem = CORBA::OperationDef::_nil ();
+    return 0;
+  }
+  ACE_ENDTRY;
+  _tao_elem = CORBA::OperationDef::_nil ();
+  return 0;
+}
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
+    defined (ACE_HAS_GNU_REPO)
+    template class TAO_Object_Manager<CORBA::OperationDef,CORBA::OperationDef_var>;
+  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+  #  pragma instantiate TAO_Object_Manager<CORBA::OperationDef,CORBA::OperationDef_var>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+void operator<<= (CORBA::Any &_tao_any, const CORBA::OperationDescription &_tao_elem) // copying
+{
+  TAO_OutputCDR stream;
+  stream << _tao_elem;
+  _tao_any._tao_replace (
+      CORBA::_tc_OperationDescription,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin ()
+    );
+}
+
+void operator<<= (CORBA::Any &_tao_any, CORBA::OperationDescription *_tao_elem) // non copying
+{
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      CORBA::_tc_OperationDescription,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      CORBA::OperationDescription::_tao_any_destructor
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::OperationDescription *&_tao_elem)
+{
+  return _tao_any >>= ACE_const_cast(const CORBA::OperationDescription*&,_tao_elem);
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::OperationDescription *&_tao_elem)
+{
+  _tao_elem = 0;
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (CORBA::_tc_OperationDescription, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    if (_tao_any.any_owns_data ())
+    {
+      _tao_elem = ACE_static_cast(
+          const CORBA::OperationDescription*,
+          _tao_any.value ()
+        );
+      return 1;
+    }
+    else
+    {
+      CORBA::OperationDescription *tmp;
+      ACE_NEW_RETURN (tmp, CORBA::OperationDescription, 0);
+      TAO_InputCDR stream (
+          _tao_any._tao_get_cdr (),
+          _tao_any._tao_byte_order ()
+        );
+      if (stream >> *tmp)
+      {
+        ((CORBA::Any *)&_tao_any)->_tao_replace (
+            CORBA::_tc_OperationDescription,
+            1,
+            ACE_static_cast (void *, tmp),
+            CORBA::OperationDescription::_tao_any_destructor
+          );
+        _tao_elem = tmp;
+        return 1;
+      }
+      else
+      {
+        delete tmp;
+      }
+    }
+  }
+  ACE_CATCHANY
+  {
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+void operator<<= (
+    CORBA::Any &_tao_any,
+    const CORBA::RepositoryIdSeq &_tao_elem
+  ) // copying
+{
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        CORBA::_tc_RepositoryIdSeq,
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin ()
+      );
+  }
+}
+
+void operator<<= (CORBA::Any &_tao_any, CORBA::RepositoryIdSeq *_tao_elem) // non copying
+{
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      CORBA::_tc_RepositoryIdSeq,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      CORBA::RepositoryIdSeq::_tao_any_destructor
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::RepositoryIdSeq *&_tao_elem)
+{
+  return _tao_any >>= ACE_const_cast(
+      const CORBA::RepositoryIdSeq*&,
+      _tao_elem
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::RepositoryIdSeq *&_tao_elem)
+{
+  _tao_elem = 0;
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (CORBA::_tc_RepositoryIdSeq, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    if (_tao_any.any_owns_data ())
+    {
+      _tao_elem = ACE_static_cast(
+          const CORBA::RepositoryIdSeq*,
+          _tao_any.value ()
+        );
+      return 1;
+    }
+    else
+    {
+      CORBA::RepositoryIdSeq *tmp;
+      ACE_NEW_RETURN (tmp, CORBA::RepositoryIdSeq, 0);
+      TAO_InputCDR stream (
+          _tao_any._tao_get_cdr (),
+          _tao_any._tao_byte_order ()
+        );
+      if (stream >> *tmp)
+      {
+        ((CORBA::Any *)&_tao_any)->_tao_replace (
+            CORBA::_tc_RepositoryIdSeq,
+            1,
+            ACE_static_cast (void *, tmp),
+            CORBA::RepositoryIdSeq::_tao_any_destructor
+          );
+        _tao_elem = tmp;
+        return 1;
+      }
+      else
+      {
+        delete tmp;
+      }
+    }
+  }
+  ACE_CATCHANY
+  {
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+void operator<<= (
+    CORBA::Any &_tao_any,
+    const CORBA::OpDescriptionSeq &_tao_elem
+  ) // copying
+{
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        CORBA::_tc_OpDescriptionSeq,
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin ()
+      );
+  }
+}
+
+void operator<<= (CORBA::Any &_tao_any, CORBA::OpDescriptionSeq *_tao_elem) // non copying
+{
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      CORBA::_tc_OpDescriptionSeq,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      CORBA::OpDescriptionSeq::_tao_any_destructor
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::OpDescriptionSeq *&_tao_elem)
+{
+  return _tao_any >>= ACE_const_cast(
+      const CORBA::OpDescriptionSeq*&,
+      _tao_elem
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::OpDescriptionSeq *&_tao_elem)
+{
+  _tao_elem = 0;
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (CORBA::_tc_OpDescriptionSeq, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    if (_tao_any.any_owns_data ())
+    {
+      _tao_elem = ACE_static_cast(
+          const CORBA::OpDescriptionSeq*,
+          _tao_any.value ()
+        );
+      return 1;
+    }
+    else
+    {
+      CORBA::OpDescriptionSeq *tmp;
+      ACE_NEW_RETURN (tmp, CORBA::OpDescriptionSeq, 0);
+      TAO_InputCDR stream (
+          _tao_any._tao_get_cdr (),
+          _tao_any._tao_byte_order ()
+        );
+      if (stream >> *tmp)
+      {
+        ((CORBA::Any *)&_tao_any)->_tao_replace (
+            CORBA::_tc_OpDescriptionSeq,
+            1,
+            ACE_static_cast (void *, tmp),
+            CORBA::OpDescriptionSeq::_tao_any_destructor
+          );
+        _tao_elem = tmp;
+        return 1;
+      }
+      else
+      {
+        delete tmp;
+      }
+    }
+  }
+  ACE_CATCHANY
+  {
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+void operator<<= (
+    CORBA::Any &_tao_any,
+    const CORBA::AttrDescriptionSeq &_tao_elem
+  ) // copying
+{
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        CORBA::_tc_AttrDescriptionSeq,
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin ()
+      );
+  }
+}
+
+void operator<<= (CORBA::Any &_tao_any, CORBA::AttrDescriptionSeq *_tao_elem) // non copying
+{
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      CORBA::_tc_AttrDescriptionSeq,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      CORBA::AttrDescriptionSeq::_tao_any_destructor
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::AttrDescriptionSeq *&_tao_elem)
+{
+  return _tao_any >>= ACE_const_cast(
+      const CORBA::AttrDescriptionSeq*&,
+      _tao_elem
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::AttrDescriptionSeq *&_tao_elem)
+{
+  _tao_elem = 0;
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (CORBA::_tc_AttrDescriptionSeq, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    if (_tao_any.any_owns_data ())
+    {
+      _tao_elem = ACE_static_cast(
+          const CORBA::AttrDescriptionSeq*,
+          _tao_any.value ()
+        );
+      return 1;
+    }
+    else
+    {
+      CORBA::AttrDescriptionSeq *tmp;
+      ACE_NEW_RETURN (tmp, CORBA::AttrDescriptionSeq, 0);
+      TAO_InputCDR stream (
+          _tao_any._tao_get_cdr (),
+          _tao_any._tao_byte_order ()
+        );
+      if (stream >> *tmp)
+      {
+        ((CORBA::Any *)&_tao_any)->_tao_replace (
+            CORBA::_tc_AttrDescriptionSeq,
+            1,
+            ACE_static_cast (void *, tmp),
+            CORBA::AttrDescriptionSeq::_tao_any_destructor
+          );
+        _tao_elem = tmp;
+        return 1;
+      }
+      else
+      {
+        delete tmp;
+      }
+    }
+  }
+  ACE_CATCHANY
+  {
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+void operator<<= (CORBA::Any &_tao_any, CORBA::InterfaceDef_ptr _tao_elem)
+{
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        CORBA::_tc_InterfaceDef, 
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin (),
+        1,
+        CORBA::InterfaceDef::_duplicate (_tao_elem),
+        CORBA::InterfaceDef::_tao_any_destructor
+      );
+  }
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::InterfaceDef_ptr &_tao_elem)
+{
+  ACE_TRY_NEW_ENV
+  {
+    _tao_elem = CORBA::InterfaceDef::_nil ();
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (CORBA::_tc_InterfaceDef, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    TAO_InputCDR stream (
+        _tao_any._tao_get_cdr (),
+        _tao_any._tao_byte_order ()
+      );
+    if (stream >> _tao_elem)
+    {
+      ((CORBA::Any *)&_tao_any)->_tao_replace (
+          CORBA::_tc_InterfaceDef,
+          1,
+          _tao_elem,
+          CORBA::InterfaceDef::_tao_any_destructor
+        );
+      return 1;
+    }
+  }
+  ACE_CATCHANY
+  {
+    _tao_elem = CORBA::InterfaceDef::_nil ();
+    return 0;
+  }
+  ACE_ENDTRY;
+  _tao_elem = CORBA::InterfaceDef::_nil ();
+  return 0;
+}
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
+    defined (ACE_HAS_GNU_REPO)
+    template class TAO_Object_Manager<CORBA::InterfaceDef,CORBA::InterfaceDef_var>;
+  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+  #  pragma instantiate TAO_Object_Manager<CORBA::InterfaceDef,CORBA::InterfaceDef_var>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+void operator<<= (CORBA::Any &_tao_any, const CORBA::InterfaceDef::FullInterfaceDescription &_tao_elem) // copying
+{
+  TAO_OutputCDR stream;
+  stream << _tao_elem;
+  _tao_any._tao_replace (
+      CORBA::InterfaceDef::_tc_FullInterfaceDescription,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin ()
+    );
+}
+
+void operator<<= (CORBA::Any &_tao_any, CORBA::InterfaceDef::FullInterfaceDescription *_tao_elem) // non copying
+{
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      CORBA::InterfaceDef::_tc_FullInterfaceDescription,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      CORBA::InterfaceDef::FullInterfaceDescription::_tao_any_destructor
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::InterfaceDef::FullInterfaceDescription *&_tao_elem)
+{
+  return _tao_any >>= ACE_const_cast(const CORBA::InterfaceDef::FullInterfaceDescription*&,_tao_elem);
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::InterfaceDef::FullInterfaceDescription *&_tao_elem)
+{
+  _tao_elem = 0;
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (CORBA::InterfaceDef::_tc_FullInterfaceDescription, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    if (_tao_any.any_owns_data ())
+    {
+      _tao_elem = ACE_static_cast(
+          const CORBA::InterfaceDef::FullInterfaceDescription*,
+          _tao_any.value ()
+        );
+      return 1;
+    }
+    else
+    {
+      CORBA::InterfaceDef::FullInterfaceDescription *tmp;
+      ACE_NEW_RETURN (tmp, CORBA::InterfaceDef::FullInterfaceDescription, 0);
+      TAO_InputCDR stream (
+          _tao_any._tao_get_cdr (),
+          _tao_any._tao_byte_order ()
+        );
+      if (stream >> *tmp)
+      {
+        ((CORBA::Any *)&_tao_any)->_tao_replace (
+            CORBA::InterfaceDef::_tc_FullInterfaceDescription,
+            1,
+            ACE_static_cast (void *, tmp),
+            CORBA::InterfaceDef::FullInterfaceDescription::_tao_any_destructor
+          );
+        _tao_elem = tmp;
+        return 1;
+      }
+      else
+      {
+        delete tmp;
+      }
+    }
+  }
+  ACE_CATCHANY
+  {
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+void operator<<= (CORBA::Any &_tao_any, const CORBA::InterfaceDescription &_tao_elem) // copying
+{
+  TAO_OutputCDR stream;
+  stream << _tao_elem;
+  _tao_any._tao_replace (
+      CORBA::_tc_InterfaceDescription,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin ()
+    );
+}
+
+void operator<<= (CORBA::Any &_tao_any, CORBA::InterfaceDescription *_tao_elem) // non copying
+{
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      CORBA::_tc_InterfaceDescription,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      CORBA::InterfaceDescription::_tao_any_destructor
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::InterfaceDescription *&_tao_elem)
+{
+  return _tao_any >>= ACE_const_cast(const CORBA::InterfaceDescription*&,_tao_elem);
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::InterfaceDescription *&_tao_elem)
+{
+  _tao_elem = 0;
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (CORBA::_tc_InterfaceDescription, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    if (_tao_any.any_owns_data ())
+    {
+      _tao_elem = ACE_static_cast(
+          const CORBA::InterfaceDescription*,
+          _tao_any.value ()
+        );
+      return 1;
+    }
+    else
+    {
+      CORBA::InterfaceDescription *tmp;
+      ACE_NEW_RETURN (tmp, CORBA::InterfaceDescription, 0);
+      TAO_InputCDR stream (
+          _tao_any._tao_get_cdr (),
+          _tao_any._tao_byte_order ()
+        );
+      if (stream >> *tmp)
+      {
+        ((CORBA::Any *)&_tao_any)->_tao_replace (
+            CORBA::_tc_InterfaceDescription,
+            1,
+            ACE_static_cast (void *, tmp),
+            CORBA::InterfaceDescription::_tao_any_destructor
+          );
+        _tao_elem = tmp;
+        return 1;
+      }
+      else
+      {
+        delete tmp;
+      }
+    }
+  }
+  ACE_CATCHANY
+  {
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+void operator<<= (CORBA::Any &_tao_any, CORBA::AbstractInterfaceDef_ptr _tao_elem)
+{
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        CORBA::_tc_AbstractInterfaceDef, 
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin (),
+        1,
+        CORBA::AbstractInterfaceDef::_duplicate (_tao_elem),
+        CORBA::AbstractInterfaceDef::_tao_any_destructor
+      );
+  }
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::AbstractInterfaceDef_ptr &_tao_elem)
+{
+  ACE_TRY_NEW_ENV
+  {
+    _tao_elem = CORBA::AbstractInterfaceDef::_nil ();
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (CORBA::_tc_AbstractInterfaceDef, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    TAO_InputCDR stream (
+        _tao_any._tao_get_cdr (),
+        _tao_any._tao_byte_order ()
+      );
+    if (stream >> _tao_elem)
+    {
+      ((CORBA::Any *)&_tao_any)->_tao_replace (
+          CORBA::_tc_AbstractInterfaceDef,
+          1,
+          _tao_elem,
+          CORBA::AbstractInterfaceDef::_tao_any_destructor
+        );
+      return 1;
+    }
+  }
+  ACE_CATCHANY
+  {
+    _tao_elem = CORBA::AbstractInterfaceDef::_nil ();
+    return 0;
+  }
+  ACE_ENDTRY;
+  _tao_elem = CORBA::AbstractInterfaceDef::_nil ();
+  return 0;
+}
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
+    defined (ACE_HAS_GNU_REPO)
+    template class TAO_Object_Manager<CORBA::AbstractInterfaceDef,CORBA::AbstractInterfaceDef_var>;
+  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+  #  pragma instantiate TAO_Object_Manager<CORBA::AbstractInterfaceDef,CORBA::AbstractInterfaceDef_var>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+void operator<<= (CORBA::Any &_tao_any, CORBA::LocalInterfaceDef_ptr _tao_elem)
+{
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        CORBA::_tc_LocalInterfaceDef, 
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin (),
+        1,
+        CORBA::LocalInterfaceDef::_duplicate (_tao_elem),
+        CORBA::LocalInterfaceDef::_tao_any_destructor
+      );
+  }
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::LocalInterfaceDef_ptr &_tao_elem)
+{
+  ACE_TRY_NEW_ENV
+  {
+    _tao_elem = CORBA::LocalInterfaceDef::_nil ();
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (CORBA::_tc_LocalInterfaceDef, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    TAO_InputCDR stream (
+        _tao_any._tao_get_cdr (),
+        _tao_any._tao_byte_order ()
+      );
+    if (stream >> _tao_elem)
+    {
+      ((CORBA::Any *)&_tao_any)->_tao_replace (
+          CORBA::_tc_LocalInterfaceDef,
+          1,
+          _tao_elem,
+          CORBA::LocalInterfaceDef::_tao_any_destructor
+        );
+      return 1;
+    }
+  }
+  ACE_CATCHANY
+  {
+    _tao_elem = CORBA::LocalInterfaceDef::_nil ();
+    return 0;
+  }
+  ACE_ENDTRY;
+  _tao_elem = CORBA::LocalInterfaceDef::_nil ();
+  return 0;
+}
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
+    defined (ACE_HAS_GNU_REPO)
+    template class TAO_Object_Manager<CORBA::LocalInterfaceDef,CORBA::LocalInterfaceDef_var>;
+  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+  #  pragma instantiate TAO_Object_Manager<CORBA::LocalInterfaceDef,CORBA::LocalInterfaceDef_var>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+// **********************************************************
+// CDR operators for classes moved from IFR_BaseC.cpp
+
+CORBA::Boolean operator<< (
+    TAO_OutputCDR &strm,
+    const CORBA::InterfaceDefSeq &_tao_sequence
+  )
+{
+  if (strm << _tao_sequence.length ())
+  {
+    // encode all elements
+    CORBA::Boolean _tao_marshal_flag = 1;
+    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
+      _tao_marshal_flag = (strm << _tao_sequence[i].in ());
+    }
+    return _tao_marshal_flag;
+  }
+  return 0; // error
+}
+
+CORBA::Boolean operator>> (
+    TAO_InputCDR &strm,
+    CORBA::InterfaceDefSeq &_tao_sequence
+  )
+{
+  CORBA::ULong _tao_seq_len;
+  if (strm >> _tao_seq_len)
+  {
+    // set the length of the sequence
+    _tao_sequence.length (_tao_seq_len);
+    // If length is 0 we return true.
+    if (0 >= _tao_seq_len) 
+      return 1;
+    // retrieve all the elements
+    CORBA::Boolean _tao_marshal_flag = 1;
+    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
+      _tao_marshal_flag = (strm >> _tao_sequence[i].out ());
+    }
+    return _tao_marshal_flag;
+  }
+  return 0; // error
+}
+
+CORBA::Boolean operator<< (
+    TAO_OutputCDR &strm,
+    const CORBA::AbstractInterfaceDefSeq &_tao_sequence
+  )
+{
+  if (strm << _tao_sequence.length ())
+  {
+    // encode all elements
+    CORBA::Boolean _tao_marshal_flag = 1;
+    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
+      _tao_marshal_flag = (strm << _tao_sequence[i].in ());
+    }
+    return _tao_marshal_flag;
+  }
+  return 0; // error
+}
+
+CORBA::Boolean operator>> (
+    TAO_InputCDR &strm,
+    CORBA::AbstractInterfaceDefSeq &_tao_sequence
+  )
+{
+  CORBA::ULong _tao_seq_len;
+  if (strm >> _tao_seq_len)
+  {
+    // set the length of the sequence
+    _tao_sequence.length (_tao_seq_len);
+    // If length is 0 we return true.
+    if (0 >= _tao_seq_len) 
+      return 1;
+    // retrieve all the elements
+    CORBA::Boolean _tao_marshal_flag = 1;
+    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
+      _tao_marshal_flag = (strm >> _tao_sequence[i].out ());
+    }
+    return _tao_marshal_flag;
+  }
+  return 0; // error
+}
+
+CORBA::Boolean operator<< (
+    TAO_OutputCDR &strm,
+    const CORBA::LocalInterfaceDefSeq &_tao_sequence
+  )
+{
+  if (strm << _tao_sequence.length ())
+  {
+    // encode all elements
+    CORBA::Boolean _tao_marshal_flag = 1;
+    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
+      _tao_marshal_flag = (strm << _tao_sequence[i].in ());
+    }
+    return _tao_marshal_flag;
+  }
+  return 0; // error
+}
+
+CORBA::Boolean operator>> (
+    TAO_InputCDR &strm,
+    CORBA::LocalInterfaceDefSeq &_tao_sequence
+  )
+{
+  CORBA::ULong _tao_seq_len;
+  if (strm >> _tao_seq_len)
+  {
+    // set the length of the sequence
+    _tao_sequence.length (_tao_seq_len);
+    // If length is 0 we return true.
+    if (0 >= _tao_seq_len) 
+      return 1;
+    // retrieve all the elements
+    CORBA::Boolean _tao_marshal_flag = 1;
+    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
+      _tao_marshal_flag = (strm >> _tao_sequence[i].out ());
+    }
+    return _tao_marshal_flag;
+  }
+  return 0; // error
+}
+
+// **************************************************************
+
+CORBA::Boolean operator<< (
+    TAO_OutputCDR &strm,
+    const CORBA::ExceptionDefSeq &_tao_sequence
+  )
+{
+  if (strm << _tao_sequence.length ())
+  {
+    // encode all elements
+    CORBA::Boolean _tao_marshal_flag = 1;
+    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
+      _tao_marshal_flag = (strm << _tao_sequence[i].in ());
+    }
+    return _tao_marshal_flag;
+  }
+  return 0; // error
+}
+
+CORBA::Boolean operator>> (
+    TAO_InputCDR &strm,
+    CORBA::ExceptionDefSeq &_tao_sequence
+  )
+{
+  CORBA::ULong _tao_seq_len;
+  if (strm >> _tao_seq_len)
+  {
+    // set the length of the sequence
+    _tao_sequence.length (_tao_seq_len);
+    // If length is 0 we return true.
+    if (0 >= _tao_seq_len) 
+      return 1;
+    // retrieve all the elements
+    CORBA::Boolean _tao_marshal_flag = 1;
+    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
+      _tao_marshal_flag = (strm >> _tao_sequence[i].out ());
+    }
+    return _tao_marshal_flag;
+  }
+  return 0; // error
+}
+
+CORBA::Boolean operator<< (
+    TAO_OutputCDR &strm,
+    const CORBA::ExcDescriptionSeq &_tao_sequence
+  )
+{
+  if (strm << _tao_sequence.length ())
+  {
+    // encode all elements
+    CORBA::Boolean _tao_marshal_flag = 1;
+    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
+      _tao_marshal_flag = (strm << _tao_sequence[i]);
+    }
+    return _tao_marshal_flag;
+  }
+  return 0; // error
+}
+
+CORBA::Boolean operator>> (
+    TAO_InputCDR &strm,
+    CORBA::ExcDescriptionSeq &_tao_sequence
+  )
+{
+  CORBA::ULong _tao_seq_len;
+  if (strm >> _tao_seq_len)
+  {
+    // set the length of the sequence
+    _tao_sequence.length (_tao_seq_len);
+    // If length is 0 we return true.
+    if (0 >= _tao_seq_len) 
+      return 1;
+    // retrieve all the elements
+    CORBA::Boolean _tao_marshal_flag = 1;
+    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
+      _tao_marshal_flag = (strm >> _tao_sequence[i]);
+    }
+    return _tao_marshal_flag;
+  }
+  return 0; // error
+}
+
+CORBA::Boolean operator<< (
+    TAO_OutputCDR &strm,
+    const CORBA::ParDescriptionSeq &_tao_sequence
+  )
+{
+  if (strm << _tao_sequence.length ())
+  {
+    // encode all elements
+    CORBA::Boolean _tao_marshal_flag = 1;
+    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
+      _tao_marshal_flag = (strm << _tao_sequence[i]);
+    }
+    return _tao_marshal_flag;
+  }
+  return 0; // error
+}
+
+CORBA::Boolean operator>> (
+    TAO_InputCDR &strm,
+    CORBA::ParDescriptionSeq &_tao_sequence
+  )
+{
+  CORBA::ULong _tao_seq_len;
+  if (strm >> _tao_seq_len)
+  {
+    // set the length of the sequence
+    _tao_sequence.length (_tao_seq_len);
+    // If length is 0 we return true.
+    if (0 >= _tao_seq_len) 
+      return 1;
+    // retrieve all the elements
+    CORBA::Boolean _tao_marshal_flag = 1;
+    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
+      _tao_marshal_flag = (strm >> _tao_sequence[i]);
+    }
+    return _tao_marshal_flag;
+  }
+  return 0; // error
+}
+
+CORBA::Boolean operator<< (
+    TAO_OutputCDR &strm,
+    const CORBA::ContextIdSeq &_tao_sequence
+  )
+{
+  if (strm << _tao_sequence.length ())
+  {
+    // encode all elements
+    CORBA::Boolean _tao_marshal_flag = 1;
+    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
+      _tao_marshal_flag = (strm << _tao_sequence[i].in ());
+    }
+    return _tao_marshal_flag;
+  }
+  return 0; // error
+}
+
+CORBA::Boolean operator>> (
+    TAO_InputCDR &strm,
+    CORBA::ContextIdSeq &_tao_sequence
+  )
+{
+  CORBA::ULong _tao_seq_len;
+  if (strm >> _tao_seq_len)
+  {
+    // set the length of the sequence
+    _tao_sequence.length (_tao_seq_len);
+    // If length is 0 we return true.
+    if (0 >= _tao_seq_len) 
+      return 1;
+    // retrieve all the elements
+    CORBA::Boolean _tao_marshal_flag = 1;
+    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
+      _tao_marshal_flag = (strm >> _tao_sequence[i].out ());
+    }
+    return _tao_marshal_flag;
+  }
+  return 0; // error
+}
+
+CORBA::Boolean operator<< (
+    TAO_OutputCDR &strm,
+    const CORBA::RepositoryIdSeq &_tao_sequence
+  )
+{
+  if (strm << _tao_sequence.length ())
+  {
+    // encode all elements
+    CORBA::Boolean _tao_marshal_flag = 1;
+    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
+      _tao_marshal_flag = (strm << _tao_sequence[i].in ());
+    }
+    return _tao_marshal_flag;
+  }
+  return 0; // error
+}
+
+CORBA::Boolean operator>> (
+    TAO_InputCDR &strm,
+    CORBA::RepositoryIdSeq &_tao_sequence
+  )
+{
+  CORBA::ULong _tao_seq_len;
+  if (strm >> _tao_seq_len)
+  {
+    // set the length of the sequence
+    _tao_sequence.length (_tao_seq_len);
+    // If length is 0 we return true.
+    if (0 >= _tao_seq_len) 
+      return 1;
+    // retrieve all the elements
+    CORBA::Boolean _tao_marshal_flag = 1;
+    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
+      _tao_marshal_flag = (strm >> _tao_sequence[i].out ());
+    }
+    return _tao_marshal_flag;
+  }
+  return 0; // error
+}
+
+CORBA::Boolean operator<< (
+    TAO_OutputCDR &strm,
+    const CORBA::OpDescriptionSeq &_tao_sequence
+  )
+{
+  if (strm << _tao_sequence.length ())
+  {
+    // encode all elements
+    CORBA::Boolean _tao_marshal_flag = 1;
+    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
+      _tao_marshal_flag = (strm << _tao_sequence[i]);
+    }
+    return _tao_marshal_flag;
+  }
+  return 0; // error
+}
+
+CORBA::Boolean operator>> (
+    TAO_InputCDR &strm,
+    CORBA::OpDescriptionSeq &_tao_sequence
+  )
+{
+  CORBA::ULong _tao_seq_len;
+  if (strm >> _tao_seq_len)
+  {
+    // set the length of the sequence
+    _tao_sequence.length (_tao_seq_len);
+    // If length is 0 we return true.
+    if (0 >= _tao_seq_len) 
+      return 1;
+    // retrieve all the elements
+    CORBA::Boolean _tao_marshal_flag = 1;
+    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
+      _tao_marshal_flag = (strm >> _tao_sequence[i]);
+    }
+    return _tao_marshal_flag;
+  }
+  return 0; // error
+}
+
+CORBA::Boolean operator<< (
+    TAO_OutputCDR &strm,
+    const CORBA::AttrDescriptionSeq &_tao_sequence
+  )
+{
+  if (strm << _tao_sequence.length ())
+  {
+    // encode all elements
+    CORBA::Boolean _tao_marshal_flag = 1;
+    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
+      _tao_marshal_flag = (strm << _tao_sequence[i]);
+    }
+    return _tao_marshal_flag;
+  }
+  return 0; // error
+}
+
+CORBA::Boolean operator>> (
+    TAO_InputCDR &strm,
+    CORBA::AttrDescriptionSeq &_tao_sequence
+  )
+{
+  CORBA::ULong _tao_seq_len;
+  if (strm >> _tao_seq_len)
+  {
+    // set the length of the sequence
+    _tao_sequence.length (_tao_seq_len);
+    // If length is 0 we return true.
+    if (0 >= _tao_seq_len) 
+      return 1;
+    // retrieve all the elements
+    CORBA::Boolean _tao_marshal_flag = 1;
+    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
+      _tao_marshal_flag = (strm >> _tao_sequence[i]);
+    }
+    return _tao_marshal_flag;
+  }
+  return 0; // error
+}
+
diff --git a/TAO/tao/IFR_Client/IFR_BasicC.h b/TAO/tao/IFR_Client/IFR_BasicC.h
new file mode 100644
index 00000000000..c9f23caae16
--- /dev/null
+++ b/TAO/tao/IFR_Client/IFR_BasicC.h
@@ -0,0 +1,12073 @@
+// -*- C++ -*-
+//
+// $Id$
+
+// ****  Code generated by the The ACE ORB (TAO) IDL Compiler ****
+// TAO and the TAO IDL Compiler have been developed by:
+//       Center for Distributed Object Computing
+//       Washington University
+//       St. Louis, MO
+//       USA
+//       http://www.cs.wustl.edu/~schmidt/doc-center.html
+// and
+//       Distributed Object Computing Laboratory
+//       University of California at Irvine
+//       Irvine, CA
+//       USA
+//       http://doc.ece.uci.edu/
+//
+// Information about TAO is available at:
+//     http://www.cs.wustl.edu/~schmidt/TAO.html
+
+#ifndef TAO_IDL_IFR_BASICC_H
+#define TAO_IDL_IFR_BASICC_H
+
+#include "ace/pre.h"
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+# pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+#include "IFR_BaseC.h"
+
+#if defined (TAO_EXPORT_MACRO)
+#undef TAO_EXPORT_MACRO
+#endif
+#define TAO_EXPORT_MACRO TAO_IFR_Client_Export
+
+#if defined (TAO_EXPORT_NESTED_CLASSES)
+#  if defined (TAO_EXPORT_NESTED_MACRO)
+#    undef TAO_EXPORT_NESTED_MACRO
+#  endif /* defined (TAO_EXPORT_NESTED_MACRO) */
+#  define TAO_EXPORT_NESTED_MACRO TAO_IFR_Client_Export
+#endif /* TAO_EXPORT_NESTED_CLASSES */
+
+#if defined(_MSC_VER)
+#if (_MSC_VER >= 1200)
+#pragma warning(push)
+#endif /* _MSC_VER >= 1200 */
+#pragma warning(disable:4250)
+#endif /* _MSC_VER */
+
+#if defined (__BORLANDC__)
+#pragma option push -w-rvl -w-rch -w-ccc -w-inl
+#endif /* __BORLANDC__ */
+
+// *******************************************************************
+// Sequence classes moved fron IFR_BaseC.h
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_INTERFACEDEFSEQ_CH_)
+#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_INTERFACEDEFSEQ_CH_
+
+  class _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq : public TAO_Unbounded_Base_Sequence
+  {
+  public:
+    // = Initialization and termination methods.
+    
+    _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq (void);
+    _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq (CORBA::ULong maximum);
+    _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq (CORBA::ULong maximum,
+      CORBA::ULong length,
+      CORBA_InterfaceDef* *value,
+      CORBA::Boolean release = 0);
+    _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq(const _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq &rhs);
+    virtual ~_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq (void);
+    _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq &operator= (const _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq &rhs);
+    TAO_Object_Manager<CORBA::InterfaceDef,CORBA::InterfaceDef_var> operator[] (CORBA::ULong index) const;
+    static CORBA_InterfaceDef **allocbuf (CORBA::ULong nelems);
+    static void freebuf (CORBA_InterfaceDef **buffer);
+    // The Base_Sequence functions, please see tao/Sequence.h
+    virtual void _allocate_buffer (CORBA::ULong length);
+    virtual void _deallocate_buffer (void);
+    CORBA_InterfaceDef* *get_buffer (CORBA::Boolean orphan = 0);
+    const CORBA_InterfaceDef* *get_buffer (void) const;
+    virtual void _shrink_buffer (CORBA::ULong nl, CORBA::ULong ol);
+    virtual void _downcast (
+        void* target,
+        CORBA_Object *src,
+        CORBA_Environment &ACE_TRY_ENV = 
+          TAO_default_environment ()
+      );
+    virtual CORBA_Object* _upcast (void *src) const;
+    
+  };
+
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_CORBA_INTERFACEDEFSEQ_CH_)
+#define _CORBA_INTERFACEDEFSEQ_CH_
+
+class CORBA_InterfaceDefSeq;
+class CORBA_InterfaceDefSeq_var;
+
+// *************************************************************
+// CORBA_InterfaceDefSeq
+// *************************************************************
+
+class TAO_IFR_Client_Export CORBA_InterfaceDefSeq : public 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<CORBA_InterfaceDef,CORBA_InterfaceDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+{
+public:
+  CORBA_InterfaceDefSeq (void); // default ctor
+  CORBA_InterfaceDefSeq (CORBA::ULong max); // uses max size
+  CORBA_InterfaceDefSeq (
+    CORBA::ULong max, 
+    CORBA::ULong length, 
+    CORBA_InterfaceDef_ptr *buffer, 
+    CORBA::Boolean release = 0
+  );
+  CORBA_InterfaceDefSeq (const CORBA_InterfaceDefSeq &); // copy ctor
+  ~CORBA_InterfaceDefSeq (void);
+  static void _tao_any_destructor (void*);
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef CORBA_InterfaceDefSeq_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+};
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_INTERFACEDEFSEQ___VAR_CH_)
+#define _CORBA_INTERFACEDEFSEQ___VAR_CH_
+
+// *************************************************************
+// class CORBA_InterfaceDefSeq_var
+// *************************************************************
+
+class TAO_IFR_Client_Export CORBA_InterfaceDefSeq_var
+{
+public:
+  CORBA_InterfaceDefSeq_var (void); // default constructor
+  CORBA_InterfaceDefSeq_var (CORBA_InterfaceDefSeq *);
+  CORBA_InterfaceDefSeq_var (const CORBA_InterfaceDefSeq_var &); // copy constructor
+  ~CORBA_InterfaceDefSeq_var (void); // destructor
+  
+  CORBA_InterfaceDefSeq_var &operator= (CORBA_InterfaceDefSeq *);
+  CORBA_InterfaceDefSeq_var &operator= (const CORBA_InterfaceDefSeq_var &);
+  CORBA_InterfaceDefSeq *operator-> (void);
+  const CORBA_InterfaceDefSeq *operator-> (void) const;
+  
+  operator const CORBA_InterfaceDefSeq &() const;
+  operator CORBA_InterfaceDefSeq &();
+  operator CORBA_InterfaceDefSeq &() const;
+  operator CORBA_InterfaceDefSeq *&(); // variable-size base types only
+  
+  TAO_Object_Manager<CORBA::InterfaceDef, CORBA::InterfaceDef_var> operator[] (CORBA::ULong index);
+  
+  // in, inout, out, _retn 
+  const CORBA_InterfaceDefSeq &in (void) const;
+  CORBA_InterfaceDefSeq &inout (void);
+  CORBA_InterfaceDefSeq *&out (void);
+  CORBA_InterfaceDefSeq *_retn (void);
+  CORBA_InterfaceDefSeq *ptr (void) const;
+
+private:
+  CORBA_InterfaceDefSeq *ptr_;
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_INTERFACEDEFSEQ___OUT_CH_)
+#define _CORBA_INTERFACEDEFSEQ___OUT_CH_
+
+class TAO_IFR_Client_Export CORBA_InterfaceDefSeq_out
+{
+public:
+  CORBA_InterfaceDefSeq_out (CORBA_InterfaceDefSeq *&);
+  CORBA_InterfaceDefSeq_out (CORBA_InterfaceDefSeq_var &);
+  CORBA_InterfaceDefSeq_out (const CORBA_InterfaceDefSeq_out &);
+  CORBA_InterfaceDefSeq_out &operator= (const CORBA_InterfaceDefSeq_out &);
+  CORBA_InterfaceDefSeq_out &operator= (CORBA_InterfaceDefSeq *);
+  operator CORBA_InterfaceDefSeq *&();
+  CORBA_InterfaceDefSeq *&ptr (void);
+  CORBA_InterfaceDefSeq *operator-> (void);
+  TAO_Object_Manager<CORBA::InterfaceDef, CORBA::InterfaceDef_var> operator[] (CORBA::ULong index);
+  
+private:
+  CORBA_InterfaceDefSeq *&ptr_;
+  // assignment from T_var not allowed
+  void operator= (const CORBA_InterfaceDefSeq_var &);
+};
+
+
+#endif /* end #if !defined */
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_ABSTRACTINTERFACEDEFSEQ_CH_)
+#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_ABSTRACTINTERFACEDEFSEQ_CH_
+
+  class _TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq : public TAO_Unbounded_Base_Sequence
+  {
+  public:
+    // = Initialization and termination methods.
+    
+    _TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq (void);
+    _TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq (CORBA::ULong maximum);
+    _TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq (CORBA::ULong maximum,
+      CORBA::ULong length,
+      CORBA_AbstractInterfaceDef* *value,
+      CORBA::Boolean release = 0);
+    _TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq(const _TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq &rhs);
+    virtual ~_TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq (void);
+    _TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq &operator= (const _TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq &rhs);
+    TAO_Object_Manager<CORBA::AbstractInterfaceDef,CORBA::AbstractInterfaceDef_var> operator[] (CORBA::ULong index) const;
+    static CORBA_AbstractInterfaceDef **allocbuf (CORBA::ULong nelems);
+    static void freebuf (CORBA_AbstractInterfaceDef **buffer);
+    // The Base_Sequence functions, please see tao/Sequence.h
+    virtual void _allocate_buffer (CORBA::ULong length);
+    virtual void _deallocate_buffer (void);
+    CORBA_AbstractInterfaceDef* *get_buffer (CORBA::Boolean orphan = 0);
+    const CORBA_AbstractInterfaceDef* *get_buffer (void) const;
+    virtual void _shrink_buffer (CORBA::ULong nl, CORBA::ULong ol);
+    virtual void _downcast (
+        void* target,
+        CORBA_Object *src,
+        CORBA_Environment &ACE_TRY_ENV = 
+          TAO_default_environment ()
+      );
+    virtual CORBA_Object* _upcast (void *src) const;
+    
+  };
+
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_CORBA_ABSTRACTINTERFACEDEFSEQ_CH_)
+#define _CORBA_ABSTRACTINTERFACEDEFSEQ_CH_
+
+class CORBA_AbstractInterfaceDefSeq;
+class CORBA_AbstractInterfaceDefSeq_var;
+
+// *************************************************************
+// CORBA_AbstractInterfaceDefSeq
+// *************************************************************
+
+class TAO_IFR_Client_Export CORBA_AbstractInterfaceDefSeq : public 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<CORBA_AbstractInterfaceDef,CORBA_AbstractInterfaceDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+{
+public:
+  CORBA_AbstractInterfaceDefSeq (void); // default ctor
+  CORBA_AbstractInterfaceDefSeq (CORBA::ULong max); // uses max size
+  CORBA_AbstractInterfaceDefSeq (
+    CORBA::ULong max, 
+    CORBA::ULong length, 
+    CORBA_AbstractInterfaceDef_ptr *buffer, 
+    CORBA::Boolean release = 0
+  );
+  CORBA_AbstractInterfaceDefSeq (const CORBA_AbstractInterfaceDefSeq &); // copy ctor
+  ~CORBA_AbstractInterfaceDefSeq (void);
+  static void _tao_any_destructor (void*);
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef CORBA_AbstractInterfaceDefSeq_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+};
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_ABSTRACTINTERFACEDEFSEQ___VAR_CH_)
+#define _CORBA_ABSTRACTINTERFACEDEFSEQ___VAR_CH_
+
+// *************************************************************
+// class CORBA_AbstractInterfaceDefSeq_var
+// *************************************************************
+
+class TAO_IFR_Client_Export CORBA_AbstractInterfaceDefSeq_var
+{
+public:
+  CORBA_AbstractInterfaceDefSeq_var (void); // default constructor
+  CORBA_AbstractInterfaceDefSeq_var (CORBA_AbstractInterfaceDefSeq *);
+  CORBA_AbstractInterfaceDefSeq_var (const CORBA_AbstractInterfaceDefSeq_var &); // copy constructor
+  ~CORBA_AbstractInterfaceDefSeq_var (void); // destructor
+  
+  CORBA_AbstractInterfaceDefSeq_var &operator= (CORBA_AbstractInterfaceDefSeq *);
+  CORBA_AbstractInterfaceDefSeq_var &operator= (const CORBA_AbstractInterfaceDefSeq_var &);
+  CORBA_AbstractInterfaceDefSeq *operator-> (void);
+  const CORBA_AbstractInterfaceDefSeq *operator-> (void) const;
+  
+  operator const CORBA_AbstractInterfaceDefSeq &() const;
+  operator CORBA_AbstractInterfaceDefSeq &();
+  operator CORBA_AbstractInterfaceDefSeq &() const;
+  operator CORBA_AbstractInterfaceDefSeq *&(); // variable-size base types only
+  
+  TAO_Object_Manager<CORBA::AbstractInterfaceDef, CORBA::AbstractInterfaceDef_var> operator[] (CORBA::ULong index);
+  
+  // in, inout, out, _retn 
+  const CORBA_AbstractInterfaceDefSeq &in (void) const;
+  CORBA_AbstractInterfaceDefSeq &inout (void);
+  CORBA_AbstractInterfaceDefSeq *&out (void);
+  CORBA_AbstractInterfaceDefSeq *_retn (void);
+  CORBA_AbstractInterfaceDefSeq *ptr (void) const;
+
+private:
+  CORBA_AbstractInterfaceDefSeq *ptr_;
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_ABSTRACTINTERFACEDEFSEQ___OUT_CH_)
+#define _CORBA_ABSTRACTINTERFACEDEFSEQ___OUT_CH_
+
+class TAO_IFR_Client_Export CORBA_AbstractInterfaceDefSeq_out
+{
+public:
+  CORBA_AbstractInterfaceDefSeq_out (CORBA_AbstractInterfaceDefSeq *&);
+  CORBA_AbstractInterfaceDefSeq_out (CORBA_AbstractInterfaceDefSeq_var &);
+  CORBA_AbstractInterfaceDefSeq_out (const CORBA_AbstractInterfaceDefSeq_out &);
+  CORBA_AbstractInterfaceDefSeq_out &operator= (const CORBA_AbstractInterfaceDefSeq_out &);
+  CORBA_AbstractInterfaceDefSeq_out &operator= (CORBA_AbstractInterfaceDefSeq *);
+  operator CORBA_AbstractInterfaceDefSeq *&();
+  CORBA_AbstractInterfaceDefSeq *&ptr (void);
+  CORBA_AbstractInterfaceDefSeq *operator-> (void);
+  TAO_Object_Manager<CORBA::AbstractInterfaceDef, CORBA::AbstractInterfaceDef_var> operator[] (CORBA::ULong index);
+  
+private:
+  CORBA_AbstractInterfaceDefSeq *&ptr_;
+  // assignment from T_var not allowed
+  void operator= (const CORBA_AbstractInterfaceDefSeq_var &);
+};
+
+
+#endif /* end #if !defined */
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_LOCALINTERFACEDEFSEQ_CH_)
+#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_LOCALINTERFACEDEFSEQ_CH_
+
+  class _TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq : public TAO_Unbounded_Base_Sequence
+  {
+  public:
+    // = Initialization and termination methods.
+    
+    _TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq (void);
+    _TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq (CORBA::ULong maximum);
+    _TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq (CORBA::ULong maximum,
+      CORBA::ULong length,
+      CORBA_LocalInterfaceDef* *value,
+      CORBA::Boolean release = 0);
+    _TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq(const _TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq &rhs);
+    virtual ~_TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq (void);
+    _TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq &operator= (const _TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq &rhs);
+    TAO_Object_Manager<CORBA::LocalInterfaceDef,CORBA::LocalInterfaceDef_var> operator[] (CORBA::ULong index) const;
+    static CORBA_LocalInterfaceDef **allocbuf (CORBA::ULong nelems);
+    static void freebuf (CORBA_LocalInterfaceDef **buffer);
+    // The Base_Sequence functions, please see tao/Sequence.h
+    virtual void _allocate_buffer (CORBA::ULong length);
+    virtual void _deallocate_buffer (void);
+    CORBA_LocalInterfaceDef* *get_buffer (CORBA::Boolean orphan = 0);
+    const CORBA_LocalInterfaceDef* *get_buffer (void) const;
+    virtual void _shrink_buffer (CORBA::ULong nl, CORBA::ULong ol);
+    virtual void _downcast (
+        void* target,
+        CORBA_Object *src,
+        CORBA_Environment &ACE_TRY_ENV = 
+          TAO_default_environment ()
+      );
+    virtual CORBA_Object* _upcast (void *src) const;
+    
+  };
+
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_CORBA_LOCALINTERFACEDEFSEQ_CH_)
+#define _CORBA_LOCALINTERFACEDEFSEQ_CH_
+
+class CORBA_LocalInterfaceDefSeq;
+class CORBA_LocalInterfaceDefSeq_var;
+
+// *************************************************************
+// CORBA_LocalInterfaceDefSeq
+// *************************************************************
+
+class TAO_IFR_Client_Export CORBA_LocalInterfaceDefSeq : public 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<CORBA_LocalInterfaceDef,CORBA_LocalInterfaceDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+{
+public:
+  CORBA_LocalInterfaceDefSeq (void); // default ctor
+  CORBA_LocalInterfaceDefSeq (CORBA::ULong max); // uses max size
+  CORBA_LocalInterfaceDefSeq (
+    CORBA::ULong max, 
+    CORBA::ULong length, 
+    CORBA_LocalInterfaceDef_ptr *buffer, 
+    CORBA::Boolean release = 0
+  );
+  CORBA_LocalInterfaceDefSeq (const CORBA_LocalInterfaceDefSeq &); // copy ctor
+  ~CORBA_LocalInterfaceDefSeq (void);
+  static void _tao_any_destructor (void*);
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef CORBA_LocalInterfaceDefSeq_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+};
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_LOCALINTERFACEDEFSEQ___VAR_CH_)
+#define _CORBA_LOCALINTERFACEDEFSEQ___VAR_CH_
+
+// *************************************************************
+// class CORBA_LocalInterfaceDefSeq_var
+// *************************************************************
+
+class TAO_IFR_Client_Export CORBA_LocalInterfaceDefSeq_var
+{
+public:
+  CORBA_LocalInterfaceDefSeq_var (void); // default constructor
+  CORBA_LocalInterfaceDefSeq_var (CORBA_LocalInterfaceDefSeq *);
+  CORBA_LocalInterfaceDefSeq_var (const CORBA_LocalInterfaceDefSeq_var &); // copy constructor
+  ~CORBA_LocalInterfaceDefSeq_var (void); // destructor
+  
+  CORBA_LocalInterfaceDefSeq_var &operator= (CORBA_LocalInterfaceDefSeq *);
+  CORBA_LocalInterfaceDefSeq_var &operator= (const CORBA_LocalInterfaceDefSeq_var &);
+  CORBA_LocalInterfaceDefSeq *operator-> (void);
+  const CORBA_LocalInterfaceDefSeq *operator-> (void) const;
+  
+  operator const CORBA_LocalInterfaceDefSeq &() const;
+  operator CORBA_LocalInterfaceDefSeq &();
+  operator CORBA_LocalInterfaceDefSeq &() const;
+  operator CORBA_LocalInterfaceDefSeq *&(); // variable-size base types only
+  
+  TAO_Object_Manager<CORBA::LocalInterfaceDef, CORBA::LocalInterfaceDef_var> operator[] (CORBA::ULong index);
+  
+  // in, inout, out, _retn 
+  const CORBA_LocalInterfaceDefSeq &in (void) const;
+  CORBA_LocalInterfaceDefSeq &inout (void);
+  CORBA_LocalInterfaceDefSeq *&out (void);
+  CORBA_LocalInterfaceDefSeq *_retn (void);
+  CORBA_LocalInterfaceDefSeq *ptr (void) const;
+
+private:
+  CORBA_LocalInterfaceDefSeq *ptr_;
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_LOCALINTERFACEDEFSEQ___OUT_CH_)
+#define _CORBA_LOCALINTERFACEDEFSEQ___OUT_CH_
+
+class TAO_IFR_Client_Export CORBA_LocalInterfaceDefSeq_out
+{
+public:
+  CORBA_LocalInterfaceDefSeq_out (CORBA_LocalInterfaceDefSeq *&);
+  CORBA_LocalInterfaceDefSeq_out (CORBA_LocalInterfaceDefSeq_var &);
+  CORBA_LocalInterfaceDefSeq_out (const CORBA_LocalInterfaceDefSeq_out &);
+  CORBA_LocalInterfaceDefSeq_out &operator= (const CORBA_LocalInterfaceDefSeq_out &);
+  CORBA_LocalInterfaceDefSeq_out &operator= (CORBA_LocalInterfaceDefSeq *);
+  operator CORBA_LocalInterfaceDefSeq *&();
+  CORBA_LocalInterfaceDefSeq *&ptr (void);
+  CORBA_LocalInterfaceDefSeq *operator-> (void);
+  TAO_Object_Manager<CORBA::LocalInterfaceDef, CORBA::LocalInterfaceDef_var> operator[] (CORBA::ULong index);
+  
+private:
+  CORBA_LocalInterfaceDefSeq *&ptr_;
+  // assignment from T_var not allowed
+  void operator= (const CORBA_LocalInterfaceDefSeq_var &);
+};
+
+
+#endif /* end #if !defined */
+
+// ************************************************************************
+
+  class CORBA_PrimitiveDef;
+  
+#if !defined (_CORBA_PRIMITIVEDEF___PTR_CH_)
+#define _CORBA_PRIMITIVEDEF___PTR_CH_
+
+typedef CORBA_PrimitiveDef *CORBA_PrimitiveDef_ptr;
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_PRIMITIVEDEF___VAR_CH_)
+#define _CORBA_PRIMITIVEDEF___VAR_CH_
+
+  class TAO_IFR_Client_Export CORBA_PrimitiveDef_var : public TAO_Base_var
+  {
+  public:
+    CORBA_PrimitiveDef_var (void); // default constructor
+    CORBA_PrimitiveDef_var (CORBA_PrimitiveDef_ptr p) : ptr_ (p) {} 
+    CORBA_PrimitiveDef_var (const CORBA_PrimitiveDef_var &); // copy constructor
+    ~CORBA_PrimitiveDef_var (void); // destructor
+    
+    CORBA_PrimitiveDef_var &operator= (CORBA_PrimitiveDef_ptr);
+    CORBA_PrimitiveDef_var &operator= (const CORBA_PrimitiveDef_var &);
+    CORBA_PrimitiveDef_ptr operator-> (void) const;
+    
+    operator const CORBA_PrimitiveDef_ptr &() const;
+    operator CORBA_PrimitiveDef_ptr &();
+    // in, inout, out, _retn 
+    CORBA_PrimitiveDef_ptr in (void) const;
+    CORBA_PrimitiveDef_ptr &inout (void);
+    CORBA_PrimitiveDef_ptr &out (void);
+    CORBA_PrimitiveDef_ptr _retn (void);
+    CORBA_PrimitiveDef_ptr ptr (void) const;
+
+  private:
+    CORBA_PrimitiveDef_ptr ptr_;
+    // Unimplemented - prevents widening assignment.
+    CORBA_PrimitiveDef_var (const TAO_Base_var &rhs);
+    CORBA_PrimitiveDef_var &operator= (const TAO_Base_var &rhs);
+  };
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_PRIMITIVEDEF___OUT_CH_)
+#define _CORBA_PRIMITIVEDEF___OUT_CH_
+
+  class TAO_IFR_Client_Export CORBA_PrimitiveDef_out
+  {
+  public:
+    CORBA_PrimitiveDef_out (CORBA_PrimitiveDef_ptr &);
+    CORBA_PrimitiveDef_out (CORBA_PrimitiveDef_var &);
+    CORBA_PrimitiveDef_out (const CORBA_PrimitiveDef_out &);
+    CORBA_PrimitiveDef_out &operator= (const CORBA_PrimitiveDef_out &);
+    CORBA_PrimitiveDef_out &operator= (const CORBA_PrimitiveDef_var &);
+    CORBA_PrimitiveDef_out &operator= (CORBA_PrimitiveDef_ptr);
+    operator CORBA_PrimitiveDef_ptr &();
+    CORBA_PrimitiveDef_ptr &ptr (void);
+    CORBA_PrimitiveDef_ptr operator-> (void);
+    
+  private:
+    CORBA_PrimitiveDef_ptr &ptr_;
+  };
+
+
+#endif /* end #if !defined */
+
+  class CORBA_StringDef;
+  
+#if !defined (_CORBA_STRINGDEF___PTR_CH_)
+#define _CORBA_STRINGDEF___PTR_CH_
+
+typedef CORBA_StringDef *CORBA_StringDef_ptr;
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_STRINGDEF___VAR_CH_)
+#define _CORBA_STRINGDEF___VAR_CH_
+
+  class TAO_IFR_Client_Export CORBA_StringDef_var : public TAO_Base_var
+  {
+  public:
+    CORBA_StringDef_var (void); // default constructor
+    CORBA_StringDef_var (CORBA_StringDef_ptr p) : ptr_ (p) {} 
+    CORBA_StringDef_var (const CORBA_StringDef_var &); // copy constructor
+    ~CORBA_StringDef_var (void); // destructor
+    
+    CORBA_StringDef_var &operator= (CORBA_StringDef_ptr);
+    CORBA_StringDef_var &operator= (const CORBA_StringDef_var &);
+    CORBA_StringDef_ptr operator-> (void) const;
+    
+    operator const CORBA_StringDef_ptr &() const;
+    operator CORBA_StringDef_ptr &();
+    // in, inout, out, _retn 
+    CORBA_StringDef_ptr in (void) const;
+    CORBA_StringDef_ptr &inout (void);
+    CORBA_StringDef_ptr &out (void);
+    CORBA_StringDef_ptr _retn (void);
+    CORBA_StringDef_ptr ptr (void) const;
+
+  private:
+    CORBA_StringDef_ptr ptr_;
+    // Unimplemented - prevents widening assignment.
+    CORBA_StringDef_var (const TAO_Base_var &rhs);
+    CORBA_StringDef_var &operator= (const TAO_Base_var &rhs);
+  };
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_STRINGDEF___OUT_CH_)
+#define _CORBA_STRINGDEF___OUT_CH_
+
+  class TAO_IFR_Client_Export CORBA_StringDef_out
+  {
+  public:
+    CORBA_StringDef_out (CORBA_StringDef_ptr &);
+    CORBA_StringDef_out (CORBA_StringDef_var &);
+    CORBA_StringDef_out (const CORBA_StringDef_out &);
+    CORBA_StringDef_out &operator= (const CORBA_StringDef_out &);
+    CORBA_StringDef_out &operator= (const CORBA_StringDef_var &);
+    CORBA_StringDef_out &operator= (CORBA_StringDef_ptr);
+    operator CORBA_StringDef_ptr &();
+    CORBA_StringDef_ptr &ptr (void);
+    CORBA_StringDef_ptr operator-> (void);
+    
+  private:
+    CORBA_StringDef_ptr &ptr_;
+  };
+
+
+#endif /* end #if !defined */
+
+  class CORBA_SequenceDef;
+  
+#if !defined (_CORBA_SEQUENCEDEF___PTR_CH_)
+#define _CORBA_SEQUENCEDEF___PTR_CH_
+
+typedef CORBA_SequenceDef *CORBA_SequenceDef_ptr;
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_SEQUENCEDEF___VAR_CH_)
+#define _CORBA_SEQUENCEDEF___VAR_CH_
+
+  class TAO_IFR_Client_Export CORBA_SequenceDef_var : public TAO_Base_var
+  {
+  public:
+    CORBA_SequenceDef_var (void); // default constructor
+    CORBA_SequenceDef_var (CORBA_SequenceDef_ptr p) : ptr_ (p) {} 
+    CORBA_SequenceDef_var (const CORBA_SequenceDef_var &); // copy constructor
+    ~CORBA_SequenceDef_var (void); // destructor
+    
+    CORBA_SequenceDef_var &operator= (CORBA_SequenceDef_ptr);
+    CORBA_SequenceDef_var &operator= (const CORBA_SequenceDef_var &);
+    CORBA_SequenceDef_ptr operator-> (void) const;
+    
+    operator const CORBA_SequenceDef_ptr &() const;
+    operator CORBA_SequenceDef_ptr &();
+    // in, inout, out, _retn 
+    CORBA_SequenceDef_ptr in (void) const;
+    CORBA_SequenceDef_ptr &inout (void);
+    CORBA_SequenceDef_ptr &out (void);
+    CORBA_SequenceDef_ptr _retn (void);
+    CORBA_SequenceDef_ptr ptr (void) const;
+
+  private:
+    CORBA_SequenceDef_ptr ptr_;
+    // Unimplemented - prevents widening assignment.
+    CORBA_SequenceDef_var (const TAO_Base_var &rhs);
+    CORBA_SequenceDef_var &operator= (const TAO_Base_var &rhs);
+  };
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_SEQUENCEDEF___OUT_CH_)
+#define _CORBA_SEQUENCEDEF___OUT_CH_
+
+  class TAO_IFR_Client_Export CORBA_SequenceDef_out
+  {
+  public:
+    CORBA_SequenceDef_out (CORBA_SequenceDef_ptr &);
+    CORBA_SequenceDef_out (CORBA_SequenceDef_var &);
+    CORBA_SequenceDef_out (const CORBA_SequenceDef_out &);
+    CORBA_SequenceDef_out &operator= (const CORBA_SequenceDef_out &);
+    CORBA_SequenceDef_out &operator= (const CORBA_SequenceDef_var &);
+    CORBA_SequenceDef_out &operator= (CORBA_SequenceDef_ptr);
+    operator CORBA_SequenceDef_ptr &();
+    CORBA_SequenceDef_ptr &ptr (void);
+    CORBA_SequenceDef_ptr operator-> (void);
+    
+  private:
+    CORBA_SequenceDef_ptr &ptr_;
+  };
+
+
+#endif /* end #if !defined */
+
+  class CORBA_ArrayDef;
+  
+#if !defined (_CORBA_ARRAYDEF___PTR_CH_)
+#define _CORBA_ARRAYDEF___PTR_CH_
+
+typedef CORBA_ArrayDef *CORBA_ArrayDef_ptr;
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_ARRAYDEF___VAR_CH_)
+#define _CORBA_ARRAYDEF___VAR_CH_
+
+  class TAO_IFR_Client_Export CORBA_ArrayDef_var : public TAO_Base_var
+  {
+  public:
+    CORBA_ArrayDef_var (void); // default constructor
+    CORBA_ArrayDef_var (CORBA_ArrayDef_ptr p) : ptr_ (p) {} 
+    CORBA_ArrayDef_var (const CORBA_ArrayDef_var &); // copy constructor
+    ~CORBA_ArrayDef_var (void); // destructor
+    
+    CORBA_ArrayDef_var &operator= (CORBA_ArrayDef_ptr);
+    CORBA_ArrayDef_var &operator= (const CORBA_ArrayDef_var &);
+    CORBA_ArrayDef_ptr operator-> (void) const;
+    
+    operator const CORBA_ArrayDef_ptr &() const;
+    operator CORBA_ArrayDef_ptr &();
+    // in, inout, out, _retn 
+    CORBA_ArrayDef_ptr in (void) const;
+    CORBA_ArrayDef_ptr &inout (void);
+    CORBA_ArrayDef_ptr &out (void);
+    CORBA_ArrayDef_ptr _retn (void);
+    CORBA_ArrayDef_ptr ptr (void) const;
+
+  private:
+    CORBA_ArrayDef_ptr ptr_;
+    // Unimplemented - prevents widening assignment.
+    CORBA_ArrayDef_var (const TAO_Base_var &rhs);
+    CORBA_ArrayDef_var &operator= (const TAO_Base_var &rhs);
+  };
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_ARRAYDEF___OUT_CH_)
+#define _CORBA_ARRAYDEF___OUT_CH_
+
+  class TAO_IFR_Client_Export CORBA_ArrayDef_out
+  {
+  public:
+    CORBA_ArrayDef_out (CORBA_ArrayDef_ptr &);
+    CORBA_ArrayDef_out (CORBA_ArrayDef_var &);
+    CORBA_ArrayDef_out (const CORBA_ArrayDef_out &);
+    CORBA_ArrayDef_out &operator= (const CORBA_ArrayDef_out &);
+    CORBA_ArrayDef_out &operator= (const CORBA_ArrayDef_var &);
+    CORBA_ArrayDef_out &operator= (CORBA_ArrayDef_ptr);
+    operator CORBA_ArrayDef_ptr &();
+    CORBA_ArrayDef_ptr &ptr (void);
+    CORBA_ArrayDef_ptr operator-> (void);
+    
+  private:
+    CORBA_ArrayDef_ptr &ptr_;
+  };
+
+
+#endif /* end #if !defined */
+
+  class CORBA_WstringDef;
+  
+#if !defined (_CORBA_WSTRINGDEF___PTR_CH_)
+#define _CORBA_WSTRINGDEF___PTR_CH_
+
+typedef CORBA_WstringDef *CORBA_WstringDef_ptr;
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_WSTRINGDEF___VAR_CH_)
+#define _CORBA_WSTRINGDEF___VAR_CH_
+
+  class TAO_IFR_Client_Export CORBA_WstringDef_var : public TAO_Base_var
+  {
+  public:
+    CORBA_WstringDef_var (void); // default constructor
+    CORBA_WstringDef_var (CORBA_WstringDef_ptr p) : ptr_ (p) {} 
+    CORBA_WstringDef_var (const CORBA_WstringDef_var &); // copy constructor
+    ~CORBA_WstringDef_var (void); // destructor
+    
+    CORBA_WstringDef_var &operator= (CORBA_WstringDef_ptr);
+    CORBA_WstringDef_var &operator= (const CORBA_WstringDef_var &);
+    CORBA_WstringDef_ptr operator-> (void) const;
+    
+    operator const CORBA_WstringDef_ptr &() const;
+    operator CORBA_WstringDef_ptr &();
+    // in, inout, out, _retn 
+    CORBA_WstringDef_ptr in (void) const;
+    CORBA_WstringDef_ptr &inout (void);
+    CORBA_WstringDef_ptr &out (void);
+    CORBA_WstringDef_ptr _retn (void);
+    CORBA_WstringDef_ptr ptr (void) const;
+
+  private:
+    CORBA_WstringDef_ptr ptr_;
+    // Unimplemented - prevents widening assignment.
+    CORBA_WstringDef_var (const TAO_Base_var &rhs);
+    CORBA_WstringDef_var &operator= (const TAO_Base_var &rhs);
+  };
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_WSTRINGDEF___OUT_CH_)
+#define _CORBA_WSTRINGDEF___OUT_CH_
+
+  class TAO_IFR_Client_Export CORBA_WstringDef_out
+  {
+  public:
+    CORBA_WstringDef_out (CORBA_WstringDef_ptr &);
+    CORBA_WstringDef_out (CORBA_WstringDef_var &);
+    CORBA_WstringDef_out (const CORBA_WstringDef_out &);
+    CORBA_WstringDef_out &operator= (const CORBA_WstringDef_out &);
+    CORBA_WstringDef_out &operator= (const CORBA_WstringDef_var &);
+    CORBA_WstringDef_out &operator= (CORBA_WstringDef_ptr);
+    operator CORBA_WstringDef_ptr &();
+    CORBA_WstringDef_ptr &ptr (void);
+    CORBA_WstringDef_ptr operator-> (void);
+    
+  private:
+    CORBA_WstringDef_ptr &ptr_;
+  };
+
+
+#endif /* end #if !defined */
+
+  class CORBA_FixedDef;
+  
+#if !defined (_CORBA_FIXEDDEF___PTR_CH_)
+#define _CORBA_FIXEDDEF___PTR_CH_
+
+typedef CORBA_FixedDef *CORBA_FixedDef_ptr;
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_FIXEDDEF___VAR_CH_)
+#define _CORBA_FIXEDDEF___VAR_CH_
+
+  class TAO_IFR_Client_Export CORBA_FixedDef_var : public TAO_Base_var
+  {
+  public:
+    CORBA_FixedDef_var (void); // default constructor
+    CORBA_FixedDef_var (CORBA_FixedDef_ptr p) : ptr_ (p) {} 
+    CORBA_FixedDef_var (const CORBA_FixedDef_var &); // copy constructor
+    ~CORBA_FixedDef_var (void); // destructor
+    
+    CORBA_FixedDef_var &operator= (CORBA_FixedDef_ptr);
+    CORBA_FixedDef_var &operator= (const CORBA_FixedDef_var &);
+    CORBA_FixedDef_ptr operator-> (void) const;
+    
+    operator const CORBA_FixedDef_ptr &() const;
+    operator CORBA_FixedDef_ptr &();
+    // in, inout, out, _retn 
+    CORBA_FixedDef_ptr in (void) const;
+    CORBA_FixedDef_ptr &inout (void);
+    CORBA_FixedDef_ptr &out (void);
+    CORBA_FixedDef_ptr _retn (void);
+    CORBA_FixedDef_ptr ptr (void) const;
+
+  private:
+    CORBA_FixedDef_ptr ptr_;
+    // Unimplemented - prevents widening assignment.
+    CORBA_FixedDef_var (const TAO_Base_var &rhs);
+    CORBA_FixedDef_var &operator= (const TAO_Base_var &rhs);
+  };
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_FIXEDDEF___OUT_CH_)
+#define _CORBA_FIXEDDEF___OUT_CH_
+
+  class TAO_IFR_Client_Export CORBA_FixedDef_out
+  {
+  public:
+    CORBA_FixedDef_out (CORBA_FixedDef_ptr &);
+    CORBA_FixedDef_out (CORBA_FixedDef_var &);
+    CORBA_FixedDef_out (const CORBA_FixedDef_out &);
+    CORBA_FixedDef_out &operator= (const CORBA_FixedDef_out &);
+    CORBA_FixedDef_out &operator= (const CORBA_FixedDef_var &);
+    CORBA_FixedDef_out &operator= (CORBA_FixedDef_ptr);
+    operator CORBA_FixedDef_ptr &();
+    CORBA_FixedDef_ptr &ptr (void);
+    CORBA_FixedDef_ptr operator-> (void);
+    
+  private:
+    CORBA_FixedDef_ptr &ptr_;
+  };
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_REPOSITORY___VAR_CH_)
+#define _CORBA_REPOSITORY___VAR_CH_
+
+  class TAO_IFR_Client_Export CORBA_Repository_var : public TAO_Base_var
+  {
+  public:
+    CORBA_Repository_var (void); // default constructor
+    CORBA_Repository_var (CORBA_Repository_ptr p) : ptr_ (p) {} 
+    CORBA_Repository_var (const CORBA_Repository_var &); // copy constructor
+    ~CORBA_Repository_var (void); // destructor
+    
+    CORBA_Repository_var &operator= (CORBA_Repository_ptr);
+    CORBA_Repository_var &operator= (const CORBA_Repository_var &);
+    CORBA_Repository_ptr operator-> (void) const;
+    
+    operator const CORBA_Repository_ptr &() const;
+    operator CORBA_Repository_ptr &();
+    // in, inout, out, _retn 
+    CORBA_Repository_ptr in (void) const;
+    CORBA_Repository_ptr &inout (void);
+    CORBA_Repository_ptr &out (void);
+    CORBA_Repository_ptr _retn (void);
+    CORBA_Repository_ptr ptr (void) const;
+
+  private:
+    CORBA_Repository_ptr ptr_;
+    // Unimplemented - prevents widening assignment.
+    CORBA_Repository_var (const TAO_Base_var &rhs);
+    CORBA_Repository_var &operator= (const TAO_Base_var &rhs);
+  };
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_REPOSITORY___OUT_CH_)
+#define _CORBA_REPOSITORY___OUT_CH_
+
+  class TAO_IFR_Client_Export CORBA_Repository_out
+  {
+  public:
+    CORBA_Repository_out (CORBA_Repository_ptr &);
+    CORBA_Repository_out (CORBA_Repository_var &);
+    CORBA_Repository_out (const CORBA_Repository_out &);
+    CORBA_Repository_out &operator= (const CORBA_Repository_out &);
+    CORBA_Repository_out &operator= (const CORBA_Repository_var &);
+    CORBA_Repository_out &operator= (CORBA_Repository_ptr);
+    operator CORBA_Repository_ptr &();
+    CORBA_Repository_ptr &ptr (void);
+    CORBA_Repository_ptr operator-> (void);
+    
+  private:
+    CORBA_Repository_ptr &ptr_;
+  };
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_REPOSITORY_CH_)
+#define _CORBA_REPOSITORY_CH_
+
+// Forward Classes Declaration
+  class _TAO_Repository_Proxy_Impl;
+  class _TAO_Repository_Remote_Proxy_Impl;
+  class _TAO_Repository_Proxy_Broker;
+  class _TAO_Repository_Remote_Proxy_Broker;
+  
+  class TAO_IFR_Client_Export CORBA_Repository: public virtual CORBA_Container
+  {
+  public:
+  #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+    typedef CORBA_Repository_ptr _ptr_type;
+    typedef CORBA_Repository_var _var_type;
+  #endif /* ! __GNUC__ || g++ >= 2.8 */
+
+    // the static operations
+    static CORBA_Repository_ptr _duplicate (CORBA_Repository_ptr obj);
+    static CORBA_Repository_ptr _narrow (
+        CORBA::Object_ptr obj,
+        CORBA::Environment &ACE_TRY_ENV = 
+          TAO_default_environment ()
+      );
+    static CORBA_Repository_ptr _unchecked_narrow (
+        CORBA::Object_ptr obj,
+        CORBA::Environment &ACE_TRY_ENV = 
+          TAO_default_environment ()
+      );
+    static CORBA_Repository_ptr _nil (void)
+      {
+        return (CORBA_Repository_ptr)0;
+      }
+
+    static void _tao_any_destructor (void*);
+
+    virtual CORBA::Contained_ptr lookup_id (
+        const char * search_id,
+        CORBA::Environment &ACE_TRY_ENV = 
+          TAO_default_environment ()
+      )
+      ACE_THROW_SPEC ((
+        CORBA::SystemException
+      ));
+
+    virtual CORBA::TypeCode_ptr get_canonical_typecode (
+        CORBA::TypeCode_ptr tc,
+        CORBA::Environment &ACE_TRY_ENV = 
+          TAO_default_environment ()
+      )
+      ACE_THROW_SPEC ((
+        CORBA::SystemException
+      ));
+
+    virtual CORBA::PrimitiveDef_ptr get_primitive (
+        CORBA::PrimitiveKind kind,
+        CORBA::Environment &ACE_TRY_ENV = 
+          TAO_default_environment ()
+      )
+      ACE_THROW_SPEC ((
+        CORBA::SystemException
+      ));
+
+    virtual CORBA::StringDef_ptr create_string (
+        CORBA::ULong bound,
+        CORBA::Environment &ACE_TRY_ENV = 
+          TAO_default_environment ()
+      )
+      ACE_THROW_SPEC ((
+        CORBA::SystemException
+      ));
+
+    virtual CORBA::WstringDef_ptr create_wstring (
+        CORBA::ULong bound,
+        CORBA::Environment &ACE_TRY_ENV = 
+          TAO_default_environment ()
+      )
+      ACE_THROW_SPEC ((
+        CORBA::SystemException
+      ));
+
+    virtual CORBA::SequenceDef_ptr create_sequence (
+        CORBA::ULong bound,
+        CORBA::IDLType_ptr element_type,
+        CORBA::Environment &ACE_TRY_ENV = 
+          TAO_default_environment ()
+      )
+      ACE_THROW_SPEC ((
+        CORBA::SystemException
+      ));
+
+    virtual CORBA::ArrayDef_ptr create_array (
+        CORBA::ULong length,
+        CORBA::IDLType_ptr element_type,
+        CORBA::Environment &ACE_TRY_ENV = 
+          TAO_default_environment ()
+      )
+      ACE_THROW_SPEC ((
+        CORBA::SystemException
+      ));
+
+    virtual CORBA::FixedDef_ptr create_fixed (
+        CORBA::UShort digits,
+        CORBA::Short scale,
+        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_Repository_Proxy_Broker *the_TAO_Repository_Proxy_Broker_;
+    
+  protected:
+    CORBA_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 CORBA_Repository_setup_collocation (int collocated);
+      
+      CORBA_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 ~CORBA_Repository (void);
+  private:
+    CORBA_Repository (const CORBA_Repository &);
+    void operator= (const CORBA_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_CORBA_Repository_lookup_id : public TAO_ClientRequestInfo
+    {
+    public:
+      friend class CORBA_Repository;
+      
+      friend class _TAO_Repository_Remote_Proxy_Impl;
+      friend class _TAO_Repository_ThruPOA_Proxy_Impl;
+      friend class _TAO_Repository_Direct_Proxy_Impl;
+    
+    TAO_ClientRequestInfo_CORBA_Repository_lookup_id (
+        TAO_GIOP_Invocation *_tao_invocation,
+        CORBA::Object_ptr _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_CORBA_Repository_lookup_id (const TAO_ClientRequestInfo_CORBA_Repository_lookup_id &);
+    void operator= (const TAO_ClientRequestInfo_CORBA_Repository_lookup_id &);
+    const char * search_id_;
+    void result (CORBA::Contained_ptr result);
+    // update the result 
+    CORBA::Contained_ptr _result;
+  };
+  
+  class TAO_ClientRequestInfo_CORBA_Repository_get_canonical_typecode : public TAO_ClientRequestInfo
+  {
+  public:
+    friend class CORBA_Repository;
+    
+    friend class _TAO_Repository_Remote_Proxy_Impl;
+    friend class _TAO_Repository_ThruPOA_Proxy_Impl;
+    friend class _TAO_Repository_Direct_Proxy_Impl;
+  
+  TAO_ClientRequestInfo_CORBA_Repository_get_canonical_typecode (
+      TAO_GIOP_Invocation *_tao_invocation,
+      CORBA::Object_ptr _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_CORBA_Repository_get_canonical_typecode (const TAO_ClientRequestInfo_CORBA_Repository_get_canonical_typecode &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_Repository_get_canonical_typecode &);
+  CORBA::TypeCode_ptr tc_;
+  void result (CORBA::TypeCode_ptr result);
+  // update the result 
+  CORBA::TypeCode_ptr _result;
+};
+
+class TAO_ClientRequestInfo_CORBA_Repository_get_primitive : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_Repository;
+  
+  friend class _TAO_Repository_Remote_Proxy_Impl;
+  friend class _TAO_Repository_ThruPOA_Proxy_Impl;
+  friend class _TAO_Repository_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_Repository_get_primitive (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::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_CORBA_Repository_get_primitive (const TAO_ClientRequestInfo_CORBA_Repository_get_primitive &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_Repository_get_primitive &);
+  const CORBA::PrimitiveKind & kind_;
+  void result (CORBA::PrimitiveDef_ptr result);
+  // update the result 
+  CORBA::PrimitiveDef_ptr _result;
+};
+
+class TAO_ClientRequestInfo_CORBA_Repository_create_string : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_Repository;
+  
+  friend class _TAO_Repository_Remote_Proxy_Impl;
+  friend class _TAO_Repository_ThruPOA_Proxy_Impl;
+  friend class _TAO_Repository_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_Repository_create_string (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _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_CORBA_Repository_create_string (const TAO_ClientRequestInfo_CORBA_Repository_create_string &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_Repository_create_string &);
+  const CORBA::ULong & bound_;
+  void result (CORBA::StringDef_ptr result);
+  // update the result 
+  CORBA::StringDef_ptr _result;
+};
+
+class TAO_ClientRequestInfo_CORBA_Repository_create_wstring : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_Repository;
+  
+  friend class _TAO_Repository_Remote_Proxy_Impl;
+  friend class _TAO_Repository_ThruPOA_Proxy_Impl;
+  friend class _TAO_Repository_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_Repository_create_wstring (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _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_CORBA_Repository_create_wstring (const TAO_ClientRequestInfo_CORBA_Repository_create_wstring &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_Repository_create_wstring &);
+  const CORBA::ULong & bound_;
+  void result (CORBA::WstringDef_ptr result);
+  // update the result 
+  CORBA::WstringDef_ptr _result;
+};
+
+class TAO_ClientRequestInfo_CORBA_Repository_create_sequence : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_Repository;
+  
+  friend class _TAO_Repository_Remote_Proxy_Impl;
+  friend class _TAO_Repository_ThruPOA_Proxy_Impl;
+  friend class _TAO_Repository_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_Repository_create_sequence (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const CORBA::ULong & bound,
+    CORBA::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_CORBA_Repository_create_sequence (const TAO_ClientRequestInfo_CORBA_Repository_create_sequence &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_Repository_create_sequence &);
+  const CORBA::ULong & bound_;
+  CORBA::IDLType_ptr element_type_;
+  void result (CORBA::SequenceDef_ptr result);
+  // update the result 
+  CORBA::SequenceDef_ptr _result;
+};
+
+class TAO_ClientRequestInfo_CORBA_Repository_create_array : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_Repository;
+  
+  friend class _TAO_Repository_Remote_Proxy_Impl;
+  friend class _TAO_Repository_ThruPOA_Proxy_Impl;
+  friend class _TAO_Repository_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_Repository_create_array (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const CORBA::ULong & length,
+    CORBA::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_CORBA_Repository_create_array (const TAO_ClientRequestInfo_CORBA_Repository_create_array &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_Repository_create_array &);
+  const CORBA::ULong & length_;
+  CORBA::IDLType_ptr element_type_;
+  void result (CORBA::ArrayDef_ptr result);
+  // update the result 
+  CORBA::ArrayDef_ptr _result;
+};
+
+class TAO_ClientRequestInfo_CORBA_Repository_create_fixed : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_Repository;
+  
+  friend class _TAO_Repository_Remote_Proxy_Impl;
+  friend class _TAO_Repository_ThruPOA_Proxy_Impl;
+  friend class _TAO_Repository_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_Repository_create_fixed (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _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_CORBA_Repository_create_fixed (const TAO_ClientRequestInfo_CORBA_Repository_create_fixed &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_Repository_create_fixed &);
+  const CORBA::UShort & digits_;
+  const CORBA::Short & scale_;
+  void result (CORBA::FixedDef_ptr result);
+  // update the result 
+  CORBA::FixedDef_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_IFR_Client_Export _TAO_Repository_Proxy_Impl : 
+  public virtual _TAO_Container_Proxy_Impl
+{
+public:
+  virtual ~_TAO_Repository_Proxy_Impl (void) { }
+  
+    virtual CORBA::Contained_ptr lookup_id (
+      CORBA_Object *_collocated_tao_target_,
+      const char * search_id,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual CORBA::TypeCode_ptr get_canonical_typecode (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::TypeCode_ptr tc,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual CORBA::PrimitiveDef_ptr get_primitive (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::PrimitiveKind kind,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual CORBA::StringDef_ptr create_string (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::ULong bound,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual CORBA::WstringDef_ptr create_wstring (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::ULong bound,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual CORBA::SequenceDef_ptr create_sequence (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::ULong bound,
+      CORBA::IDLType_ptr element_type,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual CORBA::ArrayDef_ptr create_array (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::ULong length,
+      CORBA::IDLType_ptr element_type,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual CORBA::FixedDef_ptr create_fixed (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::UShort digits,
+      CORBA::Short scale,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+protected:
+  _TAO_Repository_Proxy_Impl (void);
+
+};
+//
+//                Base  Proxy Impl. Declaration
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//                    Remote  Impl. Declaration
+//
+
+class TAO_IFR_Client_Export _TAO_Repository_Remote_Proxy_Impl : 
+  public virtual _TAO_Repository_Proxy_Impl,
+  public virtual TAO_Remote_Object_Proxy_Impl,
+  public virtual _TAO_Container_Remote_Proxy_Impl
+  
+{
+public:
+  _TAO_Repository_Remote_Proxy_Impl (void);
+  
+  virtual ~_TAO_Repository_Remote_Proxy_Impl (void) { }
+  
+    virtual CORBA::Contained_ptr lookup_id (
+      CORBA_Object *_collocated_tao_target_,
+      const char * search_id,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::TypeCode_ptr get_canonical_typecode (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::TypeCode_ptr tc,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::PrimitiveDef_ptr get_primitive (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::PrimitiveKind kind,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::StringDef_ptr create_string (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::ULong bound,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::WstringDef_ptr create_wstring (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::ULong bound,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::SequenceDef_ptr create_sequence (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::ULong bound,
+      CORBA::IDLType_ptr element_type,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::ArrayDef_ptr create_array (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::ULong length,
+      CORBA::IDLType_ptr element_type,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::FixedDef_ptr create_fixed (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::UShort digits,
+      CORBA::Short scale,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+};
+
+//
+//                Base  Proxy Impl. Declaration
+///////////////////////////////////////////////////////////////////////
+
+
+// The Proxy Brokers are used by each interface to get
+// the right proxy for performing a call. In the new 
+// collocation scheme, the proxy to be used can vary on
+// a call by call basis. 
+
+
+
+///////////////////////////////////////////////////////////////////////
+//                 Base Proxy Broker Declaration 
+//
+
+class TAO_IFR_Client_Export _TAO_Repository_Proxy_Broker
+{
+public:
+  virtual ~_TAO_Repository_Proxy_Broker (void);
+  virtual _TAO_Repository_Proxy_Impl &select_proxy (
+    CORBA_Repository *object,
+    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
+  ) = 0;
+
+protected:
+  _TAO_Repository_Proxy_Broker (void);
+  
+};
+
+//
+//              End Base Proxy Broker Declaration 
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//                 Remote Proxy Broker Declaration 
+//
+
+class TAO_IFR_Client_Export _TAO_Repository_Remote_Proxy_Broker : public virtual _TAO_Repository_Proxy_Broker
+{
+public: 
+  _TAO_Repository_Remote_Proxy_Broker (void);
+  
+  virtual ~_TAO_Repository_Remote_Proxy_Broker (void);
+  
+  virtual _TAO_Repository_Proxy_Impl &select_proxy (
+    CORBA_Repository *object,
+    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
+  );
+
+private:
+  _TAO_Repository_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_Repository_Remote_Proxy_Broker *the_TAO_Repository_Remote_Proxy_Broker (void);
+};
+
+
+//
+//              End Remote Proxy Broker Declaration 
+///////////////////////////////////////////////////////////////////////
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_MODULEDEF___VAR_CH_)
+#define _CORBA_MODULEDEF___VAR_CH_
+
+class TAO_IFR_Client_Export CORBA_ModuleDef_var : public TAO_Base_var
+{
+public:
+  CORBA_ModuleDef_var (void); // default constructor
+  CORBA_ModuleDef_var (CORBA_ModuleDef_ptr p) : ptr_ (p) {} 
+  CORBA_ModuleDef_var (const CORBA_ModuleDef_var &); // copy constructor
+  ~CORBA_ModuleDef_var (void); // destructor
+  
+  CORBA_ModuleDef_var &operator= (CORBA_ModuleDef_ptr);
+  CORBA_ModuleDef_var &operator= (const CORBA_ModuleDef_var &);
+  CORBA_ModuleDef_ptr operator-> (void) const;
+  
+  operator const CORBA_ModuleDef_ptr &() const;
+  operator CORBA_ModuleDef_ptr &();
+  // in, inout, out, _retn 
+  CORBA_ModuleDef_ptr in (void) const;
+  CORBA_ModuleDef_ptr &inout (void);
+  CORBA_ModuleDef_ptr &out (void);
+  CORBA_ModuleDef_ptr _retn (void);
+  CORBA_ModuleDef_ptr ptr (void) const;
+
+private:
+  CORBA_ModuleDef_ptr ptr_;
+  // Unimplemented - prevents widening assignment.
+  CORBA_ModuleDef_var (const TAO_Base_var &rhs);
+  CORBA_ModuleDef_var &operator= (const TAO_Base_var &rhs);
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_MODULEDEF___OUT_CH_)
+#define _CORBA_MODULEDEF___OUT_CH_
+
+class TAO_IFR_Client_Export CORBA_ModuleDef_out
+{
+public:
+  CORBA_ModuleDef_out (CORBA_ModuleDef_ptr &);
+  CORBA_ModuleDef_out (CORBA_ModuleDef_var &);
+  CORBA_ModuleDef_out (const CORBA_ModuleDef_out &);
+  CORBA_ModuleDef_out &operator= (const CORBA_ModuleDef_out &);
+  CORBA_ModuleDef_out &operator= (const CORBA_ModuleDef_var &);
+  CORBA_ModuleDef_out &operator= (CORBA_ModuleDef_ptr);
+  operator CORBA_ModuleDef_ptr &();
+  CORBA_ModuleDef_ptr &ptr (void);
+  CORBA_ModuleDef_ptr operator-> (void);
+  
+private:
+  CORBA_ModuleDef_ptr &ptr_;
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_MODULEDEF_CH_)
+#define _CORBA_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_IFR_Client_Export CORBA_ModuleDef: public virtual CORBA_Container, public virtual CORBA_Contained
+{
+public:
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef CORBA_ModuleDef_ptr _ptr_type;
+  typedef CORBA_ModuleDef_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  // the static operations
+  static CORBA_ModuleDef_ptr _duplicate (CORBA_ModuleDef_ptr obj);
+  static CORBA_ModuleDef_ptr _narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    );
+  static CORBA_ModuleDef_ptr _unchecked_narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    );
+  static CORBA_ModuleDef_ptr _nil (void)
+    {
+      return (CORBA_ModuleDef_ptr)0;
+    }
+
+  static void _tao_any_destructor (void*);
+
+  virtual CORBA::Boolean _is_a (
+      const CORBA::Char *type_id, 
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    );
+  virtual void *_tao_QueryInterface (ptr_arith_t type);
+  
+  virtual const char* _interface_repository_id (void) const;
+
+private:
+  _TAO_ModuleDef_Proxy_Broker *the_TAO_ModuleDef_Proxy_Broker_;
+  
+protected:
+  CORBA_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 CORBA_ModuleDef_setup_collocation (int collocated);
+    
+    CORBA_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;
+  
+  virtual ~CORBA_ModuleDef (void);
+private:
+  CORBA_ModuleDef (const CORBA_ModuleDef &);
+  void operator= (const CORBA_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 */
+
+};
+
+
+// The Proxy Implementations are used by each interface to
+// perform a call. Each different implementation encapsulate
+// an invocation logics.
+
+
+///////////////////////////////////////////////////////////////////////
+//                    Base  Impl. Declaration
+//
+
+class TAO_IFR_Client_Export _TAO_ModuleDef_Proxy_Impl : 
+  public virtual _TAO_Container_Proxy_Impl, 
+  public virtual _TAO_Contained_Proxy_Impl
+{
+public:
+  virtual ~_TAO_ModuleDef_Proxy_Impl (void) { }
+  
+  protected:
+  _TAO_ModuleDef_Proxy_Impl (void);
+
+};
+//
+//                Base  Proxy Impl. Declaration
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//                    Remote  Impl. Declaration
+//
+
+class TAO_IFR_Client_Export _TAO_ModuleDef_Remote_Proxy_Impl : 
+  public virtual _TAO_ModuleDef_Proxy_Impl,
+  public virtual TAO_Remote_Object_Proxy_Impl,
+  public virtual _TAO_Container_Remote_Proxy_Impl, 
+  public virtual _TAO_Contained_Remote_Proxy_Impl
+  
+{
+public:
+  _TAO_ModuleDef_Remote_Proxy_Impl (void);
+  
+  virtual ~_TAO_ModuleDef_Remote_Proxy_Impl (void) { }
+  
+  };
+
+//
+//                Base  Proxy Impl. Declaration
+///////////////////////////////////////////////////////////////////////
+
+
+// The Proxy Brokers are used by each interface to get
+// the right proxy for performing a call. In the new 
+// collocation scheme, the proxy to be used can vary on
+// a call by call basis. 
+
+
+
+///////////////////////////////////////////////////////////////////////
+//                 Base Proxy Broker Declaration 
+//
+
+class TAO_IFR_Client_Export _TAO_ModuleDef_Proxy_Broker
+{
+public:
+  virtual ~_TAO_ModuleDef_Proxy_Broker (void);
+  virtual _TAO_ModuleDef_Proxy_Impl &select_proxy (
+    CORBA_ModuleDef *object,
+    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
+  ) = 0;
+
+protected:
+  _TAO_ModuleDef_Proxy_Broker (void);
+  
+};
+
+//
+//              End Base Proxy Broker Declaration 
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//                 Remote Proxy Broker Declaration 
+//
+
+class TAO_IFR_Client_Export _TAO_ModuleDef_Remote_Proxy_Broker : public virtual _TAO_ModuleDef_Proxy_Broker
+{
+public: 
+  _TAO_ModuleDef_Remote_Proxy_Broker (void);
+  
+  virtual ~_TAO_ModuleDef_Remote_Proxy_Broker (void);
+  
+  virtual _TAO_ModuleDef_Proxy_Impl &select_proxy (
+    CORBA_ModuleDef *object,
+    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
+  );
+
+private:
+  _TAO_ModuleDef_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_ModuleDef_Remote_Proxy_Broker *the_TAO_ModuleDef_Remote_Proxy_Broker (void);
+};
+
+
+//
+//              End Remote Proxy Broker Declaration 
+///////////////////////////////////////////////////////////////////////
+
+
+#endif /* end #if !defined */
+
+struct CORBA_ModuleDescription;
+class CORBA_ModuleDescription_var;
+
+struct TAO_IFR_Client_Export CORBA_ModuleDescription
+{
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef CORBA_ModuleDescription_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  static void _tao_any_destructor (void*);
+
+  TAO_String_Manager name;
+  TAO_String_Manager id;
+  TAO_String_Manager defined_in;
+  TAO_String_Manager version;
+};
+
+class TAO_IFR_Client_Export CORBA_ModuleDescription_var
+{
+public:
+  CORBA_ModuleDescription_var (void); // default constructor
+  CORBA_ModuleDescription_var (CORBA_ModuleDescription *);
+  CORBA_ModuleDescription_var (const CORBA_ModuleDescription_var &); // copy constructor
+  ~CORBA_ModuleDescription_var (void); // destructor
+  
+  CORBA_ModuleDescription_var &operator= (CORBA_ModuleDescription *);
+  CORBA_ModuleDescription_var &operator= (const CORBA_ModuleDescription_var &);
+  CORBA_ModuleDescription *operator-> (void);
+  const CORBA_ModuleDescription *operator-> (void) const;
+  
+  operator const CORBA_ModuleDescription &() const;
+  operator CORBA_ModuleDescription &();
+  operator CORBA_ModuleDescription &() const;
+  operator CORBA_ModuleDescription *&(); // variable-size types only
+  
+  // in, inout, out, _retn 
+  const CORBA_ModuleDescription &in (void) const;
+  CORBA_ModuleDescription &inout (void);
+  CORBA_ModuleDescription *&out (void);
+  CORBA_ModuleDescription *_retn (void);
+  CORBA_ModuleDescription *ptr (void) const;
+
+private:
+  CORBA_ModuleDescription *ptr_;
+};
+
+class TAO_IFR_Client_Export CORBA_ModuleDescription_out
+{
+public:
+  CORBA_ModuleDescription_out (CORBA_ModuleDescription *&);
+  CORBA_ModuleDescription_out (CORBA_ModuleDescription_var &);
+  CORBA_ModuleDescription_out (const CORBA_ModuleDescription_out &);
+  CORBA_ModuleDescription_out &operator= (const CORBA_ModuleDescription_out &);
+  CORBA_ModuleDescription_out &operator= (CORBA_ModuleDescription *);
+  operator CORBA_ModuleDescription *&();
+  CORBA_ModuleDescription *&ptr (void);
+  CORBA_ModuleDescription *operator-> (void);
+  
+private:
+  CORBA_ModuleDescription *&ptr_;
+  // assignment from T_var not allowed
+  void operator= (const CORBA_ModuleDescription_var &);
+};
+
+
+#if !defined (_CORBA_CONSTANTDEF___VAR_CH_)
+#define _CORBA_CONSTANTDEF___VAR_CH_
+
+class TAO_IFR_Client_Export CORBA_ConstantDef_var : public TAO_Base_var
+{
+public:
+  CORBA_ConstantDef_var (void); // default constructor
+  CORBA_ConstantDef_var (CORBA_ConstantDef_ptr p) : ptr_ (p) {} 
+  CORBA_ConstantDef_var (const CORBA_ConstantDef_var &); // copy constructor
+  ~CORBA_ConstantDef_var (void); // destructor
+  
+  CORBA_ConstantDef_var &operator= (CORBA_ConstantDef_ptr);
+  CORBA_ConstantDef_var &operator= (const CORBA_ConstantDef_var &);
+  CORBA_ConstantDef_ptr operator-> (void) const;
+  
+  operator const CORBA_ConstantDef_ptr &() const;
+  operator CORBA_ConstantDef_ptr &();
+  // in, inout, out, _retn 
+  CORBA_ConstantDef_ptr in (void) const;
+  CORBA_ConstantDef_ptr &inout (void);
+  CORBA_ConstantDef_ptr &out (void);
+  CORBA_ConstantDef_ptr _retn (void);
+  CORBA_ConstantDef_ptr ptr (void) const;
+
+private:
+  CORBA_ConstantDef_ptr ptr_;
+  // Unimplemented - prevents widening assignment.
+  CORBA_ConstantDef_var (const TAO_Base_var &rhs);
+  CORBA_ConstantDef_var &operator= (const TAO_Base_var &rhs);
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_CONSTANTDEF___OUT_CH_)
+#define _CORBA_CONSTANTDEF___OUT_CH_
+
+class TAO_IFR_Client_Export CORBA_ConstantDef_out
+{
+public:
+  CORBA_ConstantDef_out (CORBA_ConstantDef_ptr &);
+  CORBA_ConstantDef_out (CORBA_ConstantDef_var &);
+  CORBA_ConstantDef_out (const CORBA_ConstantDef_out &);
+  CORBA_ConstantDef_out &operator= (const CORBA_ConstantDef_out &);
+  CORBA_ConstantDef_out &operator= (const CORBA_ConstantDef_var &);
+  CORBA_ConstantDef_out &operator= (CORBA_ConstantDef_ptr);
+  operator CORBA_ConstantDef_ptr &();
+  CORBA_ConstantDef_ptr &ptr (void);
+  CORBA_ConstantDef_ptr operator-> (void);
+  
+private:
+  CORBA_ConstantDef_ptr &ptr_;
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_CONSTANTDEF_CH_)
+#define _CORBA_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_IFR_Client_Export CORBA_ConstantDef: public virtual CORBA_Contained
+{
+public:
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef CORBA_ConstantDef_ptr _ptr_type;
+  typedef CORBA_ConstantDef_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  // the static operations
+  static CORBA_ConstantDef_ptr _duplicate (CORBA_ConstantDef_ptr obj);
+  static CORBA_ConstantDef_ptr _narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    );
+  static CORBA_ConstantDef_ptr _unchecked_narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    );
+  static CORBA_ConstantDef_ptr _nil (void)
+    {
+      return (CORBA_ConstantDef_ptr)0;
+    }
+
+  static void _tao_any_destructor (void*);
+
+  virtual CORBA::TypeCode_ptr type (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::IDLType_ptr type_def (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void type_def (
+      CORBA::IDLType_ptr type_def,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::Any * value (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void value (
+      const CORBA::Any & 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_ConstantDef_Proxy_Broker *the_TAO_ConstantDef_Proxy_Broker_;
+  
+protected:
+  CORBA_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 CORBA_ConstantDef_setup_collocation (int collocated);
+    
+    CORBA_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 ~CORBA_ConstantDef (void);
+private:
+  CORBA_ConstantDef (const CORBA_ConstantDef &);
+  void operator= (const CORBA_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_CORBA_ConstantDef_type_get : public TAO_ClientRequestInfo
+  {
+  public:
+    friend class CORBA_ConstantDef;
+    
+    friend class _TAO_ConstantDef_Remote_Proxy_Impl;
+    friend class _TAO_ConstantDef_ThruPOA_Proxy_Impl;
+    friend class _TAO_ConstantDef_Direct_Proxy_Impl;
+  
+  TAO_ClientRequestInfo_CORBA_ConstantDef_type_get (
+      TAO_GIOP_Invocation *_tao_invocation,
+      CORBA::Object_ptr _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_ConstantDef_type_get (const TAO_ClientRequestInfo_CORBA_ConstantDef_type_get &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_ConstantDef_type_get &);
+  void result (CORBA::TypeCode_ptr result);
+  // update the result 
+  CORBA::TypeCode_ptr _result;
+};
+
+class TAO_ClientRequestInfo_CORBA_ConstantDef_type_def_get : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_ConstantDef;
+  
+  friend class _TAO_ConstantDef_Remote_Proxy_Impl;
+  friend class _TAO_ConstantDef_ThruPOA_Proxy_Impl;
+  friend class _TAO_ConstantDef_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_ConstantDef_type_def_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _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_ConstantDef_type_def_get (const TAO_ClientRequestInfo_CORBA_ConstantDef_type_def_get &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_ConstantDef_type_def_get &);
+  void result (CORBA::IDLType_ptr result);
+  // update the result 
+  CORBA::IDLType_ptr _result;
+};
+
+class TAO_ClientRequestInfo_CORBA_ConstantDef_type_def_set : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_ConstantDef;
+  
+  friend class _TAO_ConstantDef_Remote_Proxy_Impl;
+  friend class _TAO_ConstantDef_ThruPOA_Proxy_Impl;
+  friend class _TAO_ConstantDef_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_ConstantDef_type_def_set (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::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_CORBA_ConstantDef_type_def_set (const TAO_ClientRequestInfo_CORBA_ConstantDef_type_def_set &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_ConstantDef_type_def_set &);
+  CORBA::IDLType_ptr type_def_;
+  
+};
+
+class TAO_ClientRequestInfo_CORBA_ConstantDef_value_get : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_ConstantDef;
+  
+  friend class _TAO_ConstantDef_Remote_Proxy_Impl;
+  friend class _TAO_ConstantDef_ThruPOA_Proxy_Impl;
+  friend class _TAO_ConstantDef_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_ConstantDef_value_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _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_ConstantDef_value_get (const TAO_ClientRequestInfo_CORBA_ConstantDef_value_get &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_ConstantDef_value_get &);
+  void result (CORBA::Any * result);
+  // update the result 
+  CORBA::Any * _result;
+};
+
+class TAO_ClientRequestInfo_CORBA_ConstantDef_value_set : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_ConstantDef;
+  
+  friend class _TAO_ConstantDef_Remote_Proxy_Impl;
+  friend class _TAO_ConstantDef_ThruPOA_Proxy_Impl;
+  friend class _TAO_ConstantDef_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_ConstantDef_value_set (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _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));
+
+private:
+  TAO_ClientRequestInfo_CORBA_ConstantDef_value_set (const TAO_ClientRequestInfo_CORBA_ConstantDef_value_set &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_ConstantDef_value_set &);
+  const CORBA::Any & value_;
+  
+};
+
+#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_IFR_Client_Export _TAO_ConstantDef_Proxy_Impl : 
+  public virtual _TAO_Contained_Proxy_Impl
+{
+public:
+  virtual ~_TAO_ConstantDef_Proxy_Impl (void) { }
+  
+    virtual CORBA::TypeCode_ptr type (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual CORBA::IDLType_ptr type_def (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual void type_def (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::IDLType_ptr type_def,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual CORBA::Any * value (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual void value (
+      CORBA_Object *_collocated_tao_target_,
+      const CORBA::Any & value,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+protected:
+  _TAO_ConstantDef_Proxy_Impl (void);
+
+};
+//
+//                Base  Proxy Impl. Declaration
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//                    Remote  Impl. Declaration
+//
+
+class TAO_IFR_Client_Export _TAO_ConstantDef_Remote_Proxy_Impl : 
+  public virtual _TAO_ConstantDef_Proxy_Impl,
+  public virtual TAO_Remote_Object_Proxy_Impl,
+  public virtual _TAO_Contained_Remote_Proxy_Impl
+  
+{
+public:
+  _TAO_ConstantDef_Remote_Proxy_Impl (void);
+  
+  virtual ~_TAO_ConstantDef_Remote_Proxy_Impl (void) { }
+  
+    virtual CORBA::TypeCode_ptr type (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::IDLType_ptr type_def (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void type_def (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::IDLType_ptr type_def,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::Any * value (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void value (
+      CORBA_Object *_collocated_tao_target_,
+      const CORBA::Any & value,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+};
+
+//
+//                Base  Proxy Impl. Declaration
+///////////////////////////////////////////////////////////////////////
+
+
+// The Proxy Brokers are used by each interface to get
+// the right proxy for performing a call. In the new 
+// collocation scheme, the proxy to be used can vary on
+// a call by call basis. 
+
+
+
+///////////////////////////////////////////////////////////////////////
+//                 Base Proxy Broker Declaration 
+//
+
+class TAO_IFR_Client_Export _TAO_ConstantDef_Proxy_Broker
+{
+public:
+  virtual ~_TAO_ConstantDef_Proxy_Broker (void);
+  virtual _TAO_ConstantDef_Proxy_Impl &select_proxy (
+    CORBA_ConstantDef *object,
+    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
+  ) = 0;
+
+protected:
+  _TAO_ConstantDef_Proxy_Broker (void);
+  
+};
+
+//
+//              End Base Proxy Broker Declaration 
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//                 Remote Proxy Broker Declaration 
+//
+
+class TAO_IFR_Client_Export _TAO_ConstantDef_Remote_Proxy_Broker : public virtual _TAO_ConstantDef_Proxy_Broker
+{
+public: 
+  _TAO_ConstantDef_Remote_Proxy_Broker (void);
+  
+  virtual ~_TAO_ConstantDef_Remote_Proxy_Broker (void);
+  
+  virtual _TAO_ConstantDef_Proxy_Impl &select_proxy (
+    CORBA_ConstantDef *object,
+    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
+  );
+
+private:
+  _TAO_ConstantDef_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_ConstantDef_Remote_Proxy_Broker *the_TAO_ConstantDef_Remote_Proxy_Broker (void);
+};
+
+
+//
+//              End Remote Proxy Broker Declaration 
+///////////////////////////////////////////////////////////////////////
+
+
+#endif /* end #if !defined */
+
+struct CORBA_ConstantDescription;
+class CORBA_ConstantDescription_var;
+
+struct TAO_IFR_Client_Export CORBA_ConstantDescription
+{
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef CORBA_ConstantDescription_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  static void _tao_any_destructor (void*);
+
+  TAO_String_Manager name;
+  TAO_String_Manager id;
+  TAO_String_Manager defined_in;
+  TAO_String_Manager version;
+  CORBA::TypeCode_var type;
+  CORBA::Any value;
+};
+
+class TAO_IFR_Client_Export CORBA_ConstantDescription_var
+{
+public:
+  CORBA_ConstantDescription_var (void); // default constructor
+  CORBA_ConstantDescription_var (CORBA_ConstantDescription *);
+  CORBA_ConstantDescription_var (const CORBA_ConstantDescription_var &); // copy constructor
+  ~CORBA_ConstantDescription_var (void); // destructor
+  
+  CORBA_ConstantDescription_var &operator= (CORBA_ConstantDescription *);
+  CORBA_ConstantDescription_var &operator= (const CORBA_ConstantDescription_var &);
+  CORBA_ConstantDescription *operator-> (void);
+  const CORBA_ConstantDescription *operator-> (void) const;
+  
+  operator const CORBA_ConstantDescription &() const;
+  operator CORBA_ConstantDescription &();
+  operator CORBA_ConstantDescription &() const;
+  operator CORBA_ConstantDescription *&(); // variable-size types only
+  
+  // in, inout, out, _retn 
+  const CORBA_ConstantDescription &in (void) const;
+  CORBA_ConstantDescription &inout (void);
+  CORBA_ConstantDescription *&out (void);
+  CORBA_ConstantDescription *_retn (void);
+  CORBA_ConstantDescription *ptr (void) const;
+
+private:
+  CORBA_ConstantDescription *ptr_;
+};
+
+class TAO_IFR_Client_Export CORBA_ConstantDescription_out
+{
+public:
+  CORBA_ConstantDescription_out (CORBA_ConstantDescription *&);
+  CORBA_ConstantDescription_out (CORBA_ConstantDescription_var &);
+  CORBA_ConstantDescription_out (const CORBA_ConstantDescription_out &);
+  CORBA_ConstantDescription_out &operator= (const CORBA_ConstantDescription_out &);
+  CORBA_ConstantDescription_out &operator= (CORBA_ConstantDescription *);
+  operator CORBA_ConstantDescription *&();
+  CORBA_ConstantDescription *&ptr (void);
+  CORBA_ConstantDescription *operator-> (void);
+  
+private:
+  CORBA_ConstantDescription *&ptr_;
+  // assignment from T_var not allowed
+  void operator= (const CORBA_ConstantDescription_var &);
+};
+
+
+#if !defined (_CORBA_STRUCTDEF___VAR_CH_)
+#define _CORBA_STRUCTDEF___VAR_CH_
+
+class TAO_IFR_Client_Export CORBA_StructDef_var : public TAO_Base_var
+{
+public:
+  CORBA_StructDef_var (void); // default constructor
+  CORBA_StructDef_var (CORBA_StructDef_ptr p) : ptr_ (p) {} 
+  CORBA_StructDef_var (const CORBA_StructDef_var &); // copy constructor
+  ~CORBA_StructDef_var (void); // destructor
+  
+  CORBA_StructDef_var &operator= (CORBA_StructDef_ptr);
+  CORBA_StructDef_var &operator= (const CORBA_StructDef_var &);
+  CORBA_StructDef_ptr operator-> (void) const;
+  
+  operator const CORBA_StructDef_ptr &() const;
+  operator CORBA_StructDef_ptr &();
+  // in, inout, out, _retn 
+  CORBA_StructDef_ptr in (void) const;
+  CORBA_StructDef_ptr &inout (void);
+  CORBA_StructDef_ptr &out (void);
+  CORBA_StructDef_ptr _retn (void);
+  CORBA_StructDef_ptr ptr (void) const;
+
+private:
+  CORBA_StructDef_ptr ptr_;
+  // Unimplemented - prevents widening assignment.
+  CORBA_StructDef_var (const TAO_Base_var &rhs);
+  CORBA_StructDef_var &operator= (const TAO_Base_var &rhs);
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_STRUCTDEF___OUT_CH_)
+#define _CORBA_STRUCTDEF___OUT_CH_
+
+class TAO_IFR_Client_Export CORBA_StructDef_out
+{
+public:
+  CORBA_StructDef_out (CORBA_StructDef_ptr &);
+  CORBA_StructDef_out (CORBA_StructDef_var &);
+  CORBA_StructDef_out (const CORBA_StructDef_out &);
+  CORBA_StructDef_out &operator= (const CORBA_StructDef_out &);
+  CORBA_StructDef_out &operator= (const CORBA_StructDef_var &);
+  CORBA_StructDef_out &operator= (CORBA_StructDef_ptr);
+  operator CORBA_StructDef_ptr &();
+  CORBA_StructDef_ptr &ptr (void);
+  CORBA_StructDef_ptr operator-> (void);
+  
+private:
+  CORBA_StructDef_ptr &ptr_;
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_STRUCTDEF_CH_)
+#define _CORBA_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_IFR_Client_Export CORBA_StructDef: public virtual CORBA_TypedefDef, public virtual CORBA_Container
+{
+public:
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef CORBA_StructDef_ptr _ptr_type;
+  typedef CORBA_StructDef_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  // the static operations
+  static CORBA_StructDef_ptr _duplicate (CORBA_StructDef_ptr obj);
+  static CORBA_StructDef_ptr _narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    );
+  static CORBA_StructDef_ptr _unchecked_narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    );
+  static CORBA_StructDef_ptr _nil (void)
+    {
+      return (CORBA_StructDef_ptr)0;
+    }
+
+  static void _tao_any_destructor (void*);
+
+  virtual CORBA::StructMemberSeq * members (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void members (
+      const CORBA::StructMemberSeq & members,
+      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_StructDef_Proxy_Broker *the_TAO_StructDef_Proxy_Broker_;
+  
+protected:
+  CORBA_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 CORBA_StructDef_setup_collocation (int collocated);
+    
+    CORBA_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 ~CORBA_StructDef (void);
+private:
+  CORBA_StructDef (const CORBA_StructDef &);
+  void operator= (const CORBA_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_CORBA_StructDef_members_get : public TAO_ClientRequestInfo
+  {
+  public:
+    friend class CORBA_StructDef;
+    
+    friend class _TAO_StructDef_Remote_Proxy_Impl;
+    friend class _TAO_StructDef_ThruPOA_Proxy_Impl;
+    friend class _TAO_StructDef_Direct_Proxy_Impl;
+  
+  TAO_ClientRequestInfo_CORBA_StructDef_members_get (
+      TAO_GIOP_Invocation *_tao_invocation,
+      CORBA::Object_ptr _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_StructDef_members_get (const TAO_ClientRequestInfo_CORBA_StructDef_members_get &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_StructDef_members_get &);
+  void result (CORBA::StructMemberSeq * result);
+  // update the result 
+  CORBA::StructMemberSeq * _result;
+};
+
+class TAO_ClientRequestInfo_CORBA_StructDef_members_set : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_StructDef;
+  
+  friend class _TAO_StructDef_Remote_Proxy_Impl;
+  friend class _TAO_StructDef_ThruPOA_Proxy_Impl;
+  friend class _TAO_StructDef_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_StructDef_members_set (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const CORBA::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_CORBA_StructDef_members_set (const TAO_ClientRequestInfo_CORBA_StructDef_members_set &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_StructDef_members_set &);
+  const CORBA::StructMemberSeq & members_;
+  
+};
+
+#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_IFR_Client_Export _TAO_StructDef_Proxy_Impl : 
+  public virtual _TAO_TypedefDef_Proxy_Impl, 
+  public virtual _TAO_Container_Proxy_Impl
+{
+public:
+  virtual ~_TAO_StructDef_Proxy_Impl (void) { }
+  
+    virtual CORBA::StructMemberSeq * members (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual void members (
+      CORBA_Object *_collocated_tao_target_,
+      const CORBA::StructMemberSeq & members,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+protected:
+  _TAO_StructDef_Proxy_Impl (void);
+
+};
+//
+//                Base  Proxy Impl. Declaration
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//                    Remote  Impl. Declaration
+//
+
+class TAO_IFR_Client_Export _TAO_StructDef_Remote_Proxy_Impl : 
+  public virtual _TAO_StructDef_Proxy_Impl,
+  public virtual TAO_Remote_Object_Proxy_Impl,
+  public virtual _TAO_TypedefDef_Remote_Proxy_Impl, 
+  public virtual _TAO_Container_Remote_Proxy_Impl
+  
+{
+public:
+  _TAO_StructDef_Remote_Proxy_Impl (void);
+  
+  virtual ~_TAO_StructDef_Remote_Proxy_Impl (void) { }
+  
+    virtual CORBA::StructMemberSeq * members (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void members (
+      CORBA_Object *_collocated_tao_target_,
+      const CORBA::StructMemberSeq & members,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+};
+
+//
+//                Base  Proxy Impl. Declaration
+///////////////////////////////////////////////////////////////////////
+
+
+// The Proxy Brokers are used by each interface to get
+// the right proxy for performing a call. In the new 
+// collocation scheme, the proxy to be used can vary on
+// a call by call basis. 
+
+
+
+///////////////////////////////////////////////////////////////////////
+//                 Base Proxy Broker Declaration 
+//
+
+class TAO_IFR_Client_Export _TAO_StructDef_Proxy_Broker
+{
+public:
+  virtual ~_TAO_StructDef_Proxy_Broker (void);
+  virtual _TAO_StructDef_Proxy_Impl &select_proxy (
+    CORBA_StructDef *object,
+    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
+  ) = 0;
+
+protected:
+  _TAO_StructDef_Proxy_Broker (void);
+  
+};
+
+//
+//              End Base Proxy Broker Declaration 
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//                 Remote Proxy Broker Declaration 
+//
+
+class TAO_IFR_Client_Export _TAO_StructDef_Remote_Proxy_Broker : public virtual _TAO_StructDef_Proxy_Broker
+{
+public: 
+  _TAO_StructDef_Remote_Proxy_Broker (void);
+  
+  virtual ~_TAO_StructDef_Remote_Proxy_Broker (void);
+  
+  virtual _TAO_StructDef_Proxy_Impl &select_proxy (
+    CORBA_StructDef *object,
+    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
+  );
+
+private:
+  _TAO_StructDef_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_StructDef_Remote_Proxy_Broker *the_TAO_StructDef_Remote_Proxy_Broker (void);
+};
+
+
+//
+//              End Remote Proxy Broker Declaration 
+///////////////////////////////////////////////////////////////////////
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_UNIONDEF___VAR_CH_)
+#define _CORBA_UNIONDEF___VAR_CH_
+
+class TAO_IFR_Client_Export CORBA_UnionDef_var : public TAO_Base_var
+{
+public:
+  CORBA_UnionDef_var (void); // default constructor
+  CORBA_UnionDef_var (CORBA_UnionDef_ptr p) : ptr_ (p) {} 
+  CORBA_UnionDef_var (const CORBA_UnionDef_var &); // copy constructor
+  ~CORBA_UnionDef_var (void); // destructor
+  
+  CORBA_UnionDef_var &operator= (CORBA_UnionDef_ptr);
+  CORBA_UnionDef_var &operator= (const CORBA_UnionDef_var &);
+  CORBA_UnionDef_ptr operator-> (void) const;
+  
+  operator const CORBA_UnionDef_ptr &() const;
+  operator CORBA_UnionDef_ptr &();
+  // in, inout, out, _retn 
+  CORBA_UnionDef_ptr in (void) const;
+  CORBA_UnionDef_ptr &inout (void);
+  CORBA_UnionDef_ptr &out (void);
+  CORBA_UnionDef_ptr _retn (void);
+  CORBA_UnionDef_ptr ptr (void) const;
+
+private:
+  CORBA_UnionDef_ptr ptr_;
+  // Unimplemented - prevents widening assignment.
+  CORBA_UnionDef_var (const TAO_Base_var &rhs);
+  CORBA_UnionDef_var &operator= (const TAO_Base_var &rhs);
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_UNIONDEF___OUT_CH_)
+#define _CORBA_UNIONDEF___OUT_CH_
+
+class TAO_IFR_Client_Export CORBA_UnionDef_out
+{
+public:
+  CORBA_UnionDef_out (CORBA_UnionDef_ptr &);
+  CORBA_UnionDef_out (CORBA_UnionDef_var &);
+  CORBA_UnionDef_out (const CORBA_UnionDef_out &);
+  CORBA_UnionDef_out &operator= (const CORBA_UnionDef_out &);
+  CORBA_UnionDef_out &operator= (const CORBA_UnionDef_var &);
+  CORBA_UnionDef_out &operator= (CORBA_UnionDef_ptr);
+  operator CORBA_UnionDef_ptr &();
+  CORBA_UnionDef_ptr &ptr (void);
+  CORBA_UnionDef_ptr operator-> (void);
+  
+private:
+  CORBA_UnionDef_ptr &ptr_;
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_UNIONDEF_CH_)
+#define _CORBA_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_IFR_Client_Export CORBA_UnionDef: public virtual CORBA_TypedefDef, public virtual CORBA_Container
+{
+public:
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef CORBA_UnionDef_ptr _ptr_type;
+  typedef CORBA_UnionDef_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  // the static operations
+  static CORBA_UnionDef_ptr _duplicate (CORBA_UnionDef_ptr obj);
+  static CORBA_UnionDef_ptr _narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    );
+  static CORBA_UnionDef_ptr _unchecked_narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    );
+  static CORBA_UnionDef_ptr _nil (void)
+    {
+      return (CORBA_UnionDef_ptr)0;
+    }
+
+  static void _tao_any_destructor (void*);
+
+  virtual CORBA::TypeCode_ptr discriminator_type (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::IDLType_ptr discriminator_type_def (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void discriminator_type_def (
+      CORBA::IDLType_ptr discriminator_type_def,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::UnionMemberSeq * members (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void members (
+      const CORBA::UnionMemberSeq & members,
+      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_UnionDef_Proxy_Broker *the_TAO_UnionDef_Proxy_Broker_;
+  
+protected:
+  CORBA_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 CORBA_UnionDef_setup_collocation (int collocated);
+    
+    CORBA_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 ~CORBA_UnionDef (void);
+private:
+  CORBA_UnionDef (const CORBA_UnionDef &);
+  void operator= (const CORBA_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_CORBA_UnionDef_discriminator_type_get : public TAO_ClientRequestInfo
+  {
+  public:
+    friend class CORBA_UnionDef;
+    
+    friend class _TAO_UnionDef_Remote_Proxy_Impl;
+    friend class _TAO_UnionDef_ThruPOA_Proxy_Impl;
+    friend class _TAO_UnionDef_Direct_Proxy_Impl;
+  
+  TAO_ClientRequestInfo_CORBA_UnionDef_discriminator_type_get (
+      TAO_GIOP_Invocation *_tao_invocation,
+      CORBA::Object_ptr _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_UnionDef_discriminator_type_get (const TAO_ClientRequestInfo_CORBA_UnionDef_discriminator_type_get &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_UnionDef_discriminator_type_get &);
+  void result (CORBA::TypeCode_ptr result);
+  // update the result 
+  CORBA::TypeCode_ptr _result;
+};
+
+class TAO_ClientRequestInfo_CORBA_UnionDef_discriminator_type_def_get : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_UnionDef;
+  
+  friend class _TAO_UnionDef_Remote_Proxy_Impl;
+  friend class _TAO_UnionDef_ThruPOA_Proxy_Impl;
+  friend class _TAO_UnionDef_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_UnionDef_discriminator_type_def_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _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_UnionDef_discriminator_type_def_get (const TAO_ClientRequestInfo_CORBA_UnionDef_discriminator_type_def_get &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_UnionDef_discriminator_type_def_get &);
+  void result (CORBA::IDLType_ptr result);
+  // update the result 
+  CORBA::IDLType_ptr _result;
+};
+
+class TAO_ClientRequestInfo_CORBA_UnionDef_discriminator_type_def_set : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_UnionDef;
+  
+  friend class _TAO_UnionDef_Remote_Proxy_Impl;
+  friend class _TAO_UnionDef_ThruPOA_Proxy_Impl;
+  friend class _TAO_UnionDef_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_UnionDef_discriminator_type_def_set (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::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_CORBA_UnionDef_discriminator_type_def_set (const TAO_ClientRequestInfo_CORBA_UnionDef_discriminator_type_def_set &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_UnionDef_discriminator_type_def_set &);
+  CORBA::IDLType_ptr discriminator_type_def_;
+  
+};
+
+class TAO_ClientRequestInfo_CORBA_UnionDef_members_get : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_UnionDef;
+  
+  friend class _TAO_UnionDef_Remote_Proxy_Impl;
+  friend class _TAO_UnionDef_ThruPOA_Proxy_Impl;
+  friend class _TAO_UnionDef_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_UnionDef_members_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _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_UnionDef_members_get (const TAO_ClientRequestInfo_CORBA_UnionDef_members_get &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_UnionDef_members_get &);
+  void result (CORBA::UnionMemberSeq * result);
+  // update the result 
+  CORBA::UnionMemberSeq * _result;
+};
+
+class TAO_ClientRequestInfo_CORBA_UnionDef_members_set : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_UnionDef;
+  
+  friend class _TAO_UnionDef_Remote_Proxy_Impl;
+  friend class _TAO_UnionDef_ThruPOA_Proxy_Impl;
+  friend class _TAO_UnionDef_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_UnionDef_members_set (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const CORBA::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_CORBA_UnionDef_members_set (const TAO_ClientRequestInfo_CORBA_UnionDef_members_set &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_UnionDef_members_set &);
+  const CORBA::UnionMemberSeq & members_;
+  
+};
+
+#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_IFR_Client_Export _TAO_UnionDef_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 (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual CORBA::IDLType_ptr discriminator_type_def (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual void discriminator_type_def (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::IDLType_ptr discriminator_type_def,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual CORBA::UnionMemberSeq * members (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual void members (
+      CORBA_Object *_collocated_tao_target_,
+      const CORBA::UnionMemberSeq & members,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+protected:
+  _TAO_UnionDef_Proxy_Impl (void);
+
+};
+//
+//                Base  Proxy Impl. Declaration
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//                    Remote  Impl. Declaration
+//
+
+class TAO_IFR_Client_Export _TAO_UnionDef_Remote_Proxy_Impl : 
+  public virtual _TAO_UnionDef_Proxy_Impl,
+  public virtual TAO_Remote_Object_Proxy_Impl,
+  public virtual _TAO_TypedefDef_Remote_Proxy_Impl, 
+  public virtual _TAO_Container_Remote_Proxy_Impl
+  
+{
+public:
+  _TAO_UnionDef_Remote_Proxy_Impl (void);
+  
+  virtual ~_TAO_UnionDef_Remote_Proxy_Impl (void) { }
+  
+    virtual CORBA::TypeCode_ptr discriminator_type (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::IDLType_ptr discriminator_type_def (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void discriminator_type_def (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::IDLType_ptr discriminator_type_def,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::UnionMemberSeq * members (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void members (
+      CORBA_Object *_collocated_tao_target_,
+      const CORBA::UnionMemberSeq & members,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+};
+
+//
+//                Base  Proxy Impl. Declaration
+///////////////////////////////////////////////////////////////////////
+
+
+// The Proxy Brokers are used by each interface to get
+// the right proxy for performing a call. In the new 
+// collocation scheme, the proxy to be used can vary on
+// a call by call basis. 
+
+
+
+///////////////////////////////////////////////////////////////////////
+//                 Base Proxy Broker Declaration 
+//
+
+class TAO_IFR_Client_Export _TAO_UnionDef_Proxy_Broker
+{
+public:
+  virtual ~_TAO_UnionDef_Proxy_Broker (void);
+  virtual _TAO_UnionDef_Proxy_Impl &select_proxy (
+    CORBA_UnionDef *object,
+    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
+  ) = 0;
+
+protected:
+  _TAO_UnionDef_Proxy_Broker (void);
+  
+};
+
+//
+//              End Base Proxy Broker Declaration 
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//                 Remote Proxy Broker Declaration 
+//
+
+class TAO_IFR_Client_Export _TAO_UnionDef_Remote_Proxy_Broker : public virtual _TAO_UnionDef_Proxy_Broker
+{
+public: 
+  _TAO_UnionDef_Remote_Proxy_Broker (void);
+  
+  virtual ~_TAO_UnionDef_Remote_Proxy_Broker (void);
+  
+  virtual _TAO_UnionDef_Proxy_Impl &select_proxy (
+    CORBA_UnionDef *object,
+    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
+  );
+
+private:
+  _TAO_UnionDef_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_UnionDef_Remote_Proxy_Broker *the_TAO_UnionDef_Remote_Proxy_Broker (void);
+};
+
+
+//
+//              End Remote Proxy Broker Declaration 
+///////////////////////////////////////////////////////////////////////
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_ENUMDEF___VAR_CH_)
+#define _CORBA_ENUMDEF___VAR_CH_
+
+class TAO_IFR_Client_Export CORBA_EnumDef_var : public TAO_Base_var
+{
+public:
+  CORBA_EnumDef_var (void); // default constructor
+  CORBA_EnumDef_var (CORBA_EnumDef_ptr p) : ptr_ (p) {} 
+  CORBA_EnumDef_var (const CORBA_EnumDef_var &); // copy constructor
+  ~CORBA_EnumDef_var (void); // destructor
+  
+  CORBA_EnumDef_var &operator= (CORBA_EnumDef_ptr);
+  CORBA_EnumDef_var &operator= (const CORBA_EnumDef_var &);
+  CORBA_EnumDef_ptr operator-> (void) const;
+  
+  operator const CORBA_EnumDef_ptr &() const;
+  operator CORBA_EnumDef_ptr &();
+  // in, inout, out, _retn 
+  CORBA_EnumDef_ptr in (void) const;
+  CORBA_EnumDef_ptr &inout (void);
+  CORBA_EnumDef_ptr &out (void);
+  CORBA_EnumDef_ptr _retn (void);
+  CORBA_EnumDef_ptr ptr (void) const;
+
+private:
+  CORBA_EnumDef_ptr ptr_;
+  // Unimplemented - prevents widening assignment.
+  CORBA_EnumDef_var (const TAO_Base_var &rhs);
+  CORBA_EnumDef_var &operator= (const TAO_Base_var &rhs);
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_ENUMDEF___OUT_CH_)
+#define _CORBA_ENUMDEF___OUT_CH_
+
+class TAO_IFR_Client_Export CORBA_EnumDef_out
+{
+public:
+  CORBA_EnumDef_out (CORBA_EnumDef_ptr &);
+  CORBA_EnumDef_out (CORBA_EnumDef_var &);
+  CORBA_EnumDef_out (const CORBA_EnumDef_out &);
+  CORBA_EnumDef_out &operator= (const CORBA_EnumDef_out &);
+  CORBA_EnumDef_out &operator= (const CORBA_EnumDef_var &);
+  CORBA_EnumDef_out &operator= (CORBA_EnumDef_ptr);
+  operator CORBA_EnumDef_ptr &();
+  CORBA_EnumDef_ptr &ptr (void);
+  CORBA_EnumDef_ptr operator-> (void);
+  
+private:
+  CORBA_EnumDef_ptr &ptr_;
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_ENUMDEF_CH_)
+#define _CORBA_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_IFR_Client_Export CORBA_EnumDef: public virtual CORBA_TypedefDef
+{
+public:
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef CORBA_EnumDef_ptr _ptr_type;
+  typedef CORBA_EnumDef_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  // the static operations
+  static CORBA_EnumDef_ptr _duplicate (CORBA_EnumDef_ptr obj);
+  static CORBA_EnumDef_ptr _narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    );
+  static CORBA_EnumDef_ptr _unchecked_narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    );
+  static CORBA_EnumDef_ptr _nil (void)
+    {
+      return (CORBA_EnumDef_ptr)0;
+    }
+
+  static void _tao_any_destructor (void*);
+
+  virtual CORBA::EnumMemberSeq * members (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void members (
+      const CORBA::EnumMemberSeq & members,
+      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_EnumDef_Proxy_Broker *the_TAO_EnumDef_Proxy_Broker_;
+  
+protected:
+  CORBA_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 CORBA_EnumDef_setup_collocation (int collocated);
+    
+    CORBA_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 ~CORBA_EnumDef (void);
+private:
+  CORBA_EnumDef (const CORBA_EnumDef &);
+  void operator= (const CORBA_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_CORBA_EnumDef_members_get : public TAO_ClientRequestInfo
+  {
+  public:
+    friend class CORBA_EnumDef;
+    
+    friend class _TAO_EnumDef_Remote_Proxy_Impl;
+    friend class _TAO_EnumDef_ThruPOA_Proxy_Impl;
+    friend class _TAO_EnumDef_Direct_Proxy_Impl;
+  
+  TAO_ClientRequestInfo_CORBA_EnumDef_members_get (
+      TAO_GIOP_Invocation *_tao_invocation,
+      CORBA::Object_ptr _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_EnumDef_members_get (const TAO_ClientRequestInfo_CORBA_EnumDef_members_get &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_EnumDef_members_get &);
+  void result (CORBA::EnumMemberSeq * result);
+  // update the result 
+  CORBA::EnumMemberSeq * _result;
+};
+
+class TAO_ClientRequestInfo_CORBA_EnumDef_members_set : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_EnumDef;
+  
+  friend class _TAO_EnumDef_Remote_Proxy_Impl;
+  friend class _TAO_EnumDef_ThruPOA_Proxy_Impl;
+  friend class _TAO_EnumDef_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_EnumDef_members_set (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const CORBA::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_CORBA_EnumDef_members_set (const TAO_ClientRequestInfo_CORBA_EnumDef_members_set &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_EnumDef_members_set &);
+  const CORBA::EnumMemberSeq & members_;
+  
+};
+
+#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_IFR_Client_Export _TAO_EnumDef_Proxy_Impl : 
+  public virtual _TAO_TypedefDef_Proxy_Impl
+{
+public:
+  virtual ~_TAO_EnumDef_Proxy_Impl (void) { }
+  
+    virtual CORBA::EnumMemberSeq * members (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual void members (
+      CORBA_Object *_collocated_tao_target_,
+      const CORBA::EnumMemberSeq & members,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+protected:
+  _TAO_EnumDef_Proxy_Impl (void);
+
+};
+//
+//                Base  Proxy Impl. Declaration
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//                    Remote  Impl. Declaration
+//
+
+class TAO_IFR_Client_Export _TAO_EnumDef_Remote_Proxy_Impl : 
+  public virtual _TAO_EnumDef_Proxy_Impl,
+  public virtual TAO_Remote_Object_Proxy_Impl,
+  public virtual _TAO_TypedefDef_Remote_Proxy_Impl
+  
+{
+public:
+  _TAO_EnumDef_Remote_Proxy_Impl (void);
+  
+  virtual ~_TAO_EnumDef_Remote_Proxy_Impl (void) { }
+  
+    virtual CORBA::EnumMemberSeq * members (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void members (
+      CORBA_Object *_collocated_tao_target_,
+      const CORBA::EnumMemberSeq & members,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+};
+
+//
+//                Base  Proxy Impl. Declaration
+///////////////////////////////////////////////////////////////////////
+
+
+// The Proxy Brokers are used by each interface to get
+// the right proxy for performing a call. In the new 
+// collocation scheme, the proxy to be used can vary on
+// a call by call basis. 
+
+
+
+///////////////////////////////////////////////////////////////////////
+//                 Base Proxy Broker Declaration 
+//
+
+class TAO_IFR_Client_Export _TAO_EnumDef_Proxy_Broker
+{
+public:
+  virtual ~_TAO_EnumDef_Proxy_Broker (void);
+  virtual _TAO_EnumDef_Proxy_Impl &select_proxy (
+    CORBA_EnumDef *object,
+    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
+  ) = 0;
+
+protected:
+  _TAO_EnumDef_Proxy_Broker (void);
+  
+};
+
+//
+//              End Base Proxy Broker Declaration 
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//                 Remote Proxy Broker Declaration 
+//
+
+class TAO_IFR_Client_Export _TAO_EnumDef_Remote_Proxy_Broker : public virtual _TAO_EnumDef_Proxy_Broker
+{
+public: 
+  _TAO_EnumDef_Remote_Proxy_Broker (void);
+  
+  virtual ~_TAO_EnumDef_Remote_Proxy_Broker (void);
+  
+  virtual _TAO_EnumDef_Proxy_Impl &select_proxy (
+    CORBA_EnumDef *object,
+    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
+  );
+
+private:
+  _TAO_EnumDef_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_EnumDef_Remote_Proxy_Broker *the_TAO_EnumDef_Remote_Proxy_Broker (void);
+};
+
+
+//
+//              End Remote Proxy Broker Declaration 
+///////////////////////////////////////////////////////////////////////
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_ALIASDEF___VAR_CH_)
+#define _CORBA_ALIASDEF___VAR_CH_
+
+class TAO_IFR_Client_Export CORBA_AliasDef_var : public TAO_Base_var
+{
+public:
+  CORBA_AliasDef_var (void); // default constructor
+  CORBA_AliasDef_var (CORBA_AliasDef_ptr p) : ptr_ (p) {} 
+  CORBA_AliasDef_var (const CORBA_AliasDef_var &); // copy constructor
+  ~CORBA_AliasDef_var (void); // destructor
+  
+  CORBA_AliasDef_var &operator= (CORBA_AliasDef_ptr);
+  CORBA_AliasDef_var &operator= (const CORBA_AliasDef_var &);
+  CORBA_AliasDef_ptr operator-> (void) const;
+  
+  operator const CORBA_AliasDef_ptr &() const;
+  operator CORBA_AliasDef_ptr &();
+  // in, inout, out, _retn 
+  CORBA_AliasDef_ptr in (void) const;
+  CORBA_AliasDef_ptr &inout (void);
+  CORBA_AliasDef_ptr &out (void);
+  CORBA_AliasDef_ptr _retn (void);
+  CORBA_AliasDef_ptr ptr (void) const;
+
+private:
+  CORBA_AliasDef_ptr ptr_;
+  // Unimplemented - prevents widening assignment.
+  CORBA_AliasDef_var (const TAO_Base_var &rhs);
+  CORBA_AliasDef_var &operator= (const TAO_Base_var &rhs);
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_ALIASDEF___OUT_CH_)
+#define _CORBA_ALIASDEF___OUT_CH_
+
+class TAO_IFR_Client_Export CORBA_AliasDef_out
+{
+public:
+  CORBA_AliasDef_out (CORBA_AliasDef_ptr &);
+  CORBA_AliasDef_out (CORBA_AliasDef_var &);
+  CORBA_AliasDef_out (const CORBA_AliasDef_out &);
+  CORBA_AliasDef_out &operator= (const CORBA_AliasDef_out &);
+  CORBA_AliasDef_out &operator= (const CORBA_AliasDef_var &);
+  CORBA_AliasDef_out &operator= (CORBA_AliasDef_ptr);
+  operator CORBA_AliasDef_ptr &();
+  CORBA_AliasDef_ptr &ptr (void);
+  CORBA_AliasDef_ptr operator-> (void);
+  
+private:
+  CORBA_AliasDef_ptr &ptr_;
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_ALIASDEF_CH_)
+#define _CORBA_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_IFR_Client_Export CORBA_AliasDef: public virtual CORBA_TypedefDef
+{
+public:
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef CORBA_AliasDef_ptr _ptr_type;
+  typedef CORBA_AliasDef_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  // the static operations
+  static CORBA_AliasDef_ptr _duplicate (CORBA_AliasDef_ptr obj);
+  static CORBA_AliasDef_ptr _narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    );
+  static CORBA_AliasDef_ptr _unchecked_narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    );
+  static CORBA_AliasDef_ptr _nil (void)
+    {
+      return (CORBA_AliasDef_ptr)0;
+    }
+
+  static void _tao_any_destructor (void*);
+
+  virtual CORBA::IDLType_ptr original_type_def (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void original_type_def (
+      CORBA::IDLType_ptr original_type_def,
+      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_AliasDef_Proxy_Broker *the_TAO_AliasDef_Proxy_Broker_;
+  
+protected:
+  CORBA_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 CORBA_AliasDef_setup_collocation (int collocated);
+    
+    CORBA_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 ~CORBA_AliasDef (void);
+private:
+  CORBA_AliasDef (const CORBA_AliasDef &);
+  void operator= (const CORBA_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_CORBA_AliasDef_original_type_def_get : public TAO_ClientRequestInfo
+  {
+  public:
+    friend class CORBA_AliasDef;
+    
+    friend class _TAO_AliasDef_Remote_Proxy_Impl;
+    friend class _TAO_AliasDef_ThruPOA_Proxy_Impl;
+    friend class _TAO_AliasDef_Direct_Proxy_Impl;
+  
+  TAO_ClientRequestInfo_CORBA_AliasDef_original_type_def_get (
+      TAO_GIOP_Invocation *_tao_invocation,
+      CORBA::Object_ptr _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_AliasDef_original_type_def_get (const TAO_ClientRequestInfo_CORBA_AliasDef_original_type_def_get &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_AliasDef_original_type_def_get &);
+  void result (CORBA::IDLType_ptr result);
+  // update the result 
+  CORBA::IDLType_ptr _result;
+};
+
+class TAO_ClientRequestInfo_CORBA_AliasDef_original_type_def_set : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_AliasDef;
+  
+  friend class _TAO_AliasDef_Remote_Proxy_Impl;
+  friend class _TAO_AliasDef_ThruPOA_Proxy_Impl;
+  friend class _TAO_AliasDef_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_AliasDef_original_type_def_set (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::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_CORBA_AliasDef_original_type_def_set (const TAO_ClientRequestInfo_CORBA_AliasDef_original_type_def_set &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_AliasDef_original_type_def_set &);
+  CORBA::IDLType_ptr original_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_IFR_Client_Export _TAO_AliasDef_Proxy_Impl : 
+  public virtual _TAO_TypedefDef_Proxy_Impl
+{
+public:
+  virtual ~_TAO_AliasDef_Proxy_Impl (void) { }
+  
+    virtual CORBA::IDLType_ptr original_type_def (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual void original_type_def (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::IDLType_ptr original_type_def,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+protected:
+  _TAO_AliasDef_Proxy_Impl (void);
+
+};
+//
+//                Base  Proxy Impl. Declaration
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//                    Remote  Impl. Declaration
+//
+
+class TAO_IFR_Client_Export _TAO_AliasDef_Remote_Proxy_Impl : 
+  public virtual _TAO_AliasDef_Proxy_Impl,
+  public virtual TAO_Remote_Object_Proxy_Impl,
+  public virtual _TAO_TypedefDef_Remote_Proxy_Impl
+  
+{
+public:
+  _TAO_AliasDef_Remote_Proxy_Impl (void);
+  
+  virtual ~_TAO_AliasDef_Remote_Proxy_Impl (void) { }
+  
+    virtual CORBA::IDLType_ptr original_type_def (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void original_type_def (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::IDLType_ptr original_type_def,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+};
+
+//
+//                Base  Proxy Impl. Declaration
+///////////////////////////////////////////////////////////////////////
+
+
+// The Proxy Brokers are used by each interface to get
+// the right proxy for performing a call. In the new 
+// collocation scheme, the proxy to be used can vary on
+// a call by call basis. 
+
+
+
+///////////////////////////////////////////////////////////////////////
+//                 Base Proxy Broker Declaration 
+//
+
+class TAO_IFR_Client_Export _TAO_AliasDef_Proxy_Broker
+{
+public:
+  virtual ~_TAO_AliasDef_Proxy_Broker (void);
+  virtual _TAO_AliasDef_Proxy_Impl &select_proxy (
+    CORBA_AliasDef *object,
+    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
+  ) = 0;
+
+protected:
+  _TAO_AliasDef_Proxy_Broker (void);
+  
+};
+
+//
+//              End Base Proxy Broker Declaration 
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//                 Remote Proxy Broker Declaration 
+//
+
+class TAO_IFR_Client_Export _TAO_AliasDef_Remote_Proxy_Broker : public virtual _TAO_AliasDef_Proxy_Broker
+{
+public: 
+  _TAO_AliasDef_Remote_Proxy_Broker (void);
+  
+  virtual ~_TAO_AliasDef_Remote_Proxy_Broker (void);
+  
+  virtual _TAO_AliasDef_Proxy_Impl &select_proxy (
+    CORBA_AliasDef *object,
+    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
+  );
+
+private:
+  _TAO_AliasDef_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_AliasDef_Remote_Proxy_Broker *the_TAO_AliasDef_Remote_Proxy_Broker (void);
+};
+
+
+//
+//              End Remote Proxy Broker Declaration 
+///////////////////////////////////////////////////////////////////////
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_NATIVEDEF___VAR_CH_)
+#define _CORBA_NATIVEDEF___VAR_CH_
+
+class TAO_IFR_Client_Export CORBA_NativeDef_var : public TAO_Base_var
+{
+public:
+  CORBA_NativeDef_var (void); // default constructor
+  CORBA_NativeDef_var (CORBA_NativeDef_ptr p) : ptr_ (p) {} 
+  CORBA_NativeDef_var (const CORBA_NativeDef_var &); // copy constructor
+  ~CORBA_NativeDef_var (void); // destructor
+  
+  CORBA_NativeDef_var &operator= (CORBA_NativeDef_ptr);
+  CORBA_NativeDef_var &operator= (const CORBA_NativeDef_var &);
+  CORBA_NativeDef_ptr operator-> (void) const;
+  
+  operator const CORBA_NativeDef_ptr &() const;
+  operator CORBA_NativeDef_ptr &();
+  // in, inout, out, _retn 
+  CORBA_NativeDef_ptr in (void) const;
+  CORBA_NativeDef_ptr &inout (void);
+  CORBA_NativeDef_ptr &out (void);
+  CORBA_NativeDef_ptr _retn (void);
+  CORBA_NativeDef_ptr ptr (void) const;
+
+private:
+  CORBA_NativeDef_ptr ptr_;
+  // Unimplemented - prevents widening assignment.
+  CORBA_NativeDef_var (const TAO_Base_var &rhs);
+  CORBA_NativeDef_var &operator= (const TAO_Base_var &rhs);
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_NATIVEDEF___OUT_CH_)
+#define _CORBA_NATIVEDEF___OUT_CH_
+
+class TAO_IFR_Client_Export CORBA_NativeDef_out
+{
+public:
+  CORBA_NativeDef_out (CORBA_NativeDef_ptr &);
+  CORBA_NativeDef_out (CORBA_NativeDef_var &);
+  CORBA_NativeDef_out (const CORBA_NativeDef_out &);
+  CORBA_NativeDef_out &operator= (const CORBA_NativeDef_out &);
+  CORBA_NativeDef_out &operator= (const CORBA_NativeDef_var &);
+  CORBA_NativeDef_out &operator= (CORBA_NativeDef_ptr);
+  operator CORBA_NativeDef_ptr &();
+  CORBA_NativeDef_ptr &ptr (void);
+  CORBA_NativeDef_ptr operator-> (void);
+  
+private:
+  CORBA_NativeDef_ptr &ptr_;
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_NATIVEDEF_CH_)
+#define _CORBA_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_IFR_Client_Export CORBA_NativeDef: public virtual CORBA_TypedefDef
+{
+public:
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef CORBA_NativeDef_ptr _ptr_type;
+  typedef CORBA_NativeDef_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  // the static operations
+  static CORBA_NativeDef_ptr _duplicate (CORBA_NativeDef_ptr obj);
+  static CORBA_NativeDef_ptr _narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    );
+  static CORBA_NativeDef_ptr _unchecked_narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    );
+  static CORBA_NativeDef_ptr _nil (void)
+    {
+      return (CORBA_NativeDef_ptr)0;
+    }
+
+  static void _tao_any_destructor (void*);
+
+  virtual CORBA::Boolean _is_a (
+      const CORBA::Char *type_id, 
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    );
+  virtual void *_tao_QueryInterface (ptr_arith_t type);
+  
+  virtual const char* _interface_repository_id (void) const;
+
+private:
+  _TAO_NativeDef_Proxy_Broker *the_TAO_NativeDef_Proxy_Broker_;
+  
+protected:
+  CORBA_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 CORBA_NativeDef_setup_collocation (int collocated);
+    
+    CORBA_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;
+  
+  virtual ~CORBA_NativeDef (void);
+private:
+  CORBA_NativeDef (const CORBA_NativeDef &);
+  void operator= (const CORBA_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 */
+
+};
+
+
+// The Proxy Implementations are used by each interface to
+// perform a call. Each different implementation encapsulate
+// an invocation logics.
+
+
+///////////////////////////////////////////////////////////////////////
+//                    Base  Impl. Declaration
+//
+
+class TAO_IFR_Client_Export _TAO_NativeDef_Proxy_Impl : 
+  public virtual _TAO_TypedefDef_Proxy_Impl
+{
+public:
+  virtual ~_TAO_NativeDef_Proxy_Impl (void) { }
+  
+  protected:
+  _TAO_NativeDef_Proxy_Impl (void);
+
+};
+//
+//                Base  Proxy Impl. Declaration
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//                    Remote  Impl. Declaration
+//
+
+class TAO_IFR_Client_Export _TAO_NativeDef_Remote_Proxy_Impl : 
+  public virtual _TAO_NativeDef_Proxy_Impl,
+  public virtual TAO_Remote_Object_Proxy_Impl,
+  public virtual _TAO_TypedefDef_Remote_Proxy_Impl
+  
+{
+public:
+  _TAO_NativeDef_Remote_Proxy_Impl (void);
+  
+  virtual ~_TAO_NativeDef_Remote_Proxy_Impl (void) { }
+  
+  };
+
+//
+//                Base  Proxy Impl. Declaration
+///////////////////////////////////////////////////////////////////////
+
+
+// The Proxy Brokers are used by each interface to get
+// the right proxy for performing a call. In the new 
+// collocation scheme, the proxy to be used can vary on
+// a call by call basis. 
+
+
+
+///////////////////////////////////////////////////////////////////////
+//                 Base Proxy Broker Declaration 
+//
+
+class TAO_IFR_Client_Export _TAO_NativeDef_Proxy_Broker
+{
+public:
+  virtual ~_TAO_NativeDef_Proxy_Broker (void);
+  virtual _TAO_NativeDef_Proxy_Impl &select_proxy (
+    CORBA_NativeDef *object,
+    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
+  ) = 0;
+
+protected:
+  _TAO_NativeDef_Proxy_Broker (void);
+  
+};
+
+//
+//              End Base Proxy Broker Declaration 
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//                 Remote Proxy Broker Declaration 
+//
+
+class TAO_IFR_Client_Export _TAO_NativeDef_Remote_Proxy_Broker : public virtual _TAO_NativeDef_Proxy_Broker
+{
+public: 
+  _TAO_NativeDef_Remote_Proxy_Broker (void);
+  
+  virtual ~_TAO_NativeDef_Remote_Proxy_Broker (void);
+  
+  virtual _TAO_NativeDef_Proxy_Impl &select_proxy (
+    CORBA_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);
+};
+
+
+//
+//              End Remote Proxy Broker Declaration 
+///////////////////////////////////////////////////////////////////////
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_PRIMITIVEDEF___VAR_CH_)
+#define _CORBA_PRIMITIVEDEF___VAR_CH_
+
+class TAO_IFR_Client_Export CORBA_PrimitiveDef_var : public TAO_Base_var
+{
+public:
+  CORBA_PrimitiveDef_var (void); // default constructor
+  CORBA_PrimitiveDef_var (CORBA_PrimitiveDef_ptr p) : ptr_ (p) {} 
+  CORBA_PrimitiveDef_var (const CORBA_PrimitiveDef_var &); // copy constructor
+  ~CORBA_PrimitiveDef_var (void); // destructor
+  
+  CORBA_PrimitiveDef_var &operator= (CORBA_PrimitiveDef_ptr);
+  CORBA_PrimitiveDef_var &operator= (const CORBA_PrimitiveDef_var &);
+  CORBA_PrimitiveDef_ptr operator-> (void) const;
+  
+  operator const CORBA_PrimitiveDef_ptr &() const;
+  operator CORBA_PrimitiveDef_ptr &();
+  // in, inout, out, _retn 
+  CORBA_PrimitiveDef_ptr in (void) const;
+  CORBA_PrimitiveDef_ptr &inout (void);
+  CORBA_PrimitiveDef_ptr &out (void);
+  CORBA_PrimitiveDef_ptr _retn (void);
+  CORBA_PrimitiveDef_ptr ptr (void) const;
+
+private:
+  CORBA_PrimitiveDef_ptr ptr_;
+  // Unimplemented - prevents widening assignment.
+  CORBA_PrimitiveDef_var (const TAO_Base_var &rhs);
+  CORBA_PrimitiveDef_var &operator= (const TAO_Base_var &rhs);
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_PRIMITIVEDEF___OUT_CH_)
+#define _CORBA_PRIMITIVEDEF___OUT_CH_
+
+class TAO_IFR_Client_Export CORBA_PrimitiveDef_out
+{
+public:
+  CORBA_PrimitiveDef_out (CORBA_PrimitiveDef_ptr &);
+  CORBA_PrimitiveDef_out (CORBA_PrimitiveDef_var &);
+  CORBA_PrimitiveDef_out (const CORBA_PrimitiveDef_out &);
+  CORBA_PrimitiveDef_out &operator= (const CORBA_PrimitiveDef_out &);
+  CORBA_PrimitiveDef_out &operator= (const CORBA_PrimitiveDef_var &);
+  CORBA_PrimitiveDef_out &operator= (CORBA_PrimitiveDef_ptr);
+  operator CORBA_PrimitiveDef_ptr &();
+  CORBA_PrimitiveDef_ptr &ptr (void);
+  CORBA_PrimitiveDef_ptr operator-> (void);
+  
+private:
+  CORBA_PrimitiveDef_ptr &ptr_;
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_PRIMITIVEDEF_CH_)
+#define _CORBA_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_IFR_Client_Export CORBA_PrimitiveDef: public virtual CORBA_IDLType
+{
+public:
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef CORBA_PrimitiveDef_ptr _ptr_type;
+  typedef CORBA_PrimitiveDef_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  // the static operations
+  static CORBA_PrimitiveDef_ptr _duplicate (CORBA_PrimitiveDef_ptr obj);
+  static CORBA_PrimitiveDef_ptr _narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    );
+  static CORBA_PrimitiveDef_ptr _unchecked_narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    );
+  static CORBA_PrimitiveDef_ptr _nil (void)
+    {
+      return (CORBA_PrimitiveDef_ptr)0;
+    }
+
+  static void _tao_any_destructor (void*);
+
+  virtual CORBA::PrimitiveKind kind (
+      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_PrimitiveDef_Proxy_Broker *the_TAO_PrimitiveDef_Proxy_Broker_;
+  
+protected:
+  CORBA_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 CORBA_PrimitiveDef_setup_collocation (int collocated);
+    
+    CORBA_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 ~CORBA_PrimitiveDef (void);
+private:
+  CORBA_PrimitiveDef (const CORBA_PrimitiveDef &);
+  void operator= (const CORBA_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_CORBA_PrimitiveDef_kind_get : public TAO_ClientRequestInfo
+  {
+  public:
+    friend class CORBA_PrimitiveDef;
+    
+    friend class _TAO_PrimitiveDef_Remote_Proxy_Impl;
+    friend class _TAO_PrimitiveDef_ThruPOA_Proxy_Impl;
+    friend class _TAO_PrimitiveDef_Direct_Proxy_Impl;
+  
+  TAO_ClientRequestInfo_CORBA_PrimitiveDef_kind_get (
+      TAO_GIOP_Invocation *_tao_invocation,
+      CORBA::Object_ptr _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_PrimitiveDef_kind_get (const TAO_ClientRequestInfo_CORBA_PrimitiveDef_kind_get &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_PrimitiveDef_kind_get &);
+  void result (CORBA::PrimitiveKind result);
+  // update the result 
+  CORBA::PrimitiveKind _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_IFR_Client_Export _TAO_PrimitiveDef_Proxy_Impl : 
+  public virtual _TAO_IDLType_Proxy_Impl
+{
+public:
+  virtual ~_TAO_PrimitiveDef_Proxy_Impl (void) { }
+  
+    virtual CORBA::PrimitiveKind kind (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+protected:
+  _TAO_PrimitiveDef_Proxy_Impl (void);
+
+};
+//
+//                Base  Proxy Impl. Declaration
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//                    Remote  Impl. Declaration
+//
+
+class TAO_IFR_Client_Export _TAO_PrimitiveDef_Remote_Proxy_Impl : 
+  public virtual _TAO_PrimitiveDef_Proxy_Impl,
+  public virtual TAO_Remote_Object_Proxy_Impl,
+  public virtual _TAO_IDLType_Remote_Proxy_Impl
+  
+{
+public:
+  _TAO_PrimitiveDef_Remote_Proxy_Impl (void);
+  
+  virtual ~_TAO_PrimitiveDef_Remote_Proxy_Impl (void) { }
+  
+    virtual CORBA::PrimitiveKind kind (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+};
+
+//
+//                Base  Proxy Impl. Declaration
+///////////////////////////////////////////////////////////////////////
+
+
+// The Proxy Brokers are used by each interface to get
+// the right proxy for performing a call. In the new 
+// collocation scheme, the proxy to be used can vary on
+// a call by call basis. 
+
+
+
+///////////////////////////////////////////////////////////////////////
+//                 Base Proxy Broker Declaration 
+//
+
+class TAO_IFR_Client_Export _TAO_PrimitiveDef_Proxy_Broker
+{
+public:
+  virtual ~_TAO_PrimitiveDef_Proxy_Broker (void);
+  virtual _TAO_PrimitiveDef_Proxy_Impl &select_proxy (
+    CORBA_PrimitiveDef *object,
+    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
+  ) = 0;
+
+protected:
+  _TAO_PrimitiveDef_Proxy_Broker (void);
+  
+};
+
+//
+//              End Base Proxy Broker Declaration 
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//                 Remote Proxy Broker Declaration 
+//
+
+class TAO_IFR_Client_Export _TAO_PrimitiveDef_Remote_Proxy_Broker : public virtual _TAO_PrimitiveDef_Proxy_Broker
+{
+public: 
+  _TAO_PrimitiveDef_Remote_Proxy_Broker (void);
+  
+  virtual ~_TAO_PrimitiveDef_Remote_Proxy_Broker (void);
+  
+  virtual _TAO_PrimitiveDef_Proxy_Impl &select_proxy (
+    CORBA_PrimitiveDef *object,
+    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
+  );
+
+private:
+  _TAO_PrimitiveDef_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_PrimitiveDef_Remote_Proxy_Broker *the_TAO_PrimitiveDef_Remote_Proxy_Broker (void);
+};
+
+
+//
+//              End Remote Proxy Broker Declaration 
+///////////////////////////////////////////////////////////////////////
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_STRINGDEF___VAR_CH_)
+#define _CORBA_STRINGDEF___VAR_CH_
+
+class TAO_IFR_Client_Export CORBA_StringDef_var : public TAO_Base_var
+{
+public:
+  CORBA_StringDef_var (void); // default constructor
+  CORBA_StringDef_var (CORBA_StringDef_ptr p) : ptr_ (p) {} 
+  CORBA_StringDef_var (const CORBA_StringDef_var &); // copy constructor
+  ~CORBA_StringDef_var (void); // destructor
+  
+  CORBA_StringDef_var &operator= (CORBA_StringDef_ptr);
+  CORBA_StringDef_var &operator= (const CORBA_StringDef_var &);
+  CORBA_StringDef_ptr operator-> (void) const;
+  
+  operator const CORBA_StringDef_ptr &() const;
+  operator CORBA_StringDef_ptr &();
+  // in, inout, out, _retn 
+  CORBA_StringDef_ptr in (void) const;
+  CORBA_StringDef_ptr &inout (void);
+  CORBA_StringDef_ptr &out (void);
+  CORBA_StringDef_ptr _retn (void);
+  CORBA_StringDef_ptr ptr (void) const;
+
+private:
+  CORBA_StringDef_ptr ptr_;
+  // Unimplemented - prevents widening assignment.
+  CORBA_StringDef_var (const TAO_Base_var &rhs);
+  CORBA_StringDef_var &operator= (const TAO_Base_var &rhs);
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_STRINGDEF___OUT_CH_)
+#define _CORBA_STRINGDEF___OUT_CH_
+
+class TAO_IFR_Client_Export CORBA_StringDef_out
+{
+public:
+  CORBA_StringDef_out (CORBA_StringDef_ptr &);
+  CORBA_StringDef_out (CORBA_StringDef_var &);
+  CORBA_StringDef_out (const CORBA_StringDef_out &);
+  CORBA_StringDef_out &operator= (const CORBA_StringDef_out &);
+  CORBA_StringDef_out &operator= (const CORBA_StringDef_var &);
+  CORBA_StringDef_out &operator= (CORBA_StringDef_ptr);
+  operator CORBA_StringDef_ptr &();
+  CORBA_StringDef_ptr &ptr (void);
+  CORBA_StringDef_ptr operator-> (void);
+  
+private:
+  CORBA_StringDef_ptr &ptr_;
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_STRINGDEF_CH_)
+#define _CORBA_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_IFR_Client_Export CORBA_StringDef: public virtual CORBA_IDLType
+{
+public:
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef CORBA_StringDef_ptr _ptr_type;
+  typedef CORBA_StringDef_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  // the static operations
+  static CORBA_StringDef_ptr _duplicate (CORBA_StringDef_ptr obj);
+  static CORBA_StringDef_ptr _narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    );
+  static CORBA_StringDef_ptr _unchecked_narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    );
+  static CORBA_StringDef_ptr _nil (void)
+    {
+      return (CORBA_StringDef_ptr)0;
+    }
+
+  static void _tao_any_destructor (void*);
+
+  virtual CORBA::ULong bound (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void bound (
+      CORBA::ULong bound,
+      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_StringDef_Proxy_Broker *the_TAO_StringDef_Proxy_Broker_;
+  
+protected:
+  CORBA_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 CORBA_StringDef_setup_collocation (int collocated);
+    
+    CORBA_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 ~CORBA_StringDef (void);
+private:
+  CORBA_StringDef (const CORBA_StringDef &);
+  void operator= (const CORBA_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_CORBA_StringDef_bound_get : public TAO_ClientRequestInfo
+  {
+  public:
+    friend class CORBA_StringDef;
+    
+    friend class _TAO_StringDef_Remote_Proxy_Impl;
+    friend class _TAO_StringDef_ThruPOA_Proxy_Impl;
+    friend class _TAO_StringDef_Direct_Proxy_Impl;
+  
+  TAO_ClientRequestInfo_CORBA_StringDef_bound_get (
+      TAO_GIOP_Invocation *_tao_invocation,
+      CORBA::Object_ptr _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_StringDef_bound_get (const TAO_ClientRequestInfo_CORBA_StringDef_bound_get &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_StringDef_bound_get &);
+  void result (CORBA::ULong result);
+  // update the result 
+  CORBA::ULong _result;
+};
+
+class TAO_ClientRequestInfo_CORBA_StringDef_bound_set : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_StringDef;
+  
+  friend class _TAO_StringDef_Remote_Proxy_Impl;
+  friend class _TAO_StringDef_ThruPOA_Proxy_Impl;
+  friend class _TAO_StringDef_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_StringDef_bound_set (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _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_CORBA_StringDef_bound_set (const TAO_ClientRequestInfo_CORBA_StringDef_bound_set &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_StringDef_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_IFR_Client_Export _TAO_StringDef_Proxy_Impl : 
+  public virtual _TAO_IDLType_Proxy_Impl
+{
+public:
+  virtual ~_TAO_StringDef_Proxy_Impl (void) { }
+  
+    virtual CORBA::ULong bound (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual void bound (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::ULong bound,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+protected:
+  _TAO_StringDef_Proxy_Impl (void);
+
+};
+//
+//                Base  Proxy Impl. Declaration
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//                    Remote  Impl. Declaration
+//
+
+class TAO_IFR_Client_Export _TAO_StringDef_Remote_Proxy_Impl : 
+  public virtual _TAO_StringDef_Proxy_Impl,
+  public virtual TAO_Remote_Object_Proxy_Impl,
+  public virtual _TAO_IDLType_Remote_Proxy_Impl
+  
+{
+public:
+  _TAO_StringDef_Remote_Proxy_Impl (void);
+  
+  virtual ~_TAO_StringDef_Remote_Proxy_Impl (void) { }
+  
+    virtual CORBA::ULong bound (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void bound (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::ULong bound,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+};
+
+//
+//                Base  Proxy Impl. Declaration
+///////////////////////////////////////////////////////////////////////
+
+
+// The Proxy Brokers are used by each interface to get
+// the right proxy for performing a call. In the new 
+// collocation scheme, the proxy to be used can vary on
+// a call by call basis. 
+
+
+
+///////////////////////////////////////////////////////////////////////
+//                 Base Proxy Broker Declaration 
+//
+
+class TAO_IFR_Client_Export _TAO_StringDef_Proxy_Broker
+{
+public:
+  virtual ~_TAO_StringDef_Proxy_Broker (void);
+  virtual _TAO_StringDef_Proxy_Impl &select_proxy (
+    CORBA_StringDef *object,
+    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
+  ) = 0;
+
+protected:
+  _TAO_StringDef_Proxy_Broker (void);
+  
+};
+
+//
+//              End Base Proxy Broker Declaration 
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//                 Remote Proxy Broker Declaration 
+//
+
+class TAO_IFR_Client_Export _TAO_StringDef_Remote_Proxy_Broker : public virtual _TAO_StringDef_Proxy_Broker
+{
+public: 
+  _TAO_StringDef_Remote_Proxy_Broker (void);
+  
+  virtual ~_TAO_StringDef_Remote_Proxy_Broker (void);
+  
+  virtual _TAO_StringDef_Proxy_Impl &select_proxy (
+    CORBA_StringDef *object,
+    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
+  );
+
+private:
+  _TAO_StringDef_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_StringDef_Remote_Proxy_Broker *the_TAO_StringDef_Remote_Proxy_Broker (void);
+};
+
+
+//
+//              End Remote Proxy Broker Declaration 
+///////////////////////////////////////////////////////////////////////
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_WSTRINGDEF___VAR_CH_)
+#define _CORBA_WSTRINGDEF___VAR_CH_
+
+class TAO_IFR_Client_Export CORBA_WstringDef_var : public TAO_Base_var
+{
+public:
+  CORBA_WstringDef_var (void); // default constructor
+  CORBA_WstringDef_var (CORBA_WstringDef_ptr p) : ptr_ (p) {} 
+  CORBA_WstringDef_var (const CORBA_WstringDef_var &); // copy constructor
+  ~CORBA_WstringDef_var (void); // destructor
+  
+  CORBA_WstringDef_var &operator= (CORBA_WstringDef_ptr);
+  CORBA_WstringDef_var &operator= (const CORBA_WstringDef_var &);
+  CORBA_WstringDef_ptr operator-> (void) const;
+  
+  operator const CORBA_WstringDef_ptr &() const;
+  operator CORBA_WstringDef_ptr &();
+  // in, inout, out, _retn 
+  CORBA_WstringDef_ptr in (void) const;
+  CORBA_WstringDef_ptr &inout (void);
+  CORBA_WstringDef_ptr &out (void);
+  CORBA_WstringDef_ptr _retn (void);
+  CORBA_WstringDef_ptr ptr (void) const;
+
+private:
+  CORBA_WstringDef_ptr ptr_;
+  // Unimplemented - prevents widening assignment.
+  CORBA_WstringDef_var (const TAO_Base_var &rhs);
+  CORBA_WstringDef_var &operator= (const TAO_Base_var &rhs);
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_WSTRINGDEF___OUT_CH_)
+#define _CORBA_WSTRINGDEF___OUT_CH_
+
+class TAO_IFR_Client_Export CORBA_WstringDef_out
+{
+public:
+  CORBA_WstringDef_out (CORBA_WstringDef_ptr &);
+  CORBA_WstringDef_out (CORBA_WstringDef_var &);
+  CORBA_WstringDef_out (const CORBA_WstringDef_out &);
+  CORBA_WstringDef_out &operator= (const CORBA_WstringDef_out &);
+  CORBA_WstringDef_out &operator= (const CORBA_WstringDef_var &);
+  CORBA_WstringDef_out &operator= (CORBA_WstringDef_ptr);
+  operator CORBA_WstringDef_ptr &();
+  CORBA_WstringDef_ptr &ptr (void);
+  CORBA_WstringDef_ptr operator-> (void);
+  
+private:
+  CORBA_WstringDef_ptr &ptr_;
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_WSTRINGDEF_CH_)
+#define _CORBA_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_IFR_Client_Export CORBA_WstringDef: public virtual CORBA_IDLType
+{
+public:
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef CORBA_WstringDef_ptr _ptr_type;
+  typedef CORBA_WstringDef_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  // the static operations
+  static CORBA_WstringDef_ptr _duplicate (CORBA_WstringDef_ptr obj);
+  static CORBA_WstringDef_ptr _narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    );
+  static CORBA_WstringDef_ptr _unchecked_narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    );
+  static CORBA_WstringDef_ptr _nil (void)
+    {
+      return (CORBA_WstringDef_ptr)0;
+    }
+
+  static void _tao_any_destructor (void*);
+
+  virtual CORBA::ULong bound (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void bound (
+      CORBA::ULong bound,
+      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_WstringDef_Proxy_Broker *the_TAO_WstringDef_Proxy_Broker_;
+  
+protected:
+  CORBA_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 CORBA_WstringDef_setup_collocation (int collocated);
+    
+    CORBA_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;
+  
+  virtual ~CORBA_WstringDef (void);
+private:
+  CORBA_WstringDef (const CORBA_WstringDef &);
+  void operator= (const CORBA_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_CORBA_WstringDef_bound_get : public TAO_ClientRequestInfo
+  {
+  public:
+    friend class CORBA_WstringDef;
+    
+    friend class _TAO_WstringDef_Remote_Proxy_Impl;
+    friend class _TAO_WstringDef_ThruPOA_Proxy_Impl;
+    friend class _TAO_WstringDef_Direct_Proxy_Impl;
+  
+  TAO_ClientRequestInfo_CORBA_WstringDef_bound_get (
+      TAO_GIOP_Invocation *_tao_invocation,
+      CORBA::Object_ptr _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_WstringDef_bound_get (const TAO_ClientRequestInfo_CORBA_WstringDef_bound_get &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_WstringDef_bound_get &);
+  void result (CORBA::ULong result);
+  // update the result 
+  CORBA::ULong _result;
+};
+
+class TAO_ClientRequestInfo_CORBA_WstringDef_bound_set : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_WstringDef;
+  
+  friend class _TAO_WstringDef_Remote_Proxy_Impl;
+  friend class _TAO_WstringDef_ThruPOA_Proxy_Impl;
+  friend class _TAO_WstringDef_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_WstringDef_bound_set (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _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_CORBA_WstringDef_bound_set (const TAO_ClientRequestInfo_CORBA_WstringDef_bound_set &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_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_IFR_Client_Export _TAO_WstringDef_Proxy_Impl : 
+  public virtual _TAO_IDLType_Proxy_Impl
+{
+public:
+  virtual ~_TAO_WstringDef_Proxy_Impl (void) { }
+  
+    virtual CORBA::ULong bound (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual void bound (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::ULong bound,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+protected:
+  _TAO_WstringDef_Proxy_Impl (void);
+
+};
+//
+//                Base  Proxy Impl. Declaration
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//                    Remote  Impl. Declaration
+//
+
+class TAO_IFR_Client_Export _TAO_WstringDef_Remote_Proxy_Impl : 
+  public virtual _TAO_WstringDef_Proxy_Impl,
+  public virtual TAO_Remote_Object_Proxy_Impl,
+  public virtual _TAO_IDLType_Remote_Proxy_Impl
+  
+{
+public:
+  _TAO_WstringDef_Remote_Proxy_Impl (void);
+  
+  virtual ~_TAO_WstringDef_Remote_Proxy_Impl (void) { }
+  
+    virtual CORBA::ULong bound (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void bound (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::ULong bound,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+};
+
+//
+//                Base  Proxy Impl. Declaration
+///////////////////////////////////////////////////////////////////////
+
+
+// The Proxy Brokers are used by each interface to get
+// the right proxy for performing a call. In the new 
+// collocation scheme, the proxy to be used can vary on
+// a call by call basis. 
+
+
+
+///////////////////////////////////////////////////////////////////////
+//                 Base Proxy Broker Declaration 
+//
+
+class TAO_IFR_Client_Export _TAO_WstringDef_Proxy_Broker
+{
+public:
+  virtual ~_TAO_WstringDef_Proxy_Broker (void);
+  virtual _TAO_WstringDef_Proxy_Impl &select_proxy (
+    CORBA_WstringDef *object,
+    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
+  ) = 0;
+
+protected:
+  _TAO_WstringDef_Proxy_Broker (void);
+  
+};
+
+//
+//              End Base Proxy Broker Declaration 
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//                 Remote Proxy Broker Declaration 
+//
+
+class TAO_IFR_Client_Export _TAO_WstringDef_Remote_Proxy_Broker : public virtual _TAO_WstringDef_Proxy_Broker
+{
+public: 
+  _TAO_WstringDef_Remote_Proxy_Broker (void);
+  
+  virtual ~_TAO_WstringDef_Remote_Proxy_Broker (void);
+  
+  virtual _TAO_WstringDef_Proxy_Impl &select_proxy (
+    CORBA_WstringDef *object,
+    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
+  );
+
+private:
+  _TAO_WstringDef_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_WstringDef_Remote_Proxy_Broker *the_TAO_WstringDef_Remote_Proxy_Broker (void);
+};
+
+
+//
+//              End Remote Proxy Broker Declaration 
+///////////////////////////////////////////////////////////////////////
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_SEQUENCEDEF___VAR_CH_)
+#define _CORBA_SEQUENCEDEF___VAR_CH_
+
+class TAO_IFR_Client_Export CORBA_SequenceDef_var : public TAO_Base_var
+{
+public:
+  CORBA_SequenceDef_var (void); // default constructor
+  CORBA_SequenceDef_var (CORBA_SequenceDef_ptr p) : ptr_ (p) {} 
+  CORBA_SequenceDef_var (const CORBA_SequenceDef_var &); // copy constructor
+  ~CORBA_SequenceDef_var (void); // destructor
+  
+  CORBA_SequenceDef_var &operator= (CORBA_SequenceDef_ptr);
+  CORBA_SequenceDef_var &operator= (const CORBA_SequenceDef_var &);
+  CORBA_SequenceDef_ptr operator-> (void) const;
+  
+  operator const CORBA_SequenceDef_ptr &() const;
+  operator CORBA_SequenceDef_ptr &();
+  // in, inout, out, _retn 
+  CORBA_SequenceDef_ptr in (void) const;
+  CORBA_SequenceDef_ptr &inout (void);
+  CORBA_SequenceDef_ptr &out (void);
+  CORBA_SequenceDef_ptr _retn (void);
+  CORBA_SequenceDef_ptr ptr (void) const;
+
+private:
+  CORBA_SequenceDef_ptr ptr_;
+  // Unimplemented - prevents widening assignment.
+  CORBA_SequenceDef_var (const TAO_Base_var &rhs);
+  CORBA_SequenceDef_var &operator= (const TAO_Base_var &rhs);
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_SEQUENCEDEF___OUT_CH_)
+#define _CORBA_SEQUENCEDEF___OUT_CH_
+
+class TAO_IFR_Client_Export CORBA_SequenceDef_out
+{
+public:
+  CORBA_SequenceDef_out (CORBA_SequenceDef_ptr &);
+  CORBA_SequenceDef_out (CORBA_SequenceDef_var &);
+  CORBA_SequenceDef_out (const CORBA_SequenceDef_out &);
+  CORBA_SequenceDef_out &operator= (const CORBA_SequenceDef_out &);
+  CORBA_SequenceDef_out &operator= (const CORBA_SequenceDef_var &);
+  CORBA_SequenceDef_out &operator= (CORBA_SequenceDef_ptr);
+  operator CORBA_SequenceDef_ptr &();
+  CORBA_SequenceDef_ptr &ptr (void);
+  CORBA_SequenceDef_ptr operator-> (void);
+  
+private:
+  CORBA_SequenceDef_ptr &ptr_;
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_SEQUENCEDEF_CH_)
+#define _CORBA_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_IFR_Client_Export CORBA_SequenceDef: public virtual CORBA_IDLType
+{
+public:
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef CORBA_SequenceDef_ptr _ptr_type;
+  typedef CORBA_SequenceDef_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  // the static operations
+  static CORBA_SequenceDef_ptr _duplicate (CORBA_SequenceDef_ptr obj);
+  static CORBA_SequenceDef_ptr _narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    );
+  static CORBA_SequenceDef_ptr _unchecked_narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    );
+  static CORBA_SequenceDef_ptr _nil (void)
+    {
+      return (CORBA_SequenceDef_ptr)0;
+    }
+
+  static void _tao_any_destructor (void*);
+
+  virtual CORBA::ULong bound (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void bound (
+      CORBA::ULong bound,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::TypeCode_ptr element_type (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::IDLType_ptr element_type_def (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void element_type_def (
+      CORBA::IDLType_ptr element_type_def,
+      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_SequenceDef_Proxy_Broker *the_TAO_SequenceDef_Proxy_Broker_;
+  
+protected:
+  CORBA_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 CORBA_SequenceDef_setup_collocation (int collocated);
+    
+    CORBA_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;
+  
+  virtual ~CORBA_SequenceDef (void);
+private:
+  CORBA_SequenceDef (const CORBA_SequenceDef &);
+  void operator= (const CORBA_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_CORBA_SequenceDef_bound_get : public TAO_ClientRequestInfo
+  {
+  public:
+    friend class CORBA_SequenceDef;
+    
+    friend class _TAO_SequenceDef_Remote_Proxy_Impl;
+    friend class _TAO_SequenceDef_ThruPOA_Proxy_Impl;
+    friend class _TAO_SequenceDef_Direct_Proxy_Impl;
+  
+  TAO_ClientRequestInfo_CORBA_SequenceDef_bound_get (
+      TAO_GIOP_Invocation *_tao_invocation,
+      CORBA::Object_ptr _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_SequenceDef_bound_get (const TAO_ClientRequestInfo_CORBA_SequenceDef_bound_get &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_SequenceDef_bound_get &);
+  void result (CORBA::ULong result);
+  // update the result 
+  CORBA::ULong _result;
+};
+
+class TAO_ClientRequestInfo_CORBA_SequenceDef_bound_set : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_SequenceDef;
+  
+  friend class _TAO_SequenceDef_Remote_Proxy_Impl;
+  friend class _TAO_SequenceDef_ThruPOA_Proxy_Impl;
+  friend class _TAO_SequenceDef_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_SequenceDef_bound_set (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _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_CORBA_SequenceDef_bound_set (const TAO_ClientRequestInfo_CORBA_SequenceDef_bound_set &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_SequenceDef_bound_set &);
+  const CORBA::ULong & bound_;
+  
+};
+
+class TAO_ClientRequestInfo_CORBA_SequenceDef_element_type_get : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_SequenceDef;
+  
+  friend class _TAO_SequenceDef_Remote_Proxy_Impl;
+  friend class _TAO_SequenceDef_ThruPOA_Proxy_Impl;
+  friend class _TAO_SequenceDef_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_SequenceDef_element_type_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _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_SequenceDef_element_type_get (const TAO_ClientRequestInfo_CORBA_SequenceDef_element_type_get &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_SequenceDef_element_type_get &);
+  void result (CORBA::TypeCode_ptr result);
+  // update the result 
+  CORBA::TypeCode_ptr _result;
+};
+
+class TAO_ClientRequestInfo_CORBA_SequenceDef_element_type_def_get : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_SequenceDef;
+  
+  friend class _TAO_SequenceDef_Remote_Proxy_Impl;
+  friend class _TAO_SequenceDef_ThruPOA_Proxy_Impl;
+  friend class _TAO_SequenceDef_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_SequenceDef_element_type_def_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _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_SequenceDef_element_type_def_get (const TAO_ClientRequestInfo_CORBA_SequenceDef_element_type_def_get &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_SequenceDef_element_type_def_get &);
+  void result (CORBA::IDLType_ptr result);
+  // update the result 
+  CORBA::IDLType_ptr _result;
+};
+
+class TAO_ClientRequestInfo_CORBA_SequenceDef_element_type_def_set : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_SequenceDef;
+  
+  friend class _TAO_SequenceDef_Remote_Proxy_Impl;
+  friend class _TAO_SequenceDef_ThruPOA_Proxy_Impl;
+  friend class _TAO_SequenceDef_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_SequenceDef_element_type_def_set (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::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_CORBA_SequenceDef_element_type_def_set (const TAO_ClientRequestInfo_CORBA_SequenceDef_element_type_def_set &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_SequenceDef_element_type_def_set &);
+  CORBA::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_IFR_Client_Export _TAO_SequenceDef_Proxy_Impl : 
+  public virtual _TAO_IDLType_Proxy_Impl
+{
+public:
+  virtual ~_TAO_SequenceDef_Proxy_Impl (void) { }
+  
+    virtual CORBA::ULong bound (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual void bound (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::ULong bound,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual CORBA::TypeCode_ptr element_type (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual CORBA::IDLType_ptr element_type_def (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual void element_type_def (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::IDLType_ptr element_type_def,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+protected:
+  _TAO_SequenceDef_Proxy_Impl (void);
+
+};
+//
+//                Base  Proxy Impl. Declaration
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//                    Remote  Impl. Declaration
+//
+
+class TAO_IFR_Client_Export _TAO_SequenceDef_Remote_Proxy_Impl : 
+  public virtual _TAO_SequenceDef_Proxy_Impl,
+  public virtual TAO_Remote_Object_Proxy_Impl,
+  public virtual _TAO_IDLType_Remote_Proxy_Impl
+  
+{
+public:
+  _TAO_SequenceDef_Remote_Proxy_Impl (void);
+  
+  virtual ~_TAO_SequenceDef_Remote_Proxy_Impl (void) { }
+  
+    virtual CORBA::ULong bound (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void bound (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::ULong bound,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::TypeCode_ptr element_type (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::IDLType_ptr element_type_def (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void element_type_def (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::IDLType_ptr element_type_def,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+};
+
+//
+//                Base  Proxy Impl. Declaration
+///////////////////////////////////////////////////////////////////////
+
+
+// The Proxy Brokers are used by each interface to get
+// the right proxy for performing a call. In the new 
+// collocation scheme, the proxy to be used can vary on
+// a call by call basis. 
+
+
+
+///////////////////////////////////////////////////////////////////////
+//                 Base Proxy Broker Declaration 
+//
+
+class TAO_IFR_Client_Export _TAO_SequenceDef_Proxy_Broker
+{
+public:
+  virtual ~_TAO_SequenceDef_Proxy_Broker (void);
+  virtual _TAO_SequenceDef_Proxy_Impl &select_proxy (
+    CORBA_SequenceDef *object,
+    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
+  ) = 0;
+
+protected:
+  _TAO_SequenceDef_Proxy_Broker (void);
+  
+};
+
+//
+//              End Base Proxy Broker Declaration 
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//                 Remote Proxy Broker Declaration 
+//
+
+class TAO_IFR_Client_Export _TAO_SequenceDef_Remote_Proxy_Broker : public virtual _TAO_SequenceDef_Proxy_Broker
+{
+public: 
+  _TAO_SequenceDef_Remote_Proxy_Broker (void);
+  
+  virtual ~_TAO_SequenceDef_Remote_Proxy_Broker (void);
+  
+  virtual _TAO_SequenceDef_Proxy_Impl &select_proxy (
+    CORBA_SequenceDef *object,
+    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
+  );
+
+private:
+  _TAO_SequenceDef_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_SequenceDef_Remote_Proxy_Broker *the_TAO_SequenceDef_Remote_Proxy_Broker (void);
+};
+
+
+//
+//              End Remote Proxy Broker Declaration 
+///////////////////////////////////////////////////////////////////////
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_ARRAYDEF___VAR_CH_)
+#define _CORBA_ARRAYDEF___VAR_CH_
+
+class TAO_IFR_Client_Export CORBA_ArrayDef_var : public TAO_Base_var
+{
+public:
+  CORBA_ArrayDef_var (void); // default constructor
+  CORBA_ArrayDef_var (CORBA_ArrayDef_ptr p) : ptr_ (p) {} 
+  CORBA_ArrayDef_var (const CORBA_ArrayDef_var &); // copy constructor
+  ~CORBA_ArrayDef_var (void); // destructor
+  
+  CORBA_ArrayDef_var &operator= (CORBA_ArrayDef_ptr);
+  CORBA_ArrayDef_var &operator= (const CORBA_ArrayDef_var &);
+  CORBA_ArrayDef_ptr operator-> (void) const;
+  
+  operator const CORBA_ArrayDef_ptr &() const;
+  operator CORBA_ArrayDef_ptr &();
+  // in, inout, out, _retn 
+  CORBA_ArrayDef_ptr in (void) const;
+  CORBA_ArrayDef_ptr &inout (void);
+  CORBA_ArrayDef_ptr &out (void);
+  CORBA_ArrayDef_ptr _retn (void);
+  CORBA_ArrayDef_ptr ptr (void) const;
+
+private:
+  CORBA_ArrayDef_ptr ptr_;
+  // Unimplemented - prevents widening assignment.
+  CORBA_ArrayDef_var (const TAO_Base_var &rhs);
+  CORBA_ArrayDef_var &operator= (const TAO_Base_var &rhs);
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_ARRAYDEF___OUT_CH_)
+#define _CORBA_ARRAYDEF___OUT_CH_
+
+class TAO_IFR_Client_Export CORBA_ArrayDef_out
+{
+public:
+  CORBA_ArrayDef_out (CORBA_ArrayDef_ptr &);
+  CORBA_ArrayDef_out (CORBA_ArrayDef_var &);
+  CORBA_ArrayDef_out (const CORBA_ArrayDef_out &);
+  CORBA_ArrayDef_out &operator= (const CORBA_ArrayDef_out &);
+  CORBA_ArrayDef_out &operator= (const CORBA_ArrayDef_var &);
+  CORBA_ArrayDef_out &operator= (CORBA_ArrayDef_ptr);
+  operator CORBA_ArrayDef_ptr &();
+  CORBA_ArrayDef_ptr &ptr (void);
+  CORBA_ArrayDef_ptr operator-> (void);
+  
+private:
+  CORBA_ArrayDef_ptr &ptr_;
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_ARRAYDEF_CH_)
+#define _CORBA_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_IFR_Client_Export CORBA_ArrayDef: public virtual CORBA_IDLType
+{
+public:
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef CORBA_ArrayDef_ptr _ptr_type;
+  typedef CORBA_ArrayDef_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  // the static operations
+  static CORBA_ArrayDef_ptr _duplicate (CORBA_ArrayDef_ptr obj);
+  static CORBA_ArrayDef_ptr _narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    );
+  static CORBA_ArrayDef_ptr _unchecked_narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    );
+  static CORBA_ArrayDef_ptr _nil (void)
+    {
+      return (CORBA_ArrayDef_ptr)0;
+    }
+
+  static void _tao_any_destructor (void*);
+
+  virtual CORBA::ULong length (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void length (
+      CORBA::ULong length,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::TypeCode_ptr element_type (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::IDLType_ptr element_type_def (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void element_type_def (
+      CORBA::IDLType_ptr element_type_def,
+      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_ArrayDef_Proxy_Broker *the_TAO_ArrayDef_Proxy_Broker_;
+  
+protected:
+  CORBA_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 CORBA_ArrayDef_setup_collocation (int collocated);
+    
+    CORBA_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 ~CORBA_ArrayDef (void);
+private:
+  CORBA_ArrayDef (const CORBA_ArrayDef &);
+  void operator= (const CORBA_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_CORBA_ArrayDef_length_get : public TAO_ClientRequestInfo
+  {
+  public:
+    friend class CORBA_ArrayDef;
+    
+    friend class _TAO_ArrayDef_Remote_Proxy_Impl;
+    friend class _TAO_ArrayDef_ThruPOA_Proxy_Impl;
+    friend class _TAO_ArrayDef_Direct_Proxy_Impl;
+  
+  TAO_ClientRequestInfo_CORBA_ArrayDef_length_get (
+      TAO_GIOP_Invocation *_tao_invocation,
+      CORBA::Object_ptr _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_ArrayDef_length_get (const TAO_ClientRequestInfo_CORBA_ArrayDef_length_get &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_ArrayDef_length_get &);
+  void result (CORBA::ULong result);
+  // update the result 
+  CORBA::ULong _result;
+};
+
+class TAO_ClientRequestInfo_CORBA_ArrayDef_length_set : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_ArrayDef;
+  
+  friend class _TAO_ArrayDef_Remote_Proxy_Impl;
+  friend class _TAO_ArrayDef_ThruPOA_Proxy_Impl;
+  friend class _TAO_ArrayDef_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_ArrayDef_length_set (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _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_CORBA_ArrayDef_length_set (const TAO_ClientRequestInfo_CORBA_ArrayDef_length_set &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_ArrayDef_length_set &);
+  const CORBA::ULong & length_;
+  
+};
+
+class TAO_ClientRequestInfo_CORBA_ArrayDef_element_type_get : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_ArrayDef;
+  
+  friend class _TAO_ArrayDef_Remote_Proxy_Impl;
+  friend class _TAO_ArrayDef_ThruPOA_Proxy_Impl;
+  friend class _TAO_ArrayDef_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_ArrayDef_element_type_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _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_ArrayDef_element_type_get (const TAO_ClientRequestInfo_CORBA_ArrayDef_element_type_get &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_ArrayDef_element_type_get &);
+  void result (CORBA::TypeCode_ptr result);
+  // update the result 
+  CORBA::TypeCode_ptr _result;
+};
+
+class TAO_ClientRequestInfo_CORBA_ArrayDef_element_type_def_get : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_ArrayDef;
+  
+  friend class _TAO_ArrayDef_Remote_Proxy_Impl;
+  friend class _TAO_ArrayDef_ThruPOA_Proxy_Impl;
+  friend class _TAO_ArrayDef_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_ArrayDef_element_type_def_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _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_ArrayDef_element_type_def_get (const TAO_ClientRequestInfo_CORBA_ArrayDef_element_type_def_get &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_ArrayDef_element_type_def_get &);
+  void result (CORBA::IDLType_ptr result);
+  // update the result 
+  CORBA::IDLType_ptr _result;
+};
+
+class TAO_ClientRequestInfo_CORBA_ArrayDef_element_type_def_set : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_ArrayDef;
+  
+  friend class _TAO_ArrayDef_Remote_Proxy_Impl;
+  friend class _TAO_ArrayDef_ThruPOA_Proxy_Impl;
+  friend class _TAO_ArrayDef_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_ArrayDef_element_type_def_set (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::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_CORBA_ArrayDef_element_type_def_set (const TAO_ClientRequestInfo_CORBA_ArrayDef_element_type_def_set &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_ArrayDef_element_type_def_set &);
+  CORBA::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_IFR_Client_Export _TAO_ArrayDef_Proxy_Impl : 
+  public virtual _TAO_IDLType_Proxy_Impl
+{
+public:
+  virtual ~_TAO_ArrayDef_Proxy_Impl (void) { }
+  
+    virtual CORBA::ULong length (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual void length (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::ULong length,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual CORBA::TypeCode_ptr element_type (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual CORBA::IDLType_ptr element_type_def (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual void element_type_def (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::IDLType_ptr element_type_def,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+protected:
+  _TAO_ArrayDef_Proxy_Impl (void);
+
+};
+//
+//                Base  Proxy Impl. Declaration
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//                    Remote  Impl. Declaration
+//
+
+class TAO_IFR_Client_Export _TAO_ArrayDef_Remote_Proxy_Impl : 
+  public virtual _TAO_ArrayDef_Proxy_Impl,
+  public virtual TAO_Remote_Object_Proxy_Impl,
+  public virtual _TAO_IDLType_Remote_Proxy_Impl
+  
+{
+public:
+  _TAO_ArrayDef_Remote_Proxy_Impl (void);
+  
+  virtual ~_TAO_ArrayDef_Remote_Proxy_Impl (void) { }
+  
+    virtual CORBA::ULong length (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void length (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::ULong length,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::TypeCode_ptr element_type (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::IDLType_ptr element_type_def (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void element_type_def (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::IDLType_ptr element_type_def,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+};
+
+//
+//                Base  Proxy Impl. Declaration
+///////////////////////////////////////////////////////////////////////
+
+
+// The Proxy Brokers are used by each interface to get
+// the right proxy for performing a call. In the new 
+// collocation scheme, the proxy to be used can vary on
+// a call by call basis. 
+
+
+
+///////////////////////////////////////////////////////////////////////
+//                 Base Proxy Broker Declaration 
+//
+
+class TAO_IFR_Client_Export _TAO_ArrayDef_Proxy_Broker
+{
+public:
+  virtual ~_TAO_ArrayDef_Proxy_Broker (void);
+  virtual _TAO_ArrayDef_Proxy_Impl &select_proxy (
+    CORBA_ArrayDef *object,
+    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
+  ) = 0;
+
+protected:
+  _TAO_ArrayDef_Proxy_Broker (void);
+  
+};
+
+//
+//              End Base Proxy Broker Declaration 
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//                 Remote Proxy Broker Declaration 
+//
+
+class TAO_IFR_Client_Export _TAO_ArrayDef_Remote_Proxy_Broker : public virtual _TAO_ArrayDef_Proxy_Broker
+{
+public: 
+  _TAO_ArrayDef_Remote_Proxy_Broker (void);
+  
+  virtual ~_TAO_ArrayDef_Remote_Proxy_Broker (void);
+  
+  virtual _TAO_ArrayDef_Proxy_Impl &select_proxy (
+    CORBA_ArrayDef *object,
+    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
+  );
+
+private:
+  _TAO_ArrayDef_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_ArrayDef_Remote_Proxy_Broker *the_TAO_ArrayDef_Remote_Proxy_Broker (void);
+};
+
+
+//
+//              End Remote Proxy Broker Declaration 
+///////////////////////////////////////////////////////////////////////
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_EXCEPTIONDEF___VAR_CH_)
+#define _CORBA_EXCEPTIONDEF___VAR_CH_
+
+class TAO_IFR_Client_Export CORBA_ExceptionDef_var : public TAO_Base_var
+{
+public:
+  CORBA_ExceptionDef_var (void); // default constructor
+  CORBA_ExceptionDef_var (CORBA_ExceptionDef_ptr p) : ptr_ (p) {} 
+  CORBA_ExceptionDef_var (const CORBA_ExceptionDef_var &); // copy constructor
+  ~CORBA_ExceptionDef_var (void); // destructor
+  
+  CORBA_ExceptionDef_var &operator= (CORBA_ExceptionDef_ptr);
+  CORBA_ExceptionDef_var &operator= (const CORBA_ExceptionDef_var &);
+  CORBA_ExceptionDef_ptr operator-> (void) const;
+  
+  operator const CORBA_ExceptionDef_ptr &() const;
+  operator CORBA_ExceptionDef_ptr &();
+  // in, inout, out, _retn 
+  CORBA_ExceptionDef_ptr in (void) const;
+  CORBA_ExceptionDef_ptr &inout (void);
+  CORBA_ExceptionDef_ptr &out (void);
+  CORBA_ExceptionDef_ptr _retn (void);
+  CORBA_ExceptionDef_ptr ptr (void) const;
+
+private:
+  CORBA_ExceptionDef_ptr ptr_;
+  // Unimplemented - prevents widening assignment.
+  CORBA_ExceptionDef_var (const TAO_Base_var &rhs);
+  CORBA_ExceptionDef_var &operator= (const TAO_Base_var &rhs);
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_EXCEPTIONDEF___OUT_CH_)
+#define _CORBA_EXCEPTIONDEF___OUT_CH_
+
+class TAO_IFR_Client_Export CORBA_ExceptionDef_out
+{
+public:
+  CORBA_ExceptionDef_out (CORBA_ExceptionDef_ptr &);
+  CORBA_ExceptionDef_out (CORBA_ExceptionDef_var &);
+  CORBA_ExceptionDef_out (const CORBA_ExceptionDef_out &);
+  CORBA_ExceptionDef_out &operator= (const CORBA_ExceptionDef_out &);
+  CORBA_ExceptionDef_out &operator= (const CORBA_ExceptionDef_var &);
+  CORBA_ExceptionDef_out &operator= (CORBA_ExceptionDef_ptr);
+  operator CORBA_ExceptionDef_ptr &();
+  CORBA_ExceptionDef_ptr &ptr (void);
+  CORBA_ExceptionDef_ptr operator-> (void);
+  
+private:
+  CORBA_ExceptionDef_ptr &ptr_;
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_EXCEPTIONDEF_CH_)
+#define _CORBA_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_IFR_Client_Export CORBA_ExceptionDef: public virtual CORBA_Contained, public virtual CORBA_Container
+{
+public:
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef CORBA_ExceptionDef_ptr _ptr_type;
+  typedef CORBA_ExceptionDef_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  // the static operations
+  static CORBA_ExceptionDef_ptr _duplicate (CORBA_ExceptionDef_ptr obj);
+  static CORBA_ExceptionDef_ptr _narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    );
+  static CORBA_ExceptionDef_ptr _unchecked_narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    );
+  static CORBA_ExceptionDef_ptr _nil (void)
+    {
+      return (CORBA_ExceptionDef_ptr)0;
+    }
+
+  static void _tao_any_destructor (void*);
+
+  virtual CORBA::TypeCode_ptr type (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::StructMemberSeq * members (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void members (
+      const CORBA::StructMemberSeq & members,
+      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_ExceptionDef_Proxy_Broker *the_TAO_ExceptionDef_Proxy_Broker_;
+  
+protected:
+  CORBA_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 CORBA_ExceptionDef_setup_collocation (int collocated);
+    
+    CORBA_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 ~CORBA_ExceptionDef (void);
+private:
+  CORBA_ExceptionDef (const CORBA_ExceptionDef &);
+  void operator= (const CORBA_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_CORBA_ExceptionDef_type_get : public TAO_ClientRequestInfo
+  {
+  public:
+    friend class CORBA_ExceptionDef;
+    
+    friend class _TAO_ExceptionDef_Remote_Proxy_Impl;
+    friend class _TAO_ExceptionDef_ThruPOA_Proxy_Impl;
+    friend class _TAO_ExceptionDef_Direct_Proxy_Impl;
+  
+  TAO_ClientRequestInfo_CORBA_ExceptionDef_type_get (
+      TAO_GIOP_Invocation *_tao_invocation,
+      CORBA::Object_ptr _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_ExceptionDef_type_get (const TAO_ClientRequestInfo_CORBA_ExceptionDef_type_get &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_ExceptionDef_type_get &);
+  void result (CORBA::TypeCode_ptr result);
+  // update the result 
+  CORBA::TypeCode_ptr _result;
+};
+
+class TAO_ClientRequestInfo_CORBA_ExceptionDef_members_get : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_ExceptionDef;
+  
+  friend class _TAO_ExceptionDef_Remote_Proxy_Impl;
+  friend class _TAO_ExceptionDef_ThruPOA_Proxy_Impl;
+  friend class _TAO_ExceptionDef_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_ExceptionDef_members_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _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_ExceptionDef_members_get (const TAO_ClientRequestInfo_CORBA_ExceptionDef_members_get &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_ExceptionDef_members_get &);
+  void result (CORBA::StructMemberSeq * result);
+  // update the result 
+  CORBA::StructMemberSeq * _result;
+};
+
+class TAO_ClientRequestInfo_CORBA_ExceptionDef_members_set : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_ExceptionDef;
+  
+  friend class _TAO_ExceptionDef_Remote_Proxy_Impl;
+  friend class _TAO_ExceptionDef_ThruPOA_Proxy_Impl;
+  friend class _TAO_ExceptionDef_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_ExceptionDef_members_set (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const CORBA::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_CORBA_ExceptionDef_members_set (const TAO_ClientRequestInfo_CORBA_ExceptionDef_members_set &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_ExceptionDef_members_set &);
+  const CORBA::StructMemberSeq & members_;
+  
+};
+
+#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_IFR_Client_Export _TAO_ExceptionDef_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 (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual CORBA::StructMemberSeq * members (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual void members (
+      CORBA_Object *_collocated_tao_target_,
+      const CORBA::StructMemberSeq & members,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+protected:
+  _TAO_ExceptionDef_Proxy_Impl (void);
+
+};
+//
+//                Base  Proxy Impl. Declaration
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//                    Remote  Impl. Declaration
+//
+
+class TAO_IFR_Client_Export _TAO_ExceptionDef_Remote_Proxy_Impl : 
+  public virtual _TAO_ExceptionDef_Proxy_Impl,
+  public virtual TAO_Remote_Object_Proxy_Impl,
+  public virtual _TAO_Contained_Remote_Proxy_Impl, 
+  public virtual _TAO_Container_Remote_Proxy_Impl
+  
+{
+public:
+  _TAO_ExceptionDef_Remote_Proxy_Impl (void);
+  
+  virtual ~_TAO_ExceptionDef_Remote_Proxy_Impl (void) { }
+  
+    virtual CORBA::TypeCode_ptr type (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::StructMemberSeq * members (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void members (
+      CORBA_Object *_collocated_tao_target_,
+      const CORBA::StructMemberSeq & members,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+};
+
+//
+//                Base  Proxy Impl. Declaration
+///////////////////////////////////////////////////////////////////////
+
+
+// The Proxy Brokers are used by each interface to get
+// the right proxy for performing a call. In the new 
+// collocation scheme, the proxy to be used can vary on
+// a call by call basis. 
+
+
+
+///////////////////////////////////////////////////////////////////////
+//                 Base Proxy Broker Declaration 
+//
+
+class TAO_IFR_Client_Export _TAO_ExceptionDef_Proxy_Broker
+{
+public:
+  virtual ~_TAO_ExceptionDef_Proxy_Broker (void);
+  virtual _TAO_ExceptionDef_Proxy_Impl &select_proxy (
+    CORBA_ExceptionDef *object,
+    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
+  ) = 0;
+
+protected:
+  _TAO_ExceptionDef_Proxy_Broker (void);
+  
+};
+
+//
+//              End Base Proxy Broker Declaration 
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//                 Remote Proxy Broker Declaration 
+//
+
+class TAO_IFR_Client_Export _TAO_ExceptionDef_Remote_Proxy_Broker : public virtual _TAO_ExceptionDef_Proxy_Broker
+{
+public: 
+  _TAO_ExceptionDef_Remote_Proxy_Broker (void);
+  
+  virtual ~_TAO_ExceptionDef_Remote_Proxy_Broker (void);
+  
+  virtual _TAO_ExceptionDef_Proxy_Impl &select_proxy (
+    CORBA_ExceptionDef *object,
+    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
+  );
+
+private:
+  _TAO_ExceptionDef_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_ExceptionDef_Remote_Proxy_Broker *the_TAO_ExceptionDef_Remote_Proxy_Broker (void);
+};
+
+
+//
+//              End Remote Proxy Broker Declaration 
+///////////////////////////////////////////////////////////////////////
+
+
+#endif /* end #if !defined */
+
+struct CORBA_ExceptionDescription;
+class CORBA_ExceptionDescription_var;
+
+struct TAO_IFR_Client_Export CORBA_ExceptionDescription
+{
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef CORBA_ExceptionDescription_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  static void _tao_any_destructor (void*);
+
+  TAO_String_Manager name;
+  TAO_String_Manager id;
+  TAO_String_Manager defined_in;
+  TAO_String_Manager version;
+  CORBA::TypeCode_var type;
+};
+
+class TAO_IFR_Client_Export CORBA_ExceptionDescription_var
+{
+public:
+  CORBA_ExceptionDescription_var (void); // default constructor
+  CORBA_ExceptionDescription_var (CORBA_ExceptionDescription *);
+  CORBA_ExceptionDescription_var (const CORBA_ExceptionDescription_var &); // copy constructor
+  ~CORBA_ExceptionDescription_var (void); // destructor
+  
+  CORBA_ExceptionDescription_var &operator= (CORBA_ExceptionDescription *);
+  CORBA_ExceptionDescription_var &operator= (const CORBA_ExceptionDescription_var &);
+  CORBA_ExceptionDescription *operator-> (void);
+  const CORBA_ExceptionDescription *operator-> (void) const;
+  
+  operator const CORBA_ExceptionDescription &() const;
+  operator CORBA_ExceptionDescription &();
+  operator CORBA_ExceptionDescription &() const;
+  operator CORBA_ExceptionDescription *&(); // variable-size types only
+  
+  // in, inout, out, _retn 
+  const CORBA_ExceptionDescription &in (void) const;
+  CORBA_ExceptionDescription &inout (void);
+  CORBA_ExceptionDescription *&out (void);
+  CORBA_ExceptionDescription *_retn (void);
+  CORBA_ExceptionDescription *ptr (void) const;
+
+private:
+  CORBA_ExceptionDescription *ptr_;
+};
+
+class TAO_IFR_Client_Export CORBA_ExceptionDescription_out
+{
+public:
+  CORBA_ExceptionDescription_out (CORBA_ExceptionDescription *&);
+  CORBA_ExceptionDescription_out (CORBA_ExceptionDescription_var &);
+  CORBA_ExceptionDescription_out (const CORBA_ExceptionDescription_out &);
+  CORBA_ExceptionDescription_out &operator= (const CORBA_ExceptionDescription_out &);
+  CORBA_ExceptionDescription_out &operator= (CORBA_ExceptionDescription *);
+  operator CORBA_ExceptionDescription *&();
+  CORBA_ExceptionDescription *&ptr (void);
+  CORBA_ExceptionDescription *operator-> (void);
+  
+private:
+  CORBA_ExceptionDescription *&ptr_;
+  // assignment from T_var not allowed
+  void operator= (const CORBA_ExceptionDescription_var &);
+};
+
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_EXCEPTIONDEFSEQ_CH_)
+#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_EXCEPTIONDEFSEQ_CH_
+
+  class _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq : public TAO_Unbounded_Base_Sequence
+  {
+  public:
+    // = Initialization and termination methods.
+    
+    _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq (void);
+    _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq (CORBA::ULong maximum);
+    _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq (CORBA::ULong maximum,
+      CORBA::ULong length,
+      CORBA_ExceptionDef* *value,
+      CORBA::Boolean release = 0);
+    _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq(const _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq &rhs);
+    virtual ~_TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq (void);
+    _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq &operator= (const _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq &rhs);
+    TAO_Object_Manager<CORBA::ExceptionDef,CORBA::ExceptionDef_var> operator[] (CORBA::ULong index) const;
+    static CORBA_ExceptionDef **allocbuf (CORBA::ULong nelems);
+    static void freebuf (CORBA_ExceptionDef **buffer);
+    // The Base_Sequence functions, please see tao/Sequence.h
+    virtual void _allocate_buffer (CORBA::ULong length);
+    virtual void _deallocate_buffer (void);
+    CORBA_ExceptionDef* *get_buffer (CORBA::Boolean orphan = 0);
+    const CORBA_ExceptionDef* *get_buffer (void) const;
+    virtual void _shrink_buffer (CORBA::ULong nl, CORBA::ULong ol);
+    virtual void _downcast (
+        void* target,
+        CORBA_Object *src,
+        CORBA_Environment &ACE_TRY_ENV = 
+          TAO_default_environment ()
+      );
+    virtual CORBA_Object* _upcast (void *src) const;
+    
+  };
+
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_CORBA_EXCEPTIONDEFSEQ_CH_)
+#define _CORBA_EXCEPTIONDEFSEQ_CH_
+
+class CORBA_ExceptionDefSeq;
+class CORBA_ExceptionDefSeq_var;
+
+// *************************************************************
+// CORBA_ExceptionDefSeq
+// *************************************************************
+
+class TAO_IFR_Client_Export CORBA_ExceptionDefSeq : public 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<CORBA_ExceptionDef,CORBA_ExceptionDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+{
+public:
+  CORBA_ExceptionDefSeq (void); // default ctor
+  CORBA_ExceptionDefSeq (CORBA::ULong max); // uses max size
+  CORBA_ExceptionDefSeq (
+    CORBA::ULong max, 
+    CORBA::ULong length, 
+    CORBA_ExceptionDef_ptr *buffer, 
+    CORBA::Boolean release = 0
+  );
+  CORBA_ExceptionDefSeq (const CORBA_ExceptionDefSeq &); // copy ctor
+  ~CORBA_ExceptionDefSeq (void);
+  static void _tao_any_destructor (void*);
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef CORBA_ExceptionDefSeq_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+};
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_EXCEPTIONDEFSEQ___VAR_CH_)
+#define _CORBA_EXCEPTIONDEFSEQ___VAR_CH_
+
+// *************************************************************
+// class CORBA_ExceptionDefSeq_var
+// *************************************************************
+
+class TAO_IFR_Client_Export CORBA_ExceptionDefSeq_var
+{
+public:
+  CORBA_ExceptionDefSeq_var (void); // default constructor
+  CORBA_ExceptionDefSeq_var (CORBA_ExceptionDefSeq *);
+  CORBA_ExceptionDefSeq_var (const CORBA_ExceptionDefSeq_var &); // copy constructor
+  ~CORBA_ExceptionDefSeq_var (void); // destructor
+  
+  CORBA_ExceptionDefSeq_var &operator= (CORBA_ExceptionDefSeq *);
+  CORBA_ExceptionDefSeq_var &operator= (const CORBA_ExceptionDefSeq_var &);
+  CORBA_ExceptionDefSeq *operator-> (void);
+  const CORBA_ExceptionDefSeq *operator-> (void) const;
+  
+  operator const CORBA_ExceptionDefSeq &() const;
+  operator CORBA_ExceptionDefSeq &();
+  operator CORBA_ExceptionDefSeq &() const;
+  operator CORBA_ExceptionDefSeq *&(); // variable-size base types only
+  
+  TAO_Object_Manager<CORBA::ExceptionDef, CORBA::ExceptionDef_var> operator[] (CORBA::ULong index);
+  
+  // in, inout, out, _retn 
+  const CORBA_ExceptionDefSeq &in (void) const;
+  CORBA_ExceptionDefSeq &inout (void);
+  CORBA_ExceptionDefSeq *&out (void);
+  CORBA_ExceptionDefSeq *_retn (void);
+  CORBA_ExceptionDefSeq *ptr (void) const;
+
+private:
+  CORBA_ExceptionDefSeq *ptr_;
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_EXCEPTIONDEFSEQ___OUT_CH_)
+#define _CORBA_EXCEPTIONDEFSEQ___OUT_CH_
+
+class TAO_IFR_Client_Export CORBA_ExceptionDefSeq_out
+{
+public:
+  CORBA_ExceptionDefSeq_out (CORBA_ExceptionDefSeq *&);
+  CORBA_ExceptionDefSeq_out (CORBA_ExceptionDefSeq_var &);
+  CORBA_ExceptionDefSeq_out (const CORBA_ExceptionDefSeq_out &);
+  CORBA_ExceptionDefSeq_out &operator= (const CORBA_ExceptionDefSeq_out &);
+  CORBA_ExceptionDefSeq_out &operator= (CORBA_ExceptionDefSeq *);
+  operator CORBA_ExceptionDefSeq *&();
+  CORBA_ExceptionDefSeq *&ptr (void);
+  CORBA_ExceptionDefSeq *operator-> (void);
+  TAO_Object_Manager<CORBA::ExceptionDef, CORBA::ExceptionDef_var> operator[] (CORBA::ULong index);
+  
+private:
+  CORBA_ExceptionDefSeq *&ptr_;
+  // assignment from T_var not allowed
+  void operator= (const CORBA_ExceptionDefSeq_var &);
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_SEQUENCE_CORBA_EXCDESCRIPTIONSEQ_CH_)
+#define __TAO_UNBOUNDED_SEQUENCE_CORBA_EXCDESCRIPTIONSEQ_CH_
+
+  class TAO_EXPORT_NESTED_MACRO _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq : public TAO_Unbounded_Base_Sequence
+  {
+  public:
+    // = Initialization and termination methods.
+    
+    _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq (void); // Default constructor.
+    _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq (CORBA::ULong maximum); 
+    _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq (CORBA::ULong maximum,
+      CORBA::ULong length,
+      CORBA_ExceptionDescription *data,
+      CORBA::Boolean release = 0);
+    _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq (const _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq &rhs);
+    _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq &operator= (const _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq &rhs);
+    virtual ~_TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq (void); // Dtor.
+    // = Accessors.
+    CORBA_ExceptionDescription &operator[] (CORBA::ULong i);
+    const CORBA_ExceptionDescription &operator[] (CORBA::ULong i) const;
+    // = Static operations.
+    static CORBA_ExceptionDescription *allocbuf (CORBA::ULong size);
+    static void freebuf (CORBA_ExceptionDescription *buffer);
+    virtual void _allocate_buffer (CORBA::ULong length);
+    virtual void _deallocate_buffer (void);
+    // Implement the TAO_Base_Sequence methods (see Sequence.h)
+    
+    CORBA_ExceptionDescription *get_buffer (CORBA::Boolean orphan = 0);
+    const CORBA_ExceptionDescription *get_buffer (void) const;
+    void replace (CORBA::ULong max,
+      CORBA::ULong length,
+      CORBA_ExceptionDescription *data,
+      CORBA::Boolean release);
+  };
+
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_CORBA_EXCDESCRIPTIONSEQ_CH_)
+#define _CORBA_EXCDESCRIPTIONSEQ_CH_
+
+class CORBA_ExcDescriptionSeq;
+class CORBA_ExcDescriptionSeq_var;
+
+// *************************************************************
+// CORBA_ExcDescriptionSeq
+// *************************************************************
+
+class TAO_IFR_Client_Export CORBA_ExcDescriptionSeq : public 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<CORBA_ExceptionDescription>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+{
+public:
+  CORBA_ExcDescriptionSeq (void); // default ctor
+  CORBA_ExcDescriptionSeq (CORBA::ULong max); // uses max size
+  CORBA_ExcDescriptionSeq (
+    CORBA::ULong max, 
+    CORBA::ULong length, 
+    CORBA::ExceptionDescription *buffer, 
+    CORBA::Boolean release = 0
+  );
+  CORBA_ExcDescriptionSeq (const CORBA_ExcDescriptionSeq &); // copy ctor
+  ~CORBA_ExcDescriptionSeq (void);
+  static void _tao_any_destructor (void*);
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef CORBA_ExcDescriptionSeq_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+};
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_EXCDESCRIPTIONSEQ___VAR_CH_)
+#define _CORBA_EXCDESCRIPTIONSEQ___VAR_CH_
+
+// *************************************************************
+// class CORBA_ExcDescriptionSeq_var
+// *************************************************************
+
+class TAO_IFR_Client_Export CORBA_ExcDescriptionSeq_var
+{
+public:
+  CORBA_ExcDescriptionSeq_var (void); // default constructor
+  CORBA_ExcDescriptionSeq_var (CORBA_ExcDescriptionSeq *);
+  CORBA_ExcDescriptionSeq_var (const CORBA_ExcDescriptionSeq_var &); // copy constructor
+  ~CORBA_ExcDescriptionSeq_var (void); // destructor
+  
+  CORBA_ExcDescriptionSeq_var &operator= (CORBA_ExcDescriptionSeq *);
+  CORBA_ExcDescriptionSeq_var &operator= (const CORBA_ExcDescriptionSeq_var &);
+  CORBA_ExcDescriptionSeq *operator-> (void);
+  const CORBA_ExcDescriptionSeq *operator-> (void) const;
+  
+  operator const CORBA_ExcDescriptionSeq &() const;
+  operator CORBA_ExcDescriptionSeq &();
+  operator CORBA_ExcDescriptionSeq &() const;
+  operator CORBA_ExcDescriptionSeq *&(); // variable-size base types only
+  
+  CORBA::ExceptionDescription & operator[] (CORBA::ULong index);
+  const CORBA::ExceptionDescription & operator[] (CORBA::ULong index) const;
+  
+  // in, inout, out, _retn 
+  const CORBA_ExcDescriptionSeq &in (void) const;
+  CORBA_ExcDescriptionSeq &inout (void);
+  CORBA_ExcDescriptionSeq *&out (void);
+  CORBA_ExcDescriptionSeq *_retn (void);
+  CORBA_ExcDescriptionSeq *ptr (void) const;
+
+private:
+  CORBA_ExcDescriptionSeq *ptr_;
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_EXCDESCRIPTIONSEQ___OUT_CH_)
+#define _CORBA_EXCDESCRIPTIONSEQ___OUT_CH_
+
+class TAO_IFR_Client_Export CORBA_ExcDescriptionSeq_out
+{
+public:
+  CORBA_ExcDescriptionSeq_out (CORBA_ExcDescriptionSeq *&);
+  CORBA_ExcDescriptionSeq_out (CORBA_ExcDescriptionSeq_var &);
+  CORBA_ExcDescriptionSeq_out (const CORBA_ExcDescriptionSeq_out &);
+  CORBA_ExcDescriptionSeq_out &operator= (const CORBA_ExcDescriptionSeq_out &);
+  CORBA_ExcDescriptionSeq_out &operator= (CORBA_ExcDescriptionSeq *);
+  operator CORBA_ExcDescriptionSeq *&();
+  CORBA_ExcDescriptionSeq *&ptr (void);
+  CORBA_ExcDescriptionSeq *operator-> (void);
+  CORBA::ExceptionDescription & operator[] (CORBA::ULong index);
+  
+private:
+  CORBA_ExcDescriptionSeq *&ptr_;
+  // assignment from T_var not allowed
+  void operator= (const CORBA_ExcDescriptionSeq_var &);
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_ATTRIBUTEDEF___VAR_CH_)
+#define _CORBA_ATTRIBUTEDEF___VAR_CH_
+
+class TAO_IFR_Client_Export CORBA_AttributeDef_var : public TAO_Base_var
+{
+public:
+  CORBA_AttributeDef_var (void); // default constructor
+  CORBA_AttributeDef_var (CORBA_AttributeDef_ptr p) : ptr_ (p) {} 
+  CORBA_AttributeDef_var (const CORBA_AttributeDef_var &); // copy constructor
+  ~CORBA_AttributeDef_var (void); // destructor
+  
+  CORBA_AttributeDef_var &operator= (CORBA_AttributeDef_ptr);
+  CORBA_AttributeDef_var &operator= (const CORBA_AttributeDef_var &);
+  CORBA_AttributeDef_ptr operator-> (void) const;
+  
+  operator const CORBA_AttributeDef_ptr &() const;
+  operator CORBA_AttributeDef_ptr &();
+  // in, inout, out, _retn 
+  CORBA_AttributeDef_ptr in (void) const;
+  CORBA_AttributeDef_ptr &inout (void);
+  CORBA_AttributeDef_ptr &out (void);
+  CORBA_AttributeDef_ptr _retn (void);
+  CORBA_AttributeDef_ptr ptr (void) const;
+
+private:
+  CORBA_AttributeDef_ptr ptr_;
+  // Unimplemented - prevents widening assignment.
+  CORBA_AttributeDef_var (const TAO_Base_var &rhs);
+  CORBA_AttributeDef_var &operator= (const TAO_Base_var &rhs);
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_ATTRIBUTEDEF___OUT_CH_)
+#define _CORBA_ATTRIBUTEDEF___OUT_CH_
+
+class TAO_IFR_Client_Export CORBA_AttributeDef_out
+{
+public:
+  CORBA_AttributeDef_out (CORBA_AttributeDef_ptr &);
+  CORBA_AttributeDef_out (CORBA_AttributeDef_var &);
+  CORBA_AttributeDef_out (const CORBA_AttributeDef_out &);
+  CORBA_AttributeDef_out &operator= (const CORBA_AttributeDef_out &);
+  CORBA_AttributeDef_out &operator= (const CORBA_AttributeDef_var &);
+  CORBA_AttributeDef_out &operator= (CORBA_AttributeDef_ptr);
+  operator CORBA_AttributeDef_ptr &();
+  CORBA_AttributeDef_ptr &ptr (void);
+  CORBA_AttributeDef_ptr operator-> (void);
+  
+private:
+  CORBA_AttributeDef_ptr &ptr_;
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_ATTRIBUTEDEF_CH_)
+#define _CORBA_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_IFR_Client_Export CORBA_AttributeDef: public virtual CORBA_Contained
+{
+public:
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef CORBA_AttributeDef_ptr _ptr_type;
+  typedef CORBA_AttributeDef_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  // the static operations
+  static CORBA_AttributeDef_ptr _duplicate (CORBA_AttributeDef_ptr obj);
+  static CORBA_AttributeDef_ptr _narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    );
+  static CORBA_AttributeDef_ptr _unchecked_narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    );
+  static CORBA_AttributeDef_ptr _nil (void)
+    {
+      return (CORBA_AttributeDef_ptr)0;
+    }
+
+  static void _tao_any_destructor (void*);
+
+  virtual CORBA::TypeCode_ptr type (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::IDLType_ptr type_def (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void type_def (
+      CORBA::IDLType_ptr type_def,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::AttributeMode mode (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void mode (
+      CORBA::AttributeMode mode,
+      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_AttributeDef_Proxy_Broker *the_TAO_AttributeDef_Proxy_Broker_;
+  
+protected:
+  CORBA_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 CORBA_AttributeDef_setup_collocation (int collocated);
+    
+    CORBA_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 ~CORBA_AttributeDef (void);
+private:
+  CORBA_AttributeDef (const CORBA_AttributeDef &);
+  void operator= (const CORBA_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_CORBA_AttributeDef_type_get : public TAO_ClientRequestInfo
+  {
+  public:
+    friend class CORBA_AttributeDef;
+    
+    friend class _TAO_AttributeDef_Remote_Proxy_Impl;
+    friend class _TAO_AttributeDef_ThruPOA_Proxy_Impl;
+    friend class _TAO_AttributeDef_Direct_Proxy_Impl;
+  
+  TAO_ClientRequestInfo_CORBA_AttributeDef_type_get (
+      TAO_GIOP_Invocation *_tao_invocation,
+      CORBA::Object_ptr _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_AttributeDef_type_get (const TAO_ClientRequestInfo_CORBA_AttributeDef_type_get &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_AttributeDef_type_get &);
+  void result (CORBA::TypeCode_ptr result);
+  // update the result 
+  CORBA::TypeCode_ptr _result;
+};
+
+class TAO_ClientRequestInfo_CORBA_AttributeDef_type_def_get : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_AttributeDef;
+  
+  friend class _TAO_AttributeDef_Remote_Proxy_Impl;
+  friend class _TAO_AttributeDef_ThruPOA_Proxy_Impl;
+  friend class _TAO_AttributeDef_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_AttributeDef_type_def_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _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_AttributeDef_type_def_get (const TAO_ClientRequestInfo_CORBA_AttributeDef_type_def_get &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_AttributeDef_type_def_get &);
+  void result (CORBA::IDLType_ptr result);
+  // update the result 
+  CORBA::IDLType_ptr _result;
+};
+
+class TAO_ClientRequestInfo_CORBA_AttributeDef_type_def_set : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_AttributeDef;
+  
+  friend class _TAO_AttributeDef_Remote_Proxy_Impl;
+  friend class _TAO_AttributeDef_ThruPOA_Proxy_Impl;
+  friend class _TAO_AttributeDef_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_AttributeDef_type_def_set (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::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_CORBA_AttributeDef_type_def_set (const TAO_ClientRequestInfo_CORBA_AttributeDef_type_def_set &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_AttributeDef_type_def_set &);
+  CORBA::IDLType_ptr type_def_;
+  
+};
+
+class TAO_ClientRequestInfo_CORBA_AttributeDef_mode_get : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_AttributeDef;
+  
+  friend class _TAO_AttributeDef_Remote_Proxy_Impl;
+  friend class _TAO_AttributeDef_ThruPOA_Proxy_Impl;
+  friend class _TAO_AttributeDef_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_AttributeDef_mode_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _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_AttributeDef_mode_get (const TAO_ClientRequestInfo_CORBA_AttributeDef_mode_get &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_AttributeDef_mode_get &);
+  void result (CORBA::AttributeMode result);
+  // update the result 
+  CORBA::AttributeMode _result;
+};
+
+class TAO_ClientRequestInfo_CORBA_AttributeDef_mode_set : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_AttributeDef;
+  
+  friend class _TAO_AttributeDef_Remote_Proxy_Impl;
+  friend class _TAO_AttributeDef_ThruPOA_Proxy_Impl;
+  friend class _TAO_AttributeDef_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_AttributeDef_mode_set (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::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));
+
+private:
+  TAO_ClientRequestInfo_CORBA_AttributeDef_mode_set (const TAO_ClientRequestInfo_CORBA_AttributeDef_mode_set &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_AttributeDef_mode_set &);
+  const CORBA::AttributeMode & mode_;
+  
+};
+
+#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_IFR_Client_Export _TAO_AttributeDef_Proxy_Impl : 
+  public virtual _TAO_Contained_Proxy_Impl
+{
+public:
+  virtual ~_TAO_AttributeDef_Proxy_Impl (void) { }
+  
+    virtual CORBA::TypeCode_ptr type (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual CORBA::IDLType_ptr type_def (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual void type_def (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::IDLType_ptr type_def,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual CORBA::AttributeMode 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_,
+      CORBA::AttributeMode mode,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+protected:
+  _TAO_AttributeDef_Proxy_Impl (void);
+
+};
+//
+//                Base  Proxy Impl. Declaration
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//                    Remote  Impl. Declaration
+//
+
+class TAO_IFR_Client_Export _TAO_AttributeDef_Remote_Proxy_Impl : 
+  public virtual _TAO_AttributeDef_Proxy_Impl,
+  public virtual TAO_Remote_Object_Proxy_Impl,
+  public virtual _TAO_Contained_Remote_Proxy_Impl
+  
+{
+public:
+  _TAO_AttributeDef_Remote_Proxy_Impl (void);
+  
+  virtual ~_TAO_AttributeDef_Remote_Proxy_Impl (void) { }
+  
+    virtual CORBA::TypeCode_ptr type (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::IDLType_ptr type_def (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void type_def (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::IDLType_ptr type_def,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::AttributeMode mode (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void mode (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::AttributeMode mode,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+};
+
+//
+//                Base  Proxy Impl. Declaration
+///////////////////////////////////////////////////////////////////////
+
+
+// The Proxy Brokers are used by each interface to get
+// the right proxy for performing a call. In the new 
+// collocation scheme, the proxy to be used can vary on
+// a call by call basis. 
+
+
+
+///////////////////////////////////////////////////////////////////////
+//                 Base Proxy Broker Declaration 
+//
+
+class TAO_IFR_Client_Export _TAO_AttributeDef_Proxy_Broker
+{
+public:
+  virtual ~_TAO_AttributeDef_Proxy_Broker (void);
+  virtual _TAO_AttributeDef_Proxy_Impl &select_proxy (
+    CORBA_AttributeDef *object,
+    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
+  ) = 0;
+
+protected:
+  _TAO_AttributeDef_Proxy_Broker (void);
+  
+};
+
+//
+//              End Base Proxy Broker Declaration 
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//                 Remote Proxy Broker Declaration 
+//
+
+class TAO_IFR_Client_Export _TAO_AttributeDef_Remote_Proxy_Broker : public virtual _TAO_AttributeDef_Proxy_Broker
+{
+public: 
+  _TAO_AttributeDef_Remote_Proxy_Broker (void);
+  
+  virtual ~_TAO_AttributeDef_Remote_Proxy_Broker (void);
+  
+  virtual _TAO_AttributeDef_Proxy_Impl &select_proxy (
+    CORBA_AttributeDef *object,
+    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
+  );
+
+private:
+  _TAO_AttributeDef_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_AttributeDef_Remote_Proxy_Broker *the_TAO_AttributeDef_Remote_Proxy_Broker (void);
+};
+
+
+//
+//              End Remote Proxy Broker Declaration 
+///////////////////////////////////////////////////////////////////////
+
+
+#endif /* end #if !defined */
+
+struct CORBA_AttributeDescription;
+class CORBA_AttributeDescription_var;
+
+struct TAO_IFR_Client_Export CORBA_AttributeDescription
+{
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef CORBA_AttributeDescription_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  static void _tao_any_destructor (void*);
+
+  TAO_String_Manager name;
+  TAO_String_Manager id;
+  TAO_String_Manager defined_in;
+  TAO_String_Manager version;
+  CORBA::TypeCode_var type;
+  CORBA::AttributeMode mode;
+};
+
+class TAO_IFR_Client_Export CORBA_AttributeDescription_var
+{
+public:
+  CORBA_AttributeDescription_var (void); // default constructor
+  CORBA_AttributeDescription_var (CORBA_AttributeDescription *);
+  CORBA_AttributeDescription_var (const CORBA_AttributeDescription_var &); // copy constructor
+  ~CORBA_AttributeDescription_var (void); // destructor
+  
+  CORBA_AttributeDescription_var &operator= (CORBA_AttributeDescription *);
+  CORBA_AttributeDescription_var &operator= (const CORBA_AttributeDescription_var &);
+  CORBA_AttributeDescription *operator-> (void);
+  const CORBA_AttributeDescription *operator-> (void) const;
+  
+  operator const CORBA_AttributeDescription &() const;
+  operator CORBA_AttributeDescription &();
+  operator CORBA_AttributeDescription &() const;
+  operator CORBA_AttributeDescription *&(); // variable-size types only
+  
+  // in, inout, out, _retn 
+  const CORBA_AttributeDescription &in (void) const;
+  CORBA_AttributeDescription &inout (void);
+  CORBA_AttributeDescription *&out (void);
+  CORBA_AttributeDescription *_retn (void);
+  CORBA_AttributeDescription *ptr (void) const;
+
+private:
+  CORBA_AttributeDescription *ptr_;
+};
+
+class TAO_IFR_Client_Export CORBA_AttributeDescription_out
+{
+public:
+  CORBA_AttributeDescription_out (CORBA_AttributeDescription *&);
+  CORBA_AttributeDescription_out (CORBA_AttributeDescription_var &);
+  CORBA_AttributeDescription_out (const CORBA_AttributeDescription_out &);
+  CORBA_AttributeDescription_out &operator= (const CORBA_AttributeDescription_out &);
+  CORBA_AttributeDescription_out &operator= (CORBA_AttributeDescription *);
+  operator CORBA_AttributeDescription *&();
+  CORBA_AttributeDescription *&ptr (void);
+  CORBA_AttributeDescription *operator-> (void);
+  
+private:
+  CORBA_AttributeDescription *&ptr_;
+  // assignment from T_var not allowed
+  void operator= (const CORBA_AttributeDescription_var &);
+};
+
+struct CORBA_ParameterDescription;
+class CORBA_ParameterDescription_var;
+
+struct TAO_IFR_Client_Export CORBA_ParameterDescription
+{
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef CORBA_ParameterDescription_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  static void _tao_any_destructor (void*);
+
+  TAO_String_Manager name;
+  CORBA::TypeCode_var type;
+  CORBA::IDLType_var type_def;
+  CORBA::ParameterMode mode;
+};
+
+class TAO_IFR_Client_Export CORBA_ParameterDescription_var
+{
+public:
+  CORBA_ParameterDescription_var (void); // default constructor
+  CORBA_ParameterDescription_var (CORBA_ParameterDescription *);
+  CORBA_ParameterDescription_var (const CORBA_ParameterDescription_var &); // copy constructor
+  ~CORBA_ParameterDescription_var (void); // destructor
+  
+  CORBA_ParameterDescription_var &operator= (CORBA_ParameterDescription *);
+  CORBA_ParameterDescription_var &operator= (const CORBA_ParameterDescription_var &);
+  CORBA_ParameterDescription *operator-> (void);
+  const CORBA_ParameterDescription *operator-> (void) const;
+  
+  operator const CORBA_ParameterDescription &() const;
+  operator CORBA_ParameterDescription &();
+  operator CORBA_ParameterDescription &() const;
+  operator CORBA_ParameterDescription *&(); // variable-size types only
+  
+  // in, inout, out, _retn 
+  const CORBA_ParameterDescription &in (void) const;
+  CORBA_ParameterDescription &inout (void);
+  CORBA_ParameterDescription *&out (void);
+  CORBA_ParameterDescription *_retn (void);
+  CORBA_ParameterDescription *ptr (void) const;
+
+private:
+  CORBA_ParameterDescription *ptr_;
+};
+
+class TAO_IFR_Client_Export CORBA_ParameterDescription_out
+{
+public:
+  CORBA_ParameterDescription_out (CORBA_ParameterDescription *&);
+  CORBA_ParameterDescription_out (CORBA_ParameterDescription_var &);
+  CORBA_ParameterDescription_out (const CORBA_ParameterDescription_out &);
+  CORBA_ParameterDescription_out &operator= (const CORBA_ParameterDescription_out &);
+  CORBA_ParameterDescription_out &operator= (CORBA_ParameterDescription *);
+  operator CORBA_ParameterDescription *&();
+  CORBA_ParameterDescription *&ptr (void);
+  CORBA_ParameterDescription *operator-> (void);
+  
+private:
+  CORBA_ParameterDescription *&ptr_;
+  // assignment from T_var not allowed
+  void operator= (const CORBA_ParameterDescription_var &);
+};
+
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_SEQUENCE_CORBA_PARDESCRIPTIONSEQ_CH_)
+#define __TAO_UNBOUNDED_SEQUENCE_CORBA_PARDESCRIPTIONSEQ_CH_
+
+  class TAO_EXPORT_NESTED_MACRO _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq : public TAO_Unbounded_Base_Sequence
+  {
+  public:
+    // = Initialization and termination methods.
+    
+    _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq (void); // Default constructor.
+    _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq (CORBA::ULong maximum); 
+    _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq (CORBA::ULong maximum,
+      CORBA::ULong length,
+      CORBA_ParameterDescription *data,
+      CORBA::Boolean release = 0);
+    _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq (const _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq &rhs);
+    _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq &operator= (const _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq &rhs);
+    virtual ~_TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq (void); // Dtor.
+    // = Accessors.
+    CORBA_ParameterDescription &operator[] (CORBA::ULong i);
+    const CORBA_ParameterDescription &operator[] (CORBA::ULong i) const;
+    // = Static operations.
+    static CORBA_ParameterDescription *allocbuf (CORBA::ULong size);
+    static void freebuf (CORBA_ParameterDescription *buffer);
+    virtual void _allocate_buffer (CORBA::ULong length);
+    virtual void _deallocate_buffer (void);
+    // Implement the TAO_Base_Sequence methods (see Sequence.h)
+    
+    CORBA_ParameterDescription *get_buffer (CORBA::Boolean orphan = 0);
+    const CORBA_ParameterDescription *get_buffer (void) const;
+    void replace (CORBA::ULong max,
+      CORBA::ULong length,
+      CORBA_ParameterDescription *data,
+      CORBA::Boolean release);
+  };
+
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_CORBA_PARDESCRIPTIONSEQ_CH_)
+#define _CORBA_PARDESCRIPTIONSEQ_CH_
+
+class CORBA_ParDescriptionSeq;
+class CORBA_ParDescriptionSeq_var;
+
+// *************************************************************
+// CORBA_ParDescriptionSeq
+// *************************************************************
+
+class TAO_IFR_Client_Export CORBA_ParDescriptionSeq : public 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<CORBA_ParameterDescription>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+{
+public:
+  CORBA_ParDescriptionSeq (void); // default ctor
+  CORBA_ParDescriptionSeq (CORBA::ULong max); // uses max size
+  CORBA_ParDescriptionSeq (
+    CORBA::ULong max, 
+    CORBA::ULong length, 
+    CORBA::ParameterDescription *buffer, 
+    CORBA::Boolean release = 0
+  );
+  CORBA_ParDescriptionSeq (const CORBA_ParDescriptionSeq &); // copy ctor
+  ~CORBA_ParDescriptionSeq (void);
+  static void _tao_any_destructor (void*);
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef CORBA_ParDescriptionSeq_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+};
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_PARDESCRIPTIONSEQ___VAR_CH_)
+#define _CORBA_PARDESCRIPTIONSEQ___VAR_CH_
+
+// *************************************************************
+// class CORBA_ParDescriptionSeq_var
+// *************************************************************
+
+class TAO_IFR_Client_Export CORBA_ParDescriptionSeq_var
+{
+public:
+  CORBA_ParDescriptionSeq_var (void); // default constructor
+  CORBA_ParDescriptionSeq_var (CORBA_ParDescriptionSeq *);
+  CORBA_ParDescriptionSeq_var (const CORBA_ParDescriptionSeq_var &); // copy constructor
+  ~CORBA_ParDescriptionSeq_var (void); // destructor
+  
+  CORBA_ParDescriptionSeq_var &operator= (CORBA_ParDescriptionSeq *);
+  CORBA_ParDescriptionSeq_var &operator= (const CORBA_ParDescriptionSeq_var &);
+  CORBA_ParDescriptionSeq *operator-> (void);
+  const CORBA_ParDescriptionSeq *operator-> (void) const;
+  
+  operator const CORBA_ParDescriptionSeq &() const;
+  operator CORBA_ParDescriptionSeq &();
+  operator CORBA_ParDescriptionSeq &() const;
+  operator CORBA_ParDescriptionSeq *&(); // variable-size base types only
+  
+  CORBA::ParameterDescription & operator[] (CORBA::ULong index);
+  const CORBA::ParameterDescription & operator[] (CORBA::ULong index) const;
+  
+  // in, inout, out, _retn 
+  const CORBA_ParDescriptionSeq &in (void) const;
+  CORBA_ParDescriptionSeq &inout (void);
+  CORBA_ParDescriptionSeq *&out (void);
+  CORBA_ParDescriptionSeq *_retn (void);
+  CORBA_ParDescriptionSeq *ptr (void) const;
+
+private:
+  CORBA_ParDescriptionSeq *ptr_;
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_PARDESCRIPTIONSEQ___OUT_CH_)
+#define _CORBA_PARDESCRIPTIONSEQ___OUT_CH_
+
+class TAO_IFR_Client_Export CORBA_ParDescriptionSeq_out
+{
+public:
+  CORBA_ParDescriptionSeq_out (CORBA_ParDescriptionSeq *&);
+  CORBA_ParDescriptionSeq_out (CORBA_ParDescriptionSeq_var &);
+  CORBA_ParDescriptionSeq_out (const CORBA_ParDescriptionSeq_out &);
+  CORBA_ParDescriptionSeq_out &operator= (const CORBA_ParDescriptionSeq_out &);
+  CORBA_ParDescriptionSeq_out &operator= (CORBA_ParDescriptionSeq *);
+  operator CORBA_ParDescriptionSeq *&();
+  CORBA_ParDescriptionSeq *&ptr (void);
+  CORBA_ParDescriptionSeq *operator-> (void);
+  CORBA::ParameterDescription & operator[] (CORBA::ULong index);
+  
+private:
+  CORBA_ParDescriptionSeq *&ptr_;
+  // assignment from T_var not allowed
+  void operator= (const CORBA_ParDescriptionSeq_var &);
+};
+
+
+#endif /* end #if !defined */
+
+typedef char * ContextIdentifier;
+typedef CORBA::String_var ContextIdentifier_var;
+typedef CORBA::String_out ContextIdentifier_out;
+
+#if !defined (_CORBA_CONTEXTIDSEQ_CH_)
+#define _CORBA_CONTEXTIDSEQ_CH_
+
+class CORBA_ContextIdSeq;
+class CORBA_ContextIdSeq_var;
+
+// *************************************************************
+// CORBA_ContextIdSeq
+// *************************************************************
+
+class TAO_IFR_Client_Export CORBA_ContextIdSeq : public 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  TAO_Unbounded_String_Sequence
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_String_Sequence
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+{
+public:
+  CORBA_ContextIdSeq (void); // default ctor
+  CORBA_ContextIdSeq (CORBA::ULong max); // uses max size
+  CORBA_ContextIdSeq (
+    CORBA::ULong max, 
+    CORBA::ULong length, 
+    char * *buffer, 
+    CORBA::Boolean release = 0
+  );
+  CORBA_ContextIdSeq (const CORBA_ContextIdSeq &); // copy ctor
+  ~CORBA_ContextIdSeq (void);
+  static void _tao_any_destructor (void*);
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef CORBA_ContextIdSeq_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+};
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_CONTEXTIDSEQ___VAR_CH_)
+#define _CORBA_CONTEXTIDSEQ___VAR_CH_
+
+// *************************************************************
+// class CORBA_ContextIdSeq_var
+// *************************************************************
+
+class TAO_IFR_Client_Export CORBA_ContextIdSeq_var
+{
+public:
+  CORBA_ContextIdSeq_var (void); // default constructor
+  CORBA_ContextIdSeq_var (CORBA_ContextIdSeq *);
+  CORBA_ContextIdSeq_var (const CORBA_ContextIdSeq_var &); // copy constructor
+  ~CORBA_ContextIdSeq_var (void); // destructor
+  
+  CORBA_ContextIdSeq_var &operator= (CORBA_ContextIdSeq *);
+  CORBA_ContextIdSeq_var &operator= (const CORBA_ContextIdSeq_var &);
+  CORBA_ContextIdSeq *operator-> (void);
+  const CORBA_ContextIdSeq *operator-> (void) const;
+  
+  operator const CORBA_ContextIdSeq &() const;
+  operator CORBA_ContextIdSeq &();
+  operator CORBA_ContextIdSeq &() const;
+  operator CORBA_ContextIdSeq *&(); // variable-size base types only
+  
+  TAO_SeqElem_String_Manager operator[] (CORBA::ULong index);
+  
+  // in, inout, out, _retn 
+  const CORBA_ContextIdSeq &in (void) const;
+  CORBA_ContextIdSeq &inout (void);
+  CORBA_ContextIdSeq *&out (void);
+  CORBA_ContextIdSeq *_retn (void);
+  CORBA_ContextIdSeq *ptr (void) const;
+
+private:
+  CORBA_ContextIdSeq *ptr_;
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_CONTEXTIDSEQ___OUT_CH_)
+#define _CORBA_CONTEXTIDSEQ___OUT_CH_
+
+class TAO_IFR_Client_Export CORBA_ContextIdSeq_out
+{
+public:
+  CORBA_ContextIdSeq_out (CORBA_ContextIdSeq *&);
+  CORBA_ContextIdSeq_out (CORBA_ContextIdSeq_var &);
+  CORBA_ContextIdSeq_out (const CORBA_ContextIdSeq_out &);
+  CORBA_ContextIdSeq_out &operator= (const CORBA_ContextIdSeq_out &);
+  CORBA_ContextIdSeq_out &operator= (CORBA_ContextIdSeq *);
+  operator CORBA_ContextIdSeq *&();
+  CORBA_ContextIdSeq *&ptr (void);
+  CORBA_ContextIdSeq *operator-> (void);
+  TAO_SeqElem_String_Manager operator[] (CORBA::ULong index);
+  
+private:
+  CORBA_ContextIdSeq *&ptr_;
+  // assignment from T_var not allowed
+  void operator= (const CORBA_ContextIdSeq_var &);
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_OPERATIONDEF___VAR_CH_)
+#define _CORBA_OPERATIONDEF___VAR_CH_
+
+class TAO_IFR_Client_Export CORBA_OperationDef_var : public TAO_Base_var
+{
+public:
+  CORBA_OperationDef_var (void); // default constructor
+  CORBA_OperationDef_var (CORBA_OperationDef_ptr p) : ptr_ (p) {} 
+  CORBA_OperationDef_var (const CORBA_OperationDef_var &); // copy constructor
+  ~CORBA_OperationDef_var (void); // destructor
+  
+  CORBA_OperationDef_var &operator= (CORBA_OperationDef_ptr);
+  CORBA_OperationDef_var &operator= (const CORBA_OperationDef_var &);
+  CORBA_OperationDef_ptr operator-> (void) const;
+  
+  operator const CORBA_OperationDef_ptr &() const;
+  operator CORBA_OperationDef_ptr &();
+  // in, inout, out, _retn 
+  CORBA_OperationDef_ptr in (void) const;
+  CORBA_OperationDef_ptr &inout (void);
+  CORBA_OperationDef_ptr &out (void);
+  CORBA_OperationDef_ptr _retn (void);
+  CORBA_OperationDef_ptr ptr (void) const;
+
+private:
+  CORBA_OperationDef_ptr ptr_;
+  // Unimplemented - prevents widening assignment.
+  CORBA_OperationDef_var (const TAO_Base_var &rhs);
+  CORBA_OperationDef_var &operator= (const TAO_Base_var &rhs);
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_OPERATIONDEF___OUT_CH_)
+#define _CORBA_OPERATIONDEF___OUT_CH_
+
+class TAO_IFR_Client_Export CORBA_OperationDef_out
+{
+public:
+  CORBA_OperationDef_out (CORBA_OperationDef_ptr &);
+  CORBA_OperationDef_out (CORBA_OperationDef_var &);
+  CORBA_OperationDef_out (const CORBA_OperationDef_out &);
+  CORBA_OperationDef_out &operator= (const CORBA_OperationDef_out &);
+  CORBA_OperationDef_out &operator= (const CORBA_OperationDef_var &);
+  CORBA_OperationDef_out &operator= (CORBA_OperationDef_ptr);
+  operator CORBA_OperationDef_ptr &();
+  CORBA_OperationDef_ptr &ptr (void);
+  CORBA_OperationDef_ptr operator-> (void);
+  
+private:
+  CORBA_OperationDef_ptr &ptr_;
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_OPERATIONDEF_CH_)
+#define _CORBA_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_IFR_Client_Export CORBA_OperationDef: public virtual CORBA_Contained
+{
+public:
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef CORBA_OperationDef_ptr _ptr_type;
+  typedef CORBA_OperationDef_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  // the static operations
+  static CORBA_OperationDef_ptr _duplicate (CORBA_OperationDef_ptr obj);
+  static CORBA_OperationDef_ptr _narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    );
+  static CORBA_OperationDef_ptr _unchecked_narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    );
+  static CORBA_OperationDef_ptr _nil (void)
+    {
+      return (CORBA_OperationDef_ptr)0;
+    }
+
+  static void _tao_any_destructor (void*);
+
+  virtual CORBA::TypeCode_ptr result (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::IDLType_ptr result_def (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void result_def (
+      CORBA::IDLType_ptr result_def,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::ParDescriptionSeq * params (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void params (
+      const CORBA::ParDescriptionSeq & params,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::OperationMode mode (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void mode (
+      CORBA::OperationMode mode,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::ContextIdSeq * contexts (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void contexts (
+      const CORBA::ContextIdSeq & contexts,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::ExceptionDefSeq * exceptions (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void exceptions (
+      const CORBA::ExceptionDefSeq & exceptions,
+      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_OperationDef_Proxy_Broker *the_TAO_OperationDef_Proxy_Broker_;
+  
+protected:
+  CORBA_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 CORBA_OperationDef_setup_collocation (int collocated);
+    
+    CORBA_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 ~CORBA_OperationDef (void);
+private:
+  CORBA_OperationDef (const CORBA_OperationDef &);
+  void operator= (const CORBA_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_CORBA_OperationDef_result_get : public TAO_ClientRequestInfo
+  {
+  public:
+    friend class CORBA_OperationDef;
+    
+    friend class _TAO_OperationDef_Remote_Proxy_Impl;
+    friend class _TAO_OperationDef_ThruPOA_Proxy_Impl;
+    friend class _TAO_OperationDef_Direct_Proxy_Impl;
+  
+  TAO_ClientRequestInfo_CORBA_OperationDef_result_get (
+      TAO_GIOP_Invocation *_tao_invocation,
+      CORBA::Object_ptr _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_OperationDef_result_get (const TAO_ClientRequestInfo_CORBA_OperationDef_result_get &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_OperationDef_result_get &);
+  void result (CORBA::TypeCode_ptr result);
+  // update the result 
+  CORBA::TypeCode_ptr _result;
+};
+
+class TAO_ClientRequestInfo_CORBA_OperationDef_result_def_get : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_OperationDef;
+  
+  friend class _TAO_OperationDef_Remote_Proxy_Impl;
+  friend class _TAO_OperationDef_ThruPOA_Proxy_Impl;
+  friend class _TAO_OperationDef_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_OperationDef_result_def_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _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_OperationDef_result_def_get (const TAO_ClientRequestInfo_CORBA_OperationDef_result_def_get &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_OperationDef_result_def_get &);
+  void result (CORBA::IDLType_ptr result);
+  // update the result 
+  CORBA::IDLType_ptr _result;
+};
+
+class TAO_ClientRequestInfo_CORBA_OperationDef_result_def_set : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_OperationDef;
+  
+  friend class _TAO_OperationDef_Remote_Proxy_Impl;
+  friend class _TAO_OperationDef_ThruPOA_Proxy_Impl;
+  friend class _TAO_OperationDef_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_OperationDef_result_def_set (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::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));
+
+virtual CORBA::Any * result (
+    CORBA::Environment &ACE_TRY_ENV = 
+      TAO_default_environment ()
+  )
+  ACE_THROW_SPEC ((CORBA::SystemException));
+
+private:
+  TAO_ClientRequestInfo_CORBA_OperationDef_result_def_set (const TAO_ClientRequestInfo_CORBA_OperationDef_result_def_set &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_OperationDef_result_def_set &);
+  CORBA::IDLType_ptr result_def_;
+  
+};
+
+class TAO_ClientRequestInfo_CORBA_OperationDef_params_get : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_OperationDef;
+  
+  friend class _TAO_OperationDef_Remote_Proxy_Impl;
+  friend class _TAO_OperationDef_ThruPOA_Proxy_Impl;
+  friend class _TAO_OperationDef_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_OperationDef_params_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _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_OperationDef_params_get (const TAO_ClientRequestInfo_CORBA_OperationDef_params_get &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_OperationDef_params_get &);
+  void result (CORBA::ParDescriptionSeq * result);
+  // update the result 
+  CORBA::ParDescriptionSeq * _result;
+};
+
+class TAO_ClientRequestInfo_CORBA_OperationDef_params_set : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_OperationDef;
+  
+  friend class _TAO_OperationDef_Remote_Proxy_Impl;
+  friend class _TAO_OperationDef_ThruPOA_Proxy_Impl;
+  friend class _TAO_OperationDef_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_OperationDef_params_set (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const CORBA::ParDescriptionSeq & params,
+    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_OperationDef_params_set (const TAO_ClientRequestInfo_CORBA_OperationDef_params_set &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_OperationDef_params_set &);
+  const CORBA::ParDescriptionSeq & params_;
+  
+};
+
+class TAO_ClientRequestInfo_CORBA_OperationDef_mode_get : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_OperationDef;
+  
+  friend class _TAO_OperationDef_Remote_Proxy_Impl;
+  friend class _TAO_OperationDef_ThruPOA_Proxy_Impl;
+  friend class _TAO_OperationDef_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_OperationDef_mode_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _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_OperationDef_mode_get (const TAO_ClientRequestInfo_CORBA_OperationDef_mode_get &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_OperationDef_mode_get &);
+  void result (CORBA::OperationMode result);
+  // update the result 
+  CORBA::OperationMode _result;
+};
+
+class TAO_ClientRequestInfo_CORBA_OperationDef_mode_set : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_OperationDef;
+  
+  friend class _TAO_OperationDef_Remote_Proxy_Impl;
+  friend class _TAO_OperationDef_ThruPOA_Proxy_Impl;
+  friend class _TAO_OperationDef_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_OperationDef_mode_set (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::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_CORBA_OperationDef_mode_set (const TAO_ClientRequestInfo_CORBA_OperationDef_mode_set &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_OperationDef_mode_set &);
+  const CORBA::OperationMode & mode_;
+  
+};
+
+class TAO_ClientRequestInfo_CORBA_OperationDef_contexts_get : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_OperationDef;
+  
+  friend class _TAO_OperationDef_Remote_Proxy_Impl;
+  friend class _TAO_OperationDef_ThruPOA_Proxy_Impl;
+  friend class _TAO_OperationDef_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_OperationDef_contexts_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _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_OperationDef_contexts_get (const TAO_ClientRequestInfo_CORBA_OperationDef_contexts_get &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_OperationDef_contexts_get &);
+  void result (CORBA::ContextIdSeq * result);
+  // update the result 
+  CORBA::ContextIdSeq * _result;
+};
+
+class TAO_ClientRequestInfo_CORBA_OperationDef_contexts_set : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_OperationDef;
+  
+  friend class _TAO_OperationDef_Remote_Proxy_Impl;
+  friend class _TAO_OperationDef_ThruPOA_Proxy_Impl;
+  friend class _TAO_OperationDef_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_OperationDef_contexts_set (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const CORBA::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_CORBA_OperationDef_contexts_set (const TAO_ClientRequestInfo_CORBA_OperationDef_contexts_set &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_OperationDef_contexts_set &);
+  const CORBA::ContextIdSeq & contexts_;
+  
+};
+
+class TAO_ClientRequestInfo_CORBA_OperationDef_exceptions_get : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_OperationDef;
+  
+  friend class _TAO_OperationDef_Remote_Proxy_Impl;
+  friend class _TAO_OperationDef_ThruPOA_Proxy_Impl;
+  friend class _TAO_OperationDef_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_OperationDef_exceptions_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _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_OperationDef_exceptions_get (const TAO_ClientRequestInfo_CORBA_OperationDef_exceptions_get &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_OperationDef_exceptions_get &);
+  void result (CORBA::ExceptionDefSeq * result);
+  // update the result 
+  CORBA::ExceptionDefSeq * _result;
+};
+
+class TAO_ClientRequestInfo_CORBA_OperationDef_exceptions_set : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_OperationDef;
+  
+  friend class _TAO_OperationDef_Remote_Proxy_Impl;
+  friend class _TAO_OperationDef_ThruPOA_Proxy_Impl;
+  friend class _TAO_OperationDef_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_OperationDef_exceptions_set (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const CORBA::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_CORBA_OperationDef_exceptions_set (const TAO_ClientRequestInfo_CORBA_OperationDef_exceptions_set &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_OperationDef_exceptions_set &);
+  const CORBA::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_IFR_Client_Export _TAO_OperationDef_Proxy_Impl : 
+  public virtual _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 CORBA::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_,
+      CORBA::IDLType_ptr result_def,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual CORBA::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 CORBA::ParDescriptionSeq & params,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual CORBA::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_,
+      CORBA::OperationMode mode,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual CORBA::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 CORBA::ContextIdSeq & contexts,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual CORBA::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 CORBA::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_IFR_Client_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:
+  _TAO_OperationDef_Remote_Proxy_Impl (void);
+  
+  virtual ~_TAO_OperationDef_Remote_Proxy_Impl (void) { }
+  
+    virtual CORBA::TypeCode_ptr result (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::IDLType_ptr result_def (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void result_def (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::IDLType_ptr result_def,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::ParDescriptionSeq * params (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void params (
+      CORBA_Object *_collocated_tao_target_,
+      const CORBA::ParDescriptionSeq & params,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::OperationMode mode (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void mode (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::OperationMode mode,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::ContextIdSeq * contexts (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void contexts (
+      CORBA_Object *_collocated_tao_target_,
+      const CORBA::ContextIdSeq & contexts,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::ExceptionDefSeq * exceptions (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void exceptions (
+      CORBA_Object *_collocated_tao_target_,
+      const CORBA::ExceptionDefSeq & exceptions,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+};
+
+//
+//                Base  Proxy Impl. Declaration
+///////////////////////////////////////////////////////////////////////
+
+
+// The Proxy Brokers are used by each interface to get
+// the right proxy for performing a call. In the new 
+// collocation scheme, the proxy to be used can vary on
+// a call by call basis. 
+
+
+
+///////////////////////////////////////////////////////////////////////
+//                 Base Proxy Broker Declaration 
+//
+
+class TAO_IFR_Client_Export _TAO_OperationDef_Proxy_Broker
+{
+public:
+  virtual ~_TAO_OperationDef_Proxy_Broker (void);
+  virtual _TAO_OperationDef_Proxy_Impl &select_proxy (
+    CORBA_OperationDef *object,
+    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
+  ) = 0;
+
+protected:
+  _TAO_OperationDef_Proxy_Broker (void);
+  
+};
+
+//
+//              End Base Proxy Broker Declaration 
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//                 Remote Proxy Broker Declaration 
+//
+
+class TAO_IFR_Client_Export _TAO_OperationDef_Remote_Proxy_Broker : public virtual _TAO_OperationDef_Proxy_Broker
+{
+public: 
+  _TAO_OperationDef_Remote_Proxy_Broker (void);
+  
+  virtual ~_TAO_OperationDef_Remote_Proxy_Broker (void);
+  
+  virtual _TAO_OperationDef_Proxy_Impl &select_proxy (
+    CORBA_OperationDef *object,
+    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
+  );
+
+private:
+  _TAO_OperationDef_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_OperationDef_Remote_Proxy_Broker *the_TAO_OperationDef_Remote_Proxy_Broker (void);
+};
+
+
+//
+//              End Remote Proxy Broker Declaration 
+///////////////////////////////////////////////////////////////////////
+
+
+#endif /* end #if !defined */
+
+struct CORBA_OperationDescription;
+class CORBA_OperationDescription_var;
+
+struct TAO_IFR_Client_Export CORBA_OperationDescription
+{
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef CORBA_OperationDescription_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  static void _tao_any_destructor (void*);
+
+  TAO_String_Manager name;
+  TAO_String_Manager id;
+  TAO_String_Manager defined_in;
+  TAO_String_Manager version;
+  CORBA::TypeCode_var result;
+  CORBA::OperationMode mode;
+  CORBA::ContextIdSeq contexts;
+  CORBA::ParDescriptionSeq parameters;
+  CORBA::ExcDescriptionSeq exceptions;
+};
+
+class TAO_IFR_Client_Export CORBA_OperationDescription_var
+{
+public:
+  CORBA_OperationDescription_var (void); // default constructor
+  CORBA_OperationDescription_var (CORBA_OperationDescription *);
+  CORBA_OperationDescription_var (const CORBA_OperationDescription_var &); // copy constructor
+  ~CORBA_OperationDescription_var (void); // destructor
+  
+  CORBA_OperationDescription_var &operator= (CORBA_OperationDescription *);
+  CORBA_OperationDescription_var &operator= (const CORBA_OperationDescription_var &);
+  CORBA_OperationDescription *operator-> (void);
+  const CORBA_OperationDescription *operator-> (void) const;
+  
+  operator const CORBA_OperationDescription &() const;
+  operator CORBA_OperationDescription &();
+  operator CORBA_OperationDescription &() const;
+  operator CORBA_OperationDescription *&(); // variable-size types only
+  
+  // in, inout, out, _retn 
+  const CORBA_OperationDescription &in (void) const;
+  CORBA_OperationDescription &inout (void);
+  CORBA_OperationDescription *&out (void);
+  CORBA_OperationDescription *_retn (void);
+  CORBA_OperationDescription *ptr (void) const;
+
+private:
+  CORBA_OperationDescription *ptr_;
+};
+
+class TAO_IFR_Client_Export CORBA_OperationDescription_out
+{
+public:
+  CORBA_OperationDescription_out (CORBA_OperationDescription *&);
+  CORBA_OperationDescription_out (CORBA_OperationDescription_var &);
+  CORBA_OperationDescription_out (const CORBA_OperationDescription_out &);
+  CORBA_OperationDescription_out &operator= (const CORBA_OperationDescription_out &);
+  CORBA_OperationDescription_out &operator= (CORBA_OperationDescription *);
+  operator CORBA_OperationDescription *&();
+  CORBA_OperationDescription *&ptr (void);
+  CORBA_OperationDescription *operator-> (void);
+  
+private:
+  CORBA_OperationDescription *&ptr_;
+  // assignment from T_var not allowed
+  void operator= (const CORBA_OperationDescription_var &);
+};
+
+
+#if !defined (_CORBA_REPOSITORYIDSEQ_CH_)
+#define _CORBA_REPOSITORYIDSEQ_CH_
+
+class CORBA_RepositoryIdSeq;
+class CORBA_RepositoryIdSeq_var;
+
+// *************************************************************
+// CORBA_RepositoryIdSeq
+// *************************************************************
+
+class TAO_IFR_Client_Export CORBA_RepositoryIdSeq : public 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  TAO_Unbounded_String_Sequence
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_String_Sequence
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+{
+public:
+  CORBA_RepositoryIdSeq (void); // default ctor
+  CORBA_RepositoryIdSeq (CORBA::ULong max); // uses max size
+  CORBA_RepositoryIdSeq (
+    CORBA::ULong max, 
+    CORBA::ULong length, 
+    char * *buffer, 
+    CORBA::Boolean release = 0
+  );
+  CORBA_RepositoryIdSeq (const CORBA_RepositoryIdSeq &); // copy ctor
+  ~CORBA_RepositoryIdSeq (void);
+  static void _tao_any_destructor (void*);
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef CORBA_RepositoryIdSeq_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+};
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_REPOSITORYIDSEQ___VAR_CH_)
+#define _CORBA_REPOSITORYIDSEQ___VAR_CH_
+
+// *************************************************************
+// class CORBA_RepositoryIdSeq_var
+// *************************************************************
+
+class TAO_IFR_Client_Export CORBA_RepositoryIdSeq_var
+{
+public:
+  CORBA_RepositoryIdSeq_var (void); // default constructor
+  CORBA_RepositoryIdSeq_var (CORBA_RepositoryIdSeq *);
+  CORBA_RepositoryIdSeq_var (const CORBA_RepositoryIdSeq_var &); // copy constructor
+  ~CORBA_RepositoryIdSeq_var (void); // destructor
+  
+  CORBA_RepositoryIdSeq_var &operator= (CORBA_RepositoryIdSeq *);
+  CORBA_RepositoryIdSeq_var &operator= (const CORBA_RepositoryIdSeq_var &);
+  CORBA_RepositoryIdSeq *operator-> (void);
+  const CORBA_RepositoryIdSeq *operator-> (void) const;
+  
+  operator const CORBA_RepositoryIdSeq &() const;
+  operator CORBA_RepositoryIdSeq &();
+  operator CORBA_RepositoryIdSeq &() const;
+  operator CORBA_RepositoryIdSeq *&(); // variable-size base types only
+  
+  TAO_SeqElem_String_Manager operator[] (CORBA::ULong index);
+  
+  // in, inout, out, _retn 
+  const CORBA_RepositoryIdSeq &in (void) const;
+  CORBA_RepositoryIdSeq &inout (void);
+  CORBA_RepositoryIdSeq *&out (void);
+  CORBA_RepositoryIdSeq *_retn (void);
+  CORBA_RepositoryIdSeq *ptr (void) const;
+
+private:
+  CORBA_RepositoryIdSeq *ptr_;
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_REPOSITORYIDSEQ___OUT_CH_)
+#define _CORBA_REPOSITORYIDSEQ___OUT_CH_
+
+class TAO_IFR_Client_Export CORBA_RepositoryIdSeq_out
+{
+public:
+  CORBA_RepositoryIdSeq_out (CORBA_RepositoryIdSeq *&);
+  CORBA_RepositoryIdSeq_out (CORBA_RepositoryIdSeq_var &);
+  CORBA_RepositoryIdSeq_out (const CORBA_RepositoryIdSeq_out &);
+  CORBA_RepositoryIdSeq_out &operator= (const CORBA_RepositoryIdSeq_out &);
+  CORBA_RepositoryIdSeq_out &operator= (CORBA_RepositoryIdSeq *);
+  operator CORBA_RepositoryIdSeq *&();
+  CORBA_RepositoryIdSeq *&ptr (void);
+  CORBA_RepositoryIdSeq *operator-> (void);
+  TAO_SeqElem_String_Manager operator[] (CORBA::ULong index);
+  
+private:
+  CORBA_RepositoryIdSeq *&ptr_;
+  // assignment from T_var not allowed
+  void operator= (const CORBA_RepositoryIdSeq_var &);
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_SEQUENCE_CORBA_OPDESCRIPTIONSEQ_CH_)
+#define __TAO_UNBOUNDED_SEQUENCE_CORBA_OPDESCRIPTIONSEQ_CH_
+
+  class TAO_EXPORT_NESTED_MACRO _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq : public TAO_Unbounded_Base_Sequence
+  {
+  public:
+    // = Initialization and termination methods.
+    
+    _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq (void); // Default constructor.
+    _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq (CORBA::ULong maximum); 
+    _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq (CORBA::ULong maximum,
+      CORBA::ULong length,
+      CORBA_OperationDescription *data,
+      CORBA::Boolean release = 0);
+    _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq (const _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq &rhs);
+    _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq &operator= (const _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq &rhs);
+    virtual ~_TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq (void); // Dtor.
+    // = Accessors.
+    CORBA_OperationDescription &operator[] (CORBA::ULong i);
+    const CORBA_OperationDescription &operator[] (CORBA::ULong i) const;
+    // = Static operations.
+    static CORBA_OperationDescription *allocbuf (CORBA::ULong size);
+    static void freebuf (CORBA_OperationDescription *buffer);
+    virtual void _allocate_buffer (CORBA::ULong length);
+    virtual void _deallocate_buffer (void);
+    // Implement the TAO_Base_Sequence methods (see Sequence.h)
+    
+    CORBA_OperationDescription *get_buffer (CORBA::Boolean orphan = 0);
+    const CORBA_OperationDescription *get_buffer (void) const;
+    void replace (CORBA::ULong max,
+      CORBA::ULong length,
+      CORBA_OperationDescription *data,
+      CORBA::Boolean release);
+  };
+
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_CORBA_OPDESCRIPTIONSEQ_CH_)
+#define _CORBA_OPDESCRIPTIONSEQ_CH_
+
+class CORBA_OpDescriptionSeq;
+class CORBA_OpDescriptionSeq_var;
+
+// *************************************************************
+// CORBA_OpDescriptionSeq
+// *************************************************************
+
+class TAO_IFR_Client_Export CORBA_OpDescriptionSeq : public 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<CORBA_OperationDescription>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+{
+public:
+  CORBA_OpDescriptionSeq (void); // default ctor
+  CORBA_OpDescriptionSeq (CORBA::ULong max); // uses max size
+  CORBA_OpDescriptionSeq (
+    CORBA::ULong max, 
+    CORBA::ULong length, 
+    CORBA::OperationDescription *buffer, 
+    CORBA::Boolean release = 0
+  );
+  CORBA_OpDescriptionSeq (const CORBA_OpDescriptionSeq &); // copy ctor
+  ~CORBA_OpDescriptionSeq (void);
+  static void _tao_any_destructor (void*);
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef CORBA_OpDescriptionSeq_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+};
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_OPDESCRIPTIONSEQ___VAR_CH_)
+#define _CORBA_OPDESCRIPTIONSEQ___VAR_CH_
+
+// *************************************************************
+// class CORBA_OpDescriptionSeq_var
+// *************************************************************
+
+class TAO_IFR_Client_Export CORBA_OpDescriptionSeq_var
+{
+public:
+  CORBA_OpDescriptionSeq_var (void); // default constructor
+  CORBA_OpDescriptionSeq_var (CORBA_OpDescriptionSeq *);
+  CORBA_OpDescriptionSeq_var (const CORBA_OpDescriptionSeq_var &); // copy constructor
+  ~CORBA_OpDescriptionSeq_var (void); // destructor
+  
+  CORBA_OpDescriptionSeq_var &operator= (CORBA_OpDescriptionSeq *);
+  CORBA_OpDescriptionSeq_var &operator= (const CORBA_OpDescriptionSeq_var &);
+  CORBA_OpDescriptionSeq *operator-> (void);
+  const CORBA_OpDescriptionSeq *operator-> (void) const;
+  
+  operator const CORBA_OpDescriptionSeq &() const;
+  operator CORBA_OpDescriptionSeq &();
+  operator CORBA_OpDescriptionSeq &() const;
+  operator CORBA_OpDescriptionSeq *&(); // variable-size base types only
+  
+  CORBA::OperationDescription & operator[] (CORBA::ULong index);
+  const CORBA::OperationDescription & operator[] (CORBA::ULong index) const;
+  
+  // in, inout, out, _retn 
+  const CORBA_OpDescriptionSeq &in (void) const;
+  CORBA_OpDescriptionSeq &inout (void);
+  CORBA_OpDescriptionSeq *&out (void);
+  CORBA_OpDescriptionSeq *_retn (void);
+  CORBA_OpDescriptionSeq *ptr (void) const;
+
+private:
+  CORBA_OpDescriptionSeq *ptr_;
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_OPDESCRIPTIONSEQ___OUT_CH_)
+#define _CORBA_OPDESCRIPTIONSEQ___OUT_CH_
+
+class TAO_IFR_Client_Export CORBA_OpDescriptionSeq_out
+{
+public:
+  CORBA_OpDescriptionSeq_out (CORBA_OpDescriptionSeq *&);
+  CORBA_OpDescriptionSeq_out (CORBA_OpDescriptionSeq_var &);
+  CORBA_OpDescriptionSeq_out (const CORBA_OpDescriptionSeq_out &);
+  CORBA_OpDescriptionSeq_out &operator= (const CORBA_OpDescriptionSeq_out &);
+  CORBA_OpDescriptionSeq_out &operator= (CORBA_OpDescriptionSeq *);
+  operator CORBA_OpDescriptionSeq *&();
+  CORBA_OpDescriptionSeq *&ptr (void);
+  CORBA_OpDescriptionSeq *operator-> (void);
+  CORBA::OperationDescription & operator[] (CORBA::ULong index);
+  
+private:
+  CORBA_OpDescriptionSeq *&ptr_;
+  // assignment from T_var not allowed
+  void operator= (const CORBA_OpDescriptionSeq_var &);
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_SEQUENCE_CORBA_ATTRDESCRIPTIONSEQ_CH_)
+#define __TAO_UNBOUNDED_SEQUENCE_CORBA_ATTRDESCRIPTIONSEQ_CH_
+
+  class TAO_EXPORT_NESTED_MACRO _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq : public TAO_Unbounded_Base_Sequence
+  {
+  public:
+    // = Initialization and termination methods.
+    
+    _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq (void); // Default constructor.
+    _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq (CORBA::ULong maximum); 
+    _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq (CORBA::ULong maximum,
+      CORBA::ULong length,
+      CORBA_AttributeDescription *data,
+      CORBA::Boolean release = 0);
+    _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq (const _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq &rhs);
+    _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq &operator= (const _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq &rhs);
+    virtual ~_TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq (void); // Dtor.
+    // = Accessors.
+    CORBA_AttributeDescription &operator[] (CORBA::ULong i);
+    const CORBA_AttributeDescription &operator[] (CORBA::ULong i) const;
+    // = Static operations.
+    static CORBA_AttributeDescription *allocbuf (CORBA::ULong size);
+    static void freebuf (CORBA_AttributeDescription *buffer);
+    virtual void _allocate_buffer (CORBA::ULong length);
+    virtual void _deallocate_buffer (void);
+    // Implement the TAO_Base_Sequence methods (see Sequence.h)
+    
+    CORBA_AttributeDescription *get_buffer (CORBA::Boolean orphan = 0);
+    const CORBA_AttributeDescription *get_buffer (void) const;
+    void replace (CORBA::ULong max,
+      CORBA::ULong length,
+      CORBA_AttributeDescription *data,
+      CORBA::Boolean release);
+  };
+
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_CORBA_ATTRDESCRIPTIONSEQ_CH_)
+#define _CORBA_ATTRDESCRIPTIONSEQ_CH_
+
+class CORBA_AttrDescriptionSeq;
+class CORBA_AttrDescriptionSeq_var;
+
+// *************************************************************
+// CORBA_AttrDescriptionSeq
+// *************************************************************
+
+class TAO_IFR_Client_Export CORBA_AttrDescriptionSeq : public 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<CORBA_AttributeDescription>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+{
+public:
+  CORBA_AttrDescriptionSeq (void); // default ctor
+  CORBA_AttrDescriptionSeq (CORBA::ULong max); // uses max size
+  CORBA_AttrDescriptionSeq (
+    CORBA::ULong max, 
+    CORBA::ULong length, 
+    CORBA::AttributeDescription *buffer, 
+    CORBA::Boolean release = 0
+  );
+  CORBA_AttrDescriptionSeq (const CORBA_AttrDescriptionSeq &); // copy ctor
+  ~CORBA_AttrDescriptionSeq (void);
+  static void _tao_any_destructor (void*);
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef CORBA_AttrDescriptionSeq_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+};
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_ATTRDESCRIPTIONSEQ___VAR_CH_)
+#define _CORBA_ATTRDESCRIPTIONSEQ___VAR_CH_
+
+// *************************************************************
+// class CORBA_AttrDescriptionSeq_var
+// *************************************************************
+
+class TAO_IFR_Client_Export CORBA_AttrDescriptionSeq_var
+{
+public:
+  CORBA_AttrDescriptionSeq_var (void); // default constructor
+  CORBA_AttrDescriptionSeq_var (CORBA_AttrDescriptionSeq *);
+  CORBA_AttrDescriptionSeq_var (const CORBA_AttrDescriptionSeq_var &); // copy constructor
+  ~CORBA_AttrDescriptionSeq_var (void); // destructor
+  
+  CORBA_AttrDescriptionSeq_var &operator= (CORBA_AttrDescriptionSeq *);
+  CORBA_AttrDescriptionSeq_var &operator= (const CORBA_AttrDescriptionSeq_var &);
+  CORBA_AttrDescriptionSeq *operator-> (void);
+  const CORBA_AttrDescriptionSeq *operator-> (void) const;
+  
+  operator const CORBA_AttrDescriptionSeq &() const;
+  operator CORBA_AttrDescriptionSeq &();
+  operator CORBA_AttrDescriptionSeq &() const;
+  operator CORBA_AttrDescriptionSeq *&(); // variable-size base types only
+  
+  CORBA::AttributeDescription & operator[] (CORBA::ULong index);
+  const CORBA::AttributeDescription & operator[] (CORBA::ULong index) const;
+  
+  // in, inout, out, _retn 
+  const CORBA_AttrDescriptionSeq &in (void) const;
+  CORBA_AttrDescriptionSeq &inout (void);
+  CORBA_AttrDescriptionSeq *&out (void);
+  CORBA_AttrDescriptionSeq *_retn (void);
+  CORBA_AttrDescriptionSeq *ptr (void) const;
+
+private:
+  CORBA_AttrDescriptionSeq *ptr_;
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_ATTRDESCRIPTIONSEQ___OUT_CH_)
+#define _CORBA_ATTRDESCRIPTIONSEQ___OUT_CH_
+
+class TAO_IFR_Client_Export CORBA_AttrDescriptionSeq_out
+{
+public:
+  CORBA_AttrDescriptionSeq_out (CORBA_AttrDescriptionSeq *&);
+  CORBA_AttrDescriptionSeq_out (CORBA_AttrDescriptionSeq_var &);
+  CORBA_AttrDescriptionSeq_out (const CORBA_AttrDescriptionSeq_out &);
+  CORBA_AttrDescriptionSeq_out &operator= (const CORBA_AttrDescriptionSeq_out &);
+  CORBA_AttrDescriptionSeq_out &operator= (CORBA_AttrDescriptionSeq *);
+  operator CORBA_AttrDescriptionSeq *&();
+  CORBA_AttrDescriptionSeq *&ptr (void);
+  CORBA_AttrDescriptionSeq *operator-> (void);
+  CORBA::AttributeDescription & operator[] (CORBA::ULong index);
+  
+private:
+  CORBA_AttrDescriptionSeq *&ptr_;
+  // assignment from T_var not allowed
+  void operator= (const CORBA_AttrDescriptionSeq_var &);
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_INTERFACEDEF___VAR_CH_)
+#define _CORBA_INTERFACEDEF___VAR_CH_
+
+class TAO_IFR_Client_Export CORBA_InterfaceDef_var : public TAO_Base_var
+{
+public:
+  CORBA_InterfaceDef_var (void); // default constructor
+  CORBA_InterfaceDef_var (CORBA_InterfaceDef_ptr p) : ptr_ (p) {} 
+  CORBA_InterfaceDef_var (const CORBA_InterfaceDef_var &); // copy constructor
+  ~CORBA_InterfaceDef_var (void); // destructor
+  
+  CORBA_InterfaceDef_var &operator= (CORBA_InterfaceDef_ptr);
+  CORBA_InterfaceDef_var &operator= (const CORBA_InterfaceDef_var &);
+  CORBA_InterfaceDef_ptr operator-> (void) const;
+  
+  operator const CORBA_InterfaceDef_ptr &() const;
+  operator CORBA_InterfaceDef_ptr &();
+  // in, inout, out, _retn 
+  CORBA_InterfaceDef_ptr in (void) const;
+  CORBA_InterfaceDef_ptr &inout (void);
+  CORBA_InterfaceDef_ptr &out (void);
+  CORBA_InterfaceDef_ptr _retn (void);
+  CORBA_InterfaceDef_ptr ptr (void) const;
+
+private:
+  CORBA_InterfaceDef_ptr ptr_;
+  // Unimplemented - prevents widening assignment.
+  CORBA_InterfaceDef_var (const TAO_Base_var &rhs);
+  CORBA_InterfaceDef_var &operator= (const TAO_Base_var &rhs);
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_INTERFACEDEF___OUT_CH_)
+#define _CORBA_INTERFACEDEF___OUT_CH_
+
+class TAO_IFR_Client_Export CORBA_InterfaceDef_out
+{
+public:
+  CORBA_InterfaceDef_out (CORBA_InterfaceDef_ptr &);
+  CORBA_InterfaceDef_out (CORBA_InterfaceDef_var &);
+  CORBA_InterfaceDef_out (const CORBA_InterfaceDef_out &);
+  CORBA_InterfaceDef_out &operator= (const CORBA_InterfaceDef_out &);
+  CORBA_InterfaceDef_out &operator= (const CORBA_InterfaceDef_var &);
+  CORBA_InterfaceDef_out &operator= (CORBA_InterfaceDef_ptr);
+  operator CORBA_InterfaceDef_ptr &();
+  CORBA_InterfaceDef_ptr &ptr (void);
+  CORBA_InterfaceDef_ptr operator-> (void);
+  
+private:
+  CORBA_InterfaceDef_ptr &ptr_;
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_INTERFACEDEF_CH_)
+#define _CORBA_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_IFR_Client_Export CORBA_InterfaceDef: public virtual CORBA_Container, public virtual CORBA_Contained, public virtual CORBA_IDLType
+{
+public:
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef CORBA_InterfaceDef_ptr _ptr_type;
+  typedef CORBA_InterfaceDef_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  // the static operations
+  static CORBA_InterfaceDef_ptr _duplicate (CORBA_InterfaceDef_ptr obj);
+  static CORBA_InterfaceDef_ptr _narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    );
+  static CORBA_InterfaceDef_ptr _unchecked_narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    );
+  static CORBA_InterfaceDef_ptr _nil (void)
+    {
+      return (CORBA_InterfaceDef_ptr)0;
+    }
+
+  static void _tao_any_destructor (void*);
+
+  virtual CORBA::InterfaceDefSeq * base_interfaces (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void base_interfaces (
+      const CORBA::InterfaceDefSeq & base_interfaces,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::Boolean is_a (
+      const char * interface_id,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  struct FullInterfaceDescription;
+  class FullInterfaceDescription_var;
+  
+  struct TAO_IFR_Client_Export FullInterfaceDescription
+  {
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+    typedef FullInterfaceDescription_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+    static void _tao_any_destructor (void*);
+
+    TAO_String_Manager name;
+    TAO_String_Manager id;
+    TAO_String_Manager defined_in;
+    TAO_String_Manager version;
+    CORBA::OpDescriptionSeq operations;
+    CORBA::AttrDescriptionSeq attributes;
+    CORBA::RepositoryIdSeq base_interfaces;
+    CORBA::TypeCode_var type;
+  };
+
+  class TAO_IFR_Client_Export FullInterfaceDescription_var
+  {
+  public:
+    FullInterfaceDescription_var (void); // default constructor
+    FullInterfaceDescription_var (FullInterfaceDescription *);
+    FullInterfaceDescription_var (const FullInterfaceDescription_var &); // copy constructor
+    ~FullInterfaceDescription_var (void); // destructor
+    
+    FullInterfaceDescription_var &operator= (FullInterfaceDescription *);
+    FullInterfaceDescription_var &operator= (const FullInterfaceDescription_var &);
+    FullInterfaceDescription *operator-> (void);
+    const FullInterfaceDescription *operator-> (void) const;
+    
+    operator const FullInterfaceDescription &() const;
+    operator FullInterfaceDescription &();
+    operator FullInterfaceDescription &() const;
+    operator FullInterfaceDescription *&(); // variable-size types only
+    
+    // in, inout, out, _retn 
+    const FullInterfaceDescription &in (void) const;
+    FullInterfaceDescription &inout (void);
+    FullInterfaceDescription *&out (void);
+    FullInterfaceDescription *_retn (void);
+    FullInterfaceDescription *ptr (void) const;
+
+  private:
+    FullInterfaceDescription *ptr_;
+  };
+
+  class TAO_IFR_Client_Export FullInterfaceDescription_out
+  {
+  public:
+    FullInterfaceDescription_out (FullInterfaceDescription *&);
+    FullInterfaceDescription_out (FullInterfaceDescription_var &);
+    FullInterfaceDescription_out (const FullInterfaceDescription_out &);
+    FullInterfaceDescription_out &operator= (const FullInterfaceDescription_out &);
+    FullInterfaceDescription_out &operator= (FullInterfaceDescription *);
+    operator FullInterfaceDescription *&();
+    FullInterfaceDescription *&ptr (void);
+    FullInterfaceDescription *operator-> (void);
+    
+  private:
+    FullInterfaceDescription *&ptr_;
+    // assignment from T_var not allowed
+    void operator= (const FullInterfaceDescription_var &);
+  };
+
+  static CORBA::TypeCode_ptr _tc_FullInterfaceDescription;
+
+  virtual CORBA::InterfaceDef::FullInterfaceDescription * describe_interface (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::AttributeDef_ptr create_attribute (
+      const char * id,
+      const char * name,
+      const char * version,
+      CORBA::IDLType_ptr type,
+      CORBA::AttributeMode mode,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::OperationDef_ptr create_operation (
+      const char * id,
+      const char * name,
+      const char * version,
+      CORBA::IDLType_ptr result,
+      CORBA::OperationMode mode,
+      const CORBA::ParDescriptionSeq & params,
+      const CORBA::ExceptionDefSeq & exceptions,
+      const CORBA::ContextIdSeq & contexts,
+      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_InterfaceDef_Proxy_Broker *the_TAO_InterfaceDef_Proxy_Broker_;
+  
+protected:
+  CORBA_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 CORBA_InterfaceDef_setup_collocation (int collocated);
+    
+    CORBA_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 ~CORBA_InterfaceDef (void);
+private:
+  CORBA_InterfaceDef (const CORBA_InterfaceDef &);
+  void operator= (const CORBA_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_CORBA_InterfaceDef_base_interfaces_get : public TAO_ClientRequestInfo
+  {
+  public:
+    friend class CORBA_InterfaceDef;
+    
+    friend class _TAO_InterfaceDef_Remote_Proxy_Impl;
+    friend class _TAO_InterfaceDef_ThruPOA_Proxy_Impl;
+    friend class _TAO_InterfaceDef_Direct_Proxy_Impl;
+  
+  TAO_ClientRequestInfo_CORBA_InterfaceDef_base_interfaces_get (
+      TAO_GIOP_Invocation *_tao_invocation,
+      CORBA::Object_ptr _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_InterfaceDef_base_interfaces_get (const TAO_ClientRequestInfo_CORBA_InterfaceDef_base_interfaces_get &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_InterfaceDef_base_interfaces_get &);
+  void result (CORBA::InterfaceDefSeq * result);
+  // update the result 
+  CORBA::InterfaceDefSeq * _result;
+};
+
+class TAO_ClientRequestInfo_CORBA_InterfaceDef_base_interfaces_set : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_InterfaceDef;
+  
+  friend class _TAO_InterfaceDef_Remote_Proxy_Impl;
+  friend class _TAO_InterfaceDef_ThruPOA_Proxy_Impl;
+  friend class _TAO_InterfaceDef_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_InterfaceDef_base_interfaces_set (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const CORBA::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_CORBA_InterfaceDef_base_interfaces_set (const TAO_ClientRequestInfo_CORBA_InterfaceDef_base_interfaces_set &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_InterfaceDef_base_interfaces_set &);
+  const CORBA::InterfaceDefSeq & base_interfaces_;
+  
+};
+
+class TAO_ClientRequestInfo_CORBA_InterfaceDef_is_a : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_InterfaceDef;
+  
+  friend class _TAO_InterfaceDef_Remote_Proxy_Impl;
+  friend class _TAO_InterfaceDef_ThruPOA_Proxy_Impl;
+  friend class _TAO_InterfaceDef_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_InterfaceDef_is_a (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _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_CORBA_InterfaceDef_is_a (const TAO_ClientRequestInfo_CORBA_InterfaceDef_is_a &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_InterfaceDef_is_a &);
+  const char * interface_id_;
+  void result (CORBA::Boolean result);
+  // update the result 
+  CORBA::Boolean _result;
+};
+
+class TAO_ClientRequestInfo_CORBA_InterfaceDef_describe_interface : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_InterfaceDef;
+  
+  friend class _TAO_InterfaceDef_Remote_Proxy_Impl;
+  friend class _TAO_InterfaceDef_ThruPOA_Proxy_Impl;
+  friend class _TAO_InterfaceDef_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_InterfaceDef_describe_interface (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _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_InterfaceDef_describe_interface (const TAO_ClientRequestInfo_CORBA_InterfaceDef_describe_interface &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_InterfaceDef_describe_interface &);
+  void result (ACE_NESTED_CLASS (CORBA::InterfaceDef,FullInterfaceDescription) * result);
+  // update the result 
+  ACE_NESTED_CLASS (CORBA::InterfaceDef,FullInterfaceDescription) * _result;
+};
+
+class TAO_ClientRequestInfo_CORBA_InterfaceDef_create_attribute : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_InterfaceDef;
+  
+  friend class _TAO_InterfaceDef_Remote_Proxy_Impl;
+  friend class _TAO_InterfaceDef_ThruPOA_Proxy_Impl;
+  friend class _TAO_InterfaceDef_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_InterfaceDef_create_attribute (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const char * id,
+    const char * name,
+    const char * version,
+    CORBA::IDLType_ptr type,
+    CORBA::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));
+
+private:
+  TAO_ClientRequestInfo_CORBA_InterfaceDef_create_attribute (const TAO_ClientRequestInfo_CORBA_InterfaceDef_create_attribute &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_InterfaceDef_create_attribute &);
+  const char * id_;
+  const char * name_;
+  const char * version_;
+  CORBA::IDLType_ptr type_;
+  const CORBA::AttributeMode & mode_;
+  void result (CORBA::AttributeDef_ptr result);
+  // update the result 
+  CORBA::AttributeDef_ptr _result;
+};
+
+class TAO_ClientRequestInfo_CORBA_InterfaceDef_create_operation : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_InterfaceDef;
+  
+  friend class _TAO_InterfaceDef_Remote_Proxy_Impl;
+  friend class _TAO_InterfaceDef_ThruPOA_Proxy_Impl;
+  friend class _TAO_InterfaceDef_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_InterfaceDef_create_operation (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const char * id,
+    const char * name,
+    const char * version,
+    CORBA::IDLType_ptr result,
+    CORBA::OperationMode & mode,
+    const CORBA::ParDescriptionSeq & params,
+    const CORBA::ExceptionDefSeq & exceptions,
+    const CORBA::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_CORBA_InterfaceDef_create_operation (const TAO_ClientRequestInfo_CORBA_InterfaceDef_create_operation &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_InterfaceDef_create_operation &);
+  const char * id_;
+  const char * name_;
+  const char * version_;
+  CORBA::IDLType_ptr result_;
+  const CORBA::OperationMode & mode_;
+  const CORBA::ParDescriptionSeq & params_;
+  const CORBA::ExceptionDefSeq & exceptions_;
+  const CORBA::ContextIdSeq & contexts_;
+  void result (CORBA::OperationDef_ptr result);
+  // update the result 
+  CORBA::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_IFR_Client_Export _TAO_InterfaceDef_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 CORBA::InterfaceDefSeq * base_interfaces (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual void base_interfaces (
+      CORBA_Object *_collocated_tao_target_,
+      const CORBA::InterfaceDefSeq & base_interfaces,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual CORBA::Boolean is_a (
+      CORBA_Object *_collocated_tao_target_,
+      const char * interface_id,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual CORBA::InterfaceDef::FullInterfaceDescription * describe_interface (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual CORBA::AttributeDef_ptr create_attribute (
+      CORBA_Object *_collocated_tao_target_,
+      const char * id,
+      const char * name,
+      const char * version,
+      CORBA::IDLType_ptr type,
+      CORBA::AttributeMode mode,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual CORBA::OperationDef_ptr create_operation (
+      CORBA_Object *_collocated_tao_target_,
+      const char * id,
+      const char * name,
+      const char * version,
+      CORBA::IDLType_ptr result,
+      CORBA::OperationMode mode,
+      const CORBA::ParDescriptionSeq & params,
+      const CORBA::ExceptionDefSeq & exceptions,
+      const CORBA::ContextIdSeq & contexts,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+protected:
+  _TAO_InterfaceDef_Proxy_Impl (void);
+
+};
+//
+//                Base  Proxy Impl. Declaration
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//                    Remote  Impl. Declaration
+//
+
+class TAO_IFR_Client_Export _TAO_InterfaceDef_Remote_Proxy_Impl : 
+  public virtual _TAO_InterfaceDef_Proxy_Impl,
+  public virtual TAO_Remote_Object_Proxy_Impl,
+  public virtual _TAO_Container_Remote_Proxy_Impl, 
+  public virtual _TAO_Contained_Remote_Proxy_Impl, 
+  public virtual _TAO_IDLType_Remote_Proxy_Impl
+  
+{
+public:
+  _TAO_InterfaceDef_Remote_Proxy_Impl (void);
+  
+  virtual ~_TAO_InterfaceDef_Remote_Proxy_Impl (void) { }
+  
+    virtual CORBA::InterfaceDefSeq * base_interfaces (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void base_interfaces (
+      CORBA_Object *_collocated_tao_target_,
+      const CORBA::InterfaceDefSeq & base_interfaces,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::Boolean is_a (
+      CORBA_Object *_collocated_tao_target_,
+      const char * interface_id,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::InterfaceDef::FullInterfaceDescription * describe_interface (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::AttributeDef_ptr create_attribute (
+      CORBA_Object *_collocated_tao_target_,
+      const char * id,
+      const char * name,
+      const char * version,
+      CORBA::IDLType_ptr type,
+      CORBA::AttributeMode mode,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::OperationDef_ptr create_operation (
+      CORBA_Object *_collocated_tao_target_,
+      const char * id,
+      const char * name,
+      const char * version,
+      CORBA::IDLType_ptr result,
+      CORBA::OperationMode mode,
+      const CORBA::ParDescriptionSeq & params,
+      const CORBA::ExceptionDefSeq & exceptions,
+      const CORBA::ContextIdSeq & contexts,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+};
+
+//
+//                Base  Proxy Impl. Declaration
+///////////////////////////////////////////////////////////////////////
+
+
+// The Proxy Brokers are used by each interface to get
+// the right proxy for performing a call. In the new 
+// collocation scheme, the proxy to be used can vary on
+// a call by call basis. 
+
+
+
+///////////////////////////////////////////////////////////////////////
+//                 Base Proxy Broker Declaration 
+//
+
+class TAO_IFR_Client_Export _TAO_InterfaceDef_Proxy_Broker
+{
+public:
+  virtual ~_TAO_InterfaceDef_Proxy_Broker (void);
+  virtual _TAO_InterfaceDef_Proxy_Impl &select_proxy (
+    CORBA_InterfaceDef *object,
+    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
+  ) = 0;
+
+protected:
+  _TAO_InterfaceDef_Proxy_Broker (void);
+  
+};
+
+//
+//              End Base Proxy Broker Declaration 
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//                 Remote Proxy Broker Declaration 
+//
+
+class TAO_IFR_Client_Export _TAO_InterfaceDef_Remote_Proxy_Broker : public virtual _TAO_InterfaceDef_Proxy_Broker
+{
+public: 
+  _TAO_InterfaceDef_Remote_Proxy_Broker (void);
+  
+  virtual ~_TAO_InterfaceDef_Remote_Proxy_Broker (void);
+  
+  virtual _TAO_InterfaceDef_Proxy_Impl &select_proxy (
+    CORBA_InterfaceDef *object,
+    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
+  );
+
+private:
+  _TAO_InterfaceDef_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_InterfaceDef_Remote_Proxy_Broker *the_TAO_InterfaceDef_Remote_Proxy_Broker (void);
+};
+
+
+//
+//              End Remote Proxy Broker Declaration 
+///////////////////////////////////////////////////////////////////////
+
+
+#endif /* end #if !defined */
+
+struct CORBA_InterfaceDescription;
+class CORBA_InterfaceDescription_var;
+
+struct TAO_IFR_Client_Export CORBA_InterfaceDescription
+{
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef CORBA_InterfaceDescription_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  static void _tao_any_destructor (void*);
+
+  TAO_String_Manager name;
+  TAO_String_Manager id;
+  TAO_String_Manager defined_in;
+  TAO_String_Manager version;
+  CORBA::RepositoryIdSeq base_interfaces;
+};
+
+class TAO_IFR_Client_Export CORBA_InterfaceDescription_var
+{
+public:
+  CORBA_InterfaceDescription_var (void); // default constructor
+  CORBA_InterfaceDescription_var (CORBA_InterfaceDescription *);
+  CORBA_InterfaceDescription_var (const CORBA_InterfaceDescription_var &); // copy constructor
+  ~CORBA_InterfaceDescription_var (void); // destructor
+  
+  CORBA_InterfaceDescription_var &operator= (CORBA_InterfaceDescription *);
+  CORBA_InterfaceDescription_var &operator= (const CORBA_InterfaceDescription_var &);
+  CORBA_InterfaceDescription *operator-> (void);
+  const CORBA_InterfaceDescription *operator-> (void) const;
+  
+  operator const CORBA_InterfaceDescription &() const;
+  operator CORBA_InterfaceDescription &();
+  operator CORBA_InterfaceDescription &() const;
+  operator CORBA_InterfaceDescription *&(); // variable-size types only
+  
+  // in, inout, out, _retn 
+  const CORBA_InterfaceDescription &in (void) const;
+  CORBA_InterfaceDescription &inout (void);
+  CORBA_InterfaceDescription *&out (void);
+  CORBA_InterfaceDescription *_retn (void);
+  CORBA_InterfaceDescription *ptr (void) const;
+
+private:
+  CORBA_InterfaceDescription *ptr_;
+};
+
+class TAO_IFR_Client_Export CORBA_InterfaceDescription_out
+{
+public:
+  CORBA_InterfaceDescription_out (CORBA_InterfaceDescription *&);
+  CORBA_InterfaceDescription_out (CORBA_InterfaceDescription_var &);
+  CORBA_InterfaceDescription_out (const CORBA_InterfaceDescription_out &);
+  CORBA_InterfaceDescription_out &operator= (const CORBA_InterfaceDescription_out &);
+  CORBA_InterfaceDescription_out &operator= (CORBA_InterfaceDescription *);
+  operator CORBA_InterfaceDescription *&();
+  CORBA_InterfaceDescription *&ptr (void);
+  CORBA_InterfaceDescription *operator-> (void);
+  
+private:
+  CORBA_InterfaceDescription *&ptr_;
+  // assignment from T_var not allowed
+  void operator= (const CORBA_InterfaceDescription_var &);
+};
+
+
+#if !defined (_CORBA_ABSTRACTINTERFACEDEF___VAR_CH_)
+#define _CORBA_ABSTRACTINTERFACEDEF___VAR_CH_
+
+class TAO_IFR_Client_Export CORBA_AbstractInterfaceDef_var : public TAO_Base_var
+{
+public:
+  CORBA_AbstractInterfaceDef_var (void); // default constructor
+  CORBA_AbstractInterfaceDef_var (CORBA_AbstractInterfaceDef_ptr p) : ptr_ (p) {} 
+  CORBA_AbstractInterfaceDef_var (const CORBA_AbstractInterfaceDef_var &); // copy constructor
+  ~CORBA_AbstractInterfaceDef_var (void); // destructor
+  
+  CORBA_AbstractInterfaceDef_var &operator= (CORBA_AbstractInterfaceDef_ptr);
+  CORBA_AbstractInterfaceDef_var &operator= (const CORBA_AbstractInterfaceDef_var &);
+  CORBA_AbstractInterfaceDef_ptr operator-> (void) const;
+  
+  operator const CORBA_AbstractInterfaceDef_ptr &() const;
+  operator CORBA_AbstractInterfaceDef_ptr &();
+  // in, inout, out, _retn 
+  CORBA_AbstractInterfaceDef_ptr in (void) const;
+  CORBA_AbstractInterfaceDef_ptr &inout (void);
+  CORBA_AbstractInterfaceDef_ptr &out (void);
+  CORBA_AbstractInterfaceDef_ptr _retn (void);
+  CORBA_AbstractInterfaceDef_ptr ptr (void) const;
+
+private:
+  CORBA_AbstractInterfaceDef_ptr ptr_;
+  // Unimplemented - prevents widening assignment.
+  CORBA_AbstractInterfaceDef_var (const TAO_Base_var &rhs);
+  CORBA_AbstractInterfaceDef_var &operator= (const TAO_Base_var &rhs);
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_ABSTRACTINTERFACEDEF___OUT_CH_)
+#define _CORBA_ABSTRACTINTERFACEDEF___OUT_CH_
+
+class TAO_IFR_Client_Export CORBA_AbstractInterfaceDef_out
+{
+public:
+  CORBA_AbstractInterfaceDef_out (CORBA_AbstractInterfaceDef_ptr &);
+  CORBA_AbstractInterfaceDef_out (CORBA_AbstractInterfaceDef_var &);
+  CORBA_AbstractInterfaceDef_out (const CORBA_AbstractInterfaceDef_out &);
+  CORBA_AbstractInterfaceDef_out &operator= (const CORBA_AbstractInterfaceDef_out &);
+  CORBA_AbstractInterfaceDef_out &operator= (const CORBA_AbstractInterfaceDef_var &);
+  CORBA_AbstractInterfaceDef_out &operator= (CORBA_AbstractInterfaceDef_ptr);
+  operator CORBA_AbstractInterfaceDef_ptr &();
+  CORBA_AbstractInterfaceDef_ptr &ptr (void);
+  CORBA_AbstractInterfaceDef_ptr operator-> (void);
+  
+private:
+  CORBA_AbstractInterfaceDef_ptr &ptr_;
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_ABSTRACTINTERFACEDEF_CH_)
+#define _CORBA_ABSTRACTINTERFACEDEF_CH_
+
+// Forward Classes Declaration
+class _TAO_AbstractInterfaceDef_Proxy_Impl;
+class _TAO_AbstractInterfaceDef_Remote_Proxy_Impl;
+class _TAO_AbstractInterfaceDef_Proxy_Broker;
+class _TAO_AbstractInterfaceDef_Remote_Proxy_Broker;
+
+class TAO_IFR_Client_Export CORBA_AbstractInterfaceDef: public virtual CORBA_InterfaceDef
+{
+public:
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef CORBA_AbstractInterfaceDef_ptr _ptr_type;
+  typedef CORBA_AbstractInterfaceDef_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  // the static operations
+  static CORBA_AbstractInterfaceDef_ptr _duplicate (CORBA_AbstractInterfaceDef_ptr obj);
+  static CORBA_AbstractInterfaceDef_ptr _narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    );
+  static CORBA_AbstractInterfaceDef_ptr _unchecked_narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    );
+  static CORBA_AbstractInterfaceDef_ptr _nil (void)
+    {
+      return (CORBA_AbstractInterfaceDef_ptr)0;
+    }
+
+  static void _tao_any_destructor (void*);
+
+  virtual CORBA::Boolean _is_a (
+      const CORBA::Char *type_id, 
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    );
+  virtual void *_tao_QueryInterface (ptr_arith_t type);
+  
+  virtual const char* _interface_repository_id (void) const;
+
+private:
+  _TAO_AbstractInterfaceDef_Proxy_Broker *the_TAO_AbstractInterfaceDef_Proxy_Broker_;
+  
+protected:
+  CORBA_AbstractInterfaceDef (int collocated = 0);
+  
+  protected:
+    // This methods travese the inheritance tree and set the
+    // parents piece of the given class in the right mode
+    virtual void CORBA_AbstractInterfaceDef_setup_collocation (int collocated);
+    
+    CORBA_AbstractInterfaceDef (
+      TAO_Stub *objref, 
+      CORBA::Boolean _tao_collocated = 0,
+      TAO_Abstract_ServantBase *servant = 0
+      );
+    
+    friend class _TAO_AbstractInterfaceDef_Remote_Proxy_Impl;
+    friend class _TAO_AbstractInterfaceDef_ThruPOA_Proxy_Impl;
+    friend class _TAO_AbstractInterfaceDef_Direct_Proxy_Impl;
+  
+  virtual ~CORBA_AbstractInterfaceDef (void);
+private:
+  CORBA_AbstractInterfaceDef (const CORBA_AbstractInterfaceDef &);
+  void operator= (const CORBA_AbstractInterfaceDef &);  
+
+#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 */
+
+};
+
+
+// The Proxy Implementations are used by each interface to
+// perform a call. Each different implementation encapsulate
+// an invocation logics.
+
+
+///////////////////////////////////////////////////////////////////////
+//                    Base  Impl. Declaration
+//
+
+class TAO_IFR_Client_Export _TAO_AbstractInterfaceDef_Proxy_Impl : 
+  public virtual _TAO_InterfaceDef_Proxy_Impl
+{
+public:
+  virtual ~_TAO_AbstractInterfaceDef_Proxy_Impl (void) { }
+  
+  protected:
+  _TAO_AbstractInterfaceDef_Proxy_Impl (void);
+
+};
+//
+//                Base  Proxy Impl. Declaration
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//                    Remote  Impl. Declaration
+//
+
+class TAO_IFR_Client_Export _TAO_AbstractInterfaceDef_Remote_Proxy_Impl : 
+  public virtual _TAO_AbstractInterfaceDef_Proxy_Impl,
+  public virtual TAO_Remote_Object_Proxy_Impl,
+  public virtual _TAO_InterfaceDef_Remote_Proxy_Impl
+  
+{
+public:
+  _TAO_AbstractInterfaceDef_Remote_Proxy_Impl (void);
+  
+  virtual ~_TAO_AbstractInterfaceDef_Remote_Proxy_Impl (void) { }
+  
+  };
+
+//
+//                Base  Proxy Impl. Declaration
+///////////////////////////////////////////////////////////////////////
+
+
+// The Proxy Brokers are used by each interface to get
+// the right proxy for performing a call. In the new 
+// collocation scheme, the proxy to be used can vary on
+// a call by call basis. 
+
+
+
+///////////////////////////////////////////////////////////////////////
+//                 Base Proxy Broker Declaration 
+//
+
+class TAO_IFR_Client_Export _TAO_AbstractInterfaceDef_Proxy_Broker
+{
+public:
+  virtual ~_TAO_AbstractInterfaceDef_Proxy_Broker (void);
+  virtual _TAO_AbstractInterfaceDef_Proxy_Impl &select_proxy (
+    CORBA_AbstractInterfaceDef *object,
+    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
+  ) = 0;
+
+protected:
+  _TAO_AbstractInterfaceDef_Proxy_Broker (void);
+  
+};
+
+//
+//              End Base Proxy Broker Declaration 
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//                 Remote Proxy Broker Declaration 
+//
+
+class TAO_IFR_Client_Export _TAO_AbstractInterfaceDef_Remote_Proxy_Broker : public virtual _TAO_AbstractInterfaceDef_Proxy_Broker
+{
+public: 
+  _TAO_AbstractInterfaceDef_Remote_Proxy_Broker (void);
+  
+  virtual ~_TAO_AbstractInterfaceDef_Remote_Proxy_Broker (void);
+  
+  virtual _TAO_AbstractInterfaceDef_Proxy_Impl &select_proxy (
+    CORBA_AbstractInterfaceDef *object,
+    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
+  );
+
+private:
+  _TAO_AbstractInterfaceDef_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_AbstractInterfaceDef_Remote_Proxy_Broker *the_TAO_AbstractInterfaceDef_Remote_Proxy_Broker (void);
+};
+
+
+//
+//              End Remote Proxy Broker Declaration 
+///////////////////////////////////////////////////////////////////////
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_LOCALINTERFACEDEF___VAR_CH_)
+#define _CORBA_LOCALINTERFACEDEF___VAR_CH_
+
+class TAO_IFR_Client_Export CORBA_LocalInterfaceDef_var : public TAO_Base_var
+{
+public:
+  CORBA_LocalInterfaceDef_var (void); // default constructor
+  CORBA_LocalInterfaceDef_var (CORBA_LocalInterfaceDef_ptr p) : ptr_ (p) {} 
+  CORBA_LocalInterfaceDef_var (const CORBA_LocalInterfaceDef_var &); // copy constructor
+  ~CORBA_LocalInterfaceDef_var (void); // destructor
+  
+  CORBA_LocalInterfaceDef_var &operator= (CORBA_LocalInterfaceDef_ptr);
+  CORBA_LocalInterfaceDef_var &operator= (const CORBA_LocalInterfaceDef_var &);
+  CORBA_LocalInterfaceDef_ptr operator-> (void) const;
+  
+  operator const CORBA_LocalInterfaceDef_ptr &() const;
+  operator CORBA_LocalInterfaceDef_ptr &();
+  // in, inout, out, _retn 
+  CORBA_LocalInterfaceDef_ptr in (void) const;
+  CORBA_LocalInterfaceDef_ptr &inout (void);
+  CORBA_LocalInterfaceDef_ptr &out (void);
+  CORBA_LocalInterfaceDef_ptr _retn (void);
+  CORBA_LocalInterfaceDef_ptr ptr (void) const;
+
+private:
+  CORBA_LocalInterfaceDef_ptr ptr_;
+  // Unimplemented - prevents widening assignment.
+  CORBA_LocalInterfaceDef_var (const TAO_Base_var &rhs);
+  CORBA_LocalInterfaceDef_var &operator= (const TAO_Base_var &rhs);
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_LOCALINTERFACEDEF___OUT_CH_)
+#define _CORBA_LOCALINTERFACEDEF___OUT_CH_
+
+class TAO_IFR_Client_Export CORBA_LocalInterfaceDef_out
+{
+public:
+  CORBA_LocalInterfaceDef_out (CORBA_LocalInterfaceDef_ptr &);
+  CORBA_LocalInterfaceDef_out (CORBA_LocalInterfaceDef_var &);
+  CORBA_LocalInterfaceDef_out (const CORBA_LocalInterfaceDef_out &);
+  CORBA_LocalInterfaceDef_out &operator= (const CORBA_LocalInterfaceDef_out &);
+  CORBA_LocalInterfaceDef_out &operator= (const CORBA_LocalInterfaceDef_var &);
+  CORBA_LocalInterfaceDef_out &operator= (CORBA_LocalInterfaceDef_ptr);
+  operator CORBA_LocalInterfaceDef_ptr &();
+  CORBA_LocalInterfaceDef_ptr &ptr (void);
+  CORBA_LocalInterfaceDef_ptr operator-> (void);
+  
+private:
+  CORBA_LocalInterfaceDef_ptr &ptr_;
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_LOCALINTERFACEDEF_CH_)
+#define _CORBA_LOCALINTERFACEDEF_CH_
+
+// Forward Classes Declaration
+class _TAO_LocalInterfaceDef_Proxy_Impl;
+class _TAO_LocalInterfaceDef_Remote_Proxy_Impl;
+class _TAO_LocalInterfaceDef_Proxy_Broker;
+class _TAO_LocalInterfaceDef_Remote_Proxy_Broker;
+
+class TAO_IFR_Client_Export CORBA_LocalInterfaceDef: public virtual CORBA_InterfaceDef
+{
+public:
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef CORBA_LocalInterfaceDef_ptr _ptr_type;
+  typedef CORBA_LocalInterfaceDef_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  // the static operations
+  static CORBA_LocalInterfaceDef_ptr _duplicate (CORBA_LocalInterfaceDef_ptr obj);
+  static CORBA_LocalInterfaceDef_ptr _narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    );
+  static CORBA_LocalInterfaceDef_ptr _unchecked_narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    );
+  static CORBA_LocalInterfaceDef_ptr _nil (void)
+    {
+      return (CORBA_LocalInterfaceDef_ptr)0;
+    }
+
+  static void _tao_any_destructor (void*);
+
+  virtual CORBA::Boolean _is_a (
+      const CORBA::Char *type_id, 
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    );
+  virtual void *_tao_QueryInterface (ptr_arith_t type);
+  
+  virtual const char* _interface_repository_id (void) const;
+
+private:
+  _TAO_LocalInterfaceDef_Proxy_Broker *the_TAO_LocalInterfaceDef_Proxy_Broker_;
+  
+protected:
+  CORBA_LocalInterfaceDef (int collocated = 0);
+  
+  protected:
+    // This methods travese the inheritance tree and set the
+    // parents piece of the given class in the right mode
+    virtual void CORBA_LocalInterfaceDef_setup_collocation (int collocated);
+    
+    CORBA_LocalInterfaceDef (
+      TAO_Stub *objref, 
+      CORBA::Boolean _tao_collocated = 0,
+      TAO_Abstract_ServantBase *servant = 0
+      );
+    
+    friend class _TAO_LocalInterfaceDef_Remote_Proxy_Impl;
+    friend class _TAO_LocalInterfaceDef_ThruPOA_Proxy_Impl;
+    friend class _TAO_LocalInterfaceDef_Direct_Proxy_Impl;
+  
+  virtual ~CORBA_LocalInterfaceDef (void);
+private:
+  CORBA_LocalInterfaceDef (const CORBA_LocalInterfaceDef &);
+  void operator= (const CORBA_LocalInterfaceDef &);  
+
+#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 */
+
+};
+
+
+// The Proxy Implementations are used by each interface to
+// perform a call. Each different implementation encapsulate
+// an invocation logics.
+
+
+///////////////////////////////////////////////////////////////////////
+//                    Base  Impl. Declaration
+//
+
+class TAO_IFR_Client_Export _TAO_LocalInterfaceDef_Proxy_Impl : 
+  public virtual _TAO_InterfaceDef_Proxy_Impl
+{
+public:
+  virtual ~_TAO_LocalInterfaceDef_Proxy_Impl (void) { }
+  
+  protected:
+  _TAO_LocalInterfaceDef_Proxy_Impl (void);
+
+};
+//
+//                Base  Proxy Impl. Declaration
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//                    Remote  Impl. Declaration
+//
+
+class TAO_IFR_Client_Export _TAO_LocalInterfaceDef_Remote_Proxy_Impl : 
+  public virtual _TAO_LocalInterfaceDef_Proxy_Impl,
+  public virtual TAO_Remote_Object_Proxy_Impl,
+  public virtual _TAO_InterfaceDef_Remote_Proxy_Impl
+  
+{
+public:
+  _TAO_LocalInterfaceDef_Remote_Proxy_Impl (void);
+  
+  virtual ~_TAO_LocalInterfaceDef_Remote_Proxy_Impl (void) { }
+  
+  };
+
+//
+//                Base  Proxy Impl. Declaration
+///////////////////////////////////////////////////////////////////////
+
+
+// The Proxy Brokers are used by each interface to get
+// the right proxy for performing a call. In the new 
+// collocation scheme, the proxy to be used can vary on
+// a call by call basis. 
+
+
+
+///////////////////////////////////////////////////////////////////////
+//                 Base Proxy Broker Declaration 
+//
+
+class TAO_IFR_Client_Export _TAO_LocalInterfaceDef_Proxy_Broker
+{
+public:
+  virtual ~_TAO_LocalInterfaceDef_Proxy_Broker (void);
+  virtual _TAO_LocalInterfaceDef_Proxy_Impl &select_proxy (
+    CORBA_LocalInterfaceDef *object,
+    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
+  ) = 0;
+
+protected:
+  _TAO_LocalInterfaceDef_Proxy_Broker (void);
+  
+};
+
+//
+//              End Base Proxy Broker Declaration 
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//                 Remote Proxy Broker Declaration 
+//
+
+class TAO_IFR_Client_Export _TAO_LocalInterfaceDef_Remote_Proxy_Broker : public virtual _TAO_LocalInterfaceDef_Proxy_Broker
+{
+public: 
+  _TAO_LocalInterfaceDef_Remote_Proxy_Broker (void);
+  
+  virtual ~_TAO_LocalInterfaceDef_Remote_Proxy_Broker (void);
+  
+  virtual _TAO_LocalInterfaceDef_Proxy_Impl &select_proxy (
+    CORBA_LocalInterfaceDef *object,
+    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
+  );
+
+private:
+  _TAO_LocalInterfaceDef_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_LocalInterfaceDef_Remote_Proxy_Broker *the_TAO_LocalInterfaceDef_Remote_Proxy_Broker (void);
+};
+
+
+//
+//              End Remote Proxy Broker Declaration 
+///////////////////////////////////////////////////////////////////////
+
+
+#endif /* end #if !defined */
+
+// Proxy Broker Factory function pointer declarations.
+
+extern TAO_IFR_Client_Export _TAO_Repository_Proxy_Broker * (*CORBA__TAO_Repository_Proxy_Broker_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  );
+
+extern TAO_IFR_Client_Export _TAO_ModuleDef_Proxy_Broker * (*CORBA__TAO_ModuleDef_Proxy_Broker_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  );
+
+extern TAO_IFR_Client_Export _TAO_ConstantDef_Proxy_Broker * (*CORBA__TAO_ConstantDef_Proxy_Broker_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  );
+
+extern TAO_IFR_Client_Export _TAO_StructDef_Proxy_Broker * (*CORBA__TAO_StructDef_Proxy_Broker_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  );
+
+extern TAO_IFR_Client_Export _TAO_UnionDef_Proxy_Broker * (*CORBA__TAO_UnionDef_Proxy_Broker_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  );
+
+extern TAO_IFR_Client_Export _TAO_EnumDef_Proxy_Broker * (*CORBA__TAO_EnumDef_Proxy_Broker_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  );
+
+extern TAO_IFR_Client_Export _TAO_AliasDef_Proxy_Broker * (*CORBA__TAO_AliasDef_Proxy_Broker_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  );
+
+extern TAO_IFR_Client_Export _TAO_NativeDef_Proxy_Broker * (*CORBA__TAO_NativeDef_Proxy_Broker_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  );
+
+extern TAO_IFR_Client_Export _TAO_PrimitiveDef_Proxy_Broker * (*CORBA__TAO_PrimitiveDef_Proxy_Broker_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  );
+
+extern TAO_IFR_Client_Export _TAO_StringDef_Proxy_Broker * (*CORBA__TAO_StringDef_Proxy_Broker_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  );
+
+extern TAO_IFR_Client_Export _TAO_WstringDef_Proxy_Broker * (*CORBA__TAO_WstringDef_Proxy_Broker_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  );
+
+extern TAO_IFR_Client_Export _TAO_SequenceDef_Proxy_Broker * (*CORBA__TAO_SequenceDef_Proxy_Broker_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  );
+
+extern TAO_IFR_Client_Export _TAO_ArrayDef_Proxy_Broker * (*CORBA__TAO_ArrayDef_Proxy_Broker_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  );
+
+extern TAO_IFR_Client_Export _TAO_ExceptionDef_Proxy_Broker * (*CORBA__TAO_ExceptionDef_Proxy_Broker_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  );
+
+extern TAO_IFR_Client_Export _TAO_AttributeDef_Proxy_Broker * (*CORBA__TAO_AttributeDef_Proxy_Broker_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  );
+
+extern TAO_IFR_Client_Export _TAO_OperationDef_Proxy_Broker * (*CORBA__TAO_OperationDef_Proxy_Broker_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  );
+
+extern TAO_IFR_Client_Export _TAO_InterfaceDef_Proxy_Broker * (*CORBA__TAO_InterfaceDef_Proxy_Broker_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  );
+
+extern TAO_IFR_Client_Export _TAO_AbstractInterfaceDef_Proxy_Broker * (*CORBA__TAO_AbstractInterfaceDef_Proxy_Broker_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  );
+
+extern TAO_IFR_Client_Export _TAO_LocalInterfaceDef_Proxy_Broker * (*CORBA__TAO_LocalInterfaceDef_Proxy_Broker_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  );
+
+// ********************************************************
+// Any operators for classes moved from IFR_BaseC.h
+
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const CORBA::InterfaceDefSeq &); // copying version
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, CORBA::InterfaceDefSeq*); // noncopying version
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::InterfaceDefSeq *&); // deprecated
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA::InterfaceDefSeq *&);
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const CORBA::AbstractInterfaceDefSeq &); // copying version
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, CORBA::AbstractInterfaceDefSeq*); // noncopying version
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::AbstractInterfaceDefSeq *&); // deprecated
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA::AbstractInterfaceDefSeq *&);
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const CORBA::LocalInterfaceDefSeq &); // copying version
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, CORBA::LocalInterfaceDefSeq*); // noncopying version
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::LocalInterfaceDefSeq *&); // deprecated
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA::LocalInterfaceDefSeq *&);
+
+// ********************************************************
+
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, CORBA::PrimitiveKind);
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::PrimitiveKind &);
+// Any operators for interface CORBA::Repository
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, CORBA::Repository_ptr);
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::Repository *&);
+// Any operators for interface CORBA::ModuleDef
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, CORBA::ModuleDef_ptr);
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::ModuleDef *&);
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const CORBA::ModuleDescription &); // copying version
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, CORBA::ModuleDescription*); // noncopying version
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::ModuleDescription *&); // deprecated
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA::ModuleDescription *&);
+// Any operators for interface CORBA::ConstantDef
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, CORBA::ConstantDef_ptr);
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::ConstantDef *&);
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const CORBA::ConstantDescription &); // copying version
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, CORBA::ConstantDescription*); // noncopying version
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::ConstantDescription *&); // deprecated
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA::ConstantDescription *&);
+// Any operators for interface CORBA::StructDef
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, CORBA::StructDef_ptr);
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::StructDef *&);
+// Any operators for interface CORBA::UnionDef
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, CORBA::UnionDef_ptr);
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::UnionDef *&);
+// Any operators for interface CORBA::EnumDef
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, CORBA::EnumDef_ptr);
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::EnumDef *&);
+// Any operators for interface CORBA::AliasDef
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, CORBA::AliasDef_ptr);
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::AliasDef *&);
+// Any operators for interface CORBA::NativeDef
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, CORBA::NativeDef_ptr);
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::NativeDef *&);
+// Any operators for interface CORBA::PrimitiveDef
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, CORBA::PrimitiveDef_ptr);
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::PrimitiveDef *&);
+// Any operators for interface CORBA::StringDef
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, CORBA::StringDef_ptr);
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::StringDef *&);
+// Any operators for interface CORBA::WstringDef
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, CORBA::WstringDef_ptr);
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::WstringDef *&);
+// Any operators for interface CORBA::SequenceDef
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, CORBA::SequenceDef_ptr);
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::SequenceDef *&);
+// Any operators for interface CORBA::ArrayDef
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, CORBA::ArrayDef_ptr);
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::ArrayDef *&);
+// Any operators for interface CORBA::ExceptionDef
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, CORBA::ExceptionDef_ptr);
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::ExceptionDef *&);
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const CORBA::ExceptionDescription &); // copying version
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, CORBA::ExceptionDescription*); // noncopying version
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::ExceptionDescription *&); // deprecated
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA::ExceptionDescription *&);
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const CORBA::ExceptionDefSeq &); // copying version
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, CORBA::ExceptionDefSeq*); // noncopying version
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::ExceptionDefSeq *&); // deprecated
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA::ExceptionDefSeq *&);
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const CORBA::ExcDescriptionSeq &); // copying version
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, CORBA::ExcDescriptionSeq*); // noncopying version
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::ExcDescriptionSeq *&); // deprecated
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA::ExcDescriptionSeq *&);
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, CORBA::AttributeMode);
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::AttributeMode &);
+// Any operators for interface CORBA::AttributeDef
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, CORBA::AttributeDef_ptr);
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::AttributeDef *&);
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const CORBA::AttributeDescription &); // copying version
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, CORBA::AttributeDescription*); // noncopying version
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::AttributeDescription *&); // deprecated
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA::AttributeDescription *&);
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, CORBA::OperationMode);
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::OperationMode &);
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, CORBA::ParameterMode);
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::ParameterMode &);
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const CORBA::ParameterDescription &); // copying version
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, CORBA::ParameterDescription*); // noncopying version
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::ParameterDescription *&); // deprecated
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA::ParameterDescription *&);
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const CORBA::ParDescriptionSeq &); // copying version
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, CORBA::ParDescriptionSeq*); // noncopying version
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::ParDescriptionSeq *&); // deprecated
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA::ParDescriptionSeq *&);
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const CORBA::ContextIdSeq &); // copying version
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, CORBA::ContextIdSeq*); // noncopying version
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::ContextIdSeq *&); // deprecated
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA::ContextIdSeq *&);
+// Any operators for interface CORBA::OperationDef
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, CORBA::OperationDef_ptr);
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::OperationDef *&);
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const CORBA::OperationDescription &); // copying version
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, CORBA::OperationDescription*); // noncopying version
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::OperationDescription *&); // deprecated
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA::OperationDescription *&);
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const CORBA::RepositoryIdSeq &); // copying version
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, CORBA::RepositoryIdSeq*); // noncopying version
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::RepositoryIdSeq *&); // deprecated
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA::RepositoryIdSeq *&);
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const CORBA::OpDescriptionSeq &); // copying version
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, CORBA::OpDescriptionSeq*); // noncopying version
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::OpDescriptionSeq *&); // deprecated
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA::OpDescriptionSeq *&);
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const CORBA::AttrDescriptionSeq &); // copying version
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, CORBA::AttrDescriptionSeq*); // noncopying version
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::AttrDescriptionSeq *&); // deprecated
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA::AttrDescriptionSeq *&);
+// Any operators for interface CORBA::InterfaceDef
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, CORBA::InterfaceDef_ptr);
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::InterfaceDef *&);
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const CORBA::InterfaceDef::FullInterfaceDescription &); // copying version
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, CORBA::InterfaceDef::FullInterfaceDescription*); // noncopying version
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::InterfaceDef::FullInterfaceDescription *&); // deprecated
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA::InterfaceDef::FullInterfaceDescription *&);
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const CORBA::InterfaceDescription &); // copying version
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, CORBA::InterfaceDescription*); // noncopying version
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::InterfaceDescription *&); // deprecated
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA::InterfaceDescription *&);
+// Any operators for interface CORBA::AbstractInterfaceDef
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, CORBA::AbstractInterfaceDef_ptr);
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::AbstractInterfaceDef *&);
+// Any operators for interface CORBA::LocalInterfaceDef
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, CORBA::LocalInterfaceDef_ptr);
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::LocalInterfaceDef *&);
+
+#ifndef __ACE_INLINE__
+
+TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::PrimitiveKind &); // 
+TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::PrimitiveKind &);
+TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::Repository_ptr );
+TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::Repository_ptr &);
+TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::ModuleDef_ptr );
+TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::ModuleDef_ptr &);
+TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::ModuleDescription &);
+TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::ModuleDescription &);
+TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::ConstantDef_ptr );
+TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::ConstantDef_ptr &);
+TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::ConstantDescription &);
+TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::ConstantDescription &);
+TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::StructDef_ptr );
+TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::StructDef_ptr &);
+TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::UnionDef_ptr );
+TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::UnionDef_ptr &);
+TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::EnumDef_ptr );
+TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::EnumDef_ptr &);
+TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::AliasDef_ptr );
+TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::AliasDef_ptr &);
+TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::NativeDef_ptr );
+TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::NativeDef_ptr &);
+TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::PrimitiveDef_ptr );
+TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::PrimitiveDef_ptr &);
+TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::StringDef_ptr );
+TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::StringDef_ptr &);
+TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::WstringDef_ptr );
+TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::WstringDef_ptr &);
+TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::SequenceDef_ptr );
+TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::SequenceDef_ptr &);
+TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::ArrayDef_ptr );
+TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::ArrayDef_ptr &);
+TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::ExceptionDef_ptr );
+TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::ExceptionDef_ptr &);
+TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::ExceptionDescription &);
+TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::ExceptionDescription &);
+
+// **************************************************************
+// CDR operators for classes moved from IFR_BaseC.h
+
+#if !defined _TAO_CDR_OP_CORBA_InterfaceDefSeq_H_
+#define _TAO_CDR_OP_CORBA_InterfaceDefSeq_H_
+
+TAO_IFR_Client_Export CORBA::Boolean operator<< (
+    TAO_OutputCDR &,
+    const CORBA::InterfaceDefSeq &
+  );
+TAO_IFR_Client_Export CORBA::Boolean operator>> (
+    TAO_InputCDR &,
+    CORBA::InterfaceDefSeq &
+  );
+
+#endif /* _TAO_CDR_OP_CORBA_InterfaceDefSeq_H_ */
+
+
+#if !defined _TAO_CDR_OP_CORBA_AbstractInterfaceDefSeq_H_
+#define _TAO_CDR_OP_CORBA_AbstractInterfaceDefSeq_H_
+
+TAO_IFR_Client_Export CORBA::Boolean operator<< (
+    TAO_OutputCDR &,
+    const CORBA::AbstractInterfaceDefSeq &
+  );
+TAO_IFR_Client_Export CORBA::Boolean operator>> (
+    TAO_InputCDR &,
+    CORBA::AbstractInterfaceDefSeq &
+  );
+
+#endif /* _TAO_CDR_OP_CORBA_AbstractInterfaceDefSeq_H_ */
+
+
+#if !defined _TAO_CDR_OP_CORBA_LocalInterfaceDefSeq_H_
+#define _TAO_CDR_OP_CORBA_LocalInterfaceDefSeq_H_
+
+TAO_IFR_Client_Export CORBA::Boolean operator<< (
+    TAO_OutputCDR &,
+    const CORBA::LocalInterfaceDefSeq &
+  );
+TAO_IFR_Client_Export CORBA::Boolean operator>> (
+    TAO_InputCDR &,
+    CORBA::LocalInterfaceDefSeq &
+  );
+
+#endif /* _TAO_CDR_OP_CORBA_LocalInterfaceDefSeq_H_ */
+
+// **********************************************************
+
+#if !defined _TAO_CDR_OP_CORBA_ExceptionDefSeq_H_
+#define _TAO_CDR_OP_CORBA_ExceptionDefSeq_H_
+
+TAO_IFR_Client_Export CORBA::Boolean operator<< (
+    TAO_OutputCDR &,
+    const CORBA::ExceptionDefSeq &
+  );
+TAO_IFR_Client_Export CORBA::Boolean operator>> (
+    TAO_InputCDR &,
+    CORBA::ExceptionDefSeq &
+  );
+
+#endif /* _TAO_CDR_OP_CORBA_ExceptionDefSeq_H_ */
+
+
+#if !defined _TAO_CDR_OP_CORBA_ExcDescriptionSeq_H_
+#define _TAO_CDR_OP_CORBA_ExcDescriptionSeq_H_
+
+TAO_IFR_Client_Export CORBA::Boolean operator<< (
+    TAO_OutputCDR &,
+    const CORBA::ExcDescriptionSeq &
+  );
+TAO_IFR_Client_Export CORBA::Boolean operator>> (
+    TAO_InputCDR &,
+    CORBA::ExcDescriptionSeq &
+  );
+
+#endif /* _TAO_CDR_OP_CORBA_ExcDescriptionSeq_H_ */
+
+TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::AttributeMode &); // 
+TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::AttributeMode &);
+TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::AttributeDef_ptr );
+TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::AttributeDef_ptr &);
+TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::AttributeDescription &);
+TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::AttributeDescription &);
+TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::OperationMode &); // 
+TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::OperationMode &);
+TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::ParameterMode &); // 
+TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::ParameterMode &);
+TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::ParameterDescription &);
+TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::ParameterDescription &);
+
+#if !defined _TAO_CDR_OP_CORBA_ParDescriptionSeq_H_
+#define _TAO_CDR_OP_CORBA_ParDescriptionSeq_H_
+
+TAO_IFR_Client_Export CORBA::Boolean operator<< (
+    TAO_OutputCDR &,
+    const CORBA::ParDescriptionSeq &
+  );
+TAO_IFR_Client_Export CORBA::Boolean operator>> (
+    TAO_InputCDR &,
+    CORBA::ParDescriptionSeq &
+  );
+
+#endif /* _TAO_CDR_OP_CORBA_ParDescriptionSeq_H_ */
+
+
+#if !defined _TAO_CDR_OP_CORBA_ContextIdSeq_H_
+#define _TAO_CDR_OP_CORBA_ContextIdSeq_H_
+
+TAO_IFR_Client_Export CORBA::Boolean operator<< (
+    TAO_OutputCDR &,
+    const CORBA::ContextIdSeq &
+  );
+TAO_IFR_Client_Export CORBA::Boolean operator>> (
+    TAO_InputCDR &,
+    CORBA::ContextIdSeq &
+  );
+
+#endif /* _TAO_CDR_OP_CORBA_ContextIdSeq_H_ */
+
+TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::OperationDef_ptr );
+TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::OperationDef_ptr &);
+TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::OperationDescription &);
+TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::OperationDescription &);
+
+#if !defined _TAO_CDR_OP_CORBA_RepositoryIdSeq_H_
+#define _TAO_CDR_OP_CORBA_RepositoryIdSeq_H_
+
+TAO_IFR_Client_Export CORBA::Boolean operator<< (
+    TAO_OutputCDR &,
+    const CORBA::RepositoryIdSeq &
+  );
+TAO_IFR_Client_Export CORBA::Boolean operator>> (
+    TAO_InputCDR &,
+    CORBA::RepositoryIdSeq &
+  );
+
+#endif /* _TAO_CDR_OP_CORBA_RepositoryIdSeq_H_ */
+
+
+#if !defined _TAO_CDR_OP_CORBA_OpDescriptionSeq_H_
+#define _TAO_CDR_OP_CORBA_OpDescriptionSeq_H_
+
+TAO_IFR_Client_Export CORBA::Boolean operator<< (
+    TAO_OutputCDR &,
+    const CORBA::OpDescriptionSeq &
+  );
+TAO_IFR_Client_Export CORBA::Boolean operator>> (
+    TAO_InputCDR &,
+    CORBA::OpDescriptionSeq &
+  );
+
+#endif /* _TAO_CDR_OP_CORBA_OpDescriptionSeq_H_ */
+
+
+#if !defined _TAO_CDR_OP_CORBA_AttrDescriptionSeq_H_
+#define _TAO_CDR_OP_CORBA_AttrDescriptionSeq_H_
+
+TAO_IFR_Client_Export CORBA::Boolean operator<< (
+    TAO_OutputCDR &,
+    const CORBA::AttrDescriptionSeq &
+  );
+TAO_IFR_Client_Export CORBA::Boolean operator>> (
+    TAO_InputCDR &,
+    CORBA::AttrDescriptionSeq &
+  );
+
+#endif /* _TAO_CDR_OP_CORBA_AttrDescriptionSeq_H_ */
+
+TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::InterfaceDef_ptr );
+TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::InterfaceDef_ptr &);
+TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::InterfaceDef::FullInterfaceDescription &);
+TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::InterfaceDef::FullInterfaceDescription &);
+TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::InterfaceDescription &);
+TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::InterfaceDescription &);
+TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::AbstractInterfaceDef_ptr );
+TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::AbstractInterfaceDef_ptr &);
+TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::LocalInterfaceDef_ptr );
+TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::LocalInterfaceDef_ptr &);
+
+#endif /* __ACE_INLINE__ */
+
+
+#if defined (__ACE_INLINE__)
+#include "IFR_BasicC.i"
+#endif /* defined INLINE */
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+#pragma warning(pop)
+#endif /* _MSC_VER */
+
+#if defined (__BORLANDC__)
+#pragma option pop
+#endif /* __BORLANDC__ */
+
+#include "ace/post.h"
+#endif /* ifndef */
diff --git a/TAO/tao/IFR_Client/IFR_BasicC.i b/TAO/tao/IFR_Client/IFR_BasicC.i
new file mode 100644
index 00000000000..e37507f627e
--- /dev/null
+++ b/TAO/tao/IFR_Client/IFR_BasicC.i
@@ -0,0 +1,10023 @@
+// -*- C++ -*-
+//
+// $Id$
+
+// ****  Code generated by the The ACE ORB (TAO) IDL Compiler ****
+// TAO and the TAO IDL Compiler have been developed by:
+//       Center for Distributed Object Computing
+//       Washington University
+//       St. Louis, MO
+//       USA
+//       http://www.cs.wustl.edu/~schmidt/doc-center.html
+// and
+//       Distributed Object Computing Laboratory
+//       University of California at Irvine
+//       Irvine, CA
+//       USA
+//       http://doc.ece.uci.edu/
+//
+// Information about TAO is available at:
+//     http://www.cs.wustl.edu/~schmidt/TAO.html
+
+
+// *******************************************************************
+// Sequence classes forward moved fron IFR_BaseC.i
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_INTERFACEDEFSEQ_CI_)
+#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_INTERFACEDEFSEQ_CI_
+
+  ACE_INLINE CORBA::InterfaceDef **
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::allocbuf (CORBA::ULong nelems)
+  {
+    CORBA::InterfaceDef **buf = 0;
+    
+    ACE_NEW_RETURN (buf, CORBA::InterfaceDef*[nelems], 0);
+    
+    for (CORBA::ULong i = 0; i < nelems; i++)
+      buf[i] = CORBA::InterfaceDef::_nil ();
+    
+    return buf;
+  }
+  
+  ACE_INLINE void 
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::freebuf (CORBA::InterfaceDef **buffer)
+  {
+    if (buffer == 0)
+      return;
+    delete[] buffer;
+  }
+  
+  ACE_INLINE
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq (void)
+  {
+  }
+  
+  ACE_INLINE
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq (CORBA::ULong maximum)
+    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::allocbuf (maximum))
+  {
+  }
+  
+  ACE_INLINE
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq (CORBA::ULong maximum,
+    CORBA::ULong length,
+    CORBA::InterfaceDef* *value,
+    CORBA::Boolean release)
+  : TAO_Unbounded_Base_Sequence (maximum, length, value, release)
+  {
+  }
+  
+  ACE_INLINE
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq(const _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq &rhs)
+    : TAO_Unbounded_Base_Sequence (rhs)
+  {
+    if (rhs.buffer_ != 0)
+    {
+      CORBA::InterfaceDef **tmp1 = _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::allocbuf (this->maximum_);
+      CORBA::InterfaceDef ** const tmp2 = ACE_reinterpret_cast (CORBA::InterfaceDef ** ACE_CAST_CONST, rhs.buffer_);
+      
+      for (CORBA::ULong i = 0; i < rhs.length_; ++i)
+        tmp1[i] = CORBA::InterfaceDef::_duplicate (tmp2[i]);
+      
+      this->buffer_ = tmp1;
+    }
+    else
+    {
+      this->buffer_ = 0;
+    }
+  }
+  
+  ACE_INLINE CORBA::_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq &
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::operator= (const _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq &rhs)
+  {
+    if (this == &rhs)
+      return *this;
+    
+    if (this->release_)
+    {
+      CORBA::InterfaceDef **tmp = ACE_reinterpret_cast (CORBA::InterfaceDef **, this->buffer_);
+      
+      for (CORBA::ULong i = 0; i < this->length_; ++i)
+      {
+        CORBA::release (tmp[i]);
+        tmp[i] = CORBA::InterfaceDef::_nil ();
+      }
+      if (this->maximum_ < rhs.maximum_)
+      {
+        _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::freebuf (tmp);
+        this->buffer_ = _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::allocbuf (rhs.maximum_);
+      }
+    }
+    else
+      this->buffer_ = _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::allocbuf (rhs.maximum_);
+    
+    TAO_Unbounded_Base_Sequence::operator= (rhs);
+    
+    CORBA::InterfaceDef **tmp1 = ACE_reinterpret_cast (CORBA::InterfaceDef **, this->buffer_);
+    CORBA::InterfaceDef ** const tmp2 = ACE_reinterpret_cast (CORBA::InterfaceDef ** ACE_CAST_CONST, rhs.buffer_);
+    
+    for (CORBA::ULong i = 0; i < rhs.length_; ++i)
+      tmp1[i] = CORBA::InterfaceDef::_duplicate (tmp2[i]);
+    
+    return *this;
+  }
+  
+  ACE_INLINE TAO_Object_Manager<CORBA::InterfaceDef,CORBA::InterfaceDef_var>
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::operator[] (CORBA::ULong index) const
+  // read-write accessor
+  {
+    ACE_ASSERT (index < this->maximum_);
+    CORBA::InterfaceDef ** const tmp = ACE_reinterpret_cast (CORBA::InterfaceDef ** ACE_CAST_CONST, this->buffer_);
+    return TAO_Object_Manager<CORBA::InterfaceDef,CORBA::InterfaceDef_var> (tmp + index, this->release_);
+  }
+  
+  ACE_INLINE CORBA::InterfaceDef* *
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::get_buffer (CORBA::Boolean orphan)
+  {
+    CORBA::InterfaceDef **result = 0;
+    if (orphan == 0)
+    {
+      // We retain ownership.
+      if (this->buffer_ == 0)
+      {
+        result = _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::allocbuf (this->maximum_);
+        this->buffer_ = result;
+        this->release_ = 1;
+      }
+      else
+      {
+        result = ACE_reinterpret_cast (CORBA::InterfaceDef**, this->buffer_);
+      }
+    }
+    else // if (orphan == 1)
+    {
+      if (this->release_ != 0)
+      {
+        // We set the state back to default and relinquish
+        // ownership.
+        result = ACE_reinterpret_cast(CORBA::InterfaceDef**,this->buffer_);
+        this->maximum_ = 0;
+        this->length_ = 0;
+        this->buffer_ = 0;
+        this->release_ = 0;
+      }
+    }
+    return result;
+  }
+  
+  ACE_INLINE const CORBA::InterfaceDef* *
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::get_buffer (void) const
+  {
+    return ACE_reinterpret_cast(const CORBA::InterfaceDef ** ACE_CAST_CONST, this->buffer_);
+  }
+  
+  
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_CORBA_INTERFACEDEFSEQ_CI_)
+#define _CORBA_INTERFACEDEFSEQ_CI_
+
+// *************************************************************
+// Inline operations for class CORBA_InterfaceDefSeq_var
+// *************************************************************
+
+ACE_INLINE
+CORBA_InterfaceDefSeq_var::CORBA_InterfaceDefSeq_var (void) // default constructor
+  : ptr_ (0)
+{}
+
+ACE_INLINE
+CORBA_InterfaceDefSeq_var::CORBA_InterfaceDefSeq_var (CORBA_InterfaceDefSeq *p)
+  : ptr_ (p)
+{}
+
+ACE_INLINE
+CORBA_InterfaceDefSeq_var::CORBA_InterfaceDefSeq_var (const ::CORBA_InterfaceDefSeq_var &p) // copy constructor
+{
+  if (p.ptr_)
+    ACE_NEW (this->ptr_, ::CORBA_InterfaceDefSeq (*p.ptr_));
+  else
+    this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA_InterfaceDefSeq_var::~CORBA_InterfaceDefSeq_var (void) // destructor
+{
+  delete this->ptr_;
+}
+
+ACE_INLINE CORBA_InterfaceDefSeq_var &
+CORBA_InterfaceDefSeq_var::operator= (CORBA_InterfaceDefSeq *p)
+{
+  delete this->ptr_;
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE ::CORBA_InterfaceDefSeq_var &
+CORBA_InterfaceDefSeq_var::operator= (const ::CORBA_InterfaceDefSeq_var &p)
+{
+  if (this != &p)
+    {
+      if (p.ptr_ == 0)
+        {
+          delete this->ptr_;
+          this->ptr_ = 0;
+        }
+      else
+        {
+          CORBA_InterfaceDefSeq *deep_copy =
+            new CORBA_InterfaceDefSeq (*p.ptr_);
+          
+          if (deep_copy != 0)
+            {
+              CORBA_InterfaceDefSeq *tmp = deep_copy;
+              deep_copy = this->ptr_;
+              this->ptr_ = tmp;
+              delete deep_copy;
+            }
+        }
+    }
+  
+  return *this;
+}
+
+ACE_INLINE const ::CORBA_InterfaceDefSeq *
+CORBA_InterfaceDefSeq_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_InterfaceDefSeq *
+CORBA_InterfaceDefSeq_var::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+CORBA_InterfaceDefSeq_var::operator const ::CORBA_InterfaceDefSeq &() const // cast
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE 
+CORBA_InterfaceDefSeq_var::operator ::CORBA_InterfaceDefSeq &() // cast 
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE 
+CORBA_InterfaceDefSeq_var::operator ::CORBA_InterfaceDefSeq &() const // cast 
+{
+  return *this->ptr_;
+}
+
+// variable-size types only
+ACE_INLINE
+CORBA_InterfaceDefSeq_var::operator ::CORBA_InterfaceDefSeq *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE TAO_Object_Manager<CORBA::InterfaceDef, CORBA::InterfaceDef_var>
+CORBA_InterfaceDefSeq_var::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+ACE_INLINE const ::CORBA_InterfaceDefSeq &
+CORBA_InterfaceDefSeq_var::in (void) const
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE ::CORBA_InterfaceDefSeq &
+CORBA_InterfaceDefSeq_var::inout (void)
+{
+  return *this->ptr_;
+}
+
+// mapping for variable size 
+ACE_INLINE ::CORBA_InterfaceDefSeq *&
+CORBA_InterfaceDefSeq_var::out (void)
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_InterfaceDefSeq *
+CORBA_InterfaceDefSeq_var::_retn (void)
+{
+  ::CORBA_InterfaceDefSeq *tmp = this->ptr_;
+  this->ptr_ = 0;
+  return tmp;
+}
+
+ACE_INLINE ::CORBA_InterfaceDefSeq *
+CORBA_InterfaceDefSeq_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+// *************************************************************
+// Inline operations for class CORBA_InterfaceDefSeq_out
+// *************************************************************
+
+ACE_INLINE
+CORBA_InterfaceDefSeq_out::CORBA_InterfaceDefSeq_out (CORBA_InterfaceDefSeq *&p)
+  : ptr_ (p)
+{
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA_InterfaceDefSeq_out::CORBA_InterfaceDefSeq_out (CORBA_InterfaceDefSeq_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA_InterfaceDefSeq_out::CORBA_InterfaceDefSeq_out (const ::CORBA_InterfaceDefSeq_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (CORBA_InterfaceDefSeq_out&, p).ptr_)
+{}
+
+ACE_INLINE ::CORBA_InterfaceDefSeq_out &
+CORBA_InterfaceDefSeq_out::operator= (const ::CORBA_InterfaceDefSeq_out &p)
+{
+  this->ptr_ = ACE_const_cast (CORBA_InterfaceDefSeq_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE ::CORBA_InterfaceDefSeq_out &
+CORBA_InterfaceDefSeq_out::operator= (CORBA_InterfaceDefSeq *p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+CORBA_InterfaceDefSeq_out::operator ::CORBA_InterfaceDefSeq *&() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_InterfaceDefSeq *&
+CORBA_InterfaceDefSeq_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_InterfaceDefSeq *
+CORBA_InterfaceDefSeq_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE TAO_Object_Manager<CORBA::InterfaceDef, CORBA::InterfaceDef_var>
+CORBA_InterfaceDefSeq_out::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+
+#endif /* end #if !defined */
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_ABSTRACTINTERFACEDEFSEQ_CI_)
+#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_ABSTRACTINTERFACEDEFSEQ_CI_
+
+  ACE_INLINE CORBA::AbstractInterfaceDef **
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::allocbuf (CORBA::ULong nelems)
+  {
+    CORBA::AbstractInterfaceDef **buf = 0;
+    
+    ACE_NEW_RETURN (buf, CORBA::AbstractInterfaceDef*[nelems], 0);
+    
+    for (CORBA::ULong i = 0; i < nelems; i++)
+      buf[i] = CORBA::AbstractInterfaceDef::_nil ();
+    
+    return buf;
+  }
+  
+  ACE_INLINE void 
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::freebuf (CORBA::AbstractInterfaceDef **buffer)
+  {
+    if (buffer == 0)
+      return;
+    delete[] buffer;
+  }
+  
+  ACE_INLINE
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq (void)
+  {
+  }
+  
+  ACE_INLINE
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq (CORBA::ULong maximum)
+    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::allocbuf (maximum))
+  {
+  }
+  
+  ACE_INLINE
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq (CORBA::ULong maximum,
+    CORBA::ULong length,
+    CORBA::AbstractInterfaceDef* *value,
+    CORBA::Boolean release)
+  : TAO_Unbounded_Base_Sequence (maximum, length, value, release)
+  {
+  }
+  
+  ACE_INLINE
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq(const _TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq &rhs)
+    : TAO_Unbounded_Base_Sequence (rhs)
+  {
+    if (rhs.buffer_ != 0)
+    {
+      CORBA::AbstractInterfaceDef **tmp1 = _TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::allocbuf (this->maximum_);
+      CORBA::AbstractInterfaceDef ** const tmp2 = ACE_reinterpret_cast (CORBA::AbstractInterfaceDef ** ACE_CAST_CONST, rhs.buffer_);
+      
+      for (CORBA::ULong i = 0; i < rhs.length_; ++i)
+        tmp1[i] = CORBA::AbstractInterfaceDef::_duplicate (tmp2[i]);
+      
+      this->buffer_ = tmp1;
+    }
+    else
+    {
+      this->buffer_ = 0;
+    }
+  }
+  
+  ACE_INLINE CORBA::_TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq &
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::operator= (const _TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq &rhs)
+  {
+    if (this == &rhs)
+      return *this;
+    
+    if (this->release_)
+    {
+      CORBA::AbstractInterfaceDef **tmp = ACE_reinterpret_cast (CORBA::AbstractInterfaceDef **, this->buffer_);
+      
+      for (CORBA::ULong i = 0; i < this->length_; ++i)
+      {
+        CORBA::release (tmp[i]);
+        tmp[i] = CORBA::AbstractInterfaceDef::_nil ();
+      }
+      if (this->maximum_ < rhs.maximum_)
+      {
+        _TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::freebuf (tmp);
+        this->buffer_ = _TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::allocbuf (rhs.maximum_);
+      }
+    }
+    else
+      this->buffer_ = _TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::allocbuf (rhs.maximum_);
+    
+    TAO_Unbounded_Base_Sequence::operator= (rhs);
+    
+    CORBA::AbstractInterfaceDef **tmp1 = ACE_reinterpret_cast (CORBA::AbstractInterfaceDef **, this->buffer_);
+    CORBA::AbstractInterfaceDef ** const tmp2 = ACE_reinterpret_cast (CORBA::AbstractInterfaceDef ** ACE_CAST_CONST, rhs.buffer_);
+    
+    for (CORBA::ULong i = 0; i < rhs.length_; ++i)
+      tmp1[i] = CORBA::AbstractInterfaceDef::_duplicate (tmp2[i]);
+    
+    return *this;
+  }
+  
+  ACE_INLINE TAO_Object_Manager<CORBA::AbstractInterfaceDef,CORBA::AbstractInterfaceDef_var>
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::operator[] (CORBA::ULong index) const
+  // read-write accessor
+  {
+    ACE_ASSERT (index < this->maximum_);
+    CORBA::AbstractInterfaceDef ** const tmp = ACE_reinterpret_cast (CORBA::AbstractInterfaceDef ** ACE_CAST_CONST, this->buffer_);
+    return TAO_Object_Manager<CORBA::AbstractInterfaceDef,CORBA::AbstractInterfaceDef_var> (tmp + index, this->release_);
+  }
+  
+  ACE_INLINE CORBA::AbstractInterfaceDef* *
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::get_buffer (CORBA::Boolean orphan)
+  {
+    CORBA::AbstractInterfaceDef **result = 0;
+    if (orphan == 0)
+    {
+      // We retain ownership.
+      if (this->buffer_ == 0)
+      {
+        result = _TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::allocbuf (this->maximum_);
+        this->buffer_ = result;
+        this->release_ = 1;
+      }
+      else
+      {
+        result = ACE_reinterpret_cast (CORBA::AbstractInterfaceDef**, this->buffer_);
+      }
+    }
+    else // if (orphan == 1)
+    {
+      if (this->release_ != 0)
+      {
+        // We set the state back to default and relinquish
+        // ownership.
+        result = ACE_reinterpret_cast(CORBA::AbstractInterfaceDef**,this->buffer_);
+        this->maximum_ = 0;
+        this->length_ = 0;
+        this->buffer_ = 0;
+        this->release_ = 0;
+      }
+    }
+    return result;
+  }
+  
+  ACE_INLINE const CORBA::AbstractInterfaceDef* *
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::get_buffer (void) const
+  {
+    return ACE_reinterpret_cast(const CORBA::AbstractInterfaceDef ** ACE_CAST_CONST, this->buffer_);
+  }
+  
+  
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_CORBA_ABSTRACTINTERFACEDEFSEQ_CI_)
+#define _CORBA_ABSTRACTINTERFACEDEFSEQ_CI_
+
+// *************************************************************
+// Inline operations for class CORBA_AbstractInterfaceDefSeq_var
+// *************************************************************
+
+ACE_INLINE
+CORBA_AbstractInterfaceDefSeq_var::CORBA_AbstractInterfaceDefSeq_var (void) // default constructor
+  : ptr_ (0)
+{}
+
+ACE_INLINE
+CORBA_AbstractInterfaceDefSeq_var::CORBA_AbstractInterfaceDefSeq_var (CORBA_AbstractInterfaceDefSeq *p)
+  : ptr_ (p)
+{}
+
+ACE_INLINE
+CORBA_AbstractInterfaceDefSeq_var::CORBA_AbstractInterfaceDefSeq_var (const ::CORBA_AbstractInterfaceDefSeq_var &p) // copy constructor
+{
+  if (p.ptr_)
+    ACE_NEW (this->ptr_, ::CORBA_AbstractInterfaceDefSeq (*p.ptr_));
+  else
+    this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA_AbstractInterfaceDefSeq_var::~CORBA_AbstractInterfaceDefSeq_var (void) // destructor
+{
+  delete this->ptr_;
+}
+
+ACE_INLINE CORBA_AbstractInterfaceDefSeq_var &
+CORBA_AbstractInterfaceDefSeq_var::operator= (CORBA_AbstractInterfaceDefSeq *p)
+{
+  delete this->ptr_;
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE ::CORBA_AbstractInterfaceDefSeq_var &
+CORBA_AbstractInterfaceDefSeq_var::operator= (const ::CORBA_AbstractInterfaceDefSeq_var &p)
+{
+  if (this != &p)
+    {
+      if (p.ptr_ == 0)
+        {
+          delete this->ptr_;
+          this->ptr_ = 0;
+        }
+      else
+        {
+          CORBA_AbstractInterfaceDefSeq *deep_copy =
+            new CORBA_AbstractInterfaceDefSeq (*p.ptr_);
+          
+          if (deep_copy != 0)
+            {
+              CORBA_AbstractInterfaceDefSeq *tmp = deep_copy;
+              deep_copy = this->ptr_;
+              this->ptr_ = tmp;
+              delete deep_copy;
+            }
+        }
+    }
+  
+  return *this;
+}
+
+ACE_INLINE const ::CORBA_AbstractInterfaceDefSeq *
+CORBA_AbstractInterfaceDefSeq_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_AbstractInterfaceDefSeq *
+CORBA_AbstractInterfaceDefSeq_var::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+CORBA_AbstractInterfaceDefSeq_var::operator const ::CORBA_AbstractInterfaceDefSeq &() const // cast
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE 
+CORBA_AbstractInterfaceDefSeq_var::operator ::CORBA_AbstractInterfaceDefSeq &() // cast 
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE 
+CORBA_AbstractInterfaceDefSeq_var::operator ::CORBA_AbstractInterfaceDefSeq &() const // cast 
+{
+  return *this->ptr_;
+}
+
+// variable-size types only
+ACE_INLINE
+CORBA_AbstractInterfaceDefSeq_var::operator ::CORBA_AbstractInterfaceDefSeq *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE TAO_Object_Manager<CORBA::AbstractInterfaceDef, CORBA::AbstractInterfaceDef_var>
+CORBA_AbstractInterfaceDefSeq_var::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+ACE_INLINE const ::CORBA_AbstractInterfaceDefSeq &
+CORBA_AbstractInterfaceDefSeq_var::in (void) const
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE ::CORBA_AbstractInterfaceDefSeq &
+CORBA_AbstractInterfaceDefSeq_var::inout (void)
+{
+  return *this->ptr_;
+}
+
+// mapping for variable size 
+ACE_INLINE ::CORBA_AbstractInterfaceDefSeq *&
+CORBA_AbstractInterfaceDefSeq_var::out (void)
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_AbstractInterfaceDefSeq *
+CORBA_AbstractInterfaceDefSeq_var::_retn (void)
+{
+  ::CORBA_AbstractInterfaceDefSeq *tmp = this->ptr_;
+  this->ptr_ = 0;
+  return tmp;
+}
+
+ACE_INLINE ::CORBA_AbstractInterfaceDefSeq *
+CORBA_AbstractInterfaceDefSeq_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+// *************************************************************
+// Inline operations for class CORBA_AbstractInterfaceDefSeq_out
+// *************************************************************
+
+ACE_INLINE
+CORBA_AbstractInterfaceDefSeq_out::CORBA_AbstractInterfaceDefSeq_out (CORBA_AbstractInterfaceDefSeq *&p)
+  : ptr_ (p)
+{
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA_AbstractInterfaceDefSeq_out::CORBA_AbstractInterfaceDefSeq_out (CORBA_AbstractInterfaceDefSeq_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA_AbstractInterfaceDefSeq_out::CORBA_AbstractInterfaceDefSeq_out (const ::CORBA_AbstractInterfaceDefSeq_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (CORBA_AbstractInterfaceDefSeq_out&, p).ptr_)
+{}
+
+ACE_INLINE ::CORBA_AbstractInterfaceDefSeq_out &
+CORBA_AbstractInterfaceDefSeq_out::operator= (const ::CORBA_AbstractInterfaceDefSeq_out &p)
+{
+  this->ptr_ = ACE_const_cast (CORBA_AbstractInterfaceDefSeq_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE ::CORBA_AbstractInterfaceDefSeq_out &
+CORBA_AbstractInterfaceDefSeq_out::operator= (CORBA_AbstractInterfaceDefSeq *p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+CORBA_AbstractInterfaceDefSeq_out::operator ::CORBA_AbstractInterfaceDefSeq *&() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_AbstractInterfaceDefSeq *&
+CORBA_AbstractInterfaceDefSeq_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_AbstractInterfaceDefSeq *
+CORBA_AbstractInterfaceDefSeq_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE TAO_Object_Manager<CORBA::AbstractInterfaceDef, CORBA::AbstractInterfaceDef_var>
+CORBA_AbstractInterfaceDefSeq_out::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+
+#endif /* end #if !defined */
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_LOCALINTERFACEDEFSEQ_CI_)
+#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_LOCALINTERFACEDEFSEQ_CI_
+
+  ACE_INLINE CORBA::LocalInterfaceDef **
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::allocbuf (CORBA::ULong nelems)
+  {
+    CORBA::LocalInterfaceDef **buf = 0;
+    
+    ACE_NEW_RETURN (buf, CORBA::LocalInterfaceDef*[nelems], 0);
+    
+    for (CORBA::ULong i = 0; i < nelems; i++)
+      buf[i] = CORBA::LocalInterfaceDef::_nil ();
+    
+    return buf;
+  }
+  
+  ACE_INLINE void 
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::freebuf (CORBA::LocalInterfaceDef **buffer)
+  {
+    if (buffer == 0)
+      return;
+    delete[] buffer;
+  }
+  
+  ACE_INLINE
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq (void)
+  {
+  }
+  
+  ACE_INLINE
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq (CORBA::ULong maximum)
+    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::allocbuf (maximum))
+  {
+  }
+  
+  ACE_INLINE
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq (CORBA::ULong maximum,
+    CORBA::ULong length,
+    CORBA::LocalInterfaceDef* *value,
+    CORBA::Boolean release)
+  : TAO_Unbounded_Base_Sequence (maximum, length, value, release)
+  {
+  }
+  
+  ACE_INLINE
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq(const _TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq &rhs)
+    : TAO_Unbounded_Base_Sequence (rhs)
+  {
+    if (rhs.buffer_ != 0)
+    {
+      CORBA::LocalInterfaceDef **tmp1 = _TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::allocbuf (this->maximum_);
+      CORBA::LocalInterfaceDef ** const tmp2 = ACE_reinterpret_cast (CORBA::LocalInterfaceDef ** ACE_CAST_CONST, rhs.buffer_);
+      
+      for (CORBA::ULong i = 0; i < rhs.length_; ++i)
+        tmp1[i] = CORBA::LocalInterfaceDef::_duplicate (tmp2[i]);
+      
+      this->buffer_ = tmp1;
+    }
+    else
+    {
+      this->buffer_ = 0;
+    }
+  }
+  
+  ACE_INLINE CORBA::_TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq &
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::operator= (const _TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq &rhs)
+  {
+    if (this == &rhs)
+      return *this;
+    
+    if (this->release_)
+    {
+      CORBA::LocalInterfaceDef **tmp = ACE_reinterpret_cast (CORBA::LocalInterfaceDef **, this->buffer_);
+      
+      for (CORBA::ULong i = 0; i < this->length_; ++i)
+      {
+        CORBA::release (tmp[i]);
+        tmp[i] = CORBA::LocalInterfaceDef::_nil ();
+      }
+      if (this->maximum_ < rhs.maximum_)
+      {
+        _TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::freebuf (tmp);
+        this->buffer_ = _TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::allocbuf (rhs.maximum_);
+      }
+    }
+    else
+      this->buffer_ = _TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::allocbuf (rhs.maximum_);
+    
+    TAO_Unbounded_Base_Sequence::operator= (rhs);
+    
+    CORBA::LocalInterfaceDef **tmp1 = ACE_reinterpret_cast (CORBA::LocalInterfaceDef **, this->buffer_);
+    CORBA::LocalInterfaceDef ** const tmp2 = ACE_reinterpret_cast (CORBA::LocalInterfaceDef ** ACE_CAST_CONST, rhs.buffer_);
+    
+    for (CORBA::ULong i = 0; i < rhs.length_; ++i)
+      tmp1[i] = CORBA::LocalInterfaceDef::_duplicate (tmp2[i]);
+    
+    return *this;
+  }
+  
+  ACE_INLINE TAO_Object_Manager<CORBA::LocalInterfaceDef,CORBA::LocalInterfaceDef_var>
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::operator[] (CORBA::ULong index) const
+  // read-write accessor
+  {
+    ACE_ASSERT (index < this->maximum_);
+    CORBA::LocalInterfaceDef ** const tmp = ACE_reinterpret_cast (CORBA::LocalInterfaceDef ** ACE_CAST_CONST, this->buffer_);
+    return TAO_Object_Manager<CORBA::LocalInterfaceDef,CORBA::LocalInterfaceDef_var> (tmp + index, this->release_);
+  }
+  
+  ACE_INLINE CORBA::LocalInterfaceDef* *
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::get_buffer (CORBA::Boolean orphan)
+  {
+    CORBA::LocalInterfaceDef **result = 0;
+    if (orphan == 0)
+    {
+      // We retain ownership.
+      if (this->buffer_ == 0)
+      {
+        result = _TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::allocbuf (this->maximum_);
+        this->buffer_ = result;
+        this->release_ = 1;
+      }
+      else
+      {
+        result = ACE_reinterpret_cast (CORBA::LocalInterfaceDef**, this->buffer_);
+      }
+    }
+    else // if (orphan == 1)
+    {
+      if (this->release_ != 0)
+      {
+        // We set the state back to default and relinquish
+        // ownership.
+        result = ACE_reinterpret_cast(CORBA::LocalInterfaceDef**,this->buffer_);
+        this->maximum_ = 0;
+        this->length_ = 0;
+        this->buffer_ = 0;
+        this->release_ = 0;
+      }
+    }
+    return result;
+  }
+  
+  ACE_INLINE const CORBA::LocalInterfaceDef* *
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::get_buffer (void) const
+  {
+    return ACE_reinterpret_cast(const CORBA::LocalInterfaceDef ** ACE_CAST_CONST, this->buffer_);
+  }
+  
+  
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_CORBA_LOCALINTERFACEDEFSEQ_CI_)
+#define _CORBA_LOCALINTERFACEDEFSEQ_CI_
+
+// *************************************************************
+// Inline operations for class CORBA_LocalInterfaceDefSeq_var
+// *************************************************************
+
+ACE_INLINE
+CORBA_LocalInterfaceDefSeq_var::CORBA_LocalInterfaceDefSeq_var (void) // default constructor
+  : ptr_ (0)
+{}
+
+ACE_INLINE
+CORBA_LocalInterfaceDefSeq_var::CORBA_LocalInterfaceDefSeq_var (CORBA_LocalInterfaceDefSeq *p)
+  : ptr_ (p)
+{}
+
+ACE_INLINE
+CORBA_LocalInterfaceDefSeq_var::CORBA_LocalInterfaceDefSeq_var (const ::CORBA_LocalInterfaceDefSeq_var &p) // copy constructor
+{
+  if (p.ptr_)
+    ACE_NEW (this->ptr_, ::CORBA_LocalInterfaceDefSeq (*p.ptr_));
+  else
+    this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA_LocalInterfaceDefSeq_var::~CORBA_LocalInterfaceDefSeq_var (void) // destructor
+{
+  delete this->ptr_;
+}
+
+ACE_INLINE CORBA_LocalInterfaceDefSeq_var &
+CORBA_LocalInterfaceDefSeq_var::operator= (CORBA_LocalInterfaceDefSeq *p)
+{
+  delete this->ptr_;
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE ::CORBA_LocalInterfaceDefSeq_var &
+CORBA_LocalInterfaceDefSeq_var::operator= (const ::CORBA_LocalInterfaceDefSeq_var &p)
+{
+  if (this != &p)
+    {
+      if (p.ptr_ == 0)
+        {
+          delete this->ptr_;
+          this->ptr_ = 0;
+        }
+      else
+        {
+          CORBA_LocalInterfaceDefSeq *deep_copy =
+            new CORBA_LocalInterfaceDefSeq (*p.ptr_);
+          
+          if (deep_copy != 0)
+            {
+              CORBA_LocalInterfaceDefSeq *tmp = deep_copy;
+              deep_copy = this->ptr_;
+              this->ptr_ = tmp;
+              delete deep_copy;
+            }
+        }
+    }
+  
+  return *this;
+}
+
+ACE_INLINE const ::CORBA_LocalInterfaceDefSeq *
+CORBA_LocalInterfaceDefSeq_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_LocalInterfaceDefSeq *
+CORBA_LocalInterfaceDefSeq_var::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+CORBA_LocalInterfaceDefSeq_var::operator const ::CORBA_LocalInterfaceDefSeq &() const // cast
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE 
+CORBA_LocalInterfaceDefSeq_var::operator ::CORBA_LocalInterfaceDefSeq &() // cast 
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE 
+CORBA_LocalInterfaceDefSeq_var::operator ::CORBA_LocalInterfaceDefSeq &() const // cast 
+{
+  return *this->ptr_;
+}
+
+// variable-size types only
+ACE_INLINE
+CORBA_LocalInterfaceDefSeq_var::operator ::CORBA_LocalInterfaceDefSeq *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE TAO_Object_Manager<CORBA::LocalInterfaceDef, CORBA::LocalInterfaceDef_var>
+CORBA_LocalInterfaceDefSeq_var::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+ACE_INLINE const ::CORBA_LocalInterfaceDefSeq &
+CORBA_LocalInterfaceDefSeq_var::in (void) const
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE ::CORBA_LocalInterfaceDefSeq &
+CORBA_LocalInterfaceDefSeq_var::inout (void)
+{
+  return *this->ptr_;
+}
+
+// mapping for variable size 
+ACE_INLINE ::CORBA_LocalInterfaceDefSeq *&
+CORBA_LocalInterfaceDefSeq_var::out (void)
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_LocalInterfaceDefSeq *
+CORBA_LocalInterfaceDefSeq_var::_retn (void)
+{
+  ::CORBA_LocalInterfaceDefSeq *tmp = this->ptr_;
+  this->ptr_ = 0;
+  return tmp;
+}
+
+ACE_INLINE ::CORBA_LocalInterfaceDefSeq *
+CORBA_LocalInterfaceDefSeq_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+// *************************************************************
+// Inline operations for class CORBA_LocalInterfaceDefSeq_out
+// *************************************************************
+
+ACE_INLINE
+CORBA_LocalInterfaceDefSeq_out::CORBA_LocalInterfaceDefSeq_out (CORBA_LocalInterfaceDefSeq *&p)
+  : ptr_ (p)
+{
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA_LocalInterfaceDefSeq_out::CORBA_LocalInterfaceDefSeq_out (CORBA_LocalInterfaceDefSeq_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA_LocalInterfaceDefSeq_out::CORBA_LocalInterfaceDefSeq_out (const ::CORBA_LocalInterfaceDefSeq_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (CORBA_LocalInterfaceDefSeq_out&, p).ptr_)
+{}
+
+ACE_INLINE ::CORBA_LocalInterfaceDefSeq_out &
+CORBA_LocalInterfaceDefSeq_out::operator= (const ::CORBA_LocalInterfaceDefSeq_out &p)
+{
+  this->ptr_ = ACE_const_cast (CORBA_LocalInterfaceDefSeq_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE ::CORBA_LocalInterfaceDefSeq_out &
+CORBA_LocalInterfaceDefSeq_out::operator= (CORBA_LocalInterfaceDefSeq *p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+CORBA_LocalInterfaceDefSeq_out::operator ::CORBA_LocalInterfaceDefSeq *&() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_LocalInterfaceDefSeq *&
+CORBA_LocalInterfaceDefSeq_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_LocalInterfaceDefSeq *
+CORBA_LocalInterfaceDefSeq_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE TAO_Object_Manager<CORBA::LocalInterfaceDef, CORBA::LocalInterfaceDef_var>
+CORBA_LocalInterfaceDefSeq_out::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+
+#endif /* end #if !defined */
+
+// *******************************************************************
+
+#if !defined (_CORBA_PRIMITIVEDEF___CI_)
+#define _CORBA_PRIMITIVEDEF___CI_
+
+ACE_INLINE
+CORBA_PrimitiveDef::CORBA_PrimitiveDef (
+    TAO_Stub *objref,
+    CORBA::Boolean _tao_collocated,
+    TAO_Abstract_ServantBase *servant
+  )
+  : CORBA_Object (objref, _tao_collocated, servant)
+{
+  this->CORBA_PrimitiveDef_setup_collocation (_tao_collocated);
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_PRIMITIVEDEF___VAR_CI_)
+#define _CORBA_PRIMITIVEDEF___VAR_CI_
+
+// *************************************************************
+// Inline operations for class CORBA_PrimitiveDef_var
+// *************************************************************
+
+ACE_INLINE
+CORBA_PrimitiveDef_var::CORBA_PrimitiveDef_var (void) // default constructor
+  : ptr_ (CORBA_PrimitiveDef::_nil ())
+{}
+
+ACE_INLINE CORBA_PrimitiveDef_ptr 
+CORBA_PrimitiveDef_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+CORBA_PrimitiveDef_var::CORBA_PrimitiveDef_var (const CORBA_PrimitiveDef_var &p) // copy constructor
+  : TAO_Base_var (),
+    ptr_ (CORBA_PrimitiveDef::_duplicate (p.ptr ()))
+{}
+
+ACE_INLINE
+CORBA_PrimitiveDef_var::~CORBA_PrimitiveDef_var (void) // destructor
+{
+  CORBA::release (this->ptr_);
+}
+
+ACE_INLINE CORBA_PrimitiveDef_var &
+CORBA_PrimitiveDef_var::operator= (CORBA_PrimitiveDef_ptr p)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE CORBA_PrimitiveDef_var &
+CORBA_PrimitiveDef_var::operator= (const CORBA_PrimitiveDef_var &p)
+{
+  if (this != &p)
+  {
+    CORBA::release (this->ptr_);
+    this->ptr_ = CORBA_PrimitiveDef::_duplicate (p.ptr ());
+  }
+  return *this;
+}
+
+ACE_INLINE 
+CORBA_PrimitiveDef_var::operator const CORBA_PrimitiveDef_ptr &() const // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+CORBA_PrimitiveDef_var::operator CORBA_PrimitiveDef_ptr &() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE CORBA_PrimitiveDef_ptr 
+CORBA_PrimitiveDef_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE CORBA_PrimitiveDef_ptr
+CORBA_PrimitiveDef_var::in (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE CORBA_PrimitiveDef_ptr &
+CORBA_PrimitiveDef_var::inout (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE CORBA_PrimitiveDef_ptr &
+CORBA_PrimitiveDef_var::out (void)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = CORBA_PrimitiveDef::_nil ();
+  return this->ptr_;
+}
+
+ACE_INLINE CORBA_PrimitiveDef_ptr 
+CORBA_PrimitiveDef_var::_retn (void)
+{
+  // yield ownership of managed obj reference
+  CORBA_PrimitiveDef_ptr val = this->ptr_;
+  this->ptr_ = CORBA_PrimitiveDef::_nil ();
+  return val;
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_PRIMITIVEDEF___OUT_CI_)
+#define _CORBA_PRIMITIVEDEF___OUT_CI_
+
+// *************************************************************
+// Inline operations for class CORBA_PrimitiveDef_out
+// *************************************************************
+
+ACE_INLINE
+CORBA_PrimitiveDef_out::CORBA_PrimitiveDef_out (CORBA_PrimitiveDef_ptr &p)
+  : ptr_ (p)
+{
+  this->ptr_ = CORBA_PrimitiveDef::_nil ();
+}
+
+ACE_INLINE
+CORBA_PrimitiveDef_out::CORBA_PrimitiveDef_out (CORBA_PrimitiveDef_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = CORBA_PrimitiveDef::_nil ();
+}
+
+ACE_INLINE
+CORBA_PrimitiveDef_out::CORBA_PrimitiveDef_out (const CORBA_PrimitiveDef_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (CORBA_PrimitiveDef_out&,p).ptr_)
+{}
+
+ACE_INLINE CORBA_PrimitiveDef_out &
+CORBA_PrimitiveDef_out::operator= (const CORBA_PrimitiveDef_out &p)
+{
+  this->ptr_ = ACE_const_cast (CORBA_PrimitiveDef_out&,p).ptr_;
+  return *this;
+}
+
+ACE_INLINE CORBA_PrimitiveDef_out &
+CORBA_PrimitiveDef_out::operator= (const CORBA_PrimitiveDef_var &p)
+{
+  this->ptr_ = CORBA_PrimitiveDef::_duplicate (p.ptr ());
+  return *this;
+}
+
+ACE_INLINE CORBA_PrimitiveDef_out &
+CORBA_PrimitiveDef_out::operator= (CORBA_PrimitiveDef_ptr p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+CORBA_PrimitiveDef_out::operator CORBA_PrimitiveDef_ptr &() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE CORBA_PrimitiveDef_ptr &
+CORBA_PrimitiveDef_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE CORBA_PrimitiveDef_ptr 
+CORBA_PrimitiveDef_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_STRINGDEF___CI_)
+#define _CORBA_STRINGDEF___CI_
+
+ACE_INLINE
+CORBA_StringDef::CORBA_StringDef (
+    TAO_Stub *objref,
+    CORBA::Boolean _tao_collocated,
+    TAO_Abstract_ServantBase *servant
+  )
+  : CORBA_Object (objref, _tao_collocated, servant)
+{
+  this->CORBA_StringDef_setup_collocation (_tao_collocated);
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_STRINGDEF___VAR_CI_)
+#define _CORBA_STRINGDEF___VAR_CI_
+
+// *************************************************************
+// Inline operations for class CORBA_StringDef_var
+// *************************************************************
+
+ACE_INLINE
+CORBA_StringDef_var::CORBA_StringDef_var (void) // default constructor
+  : ptr_ (CORBA_StringDef::_nil ())
+{}
+
+ACE_INLINE CORBA_StringDef_ptr 
+CORBA_StringDef_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+CORBA_StringDef_var::CORBA_StringDef_var (const CORBA_StringDef_var &p) // copy constructor
+  : TAO_Base_var (),
+    ptr_ (CORBA_StringDef::_duplicate (p.ptr ()))
+{}
+
+ACE_INLINE
+CORBA_StringDef_var::~CORBA_StringDef_var (void) // destructor
+{
+  CORBA::release (this->ptr_);
+}
+
+ACE_INLINE CORBA_StringDef_var &
+CORBA_StringDef_var::operator= (CORBA_StringDef_ptr p)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE CORBA_StringDef_var &
+CORBA_StringDef_var::operator= (const CORBA_StringDef_var &p)
+{
+  if (this != &p)
+  {
+    CORBA::release (this->ptr_);
+    this->ptr_ = CORBA_StringDef::_duplicate (p.ptr ());
+  }
+  return *this;
+}
+
+ACE_INLINE 
+CORBA_StringDef_var::operator const CORBA_StringDef_ptr &() const // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+CORBA_StringDef_var::operator CORBA_StringDef_ptr &() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE CORBA_StringDef_ptr 
+CORBA_StringDef_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE CORBA_StringDef_ptr
+CORBA_StringDef_var::in (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE CORBA_StringDef_ptr &
+CORBA_StringDef_var::inout (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE CORBA_StringDef_ptr &
+CORBA_StringDef_var::out (void)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = CORBA_StringDef::_nil ();
+  return this->ptr_;
+}
+
+ACE_INLINE CORBA_StringDef_ptr 
+CORBA_StringDef_var::_retn (void)
+{
+  // yield ownership of managed obj reference
+  CORBA_StringDef_ptr val = this->ptr_;
+  this->ptr_ = CORBA_StringDef::_nil ();
+  return val;
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_STRINGDEF___OUT_CI_)
+#define _CORBA_STRINGDEF___OUT_CI_
+
+// *************************************************************
+// Inline operations for class CORBA_StringDef_out
+// *************************************************************
+
+ACE_INLINE
+CORBA_StringDef_out::CORBA_StringDef_out (CORBA_StringDef_ptr &p)
+  : ptr_ (p)
+{
+  this->ptr_ = CORBA_StringDef::_nil ();
+}
+
+ACE_INLINE
+CORBA_StringDef_out::CORBA_StringDef_out (CORBA_StringDef_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = CORBA_StringDef::_nil ();
+}
+
+ACE_INLINE
+CORBA_StringDef_out::CORBA_StringDef_out (const CORBA_StringDef_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (CORBA_StringDef_out&,p).ptr_)
+{}
+
+ACE_INLINE CORBA_StringDef_out &
+CORBA_StringDef_out::operator= (const CORBA_StringDef_out &p)
+{
+  this->ptr_ = ACE_const_cast (CORBA_StringDef_out&,p).ptr_;
+  return *this;
+}
+
+ACE_INLINE CORBA_StringDef_out &
+CORBA_StringDef_out::operator= (const CORBA_StringDef_var &p)
+{
+  this->ptr_ = CORBA_StringDef::_duplicate (p.ptr ());
+  return *this;
+}
+
+ACE_INLINE CORBA_StringDef_out &
+CORBA_StringDef_out::operator= (CORBA_StringDef_ptr p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+CORBA_StringDef_out::operator CORBA_StringDef_ptr &() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE CORBA_StringDef_ptr &
+CORBA_StringDef_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE CORBA_StringDef_ptr 
+CORBA_StringDef_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_SEQUENCEDEF___CI_)
+#define _CORBA_SEQUENCEDEF___CI_
+
+ACE_INLINE
+CORBA_SequenceDef::CORBA_SequenceDef (
+    TAO_Stub *objref,
+    CORBA::Boolean _tao_collocated,
+    TAO_Abstract_ServantBase *servant
+  )
+  : CORBA_Object (objref, _tao_collocated, servant)
+{
+  this->CORBA_SequenceDef_setup_collocation (_tao_collocated);
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_SEQUENCEDEF___VAR_CI_)
+#define _CORBA_SEQUENCEDEF___VAR_CI_
+
+// *************************************************************
+// Inline operations for class CORBA_SequenceDef_var
+// *************************************************************
+
+ACE_INLINE
+CORBA_SequenceDef_var::CORBA_SequenceDef_var (void) // default constructor
+  : ptr_ (CORBA_SequenceDef::_nil ())
+{}
+
+ACE_INLINE CORBA_SequenceDef_ptr 
+CORBA_SequenceDef_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+CORBA_SequenceDef_var::CORBA_SequenceDef_var (const CORBA_SequenceDef_var &p) // copy constructor
+  : TAO_Base_var (),
+    ptr_ (CORBA_SequenceDef::_duplicate (p.ptr ()))
+{}
+
+ACE_INLINE
+CORBA_SequenceDef_var::~CORBA_SequenceDef_var (void) // destructor
+{
+  CORBA::release (this->ptr_);
+}
+
+ACE_INLINE CORBA_SequenceDef_var &
+CORBA_SequenceDef_var::operator= (CORBA_SequenceDef_ptr p)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE CORBA_SequenceDef_var &
+CORBA_SequenceDef_var::operator= (const CORBA_SequenceDef_var &p)
+{
+  if (this != &p)
+  {
+    CORBA::release (this->ptr_);
+    this->ptr_ = CORBA_SequenceDef::_duplicate (p.ptr ());
+  }
+  return *this;
+}
+
+ACE_INLINE 
+CORBA_SequenceDef_var::operator const CORBA_SequenceDef_ptr &() const // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+CORBA_SequenceDef_var::operator CORBA_SequenceDef_ptr &() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE CORBA_SequenceDef_ptr 
+CORBA_SequenceDef_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE CORBA_SequenceDef_ptr
+CORBA_SequenceDef_var::in (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE CORBA_SequenceDef_ptr &
+CORBA_SequenceDef_var::inout (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE CORBA_SequenceDef_ptr &
+CORBA_SequenceDef_var::out (void)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = CORBA_SequenceDef::_nil ();
+  return this->ptr_;
+}
+
+ACE_INLINE CORBA_SequenceDef_ptr 
+CORBA_SequenceDef_var::_retn (void)
+{
+  // yield ownership of managed obj reference
+  CORBA_SequenceDef_ptr val = this->ptr_;
+  this->ptr_ = CORBA_SequenceDef::_nil ();
+  return val;
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_SEQUENCEDEF___OUT_CI_)
+#define _CORBA_SEQUENCEDEF___OUT_CI_
+
+// *************************************************************
+// Inline operations for class CORBA_SequenceDef_out
+// *************************************************************
+
+ACE_INLINE
+CORBA_SequenceDef_out::CORBA_SequenceDef_out (CORBA_SequenceDef_ptr &p)
+  : ptr_ (p)
+{
+  this->ptr_ = CORBA_SequenceDef::_nil ();
+}
+
+ACE_INLINE
+CORBA_SequenceDef_out::CORBA_SequenceDef_out (CORBA_SequenceDef_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = CORBA_SequenceDef::_nil ();
+}
+
+ACE_INLINE
+CORBA_SequenceDef_out::CORBA_SequenceDef_out (const CORBA_SequenceDef_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (CORBA_SequenceDef_out&,p).ptr_)
+{}
+
+ACE_INLINE CORBA_SequenceDef_out &
+CORBA_SequenceDef_out::operator= (const CORBA_SequenceDef_out &p)
+{
+  this->ptr_ = ACE_const_cast (CORBA_SequenceDef_out&,p).ptr_;
+  return *this;
+}
+
+ACE_INLINE CORBA_SequenceDef_out &
+CORBA_SequenceDef_out::operator= (const CORBA_SequenceDef_var &p)
+{
+  this->ptr_ = CORBA_SequenceDef::_duplicate (p.ptr ());
+  return *this;
+}
+
+ACE_INLINE CORBA_SequenceDef_out &
+CORBA_SequenceDef_out::operator= (CORBA_SequenceDef_ptr p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+CORBA_SequenceDef_out::operator CORBA_SequenceDef_ptr &() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE CORBA_SequenceDef_ptr &
+CORBA_SequenceDef_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE CORBA_SequenceDef_ptr 
+CORBA_SequenceDef_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_ARRAYDEF___CI_)
+#define _CORBA_ARRAYDEF___CI_
+
+ACE_INLINE
+CORBA_ArrayDef::CORBA_ArrayDef (
+    TAO_Stub *objref,
+    CORBA::Boolean _tao_collocated,
+    TAO_Abstract_ServantBase *servant
+  )
+  : CORBA_Object (objref, _tao_collocated, servant)
+{
+  this->CORBA_ArrayDef_setup_collocation (_tao_collocated);
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_ARRAYDEF___VAR_CI_)
+#define _CORBA_ARRAYDEF___VAR_CI_
+
+// *************************************************************
+// Inline operations for class CORBA_ArrayDef_var
+// *************************************************************
+
+ACE_INLINE
+CORBA_ArrayDef_var::CORBA_ArrayDef_var (void) // default constructor
+  : ptr_ (CORBA_ArrayDef::_nil ())
+{}
+
+ACE_INLINE CORBA_ArrayDef_ptr 
+CORBA_ArrayDef_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+CORBA_ArrayDef_var::CORBA_ArrayDef_var (const CORBA_ArrayDef_var &p) // copy constructor
+  : TAO_Base_var (),
+    ptr_ (CORBA_ArrayDef::_duplicate (p.ptr ()))
+{}
+
+ACE_INLINE
+CORBA_ArrayDef_var::~CORBA_ArrayDef_var (void) // destructor
+{
+  CORBA::release (this->ptr_);
+}
+
+ACE_INLINE CORBA_ArrayDef_var &
+CORBA_ArrayDef_var::operator= (CORBA_ArrayDef_ptr p)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE CORBA_ArrayDef_var &
+CORBA_ArrayDef_var::operator= (const CORBA_ArrayDef_var &p)
+{
+  if (this != &p)
+  {
+    CORBA::release (this->ptr_);
+    this->ptr_ = CORBA_ArrayDef::_duplicate (p.ptr ());
+  }
+  return *this;
+}
+
+ACE_INLINE 
+CORBA_ArrayDef_var::operator const CORBA_ArrayDef_ptr &() const // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+CORBA_ArrayDef_var::operator CORBA_ArrayDef_ptr &() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE CORBA_ArrayDef_ptr 
+CORBA_ArrayDef_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE CORBA_ArrayDef_ptr
+CORBA_ArrayDef_var::in (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE CORBA_ArrayDef_ptr &
+CORBA_ArrayDef_var::inout (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE CORBA_ArrayDef_ptr &
+CORBA_ArrayDef_var::out (void)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = CORBA_ArrayDef::_nil ();
+  return this->ptr_;
+}
+
+ACE_INLINE CORBA_ArrayDef_ptr 
+CORBA_ArrayDef_var::_retn (void)
+{
+  // yield ownership of managed obj reference
+  CORBA_ArrayDef_ptr val = this->ptr_;
+  this->ptr_ = CORBA_ArrayDef::_nil ();
+  return val;
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_ARRAYDEF___OUT_CI_)
+#define _CORBA_ARRAYDEF___OUT_CI_
+
+// *************************************************************
+// Inline operations for class CORBA_ArrayDef_out
+// *************************************************************
+
+ACE_INLINE
+CORBA_ArrayDef_out::CORBA_ArrayDef_out (CORBA_ArrayDef_ptr &p)
+  : ptr_ (p)
+{
+  this->ptr_ = CORBA_ArrayDef::_nil ();
+}
+
+ACE_INLINE
+CORBA_ArrayDef_out::CORBA_ArrayDef_out (CORBA_ArrayDef_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = CORBA_ArrayDef::_nil ();
+}
+
+ACE_INLINE
+CORBA_ArrayDef_out::CORBA_ArrayDef_out (const CORBA_ArrayDef_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (CORBA_ArrayDef_out&,p).ptr_)
+{}
+
+ACE_INLINE CORBA_ArrayDef_out &
+CORBA_ArrayDef_out::operator= (const CORBA_ArrayDef_out &p)
+{
+  this->ptr_ = ACE_const_cast (CORBA_ArrayDef_out&,p).ptr_;
+  return *this;
+}
+
+ACE_INLINE CORBA_ArrayDef_out &
+CORBA_ArrayDef_out::operator= (const CORBA_ArrayDef_var &p)
+{
+  this->ptr_ = CORBA_ArrayDef::_duplicate (p.ptr ());
+  return *this;
+}
+
+ACE_INLINE CORBA_ArrayDef_out &
+CORBA_ArrayDef_out::operator= (CORBA_ArrayDef_ptr p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+CORBA_ArrayDef_out::operator CORBA_ArrayDef_ptr &() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE CORBA_ArrayDef_ptr &
+CORBA_ArrayDef_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE CORBA_ArrayDef_ptr 
+CORBA_ArrayDef_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_WSTRINGDEF___CI_)
+#define _CORBA_WSTRINGDEF___CI_
+
+ACE_INLINE
+CORBA_WstringDef::CORBA_WstringDef (
+    TAO_Stub *objref,
+    CORBA::Boolean _tao_collocated,
+    TAO_Abstract_ServantBase *servant
+  )
+  : CORBA_Object (objref, _tao_collocated, servant)
+{
+  this->CORBA_WstringDef_setup_collocation (_tao_collocated);
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_WSTRINGDEF___VAR_CI_)
+#define _CORBA_WSTRINGDEF___VAR_CI_
+
+// *************************************************************
+// Inline operations for class CORBA_WstringDef_var
+// *************************************************************
+
+ACE_INLINE
+CORBA_WstringDef_var::CORBA_WstringDef_var (void) // default constructor
+  : ptr_ (CORBA_WstringDef::_nil ())
+{}
+
+ACE_INLINE CORBA_WstringDef_ptr 
+CORBA_WstringDef_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+CORBA_WstringDef_var::CORBA_WstringDef_var (const CORBA_WstringDef_var &p) // copy constructor
+  : TAO_Base_var (),
+    ptr_ (CORBA_WstringDef::_duplicate (p.ptr ()))
+{}
+
+ACE_INLINE
+CORBA_WstringDef_var::~CORBA_WstringDef_var (void) // destructor
+{
+  CORBA::release (this->ptr_);
+}
+
+ACE_INLINE CORBA_WstringDef_var &
+CORBA_WstringDef_var::operator= (CORBA_WstringDef_ptr p)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE CORBA_WstringDef_var &
+CORBA_WstringDef_var::operator= (const CORBA_WstringDef_var &p)
+{
+  if (this != &p)
+  {
+    CORBA::release (this->ptr_);
+    this->ptr_ = CORBA_WstringDef::_duplicate (p.ptr ());
+  }
+  return *this;
+}
+
+ACE_INLINE 
+CORBA_WstringDef_var::operator const CORBA_WstringDef_ptr &() const // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+CORBA_WstringDef_var::operator CORBA_WstringDef_ptr &() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE CORBA_WstringDef_ptr 
+CORBA_WstringDef_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE CORBA_WstringDef_ptr
+CORBA_WstringDef_var::in (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE CORBA_WstringDef_ptr &
+CORBA_WstringDef_var::inout (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE CORBA_WstringDef_ptr &
+CORBA_WstringDef_var::out (void)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = CORBA_WstringDef::_nil ();
+  return this->ptr_;
+}
+
+ACE_INLINE CORBA_WstringDef_ptr 
+CORBA_WstringDef_var::_retn (void)
+{
+  // yield ownership of managed obj reference
+  CORBA_WstringDef_ptr val = this->ptr_;
+  this->ptr_ = CORBA_WstringDef::_nil ();
+  return val;
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_WSTRINGDEF___OUT_CI_)
+#define _CORBA_WSTRINGDEF___OUT_CI_
+
+// *************************************************************
+// Inline operations for class CORBA_WstringDef_out
+// *************************************************************
+
+ACE_INLINE
+CORBA_WstringDef_out::CORBA_WstringDef_out (CORBA_WstringDef_ptr &p)
+  : ptr_ (p)
+{
+  this->ptr_ = CORBA_WstringDef::_nil ();
+}
+
+ACE_INLINE
+CORBA_WstringDef_out::CORBA_WstringDef_out (CORBA_WstringDef_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = CORBA_WstringDef::_nil ();
+}
+
+ACE_INLINE
+CORBA_WstringDef_out::CORBA_WstringDef_out (const CORBA_WstringDef_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (CORBA_WstringDef_out&,p).ptr_)
+{}
+
+ACE_INLINE CORBA_WstringDef_out &
+CORBA_WstringDef_out::operator= (const CORBA_WstringDef_out &p)
+{
+  this->ptr_ = ACE_const_cast (CORBA_WstringDef_out&,p).ptr_;
+  return *this;
+}
+
+ACE_INLINE CORBA_WstringDef_out &
+CORBA_WstringDef_out::operator= (const CORBA_WstringDef_var &p)
+{
+  this->ptr_ = CORBA_WstringDef::_duplicate (p.ptr ());
+  return *this;
+}
+
+ACE_INLINE CORBA_WstringDef_out &
+CORBA_WstringDef_out::operator= (CORBA_WstringDef_ptr p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+CORBA_WstringDef_out::operator CORBA_WstringDef_ptr &() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE CORBA_WstringDef_ptr &
+CORBA_WstringDef_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE CORBA_WstringDef_ptr 
+CORBA_WstringDef_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_REPOSITORY___CI_)
+#define _CORBA_REPOSITORY___CI_
+
+ACE_INLINE
+CORBA_Repository::CORBA_Repository (
+    TAO_Stub *objref,
+    CORBA::Boolean _tao_collocated,
+    TAO_Abstract_ServantBase *servant
+  )
+  : CORBA_Object (objref, _tao_collocated, servant)
+{
+  this->CORBA_Repository_setup_collocation (_tao_collocated);
+}
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_REPOSITORY___VAR_CI_)
+#define _CORBA_REPOSITORY___VAR_CI_
+
+// *************************************************************
+// Inline operations for class CORBA_Repository_var
+// *************************************************************
+
+ACE_INLINE
+CORBA_Repository_var::CORBA_Repository_var (void) // default constructor
+  : ptr_ (CORBA_Repository::_nil ())
+{}
+
+ACE_INLINE ::CORBA_Repository_ptr
+CORBA_Repository_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+CORBA_Repository_var::CORBA_Repository_var (const ::CORBA_Repository_var &p) // copy constructor
+  : TAO_Base_var (),
+    ptr_ (CORBA_Repository::_duplicate (p.ptr ()))
+{}
+
+ACE_INLINE
+CORBA_Repository_var::~CORBA_Repository_var (void) // destructor
+{
+  CORBA::release (this->ptr_);
+}
+
+ACE_INLINE CORBA_Repository_var &
+CORBA_Repository_var::operator= (CORBA_Repository_ptr p)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE CORBA_Repository_var &
+CORBA_Repository_var::operator= (const ::CORBA_Repository_var &p)
+{
+  if (this != &p)
+  {
+    CORBA::release (this->ptr_);
+    this->ptr_ = ::CORBA_Repository::_duplicate (p.ptr ());
+  }
+  return *this;
+}
+
+ACE_INLINE 
+CORBA_Repository_var::operator const ::CORBA_Repository_ptr &() const // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+CORBA_Repository_var::operator ::CORBA_Repository_ptr &() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_Repository_ptr
+CORBA_Repository_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_Repository_ptr
+CORBA_Repository_var::in (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_Repository_ptr &
+CORBA_Repository_var::inout (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_Repository_ptr &
+CORBA_Repository_var::out (void)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = ::CORBA_Repository::_nil ();
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_Repository_ptr
+CORBA_Repository_var::_retn (void)
+{
+  // yield ownership of managed obj reference
+  ::CORBA_Repository_ptr val = this->ptr_;
+  this->ptr_ = ::CORBA_Repository::_nil ();
+  return val;
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_REPOSITORY___OUT_CI_)
+#define _CORBA_REPOSITORY___OUT_CI_
+
+// *************************************************************
+// Inline operations for class CORBA_Repository_out
+// *************************************************************
+
+ACE_INLINE
+CORBA_Repository_out::CORBA_Repository_out (CORBA_Repository_ptr &p)
+  : ptr_ (p)
+{
+  this->ptr_ = ::CORBA_Repository::_nil ();
+}
+
+ACE_INLINE
+CORBA_Repository_out::CORBA_Repository_out (CORBA_Repository_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = ::CORBA_Repository::_nil ();
+}
+
+ACE_INLINE
+CORBA_Repository_out::CORBA_Repository_out (const ::CORBA_Repository_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (CORBA_Repository_out &, p).ptr_)
+{}
+
+ACE_INLINE ::CORBA_Repository_out &
+CORBA_Repository_out::operator= (const ::CORBA_Repository_out &p)
+{
+  this->ptr_ = ACE_const_cast (CORBA_Repository_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE CORBA_Repository_out &
+CORBA_Repository_out::operator= (const ::CORBA_Repository_var &p)
+{
+  this->ptr_ = ::CORBA_Repository::_duplicate (p.ptr ());
+  return *this;
+}
+
+ACE_INLINE CORBA_Repository_out &
+CORBA_Repository_out::operator= (CORBA_Repository_ptr p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+CORBA_Repository_out::operator ::CORBA_Repository_ptr &() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_Repository_ptr &
+CORBA_Repository_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_Repository_ptr
+CORBA_Repository_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_MODULEDEF___CI_)
+#define _CORBA_MODULEDEF___CI_
+
+ACE_INLINE
+CORBA_ModuleDef::CORBA_ModuleDef (
+    TAO_Stub *objref,
+    CORBA::Boolean _tao_collocated,
+    TAO_Abstract_ServantBase *servant
+  )
+  : CORBA_Object (objref, _tao_collocated, servant)
+{
+  this->CORBA_ModuleDef_setup_collocation (_tao_collocated);
+}
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_MODULEDEF___VAR_CI_)
+#define _CORBA_MODULEDEF___VAR_CI_
+
+// *************************************************************
+// Inline operations for class CORBA_ModuleDef_var
+// *************************************************************
+
+ACE_INLINE
+CORBA_ModuleDef_var::CORBA_ModuleDef_var (void) // default constructor
+  : ptr_ (CORBA_ModuleDef::_nil ())
+{}
+
+ACE_INLINE ::CORBA_ModuleDef_ptr
+CORBA_ModuleDef_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+CORBA_ModuleDef_var::CORBA_ModuleDef_var (const ::CORBA_ModuleDef_var &p) // copy constructor
+  : TAO_Base_var (),
+    ptr_ (CORBA_ModuleDef::_duplicate (p.ptr ()))
+{}
+
+ACE_INLINE
+CORBA_ModuleDef_var::~CORBA_ModuleDef_var (void) // destructor
+{
+  CORBA::release (this->ptr_);
+}
+
+ACE_INLINE CORBA_ModuleDef_var &
+CORBA_ModuleDef_var::operator= (CORBA_ModuleDef_ptr p)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE CORBA_ModuleDef_var &
+CORBA_ModuleDef_var::operator= (const ::CORBA_ModuleDef_var &p)
+{
+  if (this != &p)
+  {
+    CORBA::release (this->ptr_);
+    this->ptr_ = ::CORBA_ModuleDef::_duplicate (p.ptr ());
+  }
+  return *this;
+}
+
+ACE_INLINE 
+CORBA_ModuleDef_var::operator const ::CORBA_ModuleDef_ptr &() const // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+CORBA_ModuleDef_var::operator ::CORBA_ModuleDef_ptr &() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ModuleDef_ptr
+CORBA_ModuleDef_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ModuleDef_ptr
+CORBA_ModuleDef_var::in (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ModuleDef_ptr &
+CORBA_ModuleDef_var::inout (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ModuleDef_ptr &
+CORBA_ModuleDef_var::out (void)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = ::CORBA_ModuleDef::_nil ();
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ModuleDef_ptr
+CORBA_ModuleDef_var::_retn (void)
+{
+  // yield ownership of managed obj reference
+  ::CORBA_ModuleDef_ptr val = this->ptr_;
+  this->ptr_ = ::CORBA_ModuleDef::_nil ();
+  return val;
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_MODULEDEF___OUT_CI_)
+#define _CORBA_MODULEDEF___OUT_CI_
+
+// *************************************************************
+// Inline operations for class CORBA_ModuleDef_out
+// *************************************************************
+
+ACE_INLINE
+CORBA_ModuleDef_out::CORBA_ModuleDef_out (CORBA_ModuleDef_ptr &p)
+  : ptr_ (p)
+{
+  this->ptr_ = ::CORBA_ModuleDef::_nil ();
+}
+
+ACE_INLINE
+CORBA_ModuleDef_out::CORBA_ModuleDef_out (CORBA_ModuleDef_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = ::CORBA_ModuleDef::_nil ();
+}
+
+ACE_INLINE
+CORBA_ModuleDef_out::CORBA_ModuleDef_out (const ::CORBA_ModuleDef_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (CORBA_ModuleDef_out &, p).ptr_)
+{}
+
+ACE_INLINE ::CORBA_ModuleDef_out &
+CORBA_ModuleDef_out::operator= (const ::CORBA_ModuleDef_out &p)
+{
+  this->ptr_ = ACE_const_cast (CORBA_ModuleDef_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE CORBA_ModuleDef_out &
+CORBA_ModuleDef_out::operator= (const ::CORBA_ModuleDef_var &p)
+{
+  this->ptr_ = ::CORBA_ModuleDef::_duplicate (p.ptr ());
+  return *this;
+}
+
+ACE_INLINE CORBA_ModuleDef_out &
+CORBA_ModuleDef_out::operator= (CORBA_ModuleDef_ptr p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+CORBA_ModuleDef_out::operator ::CORBA_ModuleDef_ptr &() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ModuleDef_ptr &
+CORBA_ModuleDef_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ModuleDef_ptr
+CORBA_ModuleDef_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+
+#endif /* end #if !defined */
+
+// *************************************************************
+// Inline operations for class CORBA_ModuleDescription_var
+// *************************************************************
+
+ACE_INLINE
+CORBA_ModuleDescription_var::CORBA_ModuleDescription_var (void) // default constructor
+  : ptr_ (0)
+{}
+
+ACE_INLINE
+CORBA_ModuleDescription_var::CORBA_ModuleDescription_var (CORBA_ModuleDescription *p)
+  : ptr_ (p)
+{}
+
+ACE_INLINE
+CORBA_ModuleDescription_var::CORBA_ModuleDescription_var (const ::CORBA_ModuleDescription_var &p) // copy constructor
+{
+  if (p.ptr_)
+    ACE_NEW (this->ptr_, ::CORBA_ModuleDescription (*p.ptr_));
+  else
+    this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA_ModuleDescription_var::~CORBA_ModuleDescription_var (void) // destructor
+{
+  delete this->ptr_;
+}
+
+ACE_INLINE CORBA_ModuleDescription_var &
+CORBA_ModuleDescription_var::operator= (CORBA_ModuleDescription *p)
+{
+  delete this->ptr_;
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE ::CORBA_ModuleDescription_var &
+CORBA_ModuleDescription_var::operator= (const ::CORBA_ModuleDescription_var &p)
+{
+  if (this != &p)
+    {
+      if (p.ptr_ == 0)
+        {
+          delete this->ptr_;
+          this->ptr_ = 0;
+        }
+      else
+        {
+          CORBA_ModuleDescription *deep_copy =
+            new CORBA_ModuleDescription (*p.ptr_);
+          
+          if (deep_copy != 0)
+            {
+              CORBA_ModuleDescription *tmp = deep_copy;
+              deep_copy = this->ptr_;
+              this->ptr_ = tmp;
+              delete deep_copy;
+            }
+        }
+    }
+  
+  return *this;
+}
+
+ACE_INLINE const ::CORBA_ModuleDescription *
+CORBA_ModuleDescription_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ModuleDescription *
+CORBA_ModuleDescription_var::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+CORBA_ModuleDescription_var::operator const ::CORBA_ModuleDescription &() const // cast
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE
+CORBA_ModuleDescription_var::operator ::CORBA_ModuleDescription &() // cast 
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE
+CORBA_ModuleDescription_var::operator ::CORBA_ModuleDescription &() const // cast 
+{
+  return *this->ptr_;
+}
+
+// variable-size types only
+ACE_INLINE
+CORBA_ModuleDescription_var::operator ::CORBA_ModuleDescription *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE const ::CORBA_ModuleDescription &
+CORBA_ModuleDescription_var::in (void) const
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ModuleDescription &
+CORBA_ModuleDescription_var::inout (void)
+{
+  return *this->ptr_;
+}
+
+// mapping for variable size 
+ACE_INLINE ::CORBA_ModuleDescription *&
+CORBA_ModuleDescription_var::out (void)
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ModuleDescription *
+CORBA_ModuleDescription_var::_retn (void)
+{
+  ::CORBA_ModuleDescription *tmp = this->ptr_;
+  this->ptr_ = 0;
+  return tmp;
+}
+
+ACE_INLINE ::CORBA_ModuleDescription *
+CORBA_ModuleDescription_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+// *************************************************************
+// Inline operations for class CORBA_ModuleDescription_out
+// *************************************************************
+
+ACE_INLINE
+CORBA_ModuleDescription_out::CORBA_ModuleDescription_out (::CORBA_ModuleDescription *&p)
+  : ptr_ (p)
+{
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA_ModuleDescription_out::CORBA_ModuleDescription_out (CORBA_ModuleDescription_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA_ModuleDescription_out::CORBA_ModuleDescription_out (const ::CORBA_ModuleDescription_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (CORBA_ModuleDescription_out&, p).ptr_)
+{}
+
+ACE_INLINE CORBA_ModuleDescription_out &
+CORBA_ModuleDescription_out::operator= (const ::CORBA_ModuleDescription_out &p)
+{
+  this->ptr_ = ACE_const_cast (CORBA_ModuleDescription_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE CORBA_ModuleDescription_out &
+CORBA_ModuleDescription_out::operator= (CORBA_ModuleDescription *p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+CORBA_ModuleDescription_out::operator ::CORBA_ModuleDescription *&() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ModuleDescription *&
+CORBA_ModuleDescription_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ModuleDescription *
+CORBA_ModuleDescription_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+
+#if !defined (_CORBA_CONSTANTDEF___CI_)
+#define _CORBA_CONSTANTDEF___CI_
+
+ACE_INLINE
+CORBA_ConstantDef::CORBA_ConstantDef (
+    TAO_Stub *objref,
+    CORBA::Boolean _tao_collocated,
+    TAO_Abstract_ServantBase *servant
+  )
+  : CORBA_Object (objref, _tao_collocated, servant)
+{
+  this->CORBA_ConstantDef_setup_collocation (_tao_collocated);
+}
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_CONSTANTDEF___VAR_CI_)
+#define _CORBA_CONSTANTDEF___VAR_CI_
+
+// *************************************************************
+// Inline operations for class CORBA_ConstantDef_var
+// *************************************************************
+
+ACE_INLINE
+CORBA_ConstantDef_var::CORBA_ConstantDef_var (void) // default constructor
+  : ptr_ (CORBA_ConstantDef::_nil ())
+{}
+
+ACE_INLINE ::CORBA_ConstantDef_ptr
+CORBA_ConstantDef_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+CORBA_ConstantDef_var::CORBA_ConstantDef_var (const ::CORBA_ConstantDef_var &p) // copy constructor
+  : TAO_Base_var (),
+    ptr_ (CORBA_ConstantDef::_duplicate (p.ptr ()))
+{}
+
+ACE_INLINE
+CORBA_ConstantDef_var::~CORBA_ConstantDef_var (void) // destructor
+{
+  CORBA::release (this->ptr_);
+}
+
+ACE_INLINE CORBA_ConstantDef_var &
+CORBA_ConstantDef_var::operator= (CORBA_ConstantDef_ptr p)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE CORBA_ConstantDef_var &
+CORBA_ConstantDef_var::operator= (const ::CORBA_ConstantDef_var &p)
+{
+  if (this != &p)
+  {
+    CORBA::release (this->ptr_);
+    this->ptr_ = ::CORBA_ConstantDef::_duplicate (p.ptr ());
+  }
+  return *this;
+}
+
+ACE_INLINE 
+CORBA_ConstantDef_var::operator const ::CORBA_ConstantDef_ptr &() const // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+CORBA_ConstantDef_var::operator ::CORBA_ConstantDef_ptr &() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ConstantDef_ptr
+CORBA_ConstantDef_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ConstantDef_ptr
+CORBA_ConstantDef_var::in (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ConstantDef_ptr &
+CORBA_ConstantDef_var::inout (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ConstantDef_ptr &
+CORBA_ConstantDef_var::out (void)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = ::CORBA_ConstantDef::_nil ();
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ConstantDef_ptr
+CORBA_ConstantDef_var::_retn (void)
+{
+  // yield ownership of managed obj reference
+  ::CORBA_ConstantDef_ptr val = this->ptr_;
+  this->ptr_ = ::CORBA_ConstantDef::_nil ();
+  return val;
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_CONSTANTDEF___OUT_CI_)
+#define _CORBA_CONSTANTDEF___OUT_CI_
+
+// *************************************************************
+// Inline operations for class CORBA_ConstantDef_out
+// *************************************************************
+
+ACE_INLINE
+CORBA_ConstantDef_out::CORBA_ConstantDef_out (CORBA_ConstantDef_ptr &p)
+  : ptr_ (p)
+{
+  this->ptr_ = ::CORBA_ConstantDef::_nil ();
+}
+
+ACE_INLINE
+CORBA_ConstantDef_out::CORBA_ConstantDef_out (CORBA_ConstantDef_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = ::CORBA_ConstantDef::_nil ();
+}
+
+ACE_INLINE
+CORBA_ConstantDef_out::CORBA_ConstantDef_out (const ::CORBA_ConstantDef_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (CORBA_ConstantDef_out &, p).ptr_)
+{}
+
+ACE_INLINE ::CORBA_ConstantDef_out &
+CORBA_ConstantDef_out::operator= (const ::CORBA_ConstantDef_out &p)
+{
+  this->ptr_ = ACE_const_cast (CORBA_ConstantDef_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE CORBA_ConstantDef_out &
+CORBA_ConstantDef_out::operator= (const ::CORBA_ConstantDef_var &p)
+{
+  this->ptr_ = ::CORBA_ConstantDef::_duplicate (p.ptr ());
+  return *this;
+}
+
+ACE_INLINE CORBA_ConstantDef_out &
+CORBA_ConstantDef_out::operator= (CORBA_ConstantDef_ptr p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+CORBA_ConstantDef_out::operator ::CORBA_ConstantDef_ptr &() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ConstantDef_ptr &
+CORBA_ConstantDef_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ConstantDef_ptr
+CORBA_ConstantDef_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+
+#endif /* end #if !defined */
+
+// *************************************************************
+// Inline operations for class CORBA_ConstantDescription_var
+// *************************************************************
+
+ACE_INLINE
+CORBA_ConstantDescription_var::CORBA_ConstantDescription_var (void) // default constructor
+  : ptr_ (0)
+{}
+
+ACE_INLINE
+CORBA_ConstantDescription_var::CORBA_ConstantDescription_var (CORBA_ConstantDescription *p)
+  : ptr_ (p)
+{}
+
+ACE_INLINE
+CORBA_ConstantDescription_var::CORBA_ConstantDescription_var (const ::CORBA_ConstantDescription_var &p) // copy constructor
+{
+  if (p.ptr_)
+    ACE_NEW (this->ptr_, ::CORBA_ConstantDescription (*p.ptr_));
+  else
+    this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA_ConstantDescription_var::~CORBA_ConstantDescription_var (void) // destructor
+{
+  delete this->ptr_;
+}
+
+ACE_INLINE CORBA_ConstantDescription_var &
+CORBA_ConstantDescription_var::operator= (CORBA_ConstantDescription *p)
+{
+  delete this->ptr_;
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE ::CORBA_ConstantDescription_var &
+CORBA_ConstantDescription_var::operator= (const ::CORBA_ConstantDescription_var &p)
+{
+  if (this != &p)
+    {
+      if (p.ptr_ == 0)
+        {
+          delete this->ptr_;
+          this->ptr_ = 0;
+        }
+      else
+        {
+          CORBA_ConstantDescription *deep_copy =
+            new CORBA_ConstantDescription (*p.ptr_);
+          
+          if (deep_copy != 0)
+            {
+              CORBA_ConstantDescription *tmp = deep_copy;
+              deep_copy = this->ptr_;
+              this->ptr_ = tmp;
+              delete deep_copy;
+            }
+        }
+    }
+  
+  return *this;
+}
+
+ACE_INLINE const ::CORBA_ConstantDescription *
+CORBA_ConstantDescription_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ConstantDescription *
+CORBA_ConstantDescription_var::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+CORBA_ConstantDescription_var::operator const ::CORBA_ConstantDescription &() const // cast
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE
+CORBA_ConstantDescription_var::operator ::CORBA_ConstantDescription &() // cast 
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE
+CORBA_ConstantDescription_var::operator ::CORBA_ConstantDescription &() const // cast 
+{
+  return *this->ptr_;
+}
+
+// variable-size types only
+ACE_INLINE
+CORBA_ConstantDescription_var::operator ::CORBA_ConstantDescription *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE const ::CORBA_ConstantDescription &
+CORBA_ConstantDescription_var::in (void) const
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ConstantDescription &
+CORBA_ConstantDescription_var::inout (void)
+{
+  return *this->ptr_;
+}
+
+// mapping for variable size 
+ACE_INLINE ::CORBA_ConstantDescription *&
+CORBA_ConstantDescription_var::out (void)
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ConstantDescription *
+CORBA_ConstantDescription_var::_retn (void)
+{
+  ::CORBA_ConstantDescription *tmp = this->ptr_;
+  this->ptr_ = 0;
+  return tmp;
+}
+
+ACE_INLINE ::CORBA_ConstantDescription *
+CORBA_ConstantDescription_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+// *************************************************************
+// Inline operations for class CORBA_ConstantDescription_out
+// *************************************************************
+
+ACE_INLINE
+CORBA_ConstantDescription_out::CORBA_ConstantDescription_out (::CORBA_ConstantDescription *&p)
+  : ptr_ (p)
+{
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA_ConstantDescription_out::CORBA_ConstantDescription_out (CORBA_ConstantDescription_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA_ConstantDescription_out::CORBA_ConstantDescription_out (const ::CORBA_ConstantDescription_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (CORBA_ConstantDescription_out&, p).ptr_)
+{}
+
+ACE_INLINE CORBA_ConstantDescription_out &
+CORBA_ConstantDescription_out::operator= (const ::CORBA_ConstantDescription_out &p)
+{
+  this->ptr_ = ACE_const_cast (CORBA_ConstantDescription_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE CORBA_ConstantDescription_out &
+CORBA_ConstantDescription_out::operator= (CORBA_ConstantDescription *p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+CORBA_ConstantDescription_out::operator ::CORBA_ConstantDescription *&() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ConstantDescription *&
+CORBA_ConstantDescription_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ConstantDescription *
+CORBA_ConstantDescription_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+
+#if !defined (_CORBA_STRUCTDEF___CI_)
+#define _CORBA_STRUCTDEF___CI_
+
+ACE_INLINE
+CORBA_StructDef::CORBA_StructDef (
+    TAO_Stub *objref,
+    CORBA::Boolean _tao_collocated,
+    TAO_Abstract_ServantBase *servant
+  )
+  : CORBA_Object (objref, _tao_collocated, servant)
+{
+  this->CORBA_StructDef_setup_collocation (_tao_collocated);
+}
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_STRUCTDEF___VAR_CI_)
+#define _CORBA_STRUCTDEF___VAR_CI_
+
+// *************************************************************
+// Inline operations for class CORBA_StructDef_var
+// *************************************************************
+
+ACE_INLINE
+CORBA_StructDef_var::CORBA_StructDef_var (void) // default constructor
+  : ptr_ (CORBA_StructDef::_nil ())
+{}
+
+ACE_INLINE ::CORBA_StructDef_ptr
+CORBA_StructDef_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+CORBA_StructDef_var::CORBA_StructDef_var (const ::CORBA_StructDef_var &p) // copy constructor
+  : TAO_Base_var (),
+    ptr_ (CORBA_StructDef::_duplicate (p.ptr ()))
+{}
+
+ACE_INLINE
+CORBA_StructDef_var::~CORBA_StructDef_var (void) // destructor
+{
+  CORBA::release (this->ptr_);
+}
+
+ACE_INLINE CORBA_StructDef_var &
+CORBA_StructDef_var::operator= (CORBA_StructDef_ptr p)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE CORBA_StructDef_var &
+CORBA_StructDef_var::operator= (const ::CORBA_StructDef_var &p)
+{
+  if (this != &p)
+  {
+    CORBA::release (this->ptr_);
+    this->ptr_ = ::CORBA_StructDef::_duplicate (p.ptr ());
+  }
+  return *this;
+}
+
+ACE_INLINE 
+CORBA_StructDef_var::operator const ::CORBA_StructDef_ptr &() const // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+CORBA_StructDef_var::operator ::CORBA_StructDef_ptr &() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_StructDef_ptr
+CORBA_StructDef_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_StructDef_ptr
+CORBA_StructDef_var::in (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_StructDef_ptr &
+CORBA_StructDef_var::inout (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_StructDef_ptr &
+CORBA_StructDef_var::out (void)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = ::CORBA_StructDef::_nil ();
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_StructDef_ptr
+CORBA_StructDef_var::_retn (void)
+{
+  // yield ownership of managed obj reference
+  ::CORBA_StructDef_ptr val = this->ptr_;
+  this->ptr_ = ::CORBA_StructDef::_nil ();
+  return val;
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_STRUCTDEF___OUT_CI_)
+#define _CORBA_STRUCTDEF___OUT_CI_
+
+// *************************************************************
+// Inline operations for class CORBA_StructDef_out
+// *************************************************************
+
+ACE_INLINE
+CORBA_StructDef_out::CORBA_StructDef_out (CORBA_StructDef_ptr &p)
+  : ptr_ (p)
+{
+  this->ptr_ = ::CORBA_StructDef::_nil ();
+}
+
+ACE_INLINE
+CORBA_StructDef_out::CORBA_StructDef_out (CORBA_StructDef_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = ::CORBA_StructDef::_nil ();
+}
+
+ACE_INLINE
+CORBA_StructDef_out::CORBA_StructDef_out (const ::CORBA_StructDef_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (CORBA_StructDef_out &, p).ptr_)
+{}
+
+ACE_INLINE ::CORBA_StructDef_out &
+CORBA_StructDef_out::operator= (const ::CORBA_StructDef_out &p)
+{
+  this->ptr_ = ACE_const_cast (CORBA_StructDef_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE CORBA_StructDef_out &
+CORBA_StructDef_out::operator= (const ::CORBA_StructDef_var &p)
+{
+  this->ptr_ = ::CORBA_StructDef::_duplicate (p.ptr ());
+  return *this;
+}
+
+ACE_INLINE CORBA_StructDef_out &
+CORBA_StructDef_out::operator= (CORBA_StructDef_ptr p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+CORBA_StructDef_out::operator ::CORBA_StructDef_ptr &() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_StructDef_ptr &
+CORBA_StructDef_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_StructDef_ptr
+CORBA_StructDef_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_UNIONDEF___CI_)
+#define _CORBA_UNIONDEF___CI_
+
+ACE_INLINE
+CORBA_UnionDef::CORBA_UnionDef (
+    TAO_Stub *objref,
+    CORBA::Boolean _tao_collocated,
+    TAO_Abstract_ServantBase *servant
+  )
+  : CORBA_Object (objref, _tao_collocated, servant)
+{
+  this->CORBA_UnionDef_setup_collocation (_tao_collocated);
+}
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_UNIONDEF___VAR_CI_)
+#define _CORBA_UNIONDEF___VAR_CI_
+
+// *************************************************************
+// Inline operations for class CORBA_UnionDef_var
+// *************************************************************
+
+ACE_INLINE
+CORBA_UnionDef_var::CORBA_UnionDef_var (void) // default constructor
+  : ptr_ (CORBA_UnionDef::_nil ())
+{}
+
+ACE_INLINE ::CORBA_UnionDef_ptr
+CORBA_UnionDef_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+CORBA_UnionDef_var::CORBA_UnionDef_var (const ::CORBA_UnionDef_var &p) // copy constructor
+  : TAO_Base_var (),
+    ptr_ (CORBA_UnionDef::_duplicate (p.ptr ()))
+{}
+
+ACE_INLINE
+CORBA_UnionDef_var::~CORBA_UnionDef_var (void) // destructor
+{
+  CORBA::release (this->ptr_);
+}
+
+ACE_INLINE CORBA_UnionDef_var &
+CORBA_UnionDef_var::operator= (CORBA_UnionDef_ptr p)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE CORBA_UnionDef_var &
+CORBA_UnionDef_var::operator= (const ::CORBA_UnionDef_var &p)
+{
+  if (this != &p)
+  {
+    CORBA::release (this->ptr_);
+    this->ptr_ = ::CORBA_UnionDef::_duplicate (p.ptr ());
+  }
+  return *this;
+}
+
+ACE_INLINE 
+CORBA_UnionDef_var::operator const ::CORBA_UnionDef_ptr &() const // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+CORBA_UnionDef_var::operator ::CORBA_UnionDef_ptr &() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_UnionDef_ptr
+CORBA_UnionDef_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_UnionDef_ptr
+CORBA_UnionDef_var::in (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_UnionDef_ptr &
+CORBA_UnionDef_var::inout (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_UnionDef_ptr &
+CORBA_UnionDef_var::out (void)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = ::CORBA_UnionDef::_nil ();
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_UnionDef_ptr
+CORBA_UnionDef_var::_retn (void)
+{
+  // yield ownership of managed obj reference
+  ::CORBA_UnionDef_ptr val = this->ptr_;
+  this->ptr_ = ::CORBA_UnionDef::_nil ();
+  return val;
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_UNIONDEF___OUT_CI_)
+#define _CORBA_UNIONDEF___OUT_CI_
+
+// *************************************************************
+// Inline operations for class CORBA_UnionDef_out
+// *************************************************************
+
+ACE_INLINE
+CORBA_UnionDef_out::CORBA_UnionDef_out (CORBA_UnionDef_ptr &p)
+  : ptr_ (p)
+{
+  this->ptr_ = ::CORBA_UnionDef::_nil ();
+}
+
+ACE_INLINE
+CORBA_UnionDef_out::CORBA_UnionDef_out (CORBA_UnionDef_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = ::CORBA_UnionDef::_nil ();
+}
+
+ACE_INLINE
+CORBA_UnionDef_out::CORBA_UnionDef_out (const ::CORBA_UnionDef_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (CORBA_UnionDef_out &, p).ptr_)
+{}
+
+ACE_INLINE ::CORBA_UnionDef_out &
+CORBA_UnionDef_out::operator= (const ::CORBA_UnionDef_out &p)
+{
+  this->ptr_ = ACE_const_cast (CORBA_UnionDef_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE CORBA_UnionDef_out &
+CORBA_UnionDef_out::operator= (const ::CORBA_UnionDef_var &p)
+{
+  this->ptr_ = ::CORBA_UnionDef::_duplicate (p.ptr ());
+  return *this;
+}
+
+ACE_INLINE CORBA_UnionDef_out &
+CORBA_UnionDef_out::operator= (CORBA_UnionDef_ptr p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+CORBA_UnionDef_out::operator ::CORBA_UnionDef_ptr &() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_UnionDef_ptr &
+CORBA_UnionDef_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_UnionDef_ptr
+CORBA_UnionDef_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_ENUMDEF___CI_)
+#define _CORBA_ENUMDEF___CI_
+
+ACE_INLINE
+CORBA_EnumDef::CORBA_EnumDef (
+    TAO_Stub *objref,
+    CORBA::Boolean _tao_collocated,
+    TAO_Abstract_ServantBase *servant
+  )
+  : CORBA_Object (objref, _tao_collocated, servant)
+{
+  this->CORBA_EnumDef_setup_collocation (_tao_collocated);
+}
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_ENUMDEF___VAR_CI_)
+#define _CORBA_ENUMDEF___VAR_CI_
+
+// *************************************************************
+// Inline operations for class CORBA_EnumDef_var
+// *************************************************************
+
+ACE_INLINE
+CORBA_EnumDef_var::CORBA_EnumDef_var (void) // default constructor
+  : ptr_ (CORBA_EnumDef::_nil ())
+{}
+
+ACE_INLINE ::CORBA_EnumDef_ptr
+CORBA_EnumDef_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+CORBA_EnumDef_var::CORBA_EnumDef_var (const ::CORBA_EnumDef_var &p) // copy constructor
+  : TAO_Base_var (),
+    ptr_ (CORBA_EnumDef::_duplicate (p.ptr ()))
+{}
+
+ACE_INLINE
+CORBA_EnumDef_var::~CORBA_EnumDef_var (void) // destructor
+{
+  CORBA::release (this->ptr_);
+}
+
+ACE_INLINE CORBA_EnumDef_var &
+CORBA_EnumDef_var::operator= (CORBA_EnumDef_ptr p)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE CORBA_EnumDef_var &
+CORBA_EnumDef_var::operator= (const ::CORBA_EnumDef_var &p)
+{
+  if (this != &p)
+  {
+    CORBA::release (this->ptr_);
+    this->ptr_ = ::CORBA_EnumDef::_duplicate (p.ptr ());
+  }
+  return *this;
+}
+
+ACE_INLINE 
+CORBA_EnumDef_var::operator const ::CORBA_EnumDef_ptr &() const // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+CORBA_EnumDef_var::operator ::CORBA_EnumDef_ptr &() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_EnumDef_ptr
+CORBA_EnumDef_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_EnumDef_ptr
+CORBA_EnumDef_var::in (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_EnumDef_ptr &
+CORBA_EnumDef_var::inout (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_EnumDef_ptr &
+CORBA_EnumDef_var::out (void)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = ::CORBA_EnumDef::_nil ();
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_EnumDef_ptr
+CORBA_EnumDef_var::_retn (void)
+{
+  // yield ownership of managed obj reference
+  ::CORBA_EnumDef_ptr val = this->ptr_;
+  this->ptr_ = ::CORBA_EnumDef::_nil ();
+  return val;
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_ENUMDEF___OUT_CI_)
+#define _CORBA_ENUMDEF___OUT_CI_
+
+// *************************************************************
+// Inline operations for class CORBA_EnumDef_out
+// *************************************************************
+
+ACE_INLINE
+CORBA_EnumDef_out::CORBA_EnumDef_out (CORBA_EnumDef_ptr &p)
+  : ptr_ (p)
+{
+  this->ptr_ = ::CORBA_EnumDef::_nil ();
+}
+
+ACE_INLINE
+CORBA_EnumDef_out::CORBA_EnumDef_out (CORBA_EnumDef_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = ::CORBA_EnumDef::_nil ();
+}
+
+ACE_INLINE
+CORBA_EnumDef_out::CORBA_EnumDef_out (const ::CORBA_EnumDef_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (CORBA_EnumDef_out &, p).ptr_)
+{}
+
+ACE_INLINE ::CORBA_EnumDef_out &
+CORBA_EnumDef_out::operator= (const ::CORBA_EnumDef_out &p)
+{
+  this->ptr_ = ACE_const_cast (CORBA_EnumDef_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE CORBA_EnumDef_out &
+CORBA_EnumDef_out::operator= (const ::CORBA_EnumDef_var &p)
+{
+  this->ptr_ = ::CORBA_EnumDef::_duplicate (p.ptr ());
+  return *this;
+}
+
+ACE_INLINE CORBA_EnumDef_out &
+CORBA_EnumDef_out::operator= (CORBA_EnumDef_ptr p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+CORBA_EnumDef_out::operator ::CORBA_EnumDef_ptr &() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_EnumDef_ptr &
+CORBA_EnumDef_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_EnumDef_ptr
+CORBA_EnumDef_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_ALIASDEF___CI_)
+#define _CORBA_ALIASDEF___CI_
+
+ACE_INLINE
+CORBA_AliasDef::CORBA_AliasDef (
+    TAO_Stub *objref,
+    CORBA::Boolean _tao_collocated,
+    TAO_Abstract_ServantBase *servant
+  )
+  : CORBA_Object (objref, _tao_collocated, servant)
+{
+  this->CORBA_AliasDef_setup_collocation (_tao_collocated);
+}
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_ALIASDEF___VAR_CI_)
+#define _CORBA_ALIASDEF___VAR_CI_
+
+// *************************************************************
+// Inline operations for class CORBA_AliasDef_var
+// *************************************************************
+
+ACE_INLINE
+CORBA_AliasDef_var::CORBA_AliasDef_var (void) // default constructor
+  : ptr_ (CORBA_AliasDef::_nil ())
+{}
+
+ACE_INLINE ::CORBA_AliasDef_ptr
+CORBA_AliasDef_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+CORBA_AliasDef_var::CORBA_AliasDef_var (const ::CORBA_AliasDef_var &p) // copy constructor
+  : TAO_Base_var (),
+    ptr_ (CORBA_AliasDef::_duplicate (p.ptr ()))
+{}
+
+ACE_INLINE
+CORBA_AliasDef_var::~CORBA_AliasDef_var (void) // destructor
+{
+  CORBA::release (this->ptr_);
+}
+
+ACE_INLINE CORBA_AliasDef_var &
+CORBA_AliasDef_var::operator= (CORBA_AliasDef_ptr p)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE CORBA_AliasDef_var &
+CORBA_AliasDef_var::operator= (const ::CORBA_AliasDef_var &p)
+{
+  if (this != &p)
+  {
+    CORBA::release (this->ptr_);
+    this->ptr_ = ::CORBA_AliasDef::_duplicate (p.ptr ());
+  }
+  return *this;
+}
+
+ACE_INLINE 
+CORBA_AliasDef_var::operator const ::CORBA_AliasDef_ptr &() const // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+CORBA_AliasDef_var::operator ::CORBA_AliasDef_ptr &() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_AliasDef_ptr
+CORBA_AliasDef_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_AliasDef_ptr
+CORBA_AliasDef_var::in (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_AliasDef_ptr &
+CORBA_AliasDef_var::inout (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_AliasDef_ptr &
+CORBA_AliasDef_var::out (void)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = ::CORBA_AliasDef::_nil ();
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_AliasDef_ptr
+CORBA_AliasDef_var::_retn (void)
+{
+  // yield ownership of managed obj reference
+  ::CORBA_AliasDef_ptr val = this->ptr_;
+  this->ptr_ = ::CORBA_AliasDef::_nil ();
+  return val;
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_ALIASDEF___OUT_CI_)
+#define _CORBA_ALIASDEF___OUT_CI_
+
+// *************************************************************
+// Inline operations for class CORBA_AliasDef_out
+// *************************************************************
+
+ACE_INLINE
+CORBA_AliasDef_out::CORBA_AliasDef_out (CORBA_AliasDef_ptr &p)
+  : ptr_ (p)
+{
+  this->ptr_ = ::CORBA_AliasDef::_nil ();
+}
+
+ACE_INLINE
+CORBA_AliasDef_out::CORBA_AliasDef_out (CORBA_AliasDef_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = ::CORBA_AliasDef::_nil ();
+}
+
+ACE_INLINE
+CORBA_AliasDef_out::CORBA_AliasDef_out (const ::CORBA_AliasDef_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (CORBA_AliasDef_out &, p).ptr_)
+{}
+
+ACE_INLINE ::CORBA_AliasDef_out &
+CORBA_AliasDef_out::operator= (const ::CORBA_AliasDef_out &p)
+{
+  this->ptr_ = ACE_const_cast (CORBA_AliasDef_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE CORBA_AliasDef_out &
+CORBA_AliasDef_out::operator= (const ::CORBA_AliasDef_var &p)
+{
+  this->ptr_ = ::CORBA_AliasDef::_duplicate (p.ptr ());
+  return *this;
+}
+
+ACE_INLINE CORBA_AliasDef_out &
+CORBA_AliasDef_out::operator= (CORBA_AliasDef_ptr p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+CORBA_AliasDef_out::operator ::CORBA_AliasDef_ptr &() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_AliasDef_ptr &
+CORBA_AliasDef_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_AliasDef_ptr
+CORBA_AliasDef_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_NATIVEDEF___CI_)
+#define _CORBA_NATIVEDEF___CI_
+
+ACE_INLINE
+CORBA_NativeDef::CORBA_NativeDef (
+    TAO_Stub *objref,
+    CORBA::Boolean _tao_collocated,
+    TAO_Abstract_ServantBase *servant
+  )
+  : CORBA_Object (objref, _tao_collocated, servant)
+{
+  this->CORBA_NativeDef_setup_collocation (_tao_collocated);
+}
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_NATIVEDEF___VAR_CI_)
+#define _CORBA_NATIVEDEF___VAR_CI_
+
+// *************************************************************
+// Inline operations for class CORBA_NativeDef_var
+// *************************************************************
+
+ACE_INLINE
+CORBA_NativeDef_var::CORBA_NativeDef_var (void) // default constructor
+  : ptr_ (CORBA_NativeDef::_nil ())
+{}
+
+ACE_INLINE ::CORBA_NativeDef_ptr
+CORBA_NativeDef_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+CORBA_NativeDef_var::CORBA_NativeDef_var (const ::CORBA_NativeDef_var &p) // copy constructor
+  : TAO_Base_var (),
+    ptr_ (CORBA_NativeDef::_duplicate (p.ptr ()))
+{}
+
+ACE_INLINE
+CORBA_NativeDef_var::~CORBA_NativeDef_var (void) // destructor
+{
+  CORBA::release (this->ptr_);
+}
+
+ACE_INLINE CORBA_NativeDef_var &
+CORBA_NativeDef_var::operator= (CORBA_NativeDef_ptr p)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE CORBA_NativeDef_var &
+CORBA_NativeDef_var::operator= (const ::CORBA_NativeDef_var &p)
+{
+  if (this != &p)
+  {
+    CORBA::release (this->ptr_);
+    this->ptr_ = ::CORBA_NativeDef::_duplicate (p.ptr ());
+  }
+  return *this;
+}
+
+ACE_INLINE 
+CORBA_NativeDef_var::operator const ::CORBA_NativeDef_ptr &() const // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+CORBA_NativeDef_var::operator ::CORBA_NativeDef_ptr &() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_NativeDef_ptr
+CORBA_NativeDef_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_NativeDef_ptr
+CORBA_NativeDef_var::in (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_NativeDef_ptr &
+CORBA_NativeDef_var::inout (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_NativeDef_ptr &
+CORBA_NativeDef_var::out (void)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = ::CORBA_NativeDef::_nil ();
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_NativeDef_ptr
+CORBA_NativeDef_var::_retn (void)
+{
+  // yield ownership of managed obj reference
+  ::CORBA_NativeDef_ptr val = this->ptr_;
+  this->ptr_ = ::CORBA_NativeDef::_nil ();
+  return val;
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_NATIVEDEF___OUT_CI_)
+#define _CORBA_NATIVEDEF___OUT_CI_
+
+// *************************************************************
+// Inline operations for class CORBA_NativeDef_out
+// *************************************************************
+
+ACE_INLINE
+CORBA_NativeDef_out::CORBA_NativeDef_out (CORBA_NativeDef_ptr &p)
+  : ptr_ (p)
+{
+  this->ptr_ = ::CORBA_NativeDef::_nil ();
+}
+
+ACE_INLINE
+CORBA_NativeDef_out::CORBA_NativeDef_out (CORBA_NativeDef_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = ::CORBA_NativeDef::_nil ();
+}
+
+ACE_INLINE
+CORBA_NativeDef_out::CORBA_NativeDef_out (const ::CORBA_NativeDef_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (CORBA_NativeDef_out &, p).ptr_)
+{}
+
+ACE_INLINE ::CORBA_NativeDef_out &
+CORBA_NativeDef_out::operator= (const ::CORBA_NativeDef_out &p)
+{
+  this->ptr_ = ACE_const_cast (CORBA_NativeDef_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE CORBA_NativeDef_out &
+CORBA_NativeDef_out::operator= (const ::CORBA_NativeDef_var &p)
+{
+  this->ptr_ = ::CORBA_NativeDef::_duplicate (p.ptr ());
+  return *this;
+}
+
+ACE_INLINE CORBA_NativeDef_out &
+CORBA_NativeDef_out::operator= (CORBA_NativeDef_ptr p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+CORBA_NativeDef_out::operator ::CORBA_NativeDef_ptr &() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_NativeDef_ptr &
+CORBA_NativeDef_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_NativeDef_ptr
+CORBA_NativeDef_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_EXCEPTIONDEF___CI_)
+#define _CORBA_EXCEPTIONDEF___CI_
+
+ACE_INLINE
+CORBA_ExceptionDef::CORBA_ExceptionDef (
+    TAO_Stub *objref,
+    CORBA::Boolean _tao_collocated,
+    TAO_Abstract_ServantBase *servant
+  )
+  : CORBA_Object (objref, _tao_collocated, servant)
+{
+  this->CORBA_ExceptionDef_setup_collocation (_tao_collocated);
+}
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_EXCEPTIONDEF___VAR_CI_)
+#define _CORBA_EXCEPTIONDEF___VAR_CI_
+
+// *************************************************************
+// Inline operations for class CORBA_ExceptionDef_var
+// *************************************************************
+
+ACE_INLINE
+CORBA_ExceptionDef_var::CORBA_ExceptionDef_var (void) // default constructor
+  : ptr_ (CORBA_ExceptionDef::_nil ())
+{}
+
+ACE_INLINE ::CORBA_ExceptionDef_ptr
+CORBA_ExceptionDef_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+CORBA_ExceptionDef_var::CORBA_ExceptionDef_var (const ::CORBA_ExceptionDef_var &p) // copy constructor
+  : TAO_Base_var (),
+    ptr_ (CORBA_ExceptionDef::_duplicate (p.ptr ()))
+{}
+
+ACE_INLINE
+CORBA_ExceptionDef_var::~CORBA_ExceptionDef_var (void) // destructor
+{
+  CORBA::release (this->ptr_);
+}
+
+ACE_INLINE CORBA_ExceptionDef_var &
+CORBA_ExceptionDef_var::operator= (CORBA_ExceptionDef_ptr p)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE CORBA_ExceptionDef_var &
+CORBA_ExceptionDef_var::operator= (const ::CORBA_ExceptionDef_var &p)
+{
+  if (this != &p)
+  {
+    CORBA::release (this->ptr_);
+    this->ptr_ = ::CORBA_ExceptionDef::_duplicate (p.ptr ());
+  }
+  return *this;
+}
+
+ACE_INLINE 
+CORBA_ExceptionDef_var::operator const ::CORBA_ExceptionDef_ptr &() const // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+CORBA_ExceptionDef_var::operator ::CORBA_ExceptionDef_ptr &() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ExceptionDef_ptr
+CORBA_ExceptionDef_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ExceptionDef_ptr
+CORBA_ExceptionDef_var::in (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ExceptionDef_ptr &
+CORBA_ExceptionDef_var::inout (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ExceptionDef_ptr &
+CORBA_ExceptionDef_var::out (void)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = ::CORBA_ExceptionDef::_nil ();
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ExceptionDef_ptr
+CORBA_ExceptionDef_var::_retn (void)
+{
+  // yield ownership of managed obj reference
+  ::CORBA_ExceptionDef_ptr val = this->ptr_;
+  this->ptr_ = ::CORBA_ExceptionDef::_nil ();
+  return val;
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_EXCEPTIONDEF___OUT_CI_)
+#define _CORBA_EXCEPTIONDEF___OUT_CI_
+
+// *************************************************************
+// Inline operations for class CORBA_ExceptionDef_out
+// *************************************************************
+
+ACE_INLINE
+CORBA_ExceptionDef_out::CORBA_ExceptionDef_out (CORBA_ExceptionDef_ptr &p)
+  : ptr_ (p)
+{
+  this->ptr_ = ::CORBA_ExceptionDef::_nil ();
+}
+
+ACE_INLINE
+CORBA_ExceptionDef_out::CORBA_ExceptionDef_out (CORBA_ExceptionDef_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = ::CORBA_ExceptionDef::_nil ();
+}
+
+ACE_INLINE
+CORBA_ExceptionDef_out::CORBA_ExceptionDef_out (const ::CORBA_ExceptionDef_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (CORBA_ExceptionDef_out &, p).ptr_)
+{}
+
+ACE_INLINE ::CORBA_ExceptionDef_out &
+CORBA_ExceptionDef_out::operator= (const ::CORBA_ExceptionDef_out &p)
+{
+  this->ptr_ = ACE_const_cast (CORBA_ExceptionDef_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE CORBA_ExceptionDef_out &
+CORBA_ExceptionDef_out::operator= (const ::CORBA_ExceptionDef_var &p)
+{
+  this->ptr_ = ::CORBA_ExceptionDef::_duplicate (p.ptr ());
+  return *this;
+}
+
+ACE_INLINE CORBA_ExceptionDef_out &
+CORBA_ExceptionDef_out::operator= (CORBA_ExceptionDef_ptr p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+CORBA_ExceptionDef_out::operator ::CORBA_ExceptionDef_ptr &() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ExceptionDef_ptr &
+CORBA_ExceptionDef_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ExceptionDef_ptr
+CORBA_ExceptionDef_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+
+#endif /* end #if !defined */
+
+// *************************************************************
+// Inline operations for class CORBA_ExceptionDescription_var
+// *************************************************************
+
+ACE_INLINE
+CORBA_ExceptionDescription_var::CORBA_ExceptionDescription_var (void) // default constructor
+  : ptr_ (0)
+{}
+
+ACE_INLINE
+CORBA_ExceptionDescription_var::CORBA_ExceptionDescription_var (CORBA_ExceptionDescription *p)
+  : ptr_ (p)
+{}
+
+ACE_INLINE
+CORBA_ExceptionDescription_var::CORBA_ExceptionDescription_var (const ::CORBA_ExceptionDescription_var &p) // copy constructor
+{
+  if (p.ptr_)
+    ACE_NEW (this->ptr_, ::CORBA_ExceptionDescription (*p.ptr_));
+  else
+    this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA_ExceptionDescription_var::~CORBA_ExceptionDescription_var (void) // destructor
+{
+  delete this->ptr_;
+}
+
+ACE_INLINE CORBA_ExceptionDescription_var &
+CORBA_ExceptionDescription_var::operator= (CORBA_ExceptionDescription *p)
+{
+  delete this->ptr_;
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE ::CORBA_ExceptionDescription_var &
+CORBA_ExceptionDescription_var::operator= (const ::CORBA_ExceptionDescription_var &p)
+{
+  if (this != &p)
+    {
+      if (p.ptr_ == 0)
+        {
+          delete this->ptr_;
+          this->ptr_ = 0;
+        }
+      else
+        {
+          CORBA_ExceptionDescription *deep_copy =
+            new CORBA_ExceptionDescription (*p.ptr_);
+          
+          if (deep_copy != 0)
+            {
+              CORBA_ExceptionDescription *tmp = deep_copy;
+              deep_copy = this->ptr_;
+              this->ptr_ = tmp;
+              delete deep_copy;
+            }
+        }
+    }
+  
+  return *this;
+}
+
+ACE_INLINE const ::CORBA_ExceptionDescription *
+CORBA_ExceptionDescription_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ExceptionDescription *
+CORBA_ExceptionDescription_var::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+CORBA_ExceptionDescription_var::operator const ::CORBA_ExceptionDescription &() const // cast
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE
+CORBA_ExceptionDescription_var::operator ::CORBA_ExceptionDescription &() // cast 
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE
+CORBA_ExceptionDescription_var::operator ::CORBA_ExceptionDescription &() const // cast 
+{
+  return *this->ptr_;
+}
+
+// variable-size types only
+ACE_INLINE
+CORBA_ExceptionDescription_var::operator ::CORBA_ExceptionDescription *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE const ::CORBA_ExceptionDescription &
+CORBA_ExceptionDescription_var::in (void) const
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ExceptionDescription &
+CORBA_ExceptionDescription_var::inout (void)
+{
+  return *this->ptr_;
+}
+
+// mapping for variable size 
+ACE_INLINE ::CORBA_ExceptionDescription *&
+CORBA_ExceptionDescription_var::out (void)
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ExceptionDescription *
+CORBA_ExceptionDescription_var::_retn (void)
+{
+  ::CORBA_ExceptionDescription *tmp = this->ptr_;
+  this->ptr_ = 0;
+  return tmp;
+}
+
+ACE_INLINE ::CORBA_ExceptionDescription *
+CORBA_ExceptionDescription_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+// *************************************************************
+// Inline operations for class CORBA_ExceptionDescription_out
+// *************************************************************
+
+ACE_INLINE
+CORBA_ExceptionDescription_out::CORBA_ExceptionDescription_out (::CORBA_ExceptionDescription *&p)
+  : ptr_ (p)
+{
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA_ExceptionDescription_out::CORBA_ExceptionDescription_out (CORBA_ExceptionDescription_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA_ExceptionDescription_out::CORBA_ExceptionDescription_out (const ::CORBA_ExceptionDescription_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (CORBA_ExceptionDescription_out&, p).ptr_)
+{}
+
+ACE_INLINE CORBA_ExceptionDescription_out &
+CORBA_ExceptionDescription_out::operator= (const ::CORBA_ExceptionDescription_out &p)
+{
+  this->ptr_ = ACE_const_cast (CORBA_ExceptionDescription_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE CORBA_ExceptionDescription_out &
+CORBA_ExceptionDescription_out::operator= (CORBA_ExceptionDescription *p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+CORBA_ExceptionDescription_out::operator ::CORBA_ExceptionDescription *&() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ExceptionDescription *&
+CORBA_ExceptionDescription_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ExceptionDescription *
+CORBA_ExceptionDescription_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_EXCEPTIONDEFSEQ_CI_)
+#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_EXCEPTIONDEFSEQ_CI_
+
+  ACE_INLINE CORBA::ExceptionDef **
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::allocbuf (CORBA::ULong nelems)
+  {
+    CORBA::ExceptionDef **buf = 0;
+    
+    ACE_NEW_RETURN (buf, CORBA::ExceptionDef*[nelems], 0);
+    
+    for (CORBA::ULong i = 0; i < nelems; i++)
+      buf[i] = CORBA::ExceptionDef::_nil ();
+    
+    return buf;
+  }
+  
+  ACE_INLINE void 
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::freebuf (CORBA::ExceptionDef **buffer)
+  {
+    if (buffer == 0)
+      return;
+    delete[] buffer;
+  }
+  
+  ACE_INLINE
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq (void)
+  {
+  }
+  
+  ACE_INLINE
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq (CORBA::ULong maximum)
+    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::allocbuf (maximum))
+  {
+  }
+  
+  ACE_INLINE
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq (CORBA::ULong maximum,
+    CORBA::ULong length,
+    CORBA::ExceptionDef* *value,
+    CORBA::Boolean release)
+  : TAO_Unbounded_Base_Sequence (maximum, length, value, release)
+  {
+  }
+  
+  ACE_INLINE
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq(const _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq &rhs)
+    : TAO_Unbounded_Base_Sequence (rhs)
+  {
+    if (rhs.buffer_ != 0)
+    {
+      CORBA::ExceptionDef **tmp1 = _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::allocbuf (this->maximum_);
+      CORBA::ExceptionDef ** const tmp2 = ACE_reinterpret_cast (CORBA::ExceptionDef ** ACE_CAST_CONST, rhs.buffer_);
+      
+      for (CORBA::ULong i = 0; i < rhs.length_; ++i)
+        tmp1[i] = CORBA::ExceptionDef::_duplicate (tmp2[i]);
+      
+      this->buffer_ = tmp1;
+    }
+    else
+    {
+      this->buffer_ = 0;
+    }
+  }
+  
+  ACE_INLINE CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq &
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::operator= (const _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq &rhs)
+  {
+    if (this == &rhs)
+      return *this;
+    
+    if (this->release_)
+    {
+      CORBA::ExceptionDef **tmp = ACE_reinterpret_cast (CORBA::ExceptionDef **, this->buffer_);
+      
+      for (CORBA::ULong i = 0; i < this->length_; ++i)
+      {
+        CORBA::release (tmp[i]);
+        tmp[i] = CORBA::ExceptionDef::_nil ();
+      }
+      if (this->maximum_ < rhs.maximum_)
+      {
+        _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::freebuf (tmp);
+        this->buffer_ = _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::allocbuf (rhs.maximum_);
+      }
+    }
+    else
+      this->buffer_ = _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::allocbuf (rhs.maximum_);
+    
+    TAO_Unbounded_Base_Sequence::operator= (rhs);
+    
+    CORBA::ExceptionDef **tmp1 = ACE_reinterpret_cast (CORBA::ExceptionDef **, this->buffer_);
+    CORBA::ExceptionDef ** const tmp2 = ACE_reinterpret_cast (CORBA::ExceptionDef ** ACE_CAST_CONST, rhs.buffer_);
+    
+    for (CORBA::ULong i = 0; i < rhs.length_; ++i)
+      tmp1[i] = CORBA::ExceptionDef::_duplicate (tmp2[i]);
+    
+    return *this;
+  }
+  
+  ACE_INLINE TAO_Object_Manager<CORBA::ExceptionDef,CORBA::ExceptionDef_var>
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::operator[] (CORBA::ULong index) const
+  // read-write accessor
+  {
+    ACE_ASSERT (index < this->maximum_);
+    CORBA::ExceptionDef ** const tmp = ACE_reinterpret_cast (CORBA::ExceptionDef ** ACE_CAST_CONST, this->buffer_);
+    return TAO_Object_Manager<CORBA::ExceptionDef,CORBA::ExceptionDef_var> (tmp + index, this->release_);
+  }
+  
+  ACE_INLINE CORBA::ExceptionDef* *
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::get_buffer (CORBA::Boolean orphan)
+  {
+    CORBA::ExceptionDef **result = 0;
+    if (orphan == 0)
+    {
+      // We retain ownership.
+      if (this->buffer_ == 0)
+      {
+        result = _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::allocbuf (this->maximum_);
+        this->buffer_ = result;
+        this->release_ = 1;
+      }
+      else
+      {
+        result = ACE_reinterpret_cast (CORBA::ExceptionDef**, this->buffer_);
+      }
+    }
+    else // if (orphan == 1)
+    {
+      if (this->release_ != 0)
+      {
+        // We set the state back to default and relinquish
+        // ownership.
+        result = ACE_reinterpret_cast(CORBA::ExceptionDef**,this->buffer_);
+        this->maximum_ = 0;
+        this->length_ = 0;
+        this->buffer_ = 0;
+        this->release_ = 0;
+      }
+    }
+    return result;
+  }
+  
+  ACE_INLINE const CORBA::ExceptionDef* *
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::get_buffer (void) const
+  {
+    return ACE_reinterpret_cast(const CORBA::ExceptionDef ** ACE_CAST_CONST, this->buffer_);
+  }
+  
+  
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_CORBA_EXCEPTIONDEFSEQ_CI_)
+#define _CORBA_EXCEPTIONDEFSEQ_CI_
+
+// *************************************************************
+// Inline operations for class CORBA_ExceptionDefSeq_var
+// *************************************************************
+
+ACE_INLINE
+CORBA_ExceptionDefSeq_var::CORBA_ExceptionDefSeq_var (void) // default constructor
+  : ptr_ (0)
+{}
+
+ACE_INLINE
+CORBA_ExceptionDefSeq_var::CORBA_ExceptionDefSeq_var (CORBA_ExceptionDefSeq *p)
+  : ptr_ (p)
+{}
+
+ACE_INLINE
+CORBA_ExceptionDefSeq_var::CORBA_ExceptionDefSeq_var (const ::CORBA_ExceptionDefSeq_var &p) // copy constructor
+{
+  if (p.ptr_)
+    ACE_NEW (this->ptr_, ::CORBA_ExceptionDefSeq (*p.ptr_));
+  else
+    this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA_ExceptionDefSeq_var::~CORBA_ExceptionDefSeq_var (void) // destructor
+{
+  delete this->ptr_;
+}
+
+ACE_INLINE CORBA_ExceptionDefSeq_var &
+CORBA_ExceptionDefSeq_var::operator= (CORBA_ExceptionDefSeq *p)
+{
+  delete this->ptr_;
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE ::CORBA_ExceptionDefSeq_var &
+CORBA_ExceptionDefSeq_var::operator= (const ::CORBA_ExceptionDefSeq_var &p)
+{
+  if (this != &p)
+    {
+      if (p.ptr_ == 0)
+        {
+          delete this->ptr_;
+          this->ptr_ = 0;
+        }
+      else
+        {
+          CORBA_ExceptionDefSeq *deep_copy =
+            new CORBA_ExceptionDefSeq (*p.ptr_);
+          
+          if (deep_copy != 0)
+            {
+              CORBA_ExceptionDefSeq *tmp = deep_copy;
+              deep_copy = this->ptr_;
+              this->ptr_ = tmp;
+              delete deep_copy;
+            }
+        }
+    }
+  
+  return *this;
+}
+
+ACE_INLINE const ::CORBA_ExceptionDefSeq *
+CORBA_ExceptionDefSeq_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ExceptionDefSeq *
+CORBA_ExceptionDefSeq_var::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+CORBA_ExceptionDefSeq_var::operator const ::CORBA_ExceptionDefSeq &() const // cast
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE 
+CORBA_ExceptionDefSeq_var::operator ::CORBA_ExceptionDefSeq &() // cast 
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE 
+CORBA_ExceptionDefSeq_var::operator ::CORBA_ExceptionDefSeq &() const // cast 
+{
+  return *this->ptr_;
+}
+
+// variable-size types only
+ACE_INLINE
+CORBA_ExceptionDefSeq_var::operator ::CORBA_ExceptionDefSeq *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE TAO_Object_Manager<CORBA::ExceptionDef, CORBA::ExceptionDef_var>
+CORBA_ExceptionDefSeq_var::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+ACE_INLINE const ::CORBA_ExceptionDefSeq &
+CORBA_ExceptionDefSeq_var::in (void) const
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ExceptionDefSeq &
+CORBA_ExceptionDefSeq_var::inout (void)
+{
+  return *this->ptr_;
+}
+
+// mapping for variable size 
+ACE_INLINE ::CORBA_ExceptionDefSeq *&
+CORBA_ExceptionDefSeq_var::out (void)
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ExceptionDefSeq *
+CORBA_ExceptionDefSeq_var::_retn (void)
+{
+  ::CORBA_ExceptionDefSeq *tmp = this->ptr_;
+  this->ptr_ = 0;
+  return tmp;
+}
+
+ACE_INLINE ::CORBA_ExceptionDefSeq *
+CORBA_ExceptionDefSeq_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+// *************************************************************
+// Inline operations for class CORBA_ExceptionDefSeq_out
+// *************************************************************
+
+ACE_INLINE
+CORBA_ExceptionDefSeq_out::CORBA_ExceptionDefSeq_out (CORBA_ExceptionDefSeq *&p)
+  : ptr_ (p)
+{
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA_ExceptionDefSeq_out::CORBA_ExceptionDefSeq_out (CORBA_ExceptionDefSeq_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA_ExceptionDefSeq_out::CORBA_ExceptionDefSeq_out (const ::CORBA_ExceptionDefSeq_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (CORBA_ExceptionDefSeq_out&, p).ptr_)
+{}
+
+ACE_INLINE ::CORBA_ExceptionDefSeq_out &
+CORBA_ExceptionDefSeq_out::operator= (const ::CORBA_ExceptionDefSeq_out &p)
+{
+  this->ptr_ = ACE_const_cast (CORBA_ExceptionDefSeq_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE ::CORBA_ExceptionDefSeq_out &
+CORBA_ExceptionDefSeq_out::operator= (CORBA_ExceptionDefSeq *p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+CORBA_ExceptionDefSeq_out::operator ::CORBA_ExceptionDefSeq *&() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ExceptionDefSeq *&
+CORBA_ExceptionDefSeq_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ExceptionDefSeq *
+CORBA_ExceptionDefSeq_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE TAO_Object_Manager<CORBA::ExceptionDef, CORBA::ExceptionDef_var>
+CORBA_ExceptionDefSeq_out::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_SEQUENCE_CORBA_EXCDESCRIPTIONSEQ_CI_)
+#define __TAO_UNBOUNDED_SEQUENCE_CORBA_EXCDESCRIPTIONSEQ_CI_
+
+  // = Static operations.
+  ACE_INLINE CORBA::ExceptionDescription *
+  CORBA::_TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::allocbuf (CORBA::ULong size)
+  // Allocate storage for the sequence.
+  {
+    CORBA::ExceptionDescription *retval = 0;
+    ACE_NEW_RETURN (retval, CORBA::ExceptionDescription[size], 0);
+    return retval;
+  }
+  
+  ACE_INLINE void CORBA::_TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::freebuf (CORBA::ExceptionDescription *buffer)
+  // Free the sequence.
+  {
+    delete [] buffer;
+  }
+  
+  ACE_INLINE
+  CORBA::_TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq (void) // Default constructor.
+  {
+  }
+  
+  ACE_INLINE
+  CORBA::_TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq (CORBA::ULong maximum) // Constructor using a maximum length value.
+    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::allocbuf (maximum))
+  {
+  }
+  
+  ACE_INLINE
+  CORBA::_TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq (CORBA::ULong maximum,
+    CORBA::ULong length,
+    CORBA::ExceptionDescription *data,
+    CORBA::Boolean release)
+  : TAO_Unbounded_Base_Sequence (maximum, length, data, release)
+  {
+  }
+  
+  ACE_INLINE
+  CORBA::_TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq (const _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq &rhs)
+  // Copy constructor.
+    : TAO_Unbounded_Base_Sequence (rhs)
+  {
+    if (rhs.buffer_ != 0)
+    {
+      CORBA::ExceptionDescription *tmp1 = _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::allocbuf (this->maximum_);
+      CORBA::ExceptionDescription * const tmp2 = ACE_reinterpret_cast (CORBA::ExceptionDescription * ACE_CAST_CONST, rhs.buffer_);
+      
+      for (CORBA::ULong i = 0; i < this->length_; ++i)
+        tmp1[i] = tmp2[i];
+      
+      this->buffer_ = tmp1;
+    }
+    else
+    {
+      this->buffer_ = 0;
+    }
+  }
+  
+  ACE_INLINE CORBA::_TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq &
+  CORBA::_TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::operator= (const _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq &rhs)
+  // Assignment operator.
+  {
+    if (this == &rhs)
+      return *this;
+    
+    if (this->release_)
+    {
+      if (this->maximum_ < rhs.maximum_)
+      {
+        // free the old buffer
+        CORBA::ExceptionDescription *tmp = ACE_reinterpret_cast (CORBA::ExceptionDescription *, this->buffer_);
+        _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::freebuf (tmp);
+        this->buffer_ = _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::allocbuf (rhs.maximum_);
+      }
+    }
+    else
+      this->buffer_ = _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::allocbuf (rhs.maximum_);
+    
+    TAO_Unbounded_Base_Sequence::operator= (rhs);
+    
+    CORBA::ExceptionDescription *tmp1 = ACE_reinterpret_cast (CORBA::ExceptionDescription *, this->buffer_);
+    CORBA::ExceptionDescription * const tmp2 = ACE_reinterpret_cast (CORBA::ExceptionDescription * ACE_CAST_CONST, rhs.buffer_);
+    
+    for (CORBA::ULong i = 0; i < this->length_; ++i)
+      tmp1[i] = tmp2[i];
+    
+    return *this;
+  }
+  
+  // = Accessors.
+  ACE_INLINE CORBA::ExceptionDescription &
+  CORBA::_TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::operator[] (CORBA::ULong i)
+  // operator []
+  {
+    ACE_ASSERT (i < this->maximum_);
+    CORBA::ExceptionDescription* tmp = ACE_reinterpret_cast(CORBA::ExceptionDescription*,this->buffer_);
+    return tmp[i];
+  }
+  
+  ACE_INLINE const CORBA::ExceptionDescription &
+  CORBA::_TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::operator[] (CORBA::ULong i) const
+  // operator []
+  {
+    ACE_ASSERT (i < this->maximum_);
+    CORBA::ExceptionDescription * const tmp = ACE_reinterpret_cast (CORBA::ExceptionDescription* ACE_CAST_CONST, this->buffer_);
+    return tmp[i];
+  }
+  
+  // Implement the TAO_Base_Sequence methods (see Sequence.h)
+  
+  ACE_INLINE CORBA::ExceptionDescription *
+  CORBA::_TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::get_buffer (CORBA::Boolean orphan)
+  {
+    CORBA::ExceptionDescription *result = 0;
+    if (orphan == 0)
+    {
+      // We retain ownership.
+      if (this->buffer_ == 0)
+      {
+        result = _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::allocbuf (this->length_);
+        this->buffer_ = result;
+        this->release_ = 1;
+      }
+      else
+      {
+        result = ACE_reinterpret_cast (CORBA::ExceptionDescription*, this->buffer_);
+      }
+    }
+    else // if (orphan == 1)
+    {
+      if (this->release_ != 0)
+      {
+        // We set the state back to default and relinquish
+        // ownership.
+        result = ACE_reinterpret_cast(CORBA::ExceptionDescription*,this->buffer_);
+        this->maximum_ = 0;
+        this->length_ = 0;
+        this->buffer_ = 0;
+        this->release_ = 0;
+      }
+    }
+    return result;
+  }
+  
+  ACE_INLINE const CORBA::ExceptionDescription *
+  CORBA::_TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::get_buffer (void) const
+  {
+    return ACE_reinterpret_cast(const CORBA::ExceptionDescription * ACE_CAST_CONST, this->buffer_);
+  }
+  
+  ACE_INLINE void
+  CORBA::_TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::replace (CORBA::ULong max,
+  CORBA::ULong length,
+  CORBA::ExceptionDescription *data,
+  CORBA::Boolean release)
+  {
+    this->maximum_ = max;
+    this->length_ = length;
+    if (this->buffer_ && this->release_ == 1)
+    {
+      CORBA::ExceptionDescription *tmp = ACE_reinterpret_cast(CORBA::ExceptionDescription*,this->buffer_);
+      _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::freebuf (tmp);
+    }
+    this->buffer_ = data;
+    this->release_ = release;
+  }
+  
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_CORBA_EXCDESCRIPTIONSEQ_CI_)
+#define _CORBA_EXCDESCRIPTIONSEQ_CI_
+
+// *************************************************************
+// Inline operations for class CORBA_ExcDescriptionSeq_var
+// *************************************************************
+
+ACE_INLINE
+CORBA_ExcDescriptionSeq_var::CORBA_ExcDescriptionSeq_var (void) // default constructor
+  : ptr_ (0)
+{}
+
+ACE_INLINE
+CORBA_ExcDescriptionSeq_var::CORBA_ExcDescriptionSeq_var (CORBA_ExcDescriptionSeq *p)
+  : ptr_ (p)
+{}
+
+ACE_INLINE
+CORBA_ExcDescriptionSeq_var::CORBA_ExcDescriptionSeq_var (const ::CORBA_ExcDescriptionSeq_var &p) // copy constructor
+{
+  if (p.ptr_)
+    ACE_NEW (this->ptr_, ::CORBA_ExcDescriptionSeq (*p.ptr_));
+  else
+    this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA_ExcDescriptionSeq_var::~CORBA_ExcDescriptionSeq_var (void) // destructor
+{
+  delete this->ptr_;
+}
+
+ACE_INLINE CORBA_ExcDescriptionSeq_var &
+CORBA_ExcDescriptionSeq_var::operator= (CORBA_ExcDescriptionSeq *p)
+{
+  delete this->ptr_;
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE ::CORBA_ExcDescriptionSeq_var &
+CORBA_ExcDescriptionSeq_var::operator= (const ::CORBA_ExcDescriptionSeq_var &p)
+{
+  if (this != &p)
+    {
+      if (p.ptr_ == 0)
+        {
+          delete this->ptr_;
+          this->ptr_ = 0;
+        }
+      else
+        {
+          CORBA_ExcDescriptionSeq *deep_copy =
+            new CORBA_ExcDescriptionSeq (*p.ptr_);
+          
+          if (deep_copy != 0)
+            {
+              CORBA_ExcDescriptionSeq *tmp = deep_copy;
+              deep_copy = this->ptr_;
+              this->ptr_ = tmp;
+              delete deep_copy;
+            }
+        }
+    }
+  
+  return *this;
+}
+
+ACE_INLINE const ::CORBA_ExcDescriptionSeq *
+CORBA_ExcDescriptionSeq_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ExcDescriptionSeq *
+CORBA_ExcDescriptionSeq_var::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+CORBA_ExcDescriptionSeq_var::operator const ::CORBA_ExcDescriptionSeq &() const // cast
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE 
+CORBA_ExcDescriptionSeq_var::operator ::CORBA_ExcDescriptionSeq &() // cast 
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE 
+CORBA_ExcDescriptionSeq_var::operator ::CORBA_ExcDescriptionSeq &() const // cast 
+{
+  return *this->ptr_;
+}
+
+// variable-size types only
+ACE_INLINE
+CORBA_ExcDescriptionSeq_var::operator ::CORBA_ExcDescriptionSeq *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE CORBA::ExceptionDescription &
+CORBA_ExcDescriptionSeq_var::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+ACE_INLINE const CORBA::ExceptionDescription &
+CORBA_ExcDescriptionSeq_var::operator[] (CORBA::ULong index) const
+{
+  return ACE_const_cast (const CORBA::ExceptionDescription &, this->ptr_->operator[] (index));
+}
+
+ACE_INLINE const ::CORBA_ExcDescriptionSeq &
+CORBA_ExcDescriptionSeq_var::in (void) const
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ExcDescriptionSeq &
+CORBA_ExcDescriptionSeq_var::inout (void)
+{
+  return *this->ptr_;
+}
+
+// mapping for variable size 
+ACE_INLINE ::CORBA_ExcDescriptionSeq *&
+CORBA_ExcDescriptionSeq_var::out (void)
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ExcDescriptionSeq *
+CORBA_ExcDescriptionSeq_var::_retn (void)
+{
+  ::CORBA_ExcDescriptionSeq *tmp = this->ptr_;
+  this->ptr_ = 0;
+  return tmp;
+}
+
+ACE_INLINE ::CORBA_ExcDescriptionSeq *
+CORBA_ExcDescriptionSeq_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+// *************************************************************
+// Inline operations for class CORBA_ExcDescriptionSeq_out
+// *************************************************************
+
+ACE_INLINE
+CORBA_ExcDescriptionSeq_out::CORBA_ExcDescriptionSeq_out (CORBA_ExcDescriptionSeq *&p)
+  : ptr_ (p)
+{
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA_ExcDescriptionSeq_out::CORBA_ExcDescriptionSeq_out (CORBA_ExcDescriptionSeq_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA_ExcDescriptionSeq_out::CORBA_ExcDescriptionSeq_out (const ::CORBA_ExcDescriptionSeq_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (CORBA_ExcDescriptionSeq_out&, p).ptr_)
+{}
+
+ACE_INLINE ::CORBA_ExcDescriptionSeq_out &
+CORBA_ExcDescriptionSeq_out::operator= (const ::CORBA_ExcDescriptionSeq_out &p)
+{
+  this->ptr_ = ACE_const_cast (CORBA_ExcDescriptionSeq_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE ::CORBA_ExcDescriptionSeq_out &
+CORBA_ExcDescriptionSeq_out::operator= (CORBA_ExcDescriptionSeq *p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+CORBA_ExcDescriptionSeq_out::operator ::CORBA_ExcDescriptionSeq *&() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ExcDescriptionSeq *&
+CORBA_ExcDescriptionSeq_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ExcDescriptionSeq *
+CORBA_ExcDescriptionSeq_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE CORBA::ExceptionDescription &
+CORBA_ExcDescriptionSeq_out::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_ATTRIBUTEDEF___CI_)
+#define _CORBA_ATTRIBUTEDEF___CI_
+
+ACE_INLINE
+CORBA_AttributeDef::CORBA_AttributeDef (
+    TAO_Stub *objref,
+    CORBA::Boolean _tao_collocated,
+    TAO_Abstract_ServantBase *servant
+  )
+  : CORBA_Object (objref, _tao_collocated, servant)
+{
+  this->CORBA_AttributeDef_setup_collocation (_tao_collocated);
+}
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_ATTRIBUTEDEF___VAR_CI_)
+#define _CORBA_ATTRIBUTEDEF___VAR_CI_
+
+// *************************************************************
+// Inline operations for class CORBA_AttributeDef_var
+// *************************************************************
+
+ACE_INLINE
+CORBA_AttributeDef_var::CORBA_AttributeDef_var (void) // default constructor
+  : ptr_ (CORBA_AttributeDef::_nil ())
+{}
+
+ACE_INLINE ::CORBA_AttributeDef_ptr
+CORBA_AttributeDef_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+CORBA_AttributeDef_var::CORBA_AttributeDef_var (const ::CORBA_AttributeDef_var &p) // copy constructor
+  : TAO_Base_var (),
+    ptr_ (CORBA_AttributeDef::_duplicate (p.ptr ()))
+{}
+
+ACE_INLINE
+CORBA_AttributeDef_var::~CORBA_AttributeDef_var (void) // destructor
+{
+  CORBA::release (this->ptr_);
+}
+
+ACE_INLINE CORBA_AttributeDef_var &
+CORBA_AttributeDef_var::operator= (CORBA_AttributeDef_ptr p)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE CORBA_AttributeDef_var &
+CORBA_AttributeDef_var::operator= (const ::CORBA_AttributeDef_var &p)
+{
+  if (this != &p)
+  {
+    CORBA::release (this->ptr_);
+    this->ptr_ = ::CORBA_AttributeDef::_duplicate (p.ptr ());
+  }
+  return *this;
+}
+
+ACE_INLINE 
+CORBA_AttributeDef_var::operator const ::CORBA_AttributeDef_ptr &() const // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+CORBA_AttributeDef_var::operator ::CORBA_AttributeDef_ptr &() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_AttributeDef_ptr
+CORBA_AttributeDef_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_AttributeDef_ptr
+CORBA_AttributeDef_var::in (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_AttributeDef_ptr &
+CORBA_AttributeDef_var::inout (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_AttributeDef_ptr &
+CORBA_AttributeDef_var::out (void)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = ::CORBA_AttributeDef::_nil ();
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_AttributeDef_ptr
+CORBA_AttributeDef_var::_retn (void)
+{
+  // yield ownership of managed obj reference
+  ::CORBA_AttributeDef_ptr val = this->ptr_;
+  this->ptr_ = ::CORBA_AttributeDef::_nil ();
+  return val;
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_ATTRIBUTEDEF___OUT_CI_)
+#define _CORBA_ATTRIBUTEDEF___OUT_CI_
+
+// *************************************************************
+// Inline operations for class CORBA_AttributeDef_out
+// *************************************************************
+
+ACE_INLINE
+CORBA_AttributeDef_out::CORBA_AttributeDef_out (CORBA_AttributeDef_ptr &p)
+  : ptr_ (p)
+{
+  this->ptr_ = ::CORBA_AttributeDef::_nil ();
+}
+
+ACE_INLINE
+CORBA_AttributeDef_out::CORBA_AttributeDef_out (CORBA_AttributeDef_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = ::CORBA_AttributeDef::_nil ();
+}
+
+ACE_INLINE
+CORBA_AttributeDef_out::CORBA_AttributeDef_out (const ::CORBA_AttributeDef_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (CORBA_AttributeDef_out &, p).ptr_)
+{}
+
+ACE_INLINE ::CORBA_AttributeDef_out &
+CORBA_AttributeDef_out::operator= (const ::CORBA_AttributeDef_out &p)
+{
+  this->ptr_ = ACE_const_cast (CORBA_AttributeDef_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE CORBA_AttributeDef_out &
+CORBA_AttributeDef_out::operator= (const ::CORBA_AttributeDef_var &p)
+{
+  this->ptr_ = ::CORBA_AttributeDef::_duplicate (p.ptr ());
+  return *this;
+}
+
+ACE_INLINE CORBA_AttributeDef_out &
+CORBA_AttributeDef_out::operator= (CORBA_AttributeDef_ptr p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+CORBA_AttributeDef_out::operator ::CORBA_AttributeDef_ptr &() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_AttributeDef_ptr &
+CORBA_AttributeDef_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_AttributeDef_ptr
+CORBA_AttributeDef_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+
+#endif /* end #if !defined */
+
+// *************************************************************
+// Inline operations for class CORBA_AttributeDescription_var
+// *************************************************************
+
+ACE_INLINE
+CORBA_AttributeDescription_var::CORBA_AttributeDescription_var (void) // default constructor
+  : ptr_ (0)
+{}
+
+ACE_INLINE
+CORBA_AttributeDescription_var::CORBA_AttributeDescription_var (CORBA_AttributeDescription *p)
+  : ptr_ (p)
+{}
+
+ACE_INLINE
+CORBA_AttributeDescription_var::CORBA_AttributeDescription_var (const ::CORBA_AttributeDescription_var &p) // copy constructor
+{
+  if (p.ptr_)
+    ACE_NEW (this->ptr_, ::CORBA_AttributeDescription (*p.ptr_));
+  else
+    this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA_AttributeDescription_var::~CORBA_AttributeDescription_var (void) // destructor
+{
+  delete this->ptr_;
+}
+
+ACE_INLINE CORBA_AttributeDescription_var &
+CORBA_AttributeDescription_var::operator= (CORBA_AttributeDescription *p)
+{
+  delete this->ptr_;
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE ::CORBA_AttributeDescription_var &
+CORBA_AttributeDescription_var::operator= (const ::CORBA_AttributeDescription_var &p)
+{
+  if (this != &p)
+    {
+      if (p.ptr_ == 0)
+        {
+          delete this->ptr_;
+          this->ptr_ = 0;
+        }
+      else
+        {
+          CORBA_AttributeDescription *deep_copy =
+            new CORBA_AttributeDescription (*p.ptr_);
+          
+          if (deep_copy != 0)
+            {
+              CORBA_AttributeDescription *tmp = deep_copy;
+              deep_copy = this->ptr_;
+              this->ptr_ = tmp;
+              delete deep_copy;
+            }
+        }
+    }
+  
+  return *this;
+}
+
+ACE_INLINE const ::CORBA_AttributeDescription *
+CORBA_AttributeDescription_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_AttributeDescription *
+CORBA_AttributeDescription_var::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+CORBA_AttributeDescription_var::operator const ::CORBA_AttributeDescription &() const // cast
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE
+CORBA_AttributeDescription_var::operator ::CORBA_AttributeDescription &() // cast 
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE
+CORBA_AttributeDescription_var::operator ::CORBA_AttributeDescription &() const // cast 
+{
+  return *this->ptr_;
+}
+
+// variable-size types only
+ACE_INLINE
+CORBA_AttributeDescription_var::operator ::CORBA_AttributeDescription *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE const ::CORBA_AttributeDescription &
+CORBA_AttributeDescription_var::in (void) const
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE ::CORBA_AttributeDescription &
+CORBA_AttributeDescription_var::inout (void)
+{
+  return *this->ptr_;
+}
+
+// mapping for variable size 
+ACE_INLINE ::CORBA_AttributeDescription *&
+CORBA_AttributeDescription_var::out (void)
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_AttributeDescription *
+CORBA_AttributeDescription_var::_retn (void)
+{
+  ::CORBA_AttributeDescription *tmp = this->ptr_;
+  this->ptr_ = 0;
+  return tmp;
+}
+
+ACE_INLINE ::CORBA_AttributeDescription *
+CORBA_AttributeDescription_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+// *************************************************************
+// Inline operations for class CORBA_AttributeDescription_out
+// *************************************************************
+
+ACE_INLINE
+CORBA_AttributeDescription_out::CORBA_AttributeDescription_out (::CORBA_AttributeDescription *&p)
+  : ptr_ (p)
+{
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA_AttributeDescription_out::CORBA_AttributeDescription_out (CORBA_AttributeDescription_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA_AttributeDescription_out::CORBA_AttributeDescription_out (const ::CORBA_AttributeDescription_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (CORBA_AttributeDescription_out&, p).ptr_)
+{}
+
+ACE_INLINE CORBA_AttributeDescription_out &
+CORBA_AttributeDescription_out::operator= (const ::CORBA_AttributeDescription_out &p)
+{
+  this->ptr_ = ACE_const_cast (CORBA_AttributeDescription_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE CORBA_AttributeDescription_out &
+CORBA_AttributeDescription_out::operator= (CORBA_AttributeDescription *p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+CORBA_AttributeDescription_out::operator ::CORBA_AttributeDescription *&() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_AttributeDescription *&
+CORBA_AttributeDescription_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_AttributeDescription *
+CORBA_AttributeDescription_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+// *************************************************************
+// Inline operations for class CORBA_ParameterDescription_var
+// *************************************************************
+
+ACE_INLINE
+CORBA_ParameterDescription_var::CORBA_ParameterDescription_var (void) // default constructor
+  : ptr_ (0)
+{}
+
+ACE_INLINE
+CORBA_ParameterDescription_var::CORBA_ParameterDescription_var (CORBA_ParameterDescription *p)
+  : ptr_ (p)
+{}
+
+ACE_INLINE
+CORBA_ParameterDescription_var::CORBA_ParameterDescription_var (const ::CORBA_ParameterDescription_var &p) // copy constructor
+{
+  if (p.ptr_)
+    ACE_NEW (this->ptr_, ::CORBA_ParameterDescription (*p.ptr_));
+  else
+    this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA_ParameterDescription_var::~CORBA_ParameterDescription_var (void) // destructor
+{
+  delete this->ptr_;
+}
+
+ACE_INLINE CORBA_ParameterDescription_var &
+CORBA_ParameterDescription_var::operator= (CORBA_ParameterDescription *p)
+{
+  delete this->ptr_;
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE ::CORBA_ParameterDescription_var &
+CORBA_ParameterDescription_var::operator= (const ::CORBA_ParameterDescription_var &p)
+{
+  if (this != &p)
+    {
+      if (p.ptr_ == 0)
+        {
+          delete this->ptr_;
+          this->ptr_ = 0;
+        }
+      else
+        {
+          CORBA_ParameterDescription *deep_copy =
+            new CORBA_ParameterDescription (*p.ptr_);
+          
+          if (deep_copy != 0)
+            {
+              CORBA_ParameterDescription *tmp = deep_copy;
+              deep_copy = this->ptr_;
+              this->ptr_ = tmp;
+              delete deep_copy;
+            }
+        }
+    }
+  
+  return *this;
+}
+
+ACE_INLINE const ::CORBA_ParameterDescription *
+CORBA_ParameterDescription_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ParameterDescription *
+CORBA_ParameterDescription_var::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+CORBA_ParameterDescription_var::operator const ::CORBA_ParameterDescription &() const // cast
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE
+CORBA_ParameterDescription_var::operator ::CORBA_ParameterDescription &() // cast 
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE
+CORBA_ParameterDescription_var::operator ::CORBA_ParameterDescription &() const // cast 
+{
+  return *this->ptr_;
+}
+
+// variable-size types only
+ACE_INLINE
+CORBA_ParameterDescription_var::operator ::CORBA_ParameterDescription *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE const ::CORBA_ParameterDescription &
+CORBA_ParameterDescription_var::in (void) const
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ParameterDescription &
+CORBA_ParameterDescription_var::inout (void)
+{
+  return *this->ptr_;
+}
+
+// mapping for variable size 
+ACE_INLINE ::CORBA_ParameterDescription *&
+CORBA_ParameterDescription_var::out (void)
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ParameterDescription *
+CORBA_ParameterDescription_var::_retn (void)
+{
+  ::CORBA_ParameterDescription *tmp = this->ptr_;
+  this->ptr_ = 0;
+  return tmp;
+}
+
+ACE_INLINE ::CORBA_ParameterDescription *
+CORBA_ParameterDescription_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+// *************************************************************
+// Inline operations for class CORBA_ParameterDescription_out
+// *************************************************************
+
+ACE_INLINE
+CORBA_ParameterDescription_out::CORBA_ParameterDescription_out (::CORBA_ParameterDescription *&p)
+  : ptr_ (p)
+{
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA_ParameterDescription_out::CORBA_ParameterDescription_out (CORBA_ParameterDescription_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA_ParameterDescription_out::CORBA_ParameterDescription_out (const ::CORBA_ParameterDescription_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (CORBA_ParameterDescription_out&, p).ptr_)
+{}
+
+ACE_INLINE CORBA_ParameterDescription_out &
+CORBA_ParameterDescription_out::operator= (const ::CORBA_ParameterDescription_out &p)
+{
+  this->ptr_ = ACE_const_cast (CORBA_ParameterDescription_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE CORBA_ParameterDescription_out &
+CORBA_ParameterDescription_out::operator= (CORBA_ParameterDescription *p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+CORBA_ParameterDescription_out::operator ::CORBA_ParameterDescription *&() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ParameterDescription *&
+CORBA_ParameterDescription_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ParameterDescription *
+CORBA_ParameterDescription_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_SEQUENCE_CORBA_PARDESCRIPTIONSEQ_CI_)
+#define __TAO_UNBOUNDED_SEQUENCE_CORBA_PARDESCRIPTIONSEQ_CI_
+
+  // = Static operations.
+  ACE_INLINE CORBA::ParameterDescription *
+  CORBA::_TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::allocbuf (CORBA::ULong size)
+  // Allocate storage for the sequence.
+  {
+    CORBA::ParameterDescription *retval = 0;
+    ACE_NEW_RETURN (retval, CORBA::ParameterDescription[size], 0);
+    return retval;
+  }
+  
+  ACE_INLINE void CORBA::_TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::freebuf (CORBA::ParameterDescription *buffer)
+  // Free the sequence.
+  {
+    delete [] buffer;
+  }
+  
+  ACE_INLINE
+  CORBA::_TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq (void) // Default constructor.
+  {
+  }
+  
+  ACE_INLINE
+  CORBA::_TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq (CORBA::ULong maximum) // Constructor using a maximum length value.
+    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::allocbuf (maximum))
+  {
+  }
+  
+  ACE_INLINE
+  CORBA::_TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq (CORBA::ULong maximum,
+    CORBA::ULong length,
+    CORBA::ParameterDescription *data,
+    CORBA::Boolean release)
+  : TAO_Unbounded_Base_Sequence (maximum, length, data, release)
+  {
+  }
+  
+  ACE_INLINE
+  CORBA::_TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq (const _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq &rhs)
+  // Copy constructor.
+    : TAO_Unbounded_Base_Sequence (rhs)
+  {
+    if (rhs.buffer_ != 0)
+    {
+      CORBA::ParameterDescription *tmp1 = _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::allocbuf (this->maximum_);
+      CORBA::ParameterDescription * const tmp2 = ACE_reinterpret_cast (CORBA::ParameterDescription * ACE_CAST_CONST, rhs.buffer_);
+      
+      for (CORBA::ULong i = 0; i < this->length_; ++i)
+        tmp1[i] = tmp2[i];
+      
+      this->buffer_ = tmp1;
+    }
+    else
+    {
+      this->buffer_ = 0;
+    }
+  }
+  
+  ACE_INLINE CORBA::_TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq &
+  CORBA::_TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::operator= (const _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq &rhs)
+  // Assignment operator.
+  {
+    if (this == &rhs)
+      return *this;
+    
+    if (this->release_)
+    {
+      if (this->maximum_ < rhs.maximum_)
+      {
+        // free the old buffer
+        CORBA::ParameterDescription *tmp = ACE_reinterpret_cast (CORBA::ParameterDescription *, this->buffer_);
+        _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::freebuf (tmp);
+        this->buffer_ = _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::allocbuf (rhs.maximum_);
+      }
+    }
+    else
+      this->buffer_ = _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::allocbuf (rhs.maximum_);
+    
+    TAO_Unbounded_Base_Sequence::operator= (rhs);
+    
+    CORBA::ParameterDescription *tmp1 = ACE_reinterpret_cast (CORBA::ParameterDescription *, this->buffer_);
+    CORBA::ParameterDescription * const tmp2 = ACE_reinterpret_cast (CORBA::ParameterDescription * ACE_CAST_CONST, rhs.buffer_);
+    
+    for (CORBA::ULong i = 0; i < this->length_; ++i)
+      tmp1[i] = tmp2[i];
+    
+    return *this;
+  }
+  
+  // = Accessors.
+  ACE_INLINE CORBA::ParameterDescription &
+  CORBA::_TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::operator[] (CORBA::ULong i)
+  // operator []
+  {
+    ACE_ASSERT (i < this->maximum_);
+    CORBA::ParameterDescription* tmp = ACE_reinterpret_cast(CORBA::ParameterDescription*,this->buffer_);
+    return tmp[i];
+  }
+  
+  ACE_INLINE const CORBA::ParameterDescription &
+  CORBA::_TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::operator[] (CORBA::ULong i) const
+  // operator []
+  {
+    ACE_ASSERT (i < this->maximum_);
+    CORBA::ParameterDescription * const tmp = ACE_reinterpret_cast (CORBA::ParameterDescription* ACE_CAST_CONST, this->buffer_);
+    return tmp[i];
+  }
+  
+  // Implement the TAO_Base_Sequence methods (see Sequence.h)
+  
+  ACE_INLINE CORBA::ParameterDescription *
+  CORBA::_TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::get_buffer (CORBA::Boolean orphan)
+  {
+    CORBA::ParameterDescription *result = 0;
+    if (orphan == 0)
+    {
+      // We retain ownership.
+      if (this->buffer_ == 0)
+      {
+        result = _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::allocbuf (this->length_);
+        this->buffer_ = result;
+        this->release_ = 1;
+      }
+      else
+      {
+        result = ACE_reinterpret_cast (CORBA::ParameterDescription*, this->buffer_);
+      }
+    }
+    else // if (orphan == 1)
+    {
+      if (this->release_ != 0)
+      {
+        // We set the state back to default and relinquish
+        // ownership.
+        result = ACE_reinterpret_cast(CORBA::ParameterDescription*,this->buffer_);
+        this->maximum_ = 0;
+        this->length_ = 0;
+        this->buffer_ = 0;
+        this->release_ = 0;
+      }
+    }
+    return result;
+  }
+  
+  ACE_INLINE const CORBA::ParameterDescription *
+  CORBA::_TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::get_buffer (void) const
+  {
+    return ACE_reinterpret_cast(const CORBA::ParameterDescription * ACE_CAST_CONST, this->buffer_);
+  }
+  
+  ACE_INLINE void
+  CORBA::_TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::replace (CORBA::ULong max,
+  CORBA::ULong length,
+  CORBA::ParameterDescription *data,
+  CORBA::Boolean release)
+  {
+    this->maximum_ = max;
+    this->length_ = length;
+    if (this->buffer_ && this->release_ == 1)
+    {
+      CORBA::ParameterDescription *tmp = ACE_reinterpret_cast(CORBA::ParameterDescription*,this->buffer_);
+      _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::freebuf (tmp);
+    }
+    this->buffer_ = data;
+    this->release_ = release;
+  }
+  
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_CORBA_PARDESCRIPTIONSEQ_CI_)
+#define _CORBA_PARDESCRIPTIONSEQ_CI_
+
+// *************************************************************
+// Inline operations for class CORBA_ParDescriptionSeq_var
+// *************************************************************
+
+ACE_INLINE
+CORBA_ParDescriptionSeq_var::CORBA_ParDescriptionSeq_var (void) // default constructor
+  : ptr_ (0)
+{}
+
+ACE_INLINE
+CORBA_ParDescriptionSeq_var::CORBA_ParDescriptionSeq_var (CORBA_ParDescriptionSeq *p)
+  : ptr_ (p)
+{}
+
+ACE_INLINE
+CORBA_ParDescriptionSeq_var::CORBA_ParDescriptionSeq_var (const ::CORBA_ParDescriptionSeq_var &p) // copy constructor
+{
+  if (p.ptr_)
+    ACE_NEW (this->ptr_, ::CORBA_ParDescriptionSeq (*p.ptr_));
+  else
+    this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA_ParDescriptionSeq_var::~CORBA_ParDescriptionSeq_var (void) // destructor
+{
+  delete this->ptr_;
+}
+
+ACE_INLINE CORBA_ParDescriptionSeq_var &
+CORBA_ParDescriptionSeq_var::operator= (CORBA_ParDescriptionSeq *p)
+{
+  delete this->ptr_;
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE ::CORBA_ParDescriptionSeq_var &
+CORBA_ParDescriptionSeq_var::operator= (const ::CORBA_ParDescriptionSeq_var &p)
+{
+  if (this != &p)
+    {
+      if (p.ptr_ == 0)
+        {
+          delete this->ptr_;
+          this->ptr_ = 0;
+        }
+      else
+        {
+          CORBA_ParDescriptionSeq *deep_copy =
+            new CORBA_ParDescriptionSeq (*p.ptr_);
+          
+          if (deep_copy != 0)
+            {
+              CORBA_ParDescriptionSeq *tmp = deep_copy;
+              deep_copy = this->ptr_;
+              this->ptr_ = tmp;
+              delete deep_copy;
+            }
+        }
+    }
+  
+  return *this;
+}
+
+ACE_INLINE const ::CORBA_ParDescriptionSeq *
+CORBA_ParDescriptionSeq_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ParDescriptionSeq *
+CORBA_ParDescriptionSeq_var::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+CORBA_ParDescriptionSeq_var::operator const ::CORBA_ParDescriptionSeq &() const // cast
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE 
+CORBA_ParDescriptionSeq_var::operator ::CORBA_ParDescriptionSeq &() // cast 
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE 
+CORBA_ParDescriptionSeq_var::operator ::CORBA_ParDescriptionSeq &() const // cast 
+{
+  return *this->ptr_;
+}
+
+// variable-size types only
+ACE_INLINE
+CORBA_ParDescriptionSeq_var::operator ::CORBA_ParDescriptionSeq *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE CORBA::ParameterDescription &
+CORBA_ParDescriptionSeq_var::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+ACE_INLINE const CORBA::ParameterDescription &
+CORBA_ParDescriptionSeq_var::operator[] (CORBA::ULong index) const
+{
+  return ACE_const_cast (const CORBA::ParameterDescription &, this->ptr_->operator[] (index));
+}
+
+ACE_INLINE const ::CORBA_ParDescriptionSeq &
+CORBA_ParDescriptionSeq_var::in (void) const
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ParDescriptionSeq &
+CORBA_ParDescriptionSeq_var::inout (void)
+{
+  return *this->ptr_;
+}
+
+// mapping for variable size 
+ACE_INLINE ::CORBA_ParDescriptionSeq *&
+CORBA_ParDescriptionSeq_var::out (void)
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ParDescriptionSeq *
+CORBA_ParDescriptionSeq_var::_retn (void)
+{
+  ::CORBA_ParDescriptionSeq *tmp = this->ptr_;
+  this->ptr_ = 0;
+  return tmp;
+}
+
+ACE_INLINE ::CORBA_ParDescriptionSeq *
+CORBA_ParDescriptionSeq_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+// *************************************************************
+// Inline operations for class CORBA_ParDescriptionSeq_out
+// *************************************************************
+
+ACE_INLINE
+CORBA_ParDescriptionSeq_out::CORBA_ParDescriptionSeq_out (CORBA_ParDescriptionSeq *&p)
+  : ptr_ (p)
+{
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA_ParDescriptionSeq_out::CORBA_ParDescriptionSeq_out (CORBA_ParDescriptionSeq_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA_ParDescriptionSeq_out::CORBA_ParDescriptionSeq_out (const ::CORBA_ParDescriptionSeq_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (CORBA_ParDescriptionSeq_out&, p).ptr_)
+{}
+
+ACE_INLINE ::CORBA_ParDescriptionSeq_out &
+CORBA_ParDescriptionSeq_out::operator= (const ::CORBA_ParDescriptionSeq_out &p)
+{
+  this->ptr_ = ACE_const_cast (CORBA_ParDescriptionSeq_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE ::CORBA_ParDescriptionSeq_out &
+CORBA_ParDescriptionSeq_out::operator= (CORBA_ParDescriptionSeq *p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+CORBA_ParDescriptionSeq_out::operator ::CORBA_ParDescriptionSeq *&() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ParDescriptionSeq *&
+CORBA_ParDescriptionSeq_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ParDescriptionSeq *
+CORBA_ParDescriptionSeq_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE CORBA::ParameterDescription &
+CORBA_ParDescriptionSeq_out::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_CONTEXTIDSEQ_CI_)
+#define _CORBA_CONTEXTIDSEQ_CI_
+
+// *************************************************************
+// Inline operations for class CORBA_ContextIdSeq_var
+// *************************************************************
+
+ACE_INLINE
+CORBA_ContextIdSeq_var::CORBA_ContextIdSeq_var (void) // default constructor
+  : ptr_ (0)
+{}
+
+ACE_INLINE
+CORBA_ContextIdSeq_var::CORBA_ContextIdSeq_var (CORBA_ContextIdSeq *p)
+  : ptr_ (p)
+{}
+
+ACE_INLINE
+CORBA_ContextIdSeq_var::CORBA_ContextIdSeq_var (const ::CORBA_ContextIdSeq_var &p) // copy constructor
+{
+  if (p.ptr_)
+    ACE_NEW (this->ptr_, ::CORBA_ContextIdSeq (*p.ptr_));
+  else
+    this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA_ContextIdSeq_var::~CORBA_ContextIdSeq_var (void) // destructor
+{
+  delete this->ptr_;
+}
+
+ACE_INLINE CORBA_ContextIdSeq_var &
+CORBA_ContextIdSeq_var::operator= (CORBA_ContextIdSeq *p)
+{
+  delete this->ptr_;
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE ::CORBA_ContextIdSeq_var &
+CORBA_ContextIdSeq_var::operator= (const ::CORBA_ContextIdSeq_var &p)
+{
+  if (this != &p)
+    {
+      if (p.ptr_ == 0)
+        {
+          delete this->ptr_;
+          this->ptr_ = 0;
+        }
+      else
+        {
+          CORBA_ContextIdSeq *deep_copy =
+            new CORBA_ContextIdSeq (*p.ptr_);
+          
+          if (deep_copy != 0)
+            {
+              CORBA_ContextIdSeq *tmp = deep_copy;
+              deep_copy = this->ptr_;
+              this->ptr_ = tmp;
+              delete deep_copy;
+            }
+        }
+    }
+  
+  return *this;
+}
+
+ACE_INLINE const ::CORBA_ContextIdSeq *
+CORBA_ContextIdSeq_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ContextIdSeq *
+CORBA_ContextIdSeq_var::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+CORBA_ContextIdSeq_var::operator const ::CORBA_ContextIdSeq &() const // cast
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE 
+CORBA_ContextIdSeq_var::operator ::CORBA_ContextIdSeq &() // cast 
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE 
+CORBA_ContextIdSeq_var::operator ::CORBA_ContextIdSeq &() const // cast 
+{
+  return *this->ptr_;
+}
+
+// variable-size types only
+ACE_INLINE
+CORBA_ContextIdSeq_var::operator ::CORBA_ContextIdSeq *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE TAO_SeqElem_String_Manager
+CORBA_ContextIdSeq_var::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+ACE_INLINE const ::CORBA_ContextIdSeq &
+CORBA_ContextIdSeq_var::in (void) const
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ContextIdSeq &
+CORBA_ContextIdSeq_var::inout (void)
+{
+  return *this->ptr_;
+}
+
+// mapping for variable size 
+ACE_INLINE ::CORBA_ContextIdSeq *&
+CORBA_ContextIdSeq_var::out (void)
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ContextIdSeq *
+CORBA_ContextIdSeq_var::_retn (void)
+{
+  ::CORBA_ContextIdSeq *tmp = this->ptr_;
+  this->ptr_ = 0;
+  return tmp;
+}
+
+ACE_INLINE ::CORBA_ContextIdSeq *
+CORBA_ContextIdSeq_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+// *************************************************************
+// Inline operations for class CORBA_ContextIdSeq_out
+// *************************************************************
+
+ACE_INLINE
+CORBA_ContextIdSeq_out::CORBA_ContextIdSeq_out (CORBA_ContextIdSeq *&p)
+  : ptr_ (p)
+{
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA_ContextIdSeq_out::CORBA_ContextIdSeq_out (CORBA_ContextIdSeq_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA_ContextIdSeq_out::CORBA_ContextIdSeq_out (const ::CORBA_ContextIdSeq_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (CORBA_ContextIdSeq_out&, p).ptr_)
+{}
+
+ACE_INLINE ::CORBA_ContextIdSeq_out &
+CORBA_ContextIdSeq_out::operator= (const ::CORBA_ContextIdSeq_out &p)
+{
+  this->ptr_ = ACE_const_cast (CORBA_ContextIdSeq_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE ::CORBA_ContextIdSeq_out &
+CORBA_ContextIdSeq_out::operator= (CORBA_ContextIdSeq *p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+CORBA_ContextIdSeq_out::operator ::CORBA_ContextIdSeq *&() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ContextIdSeq *&
+CORBA_ContextIdSeq_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ContextIdSeq *
+CORBA_ContextIdSeq_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE TAO_SeqElem_String_Manager
+CORBA_ContextIdSeq_out::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_OPERATIONDEF___CI_)
+#define _CORBA_OPERATIONDEF___CI_
+
+ACE_INLINE
+CORBA_OperationDef::CORBA_OperationDef (
+    TAO_Stub *objref,
+    CORBA::Boolean _tao_collocated,
+    TAO_Abstract_ServantBase *servant
+  )
+  : CORBA_Object (objref, _tao_collocated, servant)
+{
+  this->CORBA_OperationDef_setup_collocation (_tao_collocated);
+}
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_OPERATIONDEF___VAR_CI_)
+#define _CORBA_OPERATIONDEF___VAR_CI_
+
+// *************************************************************
+// Inline operations for class CORBA_OperationDef_var
+// *************************************************************
+
+ACE_INLINE
+CORBA_OperationDef_var::CORBA_OperationDef_var (void) // default constructor
+  : ptr_ (CORBA_OperationDef::_nil ())
+{}
+
+ACE_INLINE ::CORBA_OperationDef_ptr
+CORBA_OperationDef_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+CORBA_OperationDef_var::CORBA_OperationDef_var (const ::CORBA_OperationDef_var &p) // copy constructor
+  : TAO_Base_var (),
+    ptr_ (CORBA_OperationDef::_duplicate (p.ptr ()))
+{}
+
+ACE_INLINE
+CORBA_OperationDef_var::~CORBA_OperationDef_var (void) // destructor
+{
+  CORBA::release (this->ptr_);
+}
+
+ACE_INLINE CORBA_OperationDef_var &
+CORBA_OperationDef_var::operator= (CORBA_OperationDef_ptr p)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE CORBA_OperationDef_var &
+CORBA_OperationDef_var::operator= (const ::CORBA_OperationDef_var &p)
+{
+  if (this != &p)
+  {
+    CORBA::release (this->ptr_);
+    this->ptr_ = ::CORBA_OperationDef::_duplicate (p.ptr ());
+  }
+  return *this;
+}
+
+ACE_INLINE 
+CORBA_OperationDef_var::operator const ::CORBA_OperationDef_ptr &() const // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+CORBA_OperationDef_var::operator ::CORBA_OperationDef_ptr &() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_OperationDef_ptr
+CORBA_OperationDef_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_OperationDef_ptr
+CORBA_OperationDef_var::in (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_OperationDef_ptr &
+CORBA_OperationDef_var::inout (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_OperationDef_ptr &
+CORBA_OperationDef_var::out (void)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = ::CORBA_OperationDef::_nil ();
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_OperationDef_ptr
+CORBA_OperationDef_var::_retn (void)
+{
+  // yield ownership of managed obj reference
+  ::CORBA_OperationDef_ptr val = this->ptr_;
+  this->ptr_ = ::CORBA_OperationDef::_nil ();
+  return val;
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_OPERATIONDEF___OUT_CI_)
+#define _CORBA_OPERATIONDEF___OUT_CI_
+
+// *************************************************************
+// Inline operations for class CORBA_OperationDef_out
+// *************************************************************
+
+ACE_INLINE
+CORBA_OperationDef_out::CORBA_OperationDef_out (CORBA_OperationDef_ptr &p)
+  : ptr_ (p)
+{
+  this->ptr_ = ::CORBA_OperationDef::_nil ();
+}
+
+ACE_INLINE
+CORBA_OperationDef_out::CORBA_OperationDef_out (CORBA_OperationDef_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = ::CORBA_OperationDef::_nil ();
+}
+
+ACE_INLINE
+CORBA_OperationDef_out::CORBA_OperationDef_out (const ::CORBA_OperationDef_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (CORBA_OperationDef_out &, p).ptr_)
+{}
+
+ACE_INLINE ::CORBA_OperationDef_out &
+CORBA_OperationDef_out::operator= (const ::CORBA_OperationDef_out &p)
+{
+  this->ptr_ = ACE_const_cast (CORBA_OperationDef_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE CORBA_OperationDef_out &
+CORBA_OperationDef_out::operator= (const ::CORBA_OperationDef_var &p)
+{
+  this->ptr_ = ::CORBA_OperationDef::_duplicate (p.ptr ());
+  return *this;
+}
+
+ACE_INLINE CORBA_OperationDef_out &
+CORBA_OperationDef_out::operator= (CORBA_OperationDef_ptr p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+CORBA_OperationDef_out::operator ::CORBA_OperationDef_ptr &() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_OperationDef_ptr &
+CORBA_OperationDef_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_OperationDef_ptr
+CORBA_OperationDef_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+
+#endif /* end #if !defined */
+
+// *************************************************************
+// Inline operations for class CORBA_OperationDescription_var
+// *************************************************************
+
+ACE_INLINE
+CORBA_OperationDescription_var::CORBA_OperationDescription_var (void) // default constructor
+  : ptr_ (0)
+{}
+
+ACE_INLINE
+CORBA_OperationDescription_var::CORBA_OperationDescription_var (CORBA_OperationDescription *p)
+  : ptr_ (p)
+{}
+
+ACE_INLINE
+CORBA_OperationDescription_var::CORBA_OperationDescription_var (const ::CORBA_OperationDescription_var &p) // copy constructor
+{
+  if (p.ptr_)
+    ACE_NEW (this->ptr_, ::CORBA_OperationDescription (*p.ptr_));
+  else
+    this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA_OperationDescription_var::~CORBA_OperationDescription_var (void) // destructor
+{
+  delete this->ptr_;
+}
+
+ACE_INLINE CORBA_OperationDescription_var &
+CORBA_OperationDescription_var::operator= (CORBA_OperationDescription *p)
+{
+  delete this->ptr_;
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE ::CORBA_OperationDescription_var &
+CORBA_OperationDescription_var::operator= (const ::CORBA_OperationDescription_var &p)
+{
+  if (this != &p)
+    {
+      if (p.ptr_ == 0)
+        {
+          delete this->ptr_;
+          this->ptr_ = 0;
+        }
+      else
+        {
+          CORBA_OperationDescription *deep_copy =
+            new CORBA_OperationDescription (*p.ptr_);
+          
+          if (deep_copy != 0)
+            {
+              CORBA_OperationDescription *tmp = deep_copy;
+              deep_copy = this->ptr_;
+              this->ptr_ = tmp;
+              delete deep_copy;
+            }
+        }
+    }
+  
+  return *this;
+}
+
+ACE_INLINE const ::CORBA_OperationDescription *
+CORBA_OperationDescription_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_OperationDescription *
+CORBA_OperationDescription_var::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+CORBA_OperationDescription_var::operator const ::CORBA_OperationDescription &() const // cast
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE
+CORBA_OperationDescription_var::operator ::CORBA_OperationDescription &() // cast 
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE
+CORBA_OperationDescription_var::operator ::CORBA_OperationDescription &() const // cast 
+{
+  return *this->ptr_;
+}
+
+// variable-size types only
+ACE_INLINE
+CORBA_OperationDescription_var::operator ::CORBA_OperationDescription *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE const ::CORBA_OperationDescription &
+CORBA_OperationDescription_var::in (void) const
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE ::CORBA_OperationDescription &
+CORBA_OperationDescription_var::inout (void)
+{
+  return *this->ptr_;
+}
+
+// mapping for variable size 
+ACE_INLINE ::CORBA_OperationDescription *&
+CORBA_OperationDescription_var::out (void)
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_OperationDescription *
+CORBA_OperationDescription_var::_retn (void)
+{
+  ::CORBA_OperationDescription *tmp = this->ptr_;
+  this->ptr_ = 0;
+  return tmp;
+}
+
+ACE_INLINE ::CORBA_OperationDescription *
+CORBA_OperationDescription_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+// *************************************************************
+// Inline operations for class CORBA_OperationDescription_out
+// *************************************************************
+
+ACE_INLINE
+CORBA_OperationDescription_out::CORBA_OperationDescription_out (::CORBA_OperationDescription *&p)
+  : ptr_ (p)
+{
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA_OperationDescription_out::CORBA_OperationDescription_out (CORBA_OperationDescription_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA_OperationDescription_out::CORBA_OperationDescription_out (const ::CORBA_OperationDescription_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (CORBA_OperationDescription_out&, p).ptr_)
+{}
+
+ACE_INLINE CORBA_OperationDescription_out &
+CORBA_OperationDescription_out::operator= (const ::CORBA_OperationDescription_out &p)
+{
+  this->ptr_ = ACE_const_cast (CORBA_OperationDescription_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE CORBA_OperationDescription_out &
+CORBA_OperationDescription_out::operator= (CORBA_OperationDescription *p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+CORBA_OperationDescription_out::operator ::CORBA_OperationDescription *&() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_OperationDescription *&
+CORBA_OperationDescription_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_OperationDescription *
+CORBA_OperationDescription_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+
+#if !defined (_CORBA_REPOSITORYIDSEQ_CI_)
+#define _CORBA_REPOSITORYIDSEQ_CI_
+
+// *************************************************************
+// Inline operations for class CORBA_RepositoryIdSeq_var
+// *************************************************************
+
+ACE_INLINE
+CORBA_RepositoryIdSeq_var::CORBA_RepositoryIdSeq_var (void) // default constructor
+  : ptr_ (0)
+{}
+
+ACE_INLINE
+CORBA_RepositoryIdSeq_var::CORBA_RepositoryIdSeq_var (CORBA_RepositoryIdSeq *p)
+  : ptr_ (p)
+{}
+
+ACE_INLINE
+CORBA_RepositoryIdSeq_var::CORBA_RepositoryIdSeq_var (const ::CORBA_RepositoryIdSeq_var &p) // copy constructor
+{
+  if (p.ptr_)
+    ACE_NEW (this->ptr_, ::CORBA_RepositoryIdSeq (*p.ptr_));
+  else
+    this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA_RepositoryIdSeq_var::~CORBA_RepositoryIdSeq_var (void) // destructor
+{
+  delete this->ptr_;
+}
+
+ACE_INLINE CORBA_RepositoryIdSeq_var &
+CORBA_RepositoryIdSeq_var::operator= (CORBA_RepositoryIdSeq *p)
+{
+  delete this->ptr_;
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE ::CORBA_RepositoryIdSeq_var &
+CORBA_RepositoryIdSeq_var::operator= (const ::CORBA_RepositoryIdSeq_var &p)
+{
+  if (this != &p)
+    {
+      if (p.ptr_ == 0)
+        {
+          delete this->ptr_;
+          this->ptr_ = 0;
+        }
+      else
+        {
+          CORBA_RepositoryIdSeq *deep_copy =
+            new CORBA_RepositoryIdSeq (*p.ptr_);
+          
+          if (deep_copy != 0)
+            {
+              CORBA_RepositoryIdSeq *tmp = deep_copy;
+              deep_copy = this->ptr_;
+              this->ptr_ = tmp;
+              delete deep_copy;
+            }
+        }
+    }
+  
+  return *this;
+}
+
+ACE_INLINE const ::CORBA_RepositoryIdSeq *
+CORBA_RepositoryIdSeq_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_RepositoryIdSeq *
+CORBA_RepositoryIdSeq_var::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+CORBA_RepositoryIdSeq_var::operator const ::CORBA_RepositoryIdSeq &() const // cast
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE 
+CORBA_RepositoryIdSeq_var::operator ::CORBA_RepositoryIdSeq &() // cast 
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE 
+CORBA_RepositoryIdSeq_var::operator ::CORBA_RepositoryIdSeq &() const // cast 
+{
+  return *this->ptr_;
+}
+
+// variable-size types only
+ACE_INLINE
+CORBA_RepositoryIdSeq_var::operator ::CORBA_RepositoryIdSeq *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE TAO_SeqElem_String_Manager
+CORBA_RepositoryIdSeq_var::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+ACE_INLINE const ::CORBA_RepositoryIdSeq &
+CORBA_RepositoryIdSeq_var::in (void) const
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE ::CORBA_RepositoryIdSeq &
+CORBA_RepositoryIdSeq_var::inout (void)
+{
+  return *this->ptr_;
+}
+
+// mapping for variable size 
+ACE_INLINE ::CORBA_RepositoryIdSeq *&
+CORBA_RepositoryIdSeq_var::out (void)
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_RepositoryIdSeq *
+CORBA_RepositoryIdSeq_var::_retn (void)
+{
+  ::CORBA_RepositoryIdSeq *tmp = this->ptr_;
+  this->ptr_ = 0;
+  return tmp;
+}
+
+ACE_INLINE ::CORBA_RepositoryIdSeq *
+CORBA_RepositoryIdSeq_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+// *************************************************************
+// Inline operations for class CORBA_RepositoryIdSeq_out
+// *************************************************************
+
+ACE_INLINE
+CORBA_RepositoryIdSeq_out::CORBA_RepositoryIdSeq_out (CORBA_RepositoryIdSeq *&p)
+  : ptr_ (p)
+{
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA_RepositoryIdSeq_out::CORBA_RepositoryIdSeq_out (CORBA_RepositoryIdSeq_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA_RepositoryIdSeq_out::CORBA_RepositoryIdSeq_out (const ::CORBA_RepositoryIdSeq_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (CORBA_RepositoryIdSeq_out&, p).ptr_)
+{}
+
+ACE_INLINE ::CORBA_RepositoryIdSeq_out &
+CORBA_RepositoryIdSeq_out::operator= (const ::CORBA_RepositoryIdSeq_out &p)
+{
+  this->ptr_ = ACE_const_cast (CORBA_RepositoryIdSeq_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE ::CORBA_RepositoryIdSeq_out &
+CORBA_RepositoryIdSeq_out::operator= (CORBA_RepositoryIdSeq *p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+CORBA_RepositoryIdSeq_out::operator ::CORBA_RepositoryIdSeq *&() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_RepositoryIdSeq *&
+CORBA_RepositoryIdSeq_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_RepositoryIdSeq *
+CORBA_RepositoryIdSeq_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE TAO_SeqElem_String_Manager
+CORBA_RepositoryIdSeq_out::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_SEQUENCE_CORBA_OPDESCRIPTIONSEQ_CI_)
+#define __TAO_UNBOUNDED_SEQUENCE_CORBA_OPDESCRIPTIONSEQ_CI_
+
+  // = Static operations.
+  ACE_INLINE CORBA::OperationDescription *
+  CORBA::_TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::allocbuf (CORBA::ULong size)
+  // Allocate storage for the sequence.
+  {
+    CORBA::OperationDescription *retval = 0;
+    ACE_NEW_RETURN (retval, CORBA::OperationDescription[size], 0);
+    return retval;
+  }
+  
+  ACE_INLINE void CORBA::_TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::freebuf (CORBA::OperationDescription *buffer)
+  // Free the sequence.
+  {
+    delete [] buffer;
+  }
+  
+  ACE_INLINE
+  CORBA::_TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq (void) // Default constructor.
+  {
+  }
+  
+  ACE_INLINE
+  CORBA::_TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq (CORBA::ULong maximum) // Constructor using a maximum length value.
+    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::allocbuf (maximum))
+  {
+  }
+  
+  ACE_INLINE
+  CORBA::_TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq (CORBA::ULong maximum,
+    CORBA::ULong length,
+    CORBA::OperationDescription *data,
+    CORBA::Boolean release)
+  : TAO_Unbounded_Base_Sequence (maximum, length, data, release)
+  {
+  }
+  
+  ACE_INLINE
+  CORBA::_TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq (const _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq &rhs)
+  // Copy constructor.
+    : TAO_Unbounded_Base_Sequence (rhs)
+  {
+    if (rhs.buffer_ != 0)
+    {
+      CORBA::OperationDescription *tmp1 = _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::allocbuf (this->maximum_);
+      CORBA::OperationDescription * const tmp2 = ACE_reinterpret_cast (CORBA::OperationDescription * ACE_CAST_CONST, rhs.buffer_);
+      
+      for (CORBA::ULong i = 0; i < this->length_; ++i)
+        tmp1[i] = tmp2[i];
+      
+      this->buffer_ = tmp1;
+    }
+    else
+    {
+      this->buffer_ = 0;
+    }
+  }
+  
+  ACE_INLINE CORBA::_TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq &
+  CORBA::_TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::operator= (const _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq &rhs)
+  // Assignment operator.
+  {
+    if (this == &rhs)
+      return *this;
+    
+    if (this->release_)
+    {
+      if (this->maximum_ < rhs.maximum_)
+      {
+        // free the old buffer
+        CORBA::OperationDescription *tmp = ACE_reinterpret_cast (CORBA::OperationDescription *, this->buffer_);
+        _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::freebuf (tmp);
+        this->buffer_ = _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::allocbuf (rhs.maximum_);
+      }
+    }
+    else
+      this->buffer_ = _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::allocbuf (rhs.maximum_);
+    
+    TAO_Unbounded_Base_Sequence::operator= (rhs);
+    
+    CORBA::OperationDescription *tmp1 = ACE_reinterpret_cast (CORBA::OperationDescription *, this->buffer_);
+    CORBA::OperationDescription * const tmp2 = ACE_reinterpret_cast (CORBA::OperationDescription * ACE_CAST_CONST, rhs.buffer_);
+    
+    for (CORBA::ULong i = 0; i < this->length_; ++i)
+      tmp1[i] = tmp2[i];
+    
+    return *this;
+  }
+  
+  // = Accessors.
+  ACE_INLINE CORBA::OperationDescription &
+  CORBA::_TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::operator[] (CORBA::ULong i)
+  // operator []
+  {
+    ACE_ASSERT (i < this->maximum_);
+    CORBA::OperationDescription* tmp = ACE_reinterpret_cast(CORBA::OperationDescription*,this->buffer_);
+    return tmp[i];
+  }
+  
+  ACE_INLINE const CORBA::OperationDescription &
+  CORBA::_TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::operator[] (CORBA::ULong i) const
+  // operator []
+  {
+    ACE_ASSERT (i < this->maximum_);
+    CORBA::OperationDescription * const tmp = ACE_reinterpret_cast (CORBA::OperationDescription* ACE_CAST_CONST, this->buffer_);
+    return tmp[i];
+  }
+  
+  // Implement the TAO_Base_Sequence methods (see Sequence.h)
+  
+  ACE_INLINE CORBA::OperationDescription *
+  CORBA::_TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::get_buffer (CORBA::Boolean orphan)
+  {
+    CORBA::OperationDescription *result = 0;
+    if (orphan == 0)
+    {
+      // We retain ownership.
+      if (this->buffer_ == 0)
+      {
+        result = _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::allocbuf (this->length_);
+        this->buffer_ = result;
+        this->release_ = 1;
+      }
+      else
+      {
+        result = ACE_reinterpret_cast (CORBA::OperationDescription*, this->buffer_);
+      }
+    }
+    else // if (orphan == 1)
+    {
+      if (this->release_ != 0)
+      {
+        // We set the state back to default and relinquish
+        // ownership.
+        result = ACE_reinterpret_cast(CORBA::OperationDescription*,this->buffer_);
+        this->maximum_ = 0;
+        this->length_ = 0;
+        this->buffer_ = 0;
+        this->release_ = 0;
+      }
+    }
+    return result;
+  }
+  
+  ACE_INLINE const CORBA::OperationDescription *
+  CORBA::_TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::get_buffer (void) const
+  {
+    return ACE_reinterpret_cast(const CORBA::OperationDescription * ACE_CAST_CONST, this->buffer_);
+  }
+  
+  ACE_INLINE void
+  CORBA::_TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::replace (CORBA::ULong max,
+  CORBA::ULong length,
+  CORBA::OperationDescription *data,
+  CORBA::Boolean release)
+  {
+    this->maximum_ = max;
+    this->length_ = length;
+    if (this->buffer_ && this->release_ == 1)
+    {
+      CORBA::OperationDescription *tmp = ACE_reinterpret_cast(CORBA::OperationDescription*,this->buffer_);
+      _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::freebuf (tmp);
+    }
+    this->buffer_ = data;
+    this->release_ = release;
+  }
+  
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_CORBA_OPDESCRIPTIONSEQ_CI_)
+#define _CORBA_OPDESCRIPTIONSEQ_CI_
+
+// *************************************************************
+// Inline operations for class CORBA_OpDescriptionSeq_var
+// *************************************************************
+
+ACE_INLINE
+CORBA_OpDescriptionSeq_var::CORBA_OpDescriptionSeq_var (void) // default constructor
+  : ptr_ (0)
+{}
+
+ACE_INLINE
+CORBA_OpDescriptionSeq_var::CORBA_OpDescriptionSeq_var (CORBA_OpDescriptionSeq *p)
+  : ptr_ (p)
+{}
+
+ACE_INLINE
+CORBA_OpDescriptionSeq_var::CORBA_OpDescriptionSeq_var (const ::CORBA_OpDescriptionSeq_var &p) // copy constructor
+{
+  if (p.ptr_)
+    ACE_NEW (this->ptr_, ::CORBA_OpDescriptionSeq (*p.ptr_));
+  else
+    this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA_OpDescriptionSeq_var::~CORBA_OpDescriptionSeq_var (void) // destructor
+{
+  delete this->ptr_;
+}
+
+ACE_INLINE CORBA_OpDescriptionSeq_var &
+CORBA_OpDescriptionSeq_var::operator= (CORBA_OpDescriptionSeq *p)
+{
+  delete this->ptr_;
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE ::CORBA_OpDescriptionSeq_var &
+CORBA_OpDescriptionSeq_var::operator= (const ::CORBA_OpDescriptionSeq_var &p)
+{
+  if (this != &p)
+    {
+      if (p.ptr_ == 0)
+        {
+          delete this->ptr_;
+          this->ptr_ = 0;
+        }
+      else
+        {
+          CORBA_OpDescriptionSeq *deep_copy =
+            new CORBA_OpDescriptionSeq (*p.ptr_);
+          
+          if (deep_copy != 0)
+            {
+              CORBA_OpDescriptionSeq *tmp = deep_copy;
+              deep_copy = this->ptr_;
+              this->ptr_ = tmp;
+              delete deep_copy;
+            }
+        }
+    }
+  
+  return *this;
+}
+
+ACE_INLINE const ::CORBA_OpDescriptionSeq *
+CORBA_OpDescriptionSeq_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_OpDescriptionSeq *
+CORBA_OpDescriptionSeq_var::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+CORBA_OpDescriptionSeq_var::operator const ::CORBA_OpDescriptionSeq &() const // cast
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE 
+CORBA_OpDescriptionSeq_var::operator ::CORBA_OpDescriptionSeq &() // cast 
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE 
+CORBA_OpDescriptionSeq_var::operator ::CORBA_OpDescriptionSeq &() const // cast 
+{
+  return *this->ptr_;
+}
+
+// variable-size types only
+ACE_INLINE
+CORBA_OpDescriptionSeq_var::operator ::CORBA_OpDescriptionSeq *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE CORBA::OperationDescription &
+CORBA_OpDescriptionSeq_var::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+ACE_INLINE const CORBA::OperationDescription &
+CORBA_OpDescriptionSeq_var::operator[] (CORBA::ULong index) const
+{
+  return ACE_const_cast (const CORBA::OperationDescription &, this->ptr_->operator[] (index));
+}
+
+ACE_INLINE const ::CORBA_OpDescriptionSeq &
+CORBA_OpDescriptionSeq_var::in (void) const
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE ::CORBA_OpDescriptionSeq &
+CORBA_OpDescriptionSeq_var::inout (void)
+{
+  return *this->ptr_;
+}
+
+// mapping for variable size 
+ACE_INLINE ::CORBA_OpDescriptionSeq *&
+CORBA_OpDescriptionSeq_var::out (void)
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_OpDescriptionSeq *
+CORBA_OpDescriptionSeq_var::_retn (void)
+{
+  ::CORBA_OpDescriptionSeq *tmp = this->ptr_;
+  this->ptr_ = 0;
+  return tmp;
+}
+
+ACE_INLINE ::CORBA_OpDescriptionSeq *
+CORBA_OpDescriptionSeq_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+// *************************************************************
+// Inline operations for class CORBA_OpDescriptionSeq_out
+// *************************************************************
+
+ACE_INLINE
+CORBA_OpDescriptionSeq_out::CORBA_OpDescriptionSeq_out (CORBA_OpDescriptionSeq *&p)
+  : ptr_ (p)
+{
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA_OpDescriptionSeq_out::CORBA_OpDescriptionSeq_out (CORBA_OpDescriptionSeq_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA_OpDescriptionSeq_out::CORBA_OpDescriptionSeq_out (const ::CORBA_OpDescriptionSeq_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (CORBA_OpDescriptionSeq_out&, p).ptr_)
+{}
+
+ACE_INLINE ::CORBA_OpDescriptionSeq_out &
+CORBA_OpDescriptionSeq_out::operator= (const ::CORBA_OpDescriptionSeq_out &p)
+{
+  this->ptr_ = ACE_const_cast (CORBA_OpDescriptionSeq_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE ::CORBA_OpDescriptionSeq_out &
+CORBA_OpDescriptionSeq_out::operator= (CORBA_OpDescriptionSeq *p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+CORBA_OpDescriptionSeq_out::operator ::CORBA_OpDescriptionSeq *&() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_OpDescriptionSeq *&
+CORBA_OpDescriptionSeq_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_OpDescriptionSeq *
+CORBA_OpDescriptionSeq_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE CORBA::OperationDescription &
+CORBA_OpDescriptionSeq_out::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_SEQUENCE_CORBA_ATTRDESCRIPTIONSEQ_CI_)
+#define __TAO_UNBOUNDED_SEQUENCE_CORBA_ATTRDESCRIPTIONSEQ_CI_
+
+  // = Static operations.
+  ACE_INLINE CORBA::AttributeDescription *
+  CORBA::_TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::allocbuf (CORBA::ULong size)
+  // Allocate storage for the sequence.
+  {
+    CORBA::AttributeDescription *retval = 0;
+    ACE_NEW_RETURN (retval, CORBA::AttributeDescription[size], 0);
+    return retval;
+  }
+  
+  ACE_INLINE void CORBA::_TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::freebuf (CORBA::AttributeDescription *buffer)
+  // Free the sequence.
+  {
+    delete [] buffer;
+  }
+  
+  ACE_INLINE
+  CORBA::_TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq (void) // Default constructor.
+  {
+  }
+  
+  ACE_INLINE
+  CORBA::_TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq (CORBA::ULong maximum) // Constructor using a maximum length value.
+    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::allocbuf (maximum))
+  {
+  }
+  
+  ACE_INLINE
+  CORBA::_TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq (CORBA::ULong maximum,
+    CORBA::ULong length,
+    CORBA::AttributeDescription *data,
+    CORBA::Boolean release)
+  : TAO_Unbounded_Base_Sequence (maximum, length, data, release)
+  {
+  }
+  
+  ACE_INLINE
+  CORBA::_TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq (const _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq &rhs)
+  // Copy constructor.
+    : TAO_Unbounded_Base_Sequence (rhs)
+  {
+    if (rhs.buffer_ != 0)
+    {
+      CORBA::AttributeDescription *tmp1 = _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::allocbuf (this->maximum_);
+      CORBA::AttributeDescription * const tmp2 = ACE_reinterpret_cast (CORBA::AttributeDescription * ACE_CAST_CONST, rhs.buffer_);
+      
+      for (CORBA::ULong i = 0; i < this->length_; ++i)
+        tmp1[i] = tmp2[i];
+      
+      this->buffer_ = tmp1;
+    }
+    else
+    {
+      this->buffer_ = 0;
+    }
+  }
+  
+  ACE_INLINE CORBA::_TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq &
+  CORBA::_TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::operator= (const _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq &rhs)
+  // Assignment operator.
+  {
+    if (this == &rhs)
+      return *this;
+    
+    if (this->release_)
+    {
+      if (this->maximum_ < rhs.maximum_)
+      {
+        // free the old buffer
+        CORBA::AttributeDescription *tmp = ACE_reinterpret_cast (CORBA::AttributeDescription *, this->buffer_);
+        _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::freebuf (tmp);
+        this->buffer_ = _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::allocbuf (rhs.maximum_);
+      }
+    }
+    else
+      this->buffer_ = _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::allocbuf (rhs.maximum_);
+    
+    TAO_Unbounded_Base_Sequence::operator= (rhs);
+    
+    CORBA::AttributeDescription *tmp1 = ACE_reinterpret_cast (CORBA::AttributeDescription *, this->buffer_);
+    CORBA::AttributeDescription * const tmp2 = ACE_reinterpret_cast (CORBA::AttributeDescription * ACE_CAST_CONST, rhs.buffer_);
+    
+    for (CORBA::ULong i = 0; i < this->length_; ++i)
+      tmp1[i] = tmp2[i];
+    
+    return *this;
+  }
+  
+  // = Accessors.
+  ACE_INLINE CORBA::AttributeDescription &
+  CORBA::_TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::operator[] (CORBA::ULong i)
+  // operator []
+  {
+    ACE_ASSERT (i < this->maximum_);
+    CORBA::AttributeDescription* tmp = ACE_reinterpret_cast(CORBA::AttributeDescription*,this->buffer_);
+    return tmp[i];
+  }
+  
+  ACE_INLINE const CORBA::AttributeDescription &
+  CORBA::_TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::operator[] (CORBA::ULong i) const
+  // operator []
+  {
+    ACE_ASSERT (i < this->maximum_);
+    CORBA::AttributeDescription * const tmp = ACE_reinterpret_cast (CORBA::AttributeDescription* ACE_CAST_CONST, this->buffer_);
+    return tmp[i];
+  }
+  
+  // Implement the TAO_Base_Sequence methods (see Sequence.h)
+  
+  ACE_INLINE CORBA::AttributeDescription *
+  CORBA::_TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::get_buffer (CORBA::Boolean orphan)
+  {
+    CORBA::AttributeDescription *result = 0;
+    if (orphan == 0)
+    {
+      // We retain ownership.
+      if (this->buffer_ == 0)
+      {
+        result = _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::allocbuf (this->length_);
+        this->buffer_ = result;
+        this->release_ = 1;
+      }
+      else
+      {
+        result = ACE_reinterpret_cast (CORBA::AttributeDescription*, this->buffer_);
+      }
+    }
+    else // if (orphan == 1)
+    {
+      if (this->release_ != 0)
+      {
+        // We set the state back to default and relinquish
+        // ownership.
+        result = ACE_reinterpret_cast(CORBA::AttributeDescription*,this->buffer_);
+        this->maximum_ = 0;
+        this->length_ = 0;
+        this->buffer_ = 0;
+        this->release_ = 0;
+      }
+    }
+    return result;
+  }
+  
+  ACE_INLINE const CORBA::AttributeDescription *
+  CORBA::_TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::get_buffer (void) const
+  {
+    return ACE_reinterpret_cast(const CORBA::AttributeDescription * ACE_CAST_CONST, this->buffer_);
+  }
+  
+  ACE_INLINE void
+  CORBA::_TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::replace (CORBA::ULong max,
+  CORBA::ULong length,
+  CORBA::AttributeDescription *data,
+  CORBA::Boolean release)
+  {
+    this->maximum_ = max;
+    this->length_ = length;
+    if (this->buffer_ && this->release_ == 1)
+    {
+      CORBA::AttributeDescription *tmp = ACE_reinterpret_cast(CORBA::AttributeDescription*,this->buffer_);
+      _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::freebuf (tmp);
+    }
+    this->buffer_ = data;
+    this->release_ = release;
+  }
+  
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_CORBA_ATTRDESCRIPTIONSEQ_CI_)
+#define _CORBA_ATTRDESCRIPTIONSEQ_CI_
+
+// *************************************************************
+// Inline operations for class CORBA_AttrDescriptionSeq_var
+// *************************************************************
+
+ACE_INLINE
+CORBA_AttrDescriptionSeq_var::CORBA_AttrDescriptionSeq_var (void) // default constructor
+  : ptr_ (0)
+{}
+
+ACE_INLINE
+CORBA_AttrDescriptionSeq_var::CORBA_AttrDescriptionSeq_var (CORBA_AttrDescriptionSeq *p)
+  : ptr_ (p)
+{}
+
+ACE_INLINE
+CORBA_AttrDescriptionSeq_var::CORBA_AttrDescriptionSeq_var (const ::CORBA_AttrDescriptionSeq_var &p) // copy constructor
+{
+  if (p.ptr_)
+    ACE_NEW (this->ptr_, ::CORBA_AttrDescriptionSeq (*p.ptr_));
+  else
+    this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA_AttrDescriptionSeq_var::~CORBA_AttrDescriptionSeq_var (void) // destructor
+{
+  delete this->ptr_;
+}
+
+ACE_INLINE CORBA_AttrDescriptionSeq_var &
+CORBA_AttrDescriptionSeq_var::operator= (CORBA_AttrDescriptionSeq *p)
+{
+  delete this->ptr_;
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE ::CORBA_AttrDescriptionSeq_var &
+CORBA_AttrDescriptionSeq_var::operator= (const ::CORBA_AttrDescriptionSeq_var &p)
+{
+  if (this != &p)
+    {
+      if (p.ptr_ == 0)
+        {
+          delete this->ptr_;
+          this->ptr_ = 0;
+        }
+      else
+        {
+          CORBA_AttrDescriptionSeq *deep_copy =
+            new CORBA_AttrDescriptionSeq (*p.ptr_);
+          
+          if (deep_copy != 0)
+            {
+              CORBA_AttrDescriptionSeq *tmp = deep_copy;
+              deep_copy = this->ptr_;
+              this->ptr_ = tmp;
+              delete deep_copy;
+            }
+        }
+    }
+  
+  return *this;
+}
+
+ACE_INLINE const ::CORBA_AttrDescriptionSeq *
+CORBA_AttrDescriptionSeq_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_AttrDescriptionSeq *
+CORBA_AttrDescriptionSeq_var::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+CORBA_AttrDescriptionSeq_var::operator const ::CORBA_AttrDescriptionSeq &() const // cast
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE 
+CORBA_AttrDescriptionSeq_var::operator ::CORBA_AttrDescriptionSeq &() // cast 
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE 
+CORBA_AttrDescriptionSeq_var::operator ::CORBA_AttrDescriptionSeq &() const // cast 
+{
+  return *this->ptr_;
+}
+
+// variable-size types only
+ACE_INLINE
+CORBA_AttrDescriptionSeq_var::operator ::CORBA_AttrDescriptionSeq *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE CORBA::AttributeDescription &
+CORBA_AttrDescriptionSeq_var::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+ACE_INLINE const CORBA::AttributeDescription &
+CORBA_AttrDescriptionSeq_var::operator[] (CORBA::ULong index) const
+{
+  return ACE_const_cast (const CORBA::AttributeDescription &, this->ptr_->operator[] (index));
+}
+
+ACE_INLINE const ::CORBA_AttrDescriptionSeq &
+CORBA_AttrDescriptionSeq_var::in (void) const
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE ::CORBA_AttrDescriptionSeq &
+CORBA_AttrDescriptionSeq_var::inout (void)
+{
+  return *this->ptr_;
+}
+
+// mapping for variable size 
+ACE_INLINE ::CORBA_AttrDescriptionSeq *&
+CORBA_AttrDescriptionSeq_var::out (void)
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_AttrDescriptionSeq *
+CORBA_AttrDescriptionSeq_var::_retn (void)
+{
+  ::CORBA_AttrDescriptionSeq *tmp = this->ptr_;
+  this->ptr_ = 0;
+  return tmp;
+}
+
+ACE_INLINE ::CORBA_AttrDescriptionSeq *
+CORBA_AttrDescriptionSeq_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+// *************************************************************
+// Inline operations for class CORBA_AttrDescriptionSeq_out
+// *************************************************************
+
+ACE_INLINE
+CORBA_AttrDescriptionSeq_out::CORBA_AttrDescriptionSeq_out (CORBA_AttrDescriptionSeq *&p)
+  : ptr_ (p)
+{
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA_AttrDescriptionSeq_out::CORBA_AttrDescriptionSeq_out (CORBA_AttrDescriptionSeq_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA_AttrDescriptionSeq_out::CORBA_AttrDescriptionSeq_out (const ::CORBA_AttrDescriptionSeq_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (CORBA_AttrDescriptionSeq_out&, p).ptr_)
+{}
+
+ACE_INLINE ::CORBA_AttrDescriptionSeq_out &
+CORBA_AttrDescriptionSeq_out::operator= (const ::CORBA_AttrDescriptionSeq_out &p)
+{
+  this->ptr_ = ACE_const_cast (CORBA_AttrDescriptionSeq_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE ::CORBA_AttrDescriptionSeq_out &
+CORBA_AttrDescriptionSeq_out::operator= (CORBA_AttrDescriptionSeq *p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+CORBA_AttrDescriptionSeq_out::operator ::CORBA_AttrDescriptionSeq *&() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_AttrDescriptionSeq *&
+CORBA_AttrDescriptionSeq_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_AttrDescriptionSeq *
+CORBA_AttrDescriptionSeq_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE CORBA::AttributeDescription &
+CORBA_AttrDescriptionSeq_out::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+
+#endif /* end #if !defined */
+
+// *************************************************************
+// Inline operations for class CORBA::InterfaceDef::FullInterfaceDescription_var
+// *************************************************************
+
+ACE_INLINE
+CORBA::InterfaceDef::FullInterfaceDescription_var::FullInterfaceDescription_var (void) // default constructor
+  : ptr_ (0)
+{}
+
+ACE_INLINE
+CORBA::InterfaceDef::FullInterfaceDescription_var::FullInterfaceDescription_var (FullInterfaceDescription *p)
+  : ptr_ (p)
+{}
+
+ACE_INLINE
+CORBA::InterfaceDef::FullInterfaceDescription_var::FullInterfaceDescription_var (const ::CORBA::InterfaceDef::FullInterfaceDescription_var &p) // copy constructor
+{
+  if (p.ptr_)
+    ACE_NEW (this->ptr_, ::CORBA::InterfaceDef::FullInterfaceDescription (*p.ptr_));
+  else
+    this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA::InterfaceDef::FullInterfaceDescription_var::~FullInterfaceDescription_var (void) // destructor
+{
+  delete this->ptr_;
+}
+
+ACE_INLINE CORBA::InterfaceDef::FullInterfaceDescription_var &
+CORBA::InterfaceDef::FullInterfaceDescription_var::operator= (FullInterfaceDescription *p)
+{
+  delete this->ptr_;
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE ::CORBA::InterfaceDef::FullInterfaceDescription_var &
+CORBA::InterfaceDef::FullInterfaceDescription_var::operator= (const ::CORBA::InterfaceDef::FullInterfaceDescription_var &p)
+{
+  if (this != &p)
+    {
+      if (p.ptr_ == 0)
+        {
+          delete this->ptr_;
+          this->ptr_ = 0;
+        }
+      else
+        {
+          FullInterfaceDescription *deep_copy =
+            new FullInterfaceDescription (*p.ptr_);
+          
+          if (deep_copy != 0)
+            {
+              FullInterfaceDescription *tmp = deep_copy;
+              deep_copy = this->ptr_;
+              this->ptr_ = tmp;
+              delete deep_copy;
+            }
+        }
+    }
+  
+  return *this;
+}
+
+ACE_INLINE const ::CORBA::InterfaceDef::FullInterfaceDescription *
+CORBA::InterfaceDef::FullInterfaceDescription_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA::InterfaceDef::FullInterfaceDescription *
+CORBA::InterfaceDef::FullInterfaceDescription_var::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+CORBA::InterfaceDef::FullInterfaceDescription_var::operator const ::CORBA::InterfaceDef::FullInterfaceDescription &() const // cast
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE
+CORBA::InterfaceDef::FullInterfaceDescription_var::operator ::CORBA::InterfaceDef::FullInterfaceDescription &() // cast 
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE
+CORBA::InterfaceDef::FullInterfaceDescription_var::operator ::CORBA::InterfaceDef::FullInterfaceDescription &() const // cast 
+{
+  return *this->ptr_;
+}
+
+// variable-size types only
+ACE_INLINE
+CORBA::InterfaceDef::FullInterfaceDescription_var::operator ::CORBA::InterfaceDef::FullInterfaceDescription *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE const ::CORBA::InterfaceDef::FullInterfaceDescription &
+CORBA::InterfaceDef::FullInterfaceDescription_var::in (void) const
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE ::CORBA::InterfaceDef::FullInterfaceDescription &
+CORBA::InterfaceDef::FullInterfaceDescription_var::inout (void)
+{
+  return *this->ptr_;
+}
+
+// mapping for variable size 
+ACE_INLINE ::CORBA::InterfaceDef::FullInterfaceDescription *&
+CORBA::InterfaceDef::FullInterfaceDescription_var::out (void)
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA::InterfaceDef::FullInterfaceDescription *
+CORBA::InterfaceDef::FullInterfaceDescription_var::_retn (void)
+{
+  ::CORBA::InterfaceDef::FullInterfaceDescription *tmp = this->ptr_;
+  this->ptr_ = 0;
+  return tmp;
+}
+
+ACE_INLINE ::CORBA::InterfaceDef::FullInterfaceDescription *
+CORBA::InterfaceDef::FullInterfaceDescription_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+// *************************************************************
+// Inline operations for class CORBA::InterfaceDef::FullInterfaceDescription_out
+// *************************************************************
+
+ACE_INLINE
+CORBA::InterfaceDef::FullInterfaceDescription_out::FullInterfaceDescription_out (::CORBA::InterfaceDef::FullInterfaceDescription *&p)
+  : ptr_ (p)
+{
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA::InterfaceDef::FullInterfaceDescription_out::FullInterfaceDescription_out (FullInterfaceDescription_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA::InterfaceDef::FullInterfaceDescription_out::FullInterfaceDescription_out (const ::CORBA::InterfaceDef::FullInterfaceDescription_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (FullInterfaceDescription_out&, p).ptr_)
+{}
+
+ACE_INLINE CORBA::InterfaceDef::FullInterfaceDescription_out &
+CORBA::InterfaceDef::FullInterfaceDescription_out::operator= (const ::CORBA::InterfaceDef::FullInterfaceDescription_out &p)
+{
+  this->ptr_ = ACE_const_cast (FullInterfaceDescription_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE CORBA::InterfaceDef::FullInterfaceDescription_out &
+CORBA::InterfaceDef::FullInterfaceDescription_out::operator= (FullInterfaceDescription *p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+CORBA::InterfaceDef::FullInterfaceDescription_out::operator ::CORBA::InterfaceDef::FullInterfaceDescription *&() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA::InterfaceDef::FullInterfaceDescription *&
+CORBA::InterfaceDef::FullInterfaceDescription_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA::InterfaceDef::FullInterfaceDescription *
+CORBA::InterfaceDef::FullInterfaceDescription_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+
+#if !defined (_CORBA_INTERFACEDEF___CI_)
+#define _CORBA_INTERFACEDEF___CI_
+
+ACE_INLINE
+CORBA_InterfaceDef::CORBA_InterfaceDef (
+    TAO_Stub *objref,
+    CORBA::Boolean _tao_collocated,
+    TAO_Abstract_ServantBase *servant
+  )
+  : CORBA_Object (objref, _tao_collocated, servant)
+{
+  this->CORBA_InterfaceDef_setup_collocation (_tao_collocated);
+}
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_INTERFACEDEF___VAR_CI_)
+#define _CORBA_INTERFACEDEF___VAR_CI_
+
+// *************************************************************
+// Inline operations for class CORBA_InterfaceDef_var
+// *************************************************************
+
+ACE_INLINE
+CORBA_InterfaceDef_var::CORBA_InterfaceDef_var (void) // default constructor
+  : ptr_ (CORBA_InterfaceDef::_nil ())
+{}
+
+ACE_INLINE ::CORBA_InterfaceDef_ptr
+CORBA_InterfaceDef_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+CORBA_InterfaceDef_var::CORBA_InterfaceDef_var (const ::CORBA_InterfaceDef_var &p) // copy constructor
+  : TAO_Base_var (),
+    ptr_ (CORBA_InterfaceDef::_duplicate (p.ptr ()))
+{}
+
+ACE_INLINE
+CORBA_InterfaceDef_var::~CORBA_InterfaceDef_var (void) // destructor
+{
+  CORBA::release (this->ptr_);
+}
+
+ACE_INLINE CORBA_InterfaceDef_var &
+CORBA_InterfaceDef_var::operator= (CORBA_InterfaceDef_ptr p)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE CORBA_InterfaceDef_var &
+CORBA_InterfaceDef_var::operator= (const ::CORBA_InterfaceDef_var &p)
+{
+  if (this != &p)
+  {
+    CORBA::release (this->ptr_);
+    this->ptr_ = ::CORBA_InterfaceDef::_duplicate (p.ptr ());
+  }
+  return *this;
+}
+
+ACE_INLINE 
+CORBA_InterfaceDef_var::operator const ::CORBA_InterfaceDef_ptr &() const // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+CORBA_InterfaceDef_var::operator ::CORBA_InterfaceDef_ptr &() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_InterfaceDef_ptr
+CORBA_InterfaceDef_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_InterfaceDef_ptr
+CORBA_InterfaceDef_var::in (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_InterfaceDef_ptr &
+CORBA_InterfaceDef_var::inout (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_InterfaceDef_ptr &
+CORBA_InterfaceDef_var::out (void)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = ::CORBA_InterfaceDef::_nil ();
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_InterfaceDef_ptr
+CORBA_InterfaceDef_var::_retn (void)
+{
+  // yield ownership of managed obj reference
+  ::CORBA_InterfaceDef_ptr val = this->ptr_;
+  this->ptr_ = ::CORBA_InterfaceDef::_nil ();
+  return val;
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_INTERFACEDEF___OUT_CI_)
+#define _CORBA_INTERFACEDEF___OUT_CI_
+
+// *************************************************************
+// Inline operations for class CORBA_InterfaceDef_out
+// *************************************************************
+
+ACE_INLINE
+CORBA_InterfaceDef_out::CORBA_InterfaceDef_out (CORBA_InterfaceDef_ptr &p)
+  : ptr_ (p)
+{
+  this->ptr_ = ::CORBA_InterfaceDef::_nil ();
+}
+
+ACE_INLINE
+CORBA_InterfaceDef_out::CORBA_InterfaceDef_out (CORBA_InterfaceDef_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = ::CORBA_InterfaceDef::_nil ();
+}
+
+ACE_INLINE
+CORBA_InterfaceDef_out::CORBA_InterfaceDef_out (const ::CORBA_InterfaceDef_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (CORBA_InterfaceDef_out &, p).ptr_)
+{}
+
+ACE_INLINE ::CORBA_InterfaceDef_out &
+CORBA_InterfaceDef_out::operator= (const ::CORBA_InterfaceDef_out &p)
+{
+  this->ptr_ = ACE_const_cast (CORBA_InterfaceDef_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE CORBA_InterfaceDef_out &
+CORBA_InterfaceDef_out::operator= (const ::CORBA_InterfaceDef_var &p)
+{
+  this->ptr_ = ::CORBA_InterfaceDef::_duplicate (p.ptr ());
+  return *this;
+}
+
+ACE_INLINE CORBA_InterfaceDef_out &
+CORBA_InterfaceDef_out::operator= (CORBA_InterfaceDef_ptr p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+CORBA_InterfaceDef_out::operator ::CORBA_InterfaceDef_ptr &() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_InterfaceDef_ptr &
+CORBA_InterfaceDef_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_InterfaceDef_ptr
+CORBA_InterfaceDef_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+
+#endif /* end #if !defined */
+
+// *************************************************************
+// Inline operations for class CORBA_InterfaceDescription_var
+// *************************************************************
+
+ACE_INLINE
+CORBA_InterfaceDescription_var::CORBA_InterfaceDescription_var (void) // default constructor
+  : ptr_ (0)
+{}
+
+ACE_INLINE
+CORBA_InterfaceDescription_var::CORBA_InterfaceDescription_var (CORBA_InterfaceDescription *p)
+  : ptr_ (p)
+{}
+
+ACE_INLINE
+CORBA_InterfaceDescription_var::CORBA_InterfaceDescription_var (const ::CORBA_InterfaceDescription_var &p) // copy constructor
+{
+  if (p.ptr_)
+    ACE_NEW (this->ptr_, ::CORBA_InterfaceDescription (*p.ptr_));
+  else
+    this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA_InterfaceDescription_var::~CORBA_InterfaceDescription_var (void) // destructor
+{
+  delete this->ptr_;
+}
+
+ACE_INLINE CORBA_InterfaceDescription_var &
+CORBA_InterfaceDescription_var::operator= (CORBA_InterfaceDescription *p)
+{
+  delete this->ptr_;
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE ::CORBA_InterfaceDescription_var &
+CORBA_InterfaceDescription_var::operator= (const ::CORBA_InterfaceDescription_var &p)
+{
+  if (this != &p)
+    {
+      if (p.ptr_ == 0)
+        {
+          delete this->ptr_;
+          this->ptr_ = 0;
+        }
+      else
+        {
+          CORBA_InterfaceDescription *deep_copy =
+            new CORBA_InterfaceDescription (*p.ptr_);
+          
+          if (deep_copy != 0)
+            {
+              CORBA_InterfaceDescription *tmp = deep_copy;
+              deep_copy = this->ptr_;
+              this->ptr_ = tmp;
+              delete deep_copy;
+            }
+        }
+    }
+  
+  return *this;
+}
+
+ACE_INLINE const ::CORBA_InterfaceDescription *
+CORBA_InterfaceDescription_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_InterfaceDescription *
+CORBA_InterfaceDescription_var::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+CORBA_InterfaceDescription_var::operator const ::CORBA_InterfaceDescription &() const // cast
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE
+CORBA_InterfaceDescription_var::operator ::CORBA_InterfaceDescription &() // cast 
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE
+CORBA_InterfaceDescription_var::operator ::CORBA_InterfaceDescription &() const // cast 
+{
+  return *this->ptr_;
+}
+
+// variable-size types only
+ACE_INLINE
+CORBA_InterfaceDescription_var::operator ::CORBA_InterfaceDescription *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE const ::CORBA_InterfaceDescription &
+CORBA_InterfaceDescription_var::in (void) const
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE ::CORBA_InterfaceDescription &
+CORBA_InterfaceDescription_var::inout (void)
+{
+  return *this->ptr_;
+}
+
+// mapping for variable size 
+ACE_INLINE ::CORBA_InterfaceDescription *&
+CORBA_InterfaceDescription_var::out (void)
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_InterfaceDescription *
+CORBA_InterfaceDescription_var::_retn (void)
+{
+  ::CORBA_InterfaceDescription *tmp = this->ptr_;
+  this->ptr_ = 0;
+  return tmp;
+}
+
+ACE_INLINE ::CORBA_InterfaceDescription *
+CORBA_InterfaceDescription_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+// *************************************************************
+// Inline operations for class CORBA_InterfaceDescription_out
+// *************************************************************
+
+ACE_INLINE
+CORBA_InterfaceDescription_out::CORBA_InterfaceDescription_out (::CORBA_InterfaceDescription *&p)
+  : ptr_ (p)
+{
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA_InterfaceDescription_out::CORBA_InterfaceDescription_out (CORBA_InterfaceDescription_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA_InterfaceDescription_out::CORBA_InterfaceDescription_out (const ::CORBA_InterfaceDescription_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (CORBA_InterfaceDescription_out&, p).ptr_)
+{}
+
+ACE_INLINE CORBA_InterfaceDescription_out &
+CORBA_InterfaceDescription_out::operator= (const ::CORBA_InterfaceDescription_out &p)
+{
+  this->ptr_ = ACE_const_cast (CORBA_InterfaceDescription_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE CORBA_InterfaceDescription_out &
+CORBA_InterfaceDescription_out::operator= (CORBA_InterfaceDescription *p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+CORBA_InterfaceDescription_out::operator ::CORBA_InterfaceDescription *&() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_InterfaceDescription *&
+CORBA_InterfaceDescription_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_InterfaceDescription *
+CORBA_InterfaceDescription_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+
+#if !defined (_CORBA_ABSTRACTINTERFACEDEF___CI_)
+#define _CORBA_ABSTRACTINTERFACEDEF___CI_
+
+ACE_INLINE
+CORBA_AbstractInterfaceDef::CORBA_AbstractInterfaceDef (
+    TAO_Stub *objref,
+    CORBA::Boolean _tao_collocated,
+    TAO_Abstract_ServantBase *servant
+  )
+  : CORBA_Object (objref, _tao_collocated, servant)
+{
+  this->CORBA_AbstractInterfaceDef_setup_collocation (_tao_collocated);
+}
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_ABSTRACTINTERFACEDEF___VAR_CI_)
+#define _CORBA_ABSTRACTINTERFACEDEF___VAR_CI_
+
+// *************************************************************
+// Inline operations for class CORBA_AbstractInterfaceDef_var
+// *************************************************************
+
+ACE_INLINE
+CORBA_AbstractInterfaceDef_var::CORBA_AbstractInterfaceDef_var (void) // default constructor
+  : ptr_ (CORBA_AbstractInterfaceDef::_nil ())
+{}
+
+ACE_INLINE ::CORBA_AbstractInterfaceDef_ptr
+CORBA_AbstractInterfaceDef_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+CORBA_AbstractInterfaceDef_var::CORBA_AbstractInterfaceDef_var (const ::CORBA_AbstractInterfaceDef_var &p) // copy constructor
+  : TAO_Base_var (),
+    ptr_ (CORBA_AbstractInterfaceDef::_duplicate (p.ptr ()))
+{}
+
+ACE_INLINE
+CORBA_AbstractInterfaceDef_var::~CORBA_AbstractInterfaceDef_var (void) // destructor
+{
+  CORBA::release (this->ptr_);
+}
+
+ACE_INLINE CORBA_AbstractInterfaceDef_var &
+CORBA_AbstractInterfaceDef_var::operator= (CORBA_AbstractInterfaceDef_ptr p)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE CORBA_AbstractInterfaceDef_var &
+CORBA_AbstractInterfaceDef_var::operator= (const ::CORBA_AbstractInterfaceDef_var &p)
+{
+  if (this != &p)
+  {
+    CORBA::release (this->ptr_);
+    this->ptr_ = ::CORBA_AbstractInterfaceDef::_duplicate (p.ptr ());
+  }
+  return *this;
+}
+
+ACE_INLINE 
+CORBA_AbstractInterfaceDef_var::operator const ::CORBA_AbstractInterfaceDef_ptr &() const // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+CORBA_AbstractInterfaceDef_var::operator ::CORBA_AbstractInterfaceDef_ptr &() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_AbstractInterfaceDef_ptr
+CORBA_AbstractInterfaceDef_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_AbstractInterfaceDef_ptr
+CORBA_AbstractInterfaceDef_var::in (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_AbstractInterfaceDef_ptr &
+CORBA_AbstractInterfaceDef_var::inout (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_AbstractInterfaceDef_ptr &
+CORBA_AbstractInterfaceDef_var::out (void)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = ::CORBA_AbstractInterfaceDef::_nil ();
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_AbstractInterfaceDef_ptr
+CORBA_AbstractInterfaceDef_var::_retn (void)
+{
+  // yield ownership of managed obj reference
+  ::CORBA_AbstractInterfaceDef_ptr val = this->ptr_;
+  this->ptr_ = ::CORBA_AbstractInterfaceDef::_nil ();
+  return val;
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_ABSTRACTINTERFACEDEF___OUT_CI_)
+#define _CORBA_ABSTRACTINTERFACEDEF___OUT_CI_
+
+// *************************************************************
+// Inline operations for class CORBA_AbstractInterfaceDef_out
+// *************************************************************
+
+ACE_INLINE
+CORBA_AbstractInterfaceDef_out::CORBA_AbstractInterfaceDef_out (CORBA_AbstractInterfaceDef_ptr &p)
+  : ptr_ (p)
+{
+  this->ptr_ = ::CORBA_AbstractInterfaceDef::_nil ();
+}
+
+ACE_INLINE
+CORBA_AbstractInterfaceDef_out::CORBA_AbstractInterfaceDef_out (CORBA_AbstractInterfaceDef_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = ::CORBA_AbstractInterfaceDef::_nil ();
+}
+
+ACE_INLINE
+CORBA_AbstractInterfaceDef_out::CORBA_AbstractInterfaceDef_out (const ::CORBA_AbstractInterfaceDef_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (CORBA_AbstractInterfaceDef_out &, p).ptr_)
+{}
+
+ACE_INLINE ::CORBA_AbstractInterfaceDef_out &
+CORBA_AbstractInterfaceDef_out::operator= (const ::CORBA_AbstractInterfaceDef_out &p)
+{
+  this->ptr_ = ACE_const_cast (CORBA_AbstractInterfaceDef_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE CORBA_AbstractInterfaceDef_out &
+CORBA_AbstractInterfaceDef_out::operator= (const ::CORBA_AbstractInterfaceDef_var &p)
+{
+  this->ptr_ = ::CORBA_AbstractInterfaceDef::_duplicate (p.ptr ());
+  return *this;
+}
+
+ACE_INLINE CORBA_AbstractInterfaceDef_out &
+CORBA_AbstractInterfaceDef_out::operator= (CORBA_AbstractInterfaceDef_ptr p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+CORBA_AbstractInterfaceDef_out::operator ::CORBA_AbstractInterfaceDef_ptr &() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_AbstractInterfaceDef_ptr &
+CORBA_AbstractInterfaceDef_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_AbstractInterfaceDef_ptr
+CORBA_AbstractInterfaceDef_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_LOCALINTERFACEDEF___CI_)
+#define _CORBA_LOCALINTERFACEDEF___CI_
+
+ACE_INLINE
+CORBA_LocalInterfaceDef::CORBA_LocalInterfaceDef (
+    TAO_Stub *objref,
+    CORBA::Boolean _tao_collocated,
+    TAO_Abstract_ServantBase *servant
+  )
+  : CORBA_Object (objref, _tao_collocated, servant)
+{
+  this->CORBA_LocalInterfaceDef_setup_collocation (_tao_collocated);
+}
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_LOCALINTERFACEDEF___VAR_CI_)
+#define _CORBA_LOCALINTERFACEDEF___VAR_CI_
+
+// *************************************************************
+// Inline operations for class CORBA_LocalInterfaceDef_var
+// *************************************************************
+
+ACE_INLINE
+CORBA_LocalInterfaceDef_var::CORBA_LocalInterfaceDef_var (void) // default constructor
+  : ptr_ (CORBA_LocalInterfaceDef::_nil ())
+{}
+
+ACE_INLINE ::CORBA_LocalInterfaceDef_ptr
+CORBA_LocalInterfaceDef_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+CORBA_LocalInterfaceDef_var::CORBA_LocalInterfaceDef_var (const ::CORBA_LocalInterfaceDef_var &p) // copy constructor
+  : TAO_Base_var (),
+    ptr_ (CORBA_LocalInterfaceDef::_duplicate (p.ptr ()))
+{}
+
+ACE_INLINE
+CORBA_LocalInterfaceDef_var::~CORBA_LocalInterfaceDef_var (void) // destructor
+{
+  CORBA::release (this->ptr_);
+}
+
+ACE_INLINE CORBA_LocalInterfaceDef_var &
+CORBA_LocalInterfaceDef_var::operator= (CORBA_LocalInterfaceDef_ptr p)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE CORBA_LocalInterfaceDef_var &
+CORBA_LocalInterfaceDef_var::operator= (const ::CORBA_LocalInterfaceDef_var &p)
+{
+  if (this != &p)
+  {
+    CORBA::release (this->ptr_);
+    this->ptr_ = ::CORBA_LocalInterfaceDef::_duplicate (p.ptr ());
+  }
+  return *this;
+}
+
+ACE_INLINE 
+CORBA_LocalInterfaceDef_var::operator const ::CORBA_LocalInterfaceDef_ptr &() const // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+CORBA_LocalInterfaceDef_var::operator ::CORBA_LocalInterfaceDef_ptr &() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_LocalInterfaceDef_ptr
+CORBA_LocalInterfaceDef_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_LocalInterfaceDef_ptr
+CORBA_LocalInterfaceDef_var::in (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_LocalInterfaceDef_ptr &
+CORBA_LocalInterfaceDef_var::inout (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_LocalInterfaceDef_ptr &
+CORBA_LocalInterfaceDef_var::out (void)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = ::CORBA_LocalInterfaceDef::_nil ();
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_LocalInterfaceDef_ptr
+CORBA_LocalInterfaceDef_var::_retn (void)
+{
+  // yield ownership of managed obj reference
+  ::CORBA_LocalInterfaceDef_ptr val = this->ptr_;
+  this->ptr_ = ::CORBA_LocalInterfaceDef::_nil ();
+  return val;
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_LOCALINTERFACEDEF___OUT_CI_)
+#define _CORBA_LOCALINTERFACEDEF___OUT_CI_
+
+// *************************************************************
+// Inline operations for class CORBA_LocalInterfaceDef_out
+// *************************************************************
+
+ACE_INLINE
+CORBA_LocalInterfaceDef_out::CORBA_LocalInterfaceDef_out (CORBA_LocalInterfaceDef_ptr &p)
+  : ptr_ (p)
+{
+  this->ptr_ = ::CORBA_LocalInterfaceDef::_nil ();
+}
+
+ACE_INLINE
+CORBA_LocalInterfaceDef_out::CORBA_LocalInterfaceDef_out (CORBA_LocalInterfaceDef_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = ::CORBA_LocalInterfaceDef::_nil ();
+}
+
+ACE_INLINE
+CORBA_LocalInterfaceDef_out::CORBA_LocalInterfaceDef_out (const ::CORBA_LocalInterfaceDef_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (CORBA_LocalInterfaceDef_out &, p).ptr_)
+{}
+
+ACE_INLINE ::CORBA_LocalInterfaceDef_out &
+CORBA_LocalInterfaceDef_out::operator= (const ::CORBA_LocalInterfaceDef_out &p)
+{
+  this->ptr_ = ACE_const_cast (CORBA_LocalInterfaceDef_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE CORBA_LocalInterfaceDef_out &
+CORBA_LocalInterfaceDef_out::operator= (const ::CORBA_LocalInterfaceDef_var &p)
+{
+  this->ptr_ = ::CORBA_LocalInterfaceDef::_duplicate (p.ptr ());
+  return *this;
+}
+
+ACE_INLINE CORBA_LocalInterfaceDef_out &
+CORBA_LocalInterfaceDef_out::operator= (CORBA_LocalInterfaceDef_ptr p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+CORBA_LocalInterfaceDef_out::operator ::CORBA_LocalInterfaceDef_ptr &() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_LocalInterfaceDef_ptr &
+CORBA_LocalInterfaceDef_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_LocalInterfaceDef_ptr
+CORBA_LocalInterfaceDef_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+
+#endif /* end #if !defined */
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &,
+    const CORBA::PrimitiveDef_ptr
+  );
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &,
+    CORBA::PrimitiveDef_ptr &
+  );
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &,
+    const CORBA::StringDef_ptr
+  );
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &,
+    CORBA::StringDef_ptr &
+  );
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &,
+    const CORBA::SequenceDef_ptr
+  );
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &,
+    CORBA::SequenceDef_ptr &
+  );
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &,
+    const CORBA::ArrayDef_ptr
+  );
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &,
+    CORBA::ArrayDef_ptr &
+  );
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &,
+    const CORBA::WstringDef_ptr
+  );
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &,
+    CORBA::WstringDef_ptr &
+  );
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &,
+    const CORBA::FixedDef_ptr
+  );
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &,
+    CORBA::FixedDef_ptr &
+  );
+ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA::PrimitiveKind &_tao_enumval)
+{
+  CORBA::ULong _tao_temp = _tao_enumval;
+  return strm << _tao_temp;
+}
+
+ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA::PrimitiveKind &_tao_enumval)
+{
+  CORBA::ULong _tao_temp = 0;
+  CORBA::Boolean _tao_result = strm >> _tao_temp;
+  
+  if (_tao_result == 1)
+    {
+      _tao_enumval = ACE_static_cast (CORBA::PrimitiveKind, _tao_temp);
+    }
+  
+  return _tao_result;
+}
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &,
+    const CORBA::Repository_ptr
+  );
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &,
+    CORBA::Repository_ptr &
+  );
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &strm,
+    const CORBA::Repository_ptr _tao_objref
+  )
+{
+  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
+  return (strm << _tao_corba_obj);
+}
+
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &strm,
+    CORBA::Repository_ptr &_tao_objref
+  )
+{
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::Object_var obj;
+    if ((strm >> obj.inout ()) == 0)
+      return 0;
+    // narrow to the right type
+    _tao_objref =
+      CORBA::Repository::_unchecked_narrow (
+          obj.in (),
+          ACE_TRY_ENV
+        );
+    ACE_TRY_CHECK;
+    return 1;
+  }
+  ACE_CATCHANY
+  {
+    // do nothing
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &,
+    const CORBA::ModuleDef_ptr
+  );
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &,
+    CORBA::ModuleDef_ptr &
+  );
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &strm,
+    const CORBA::ModuleDef_ptr _tao_objref
+  )
+{
+  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
+  return (strm << _tao_corba_obj);
+}
+
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &strm,
+    CORBA::ModuleDef_ptr &_tao_objref
+  )
+{
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::Object_var obj;
+    if ((strm >> obj.inout ()) == 0)
+      return 0;
+    // narrow to the right type
+    _tao_objref =
+      CORBA::ModuleDef::_unchecked_narrow (
+          obj.in (),
+          ACE_TRY_ENV
+        );
+    ACE_TRY_CHECK;
+    return 1;
+  }
+  ACE_CATCHANY
+  {
+    // do nothing
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA::ModuleDescription &_tao_aggregate)
+{
+  if (
+    (strm << _tao_aggregate.name.in ()) &&
+    (strm << _tao_aggregate.id.in ()) &&
+    (strm << _tao_aggregate.defined_in.in ()) &&
+    (strm << _tao_aggregate.version.in ())
+  )
+    return 1;
+  else
+    return 0;
+  
+}
+
+ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA::ModuleDescription &_tao_aggregate)
+{
+  if (
+    (strm >> _tao_aggregate.name.out ()) &&
+    (strm >> _tao_aggregate.id.out ()) &&
+    (strm >> _tao_aggregate.defined_in.out ()) &&
+    (strm >> _tao_aggregate.version.out ())
+  )
+    return 1;
+  else
+    return 0;
+  
+}
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &,
+    const CORBA::ConstantDef_ptr
+  );
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &,
+    CORBA::ConstantDef_ptr &
+  );
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &strm,
+    const CORBA::ConstantDef_ptr _tao_objref
+  )
+{
+  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
+  return (strm << _tao_corba_obj);
+}
+
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &strm,
+    CORBA::ConstantDef_ptr &_tao_objref
+  )
+{
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::Object_var obj;
+    if ((strm >> obj.inout ()) == 0)
+      return 0;
+    // narrow to the right type
+    _tao_objref =
+      CORBA::ConstantDef::_unchecked_narrow (
+          obj.in (),
+          ACE_TRY_ENV
+        );
+    ACE_TRY_CHECK;
+    return 1;
+  }
+  ACE_CATCHANY
+  {
+    // do nothing
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA::ConstantDescription &_tao_aggregate)
+{
+  if (
+    (strm << _tao_aggregate.name.in ()) &&
+    (strm << _tao_aggregate.id.in ()) &&
+    (strm << _tao_aggregate.defined_in.in ()) &&
+    (strm << _tao_aggregate.version.in ()) &&
+    (strm << _tao_aggregate.type.in ()) &&
+    (strm << _tao_aggregate.value)
+  )
+    return 1;
+  else
+    return 0;
+  
+}
+
+ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA::ConstantDescription &_tao_aggregate)
+{
+  if (
+    (strm >> _tao_aggregate.name.out ()) &&
+    (strm >> _tao_aggregate.id.out ()) &&
+    (strm >> _tao_aggregate.defined_in.out ()) &&
+    (strm >> _tao_aggregate.version.out ()) &&
+    (strm >> _tao_aggregate.type.out ()) &&
+    (strm >> _tao_aggregate.value)
+  )
+    return 1;
+  else
+    return 0;
+  
+}
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &,
+    const CORBA::StructDef_ptr
+  );
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &,
+    CORBA::StructDef_ptr &
+  );
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &strm,
+    const CORBA::StructDef_ptr _tao_objref
+  )
+{
+  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
+  return (strm << _tao_corba_obj);
+}
+
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &strm,
+    CORBA::StructDef_ptr &_tao_objref
+  )
+{
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::Object_var obj;
+    if ((strm >> obj.inout ()) == 0)
+      return 0;
+    // narrow to the right type
+    _tao_objref =
+      CORBA::StructDef::_unchecked_narrow (
+          obj.in (),
+          ACE_TRY_ENV
+        );
+    ACE_TRY_CHECK;
+    return 1;
+  }
+  ACE_CATCHANY
+  {
+    // do nothing
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &,
+    const CORBA::UnionDef_ptr
+  );
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &,
+    CORBA::UnionDef_ptr &
+  );
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &strm,
+    const CORBA::UnionDef_ptr _tao_objref
+  )
+{
+  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
+  return (strm << _tao_corba_obj);
+}
+
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &strm,
+    CORBA::UnionDef_ptr &_tao_objref
+  )
+{
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::Object_var obj;
+    if ((strm >> obj.inout ()) == 0)
+      return 0;
+    // narrow to the right type
+    _tao_objref =
+      CORBA::UnionDef::_unchecked_narrow (
+          obj.in (),
+          ACE_TRY_ENV
+        );
+    ACE_TRY_CHECK;
+    return 1;
+  }
+  ACE_CATCHANY
+  {
+    // do nothing
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &,
+    const CORBA::EnumDef_ptr
+  );
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &,
+    CORBA::EnumDef_ptr &
+  );
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &strm,
+    const CORBA::EnumDef_ptr _tao_objref
+  )
+{
+  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
+  return (strm << _tao_corba_obj);
+}
+
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &strm,
+    CORBA::EnumDef_ptr &_tao_objref
+  )
+{
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::Object_var obj;
+    if ((strm >> obj.inout ()) == 0)
+      return 0;
+    // narrow to the right type
+    _tao_objref =
+      CORBA::EnumDef::_unchecked_narrow (
+          obj.in (),
+          ACE_TRY_ENV
+        );
+    ACE_TRY_CHECK;
+    return 1;
+  }
+  ACE_CATCHANY
+  {
+    // do nothing
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &,
+    const CORBA::AliasDef_ptr
+  );
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &,
+    CORBA::AliasDef_ptr &
+  );
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &strm,
+    const CORBA::AliasDef_ptr _tao_objref
+  )
+{
+  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
+  return (strm << _tao_corba_obj);
+}
+
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &strm,
+    CORBA::AliasDef_ptr &_tao_objref
+  )
+{
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::Object_var obj;
+    if ((strm >> obj.inout ()) == 0)
+      return 0;
+    // narrow to the right type
+    _tao_objref =
+      CORBA::AliasDef::_unchecked_narrow (
+          obj.in (),
+          ACE_TRY_ENV
+        );
+    ACE_TRY_CHECK;
+    return 1;
+  }
+  ACE_CATCHANY
+  {
+    // do nothing
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &,
+    const CORBA::NativeDef_ptr
+  );
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &,
+    CORBA::NativeDef_ptr &
+  );
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &strm,
+    const CORBA::NativeDef_ptr _tao_objref
+  )
+{
+  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
+  return (strm << _tao_corba_obj);
+}
+
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &strm,
+    CORBA::NativeDef_ptr &_tao_objref
+  )
+{
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::Object_var obj;
+    if ((strm >> obj.inout ()) == 0)
+      return 0;
+    // narrow to the right type
+    _tao_objref =
+      CORBA::NativeDef::_unchecked_narrow (
+          obj.in (),
+          ACE_TRY_ENV
+        );
+    ACE_TRY_CHECK;
+    return 1;
+  }
+  ACE_CATCHANY
+  {
+    // do nothing
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &,
+    const CORBA::PrimitiveDef_ptr
+  );
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &,
+    CORBA::PrimitiveDef_ptr &
+  );
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &strm,
+    const CORBA::PrimitiveDef_ptr _tao_objref
+  )
+{
+  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
+  return (strm << _tao_corba_obj);
+}
+
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &strm,
+    CORBA::PrimitiveDef_ptr &_tao_objref
+  )
+{
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::Object_var obj;
+    if ((strm >> obj.inout ()) == 0)
+      return 0;
+    // narrow to the right type
+    _tao_objref =
+      CORBA::PrimitiveDef::_unchecked_narrow (
+          obj.in (),
+          ACE_TRY_ENV
+        );
+    ACE_TRY_CHECK;
+    return 1;
+  }
+  ACE_CATCHANY
+  {
+    // do nothing
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &,
+    const CORBA::StringDef_ptr
+  );
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &,
+    CORBA::StringDef_ptr &
+  );
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &strm,
+    const CORBA::StringDef_ptr _tao_objref
+  )
+{
+  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
+  return (strm << _tao_corba_obj);
+}
+
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &strm,
+    CORBA::StringDef_ptr &_tao_objref
+  )
+{
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::Object_var obj;
+    if ((strm >> obj.inout ()) == 0)
+      return 0;
+    // narrow to the right type
+    _tao_objref =
+      CORBA::StringDef::_unchecked_narrow (
+          obj.in (),
+          ACE_TRY_ENV
+        );
+    ACE_TRY_CHECK;
+    return 1;
+  }
+  ACE_CATCHANY
+  {
+    // do nothing
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &,
+    const CORBA::WstringDef_ptr
+  );
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &,
+    CORBA::WstringDef_ptr &
+  );
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &strm,
+    const CORBA::WstringDef_ptr _tao_objref
+  )
+{
+  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
+  return (strm << _tao_corba_obj);
+}
+
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &strm,
+    CORBA::WstringDef_ptr &_tao_objref
+  )
+{
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::Object_var obj;
+    if ((strm >> obj.inout ()) == 0)
+      return 0;
+    // narrow to the right type
+    _tao_objref =
+      CORBA::WstringDef::_unchecked_narrow (
+          obj.in (),
+          ACE_TRY_ENV
+        );
+    ACE_TRY_CHECK;
+    return 1;
+  }
+  ACE_CATCHANY
+  {
+    // do nothing
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &,
+    const CORBA::SequenceDef_ptr
+  );
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &,
+    CORBA::SequenceDef_ptr &
+  );
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &strm,
+    const CORBA::SequenceDef_ptr _tao_objref
+  )
+{
+  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
+  return (strm << _tao_corba_obj);
+}
+
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &strm,
+    CORBA::SequenceDef_ptr &_tao_objref
+  )
+{
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::Object_var obj;
+    if ((strm >> obj.inout ()) == 0)
+      return 0;
+    // narrow to the right type
+    _tao_objref =
+      CORBA::SequenceDef::_unchecked_narrow (
+          obj.in (),
+          ACE_TRY_ENV
+        );
+    ACE_TRY_CHECK;
+    return 1;
+  }
+  ACE_CATCHANY
+  {
+    // do nothing
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &,
+    const CORBA::ArrayDef_ptr
+  );
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &,
+    CORBA::ArrayDef_ptr &
+  );
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &strm,
+    const CORBA::ArrayDef_ptr _tao_objref
+  )
+{
+  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
+  return (strm << _tao_corba_obj);
+}
+
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &strm,
+    CORBA::ArrayDef_ptr &_tao_objref
+  )
+{
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::Object_var obj;
+    if ((strm >> obj.inout ()) == 0)
+      return 0;
+    // narrow to the right type
+    _tao_objref =
+      CORBA::ArrayDef::_unchecked_narrow (
+          obj.in (),
+          ACE_TRY_ENV
+        );
+    ACE_TRY_CHECK;
+    return 1;
+  }
+  ACE_CATCHANY
+  {
+    // do nothing
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &,
+    const CORBA::ExceptionDef_ptr
+  );
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &,
+    CORBA::ExceptionDef_ptr &
+  );
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &strm,
+    const CORBA::ExceptionDef_ptr _tao_objref
+  )
+{
+  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
+  return (strm << _tao_corba_obj);
+}
+
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &strm,
+    CORBA::ExceptionDef_ptr &_tao_objref
+  )
+{
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::Object_var obj;
+    if ((strm >> obj.inout ()) == 0)
+      return 0;
+    // narrow to the right type
+    _tao_objref =
+      CORBA::ExceptionDef::_unchecked_narrow (
+          obj.in (),
+          ACE_TRY_ENV
+        );
+    ACE_TRY_CHECK;
+    return 1;
+  }
+  ACE_CATCHANY
+  {
+    // do nothing
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA::ExceptionDescription &_tao_aggregate)
+{
+  if (
+    (strm << _tao_aggregate.name.in ()) &&
+    (strm << _tao_aggregate.id.in ()) &&
+    (strm << _tao_aggregate.defined_in.in ()) &&
+    (strm << _tao_aggregate.version.in ()) &&
+    (strm << _tao_aggregate.type.in ())
+  )
+    return 1;
+  else
+    return 0;
+  
+}
+
+ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA::ExceptionDescription &_tao_aggregate)
+{
+  if (
+    (strm >> _tao_aggregate.name.out ()) &&
+    (strm >> _tao_aggregate.id.out ()) &&
+    (strm >> _tao_aggregate.defined_in.out ()) &&
+    (strm >> _tao_aggregate.version.out ()) &&
+    (strm >> _tao_aggregate.type.out ())
+  )
+    return 1;
+  else
+    return 0;
+  
+}
+
+
+#if !defined _TAO_CDR_OP_CORBA_ExceptionDefSeq_I_
+#define _TAO_CDR_OP_CORBA_ExceptionDefSeq_I_
+
+CORBA::Boolean TAO_IFR_Client_Export operator<< (
+    TAO_OutputCDR &,
+    const CORBA::ExceptionDefSeq &
+  );
+CORBA::Boolean TAO_IFR_Client_Export operator>> (
+    TAO_InputCDR &,
+    CORBA::ExceptionDefSeq &
+  );
+
+#endif /* _TAO_CDR_OP_CORBA_ExceptionDefSeq_I_ */
+
+
+#if !defined _TAO_CDR_OP_CORBA_ExcDescriptionSeq_I_
+#define _TAO_CDR_OP_CORBA_ExcDescriptionSeq_I_
+
+CORBA::Boolean TAO_IFR_Client_Export operator<< (
+    TAO_OutputCDR &,
+    const CORBA::ExcDescriptionSeq &
+  );
+CORBA::Boolean TAO_IFR_Client_Export operator>> (
+    TAO_InputCDR &,
+    CORBA::ExcDescriptionSeq &
+  );
+
+#endif /* _TAO_CDR_OP_CORBA_ExcDescriptionSeq_I_ */
+
+ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA::AttributeMode &_tao_enumval)
+{
+  CORBA::ULong _tao_temp = _tao_enumval;
+  return strm << _tao_temp;
+}
+
+ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA::AttributeMode &_tao_enumval)
+{
+  CORBA::ULong _tao_temp = 0;
+  CORBA::Boolean _tao_result = strm >> _tao_temp;
+  
+  if (_tao_result == 1)
+    {
+      _tao_enumval = ACE_static_cast (CORBA::AttributeMode, _tao_temp);
+    }
+  
+  return _tao_result;
+}
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &,
+    const CORBA::AttributeDef_ptr
+  );
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &,
+    CORBA::AttributeDef_ptr &
+  );
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &strm,
+    const CORBA::AttributeDef_ptr _tao_objref
+  )
+{
+  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
+  return (strm << _tao_corba_obj);
+}
+
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &strm,
+    CORBA::AttributeDef_ptr &_tao_objref
+  )
+{
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::Object_var obj;
+    if ((strm >> obj.inout ()) == 0)
+      return 0;
+    // narrow to the right type
+    _tao_objref =
+      CORBA::AttributeDef::_unchecked_narrow (
+          obj.in (),
+          ACE_TRY_ENV
+        );
+    ACE_TRY_CHECK;
+    return 1;
+  }
+  ACE_CATCHANY
+  {
+    // do nothing
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA::AttributeDescription &_tao_aggregate)
+{
+  if (
+    (strm << _tao_aggregate.name.in ()) &&
+    (strm << _tao_aggregate.id.in ()) &&
+    (strm << _tao_aggregate.defined_in.in ()) &&
+    (strm << _tao_aggregate.version.in ()) &&
+    (strm << _tao_aggregate.type.in ()) &&
+    (strm << _tao_aggregate.mode)
+  )
+    return 1;
+  else
+    return 0;
+  
+}
+
+ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA::AttributeDescription &_tao_aggregate)
+{
+  if (
+    (strm >> _tao_aggregate.name.out ()) &&
+    (strm >> _tao_aggregate.id.out ()) &&
+    (strm >> _tao_aggregate.defined_in.out ()) &&
+    (strm >> _tao_aggregate.version.out ()) &&
+    (strm >> _tao_aggregate.type.out ()) &&
+    (strm >> _tao_aggregate.mode)
+  )
+    return 1;
+  else
+    return 0;
+  
+}
+
+ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA::OperationMode &_tao_enumval)
+{
+  CORBA::ULong _tao_temp = _tao_enumval;
+  return strm << _tao_temp;
+}
+
+ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA::OperationMode &_tao_enumval)
+{
+  CORBA::ULong _tao_temp = 0;
+  CORBA::Boolean _tao_result = strm >> _tao_temp;
+  
+  if (_tao_result == 1)
+    {
+      _tao_enumval = ACE_static_cast (CORBA::OperationMode, _tao_temp);
+    }
+  
+  return _tao_result;
+}
+
+ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA::ParameterMode &_tao_enumval)
+{
+  CORBA::ULong _tao_temp = _tao_enumval;
+  return strm << _tao_temp;
+}
+
+ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA::ParameterMode &_tao_enumval)
+{
+  CORBA::ULong _tao_temp = 0;
+  CORBA::Boolean _tao_result = strm >> _tao_temp;
+  
+  if (_tao_result == 1)
+    {
+      _tao_enumval = ACE_static_cast (CORBA::ParameterMode, _tao_temp);
+    }
+  
+  return _tao_result;
+}
+
+ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA::ParameterDescription &_tao_aggregate)
+{
+  if (
+    (strm << _tao_aggregate.name.in ()) &&
+    (strm << _tao_aggregate.type.in ()) &&
+    (strm << _tao_aggregate.type_def.in ()) &&
+    (strm << _tao_aggregate.mode)
+  )
+    return 1;
+  else
+    return 0;
+  
+}
+
+ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA::ParameterDescription &_tao_aggregate)
+{
+  if (
+    (strm >> _tao_aggregate.name.out ()) &&
+    (strm >> _tao_aggregate.type.out ()) &&
+    (strm >> _tao_aggregate.type_def.out ()) &&
+    (strm >> _tao_aggregate.mode)
+  )
+    return 1;
+  else
+    return 0;
+  
+}
+
+
+#if !defined _TAO_CDR_OP_CORBA_ParDescriptionSeq_I_
+#define _TAO_CDR_OP_CORBA_ParDescriptionSeq_I_
+
+CORBA::Boolean TAO_IFR_Client_Export operator<< (
+    TAO_OutputCDR &,
+    const CORBA::ParDescriptionSeq &
+  );
+CORBA::Boolean TAO_IFR_Client_Export operator>> (
+    TAO_InputCDR &,
+    CORBA::ParDescriptionSeq &
+  );
+
+#endif /* _TAO_CDR_OP_CORBA_ParDescriptionSeq_I_ */
+
+
+#if !defined _TAO_CDR_OP_CORBA_ContextIdSeq_I_
+#define _TAO_CDR_OP_CORBA_ContextIdSeq_I_
+
+CORBA::Boolean TAO_IFR_Client_Export operator<< (
+    TAO_OutputCDR &,
+    const CORBA::ContextIdSeq &
+  );
+CORBA::Boolean TAO_IFR_Client_Export operator>> (
+    TAO_InputCDR &,
+    CORBA::ContextIdSeq &
+  );
+
+#endif /* _TAO_CDR_OP_CORBA_ContextIdSeq_I_ */
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &,
+    const CORBA::OperationDef_ptr
+  );
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &,
+    CORBA::OperationDef_ptr &
+  );
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &strm,
+    const CORBA::OperationDef_ptr _tao_objref
+  )
+{
+  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
+  return (strm << _tao_corba_obj);
+}
+
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &strm,
+    CORBA::OperationDef_ptr &_tao_objref
+  )
+{
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::Object_var obj;
+    if ((strm >> obj.inout ()) == 0)
+      return 0;
+    // narrow to the right type
+    _tao_objref =
+      CORBA::OperationDef::_unchecked_narrow (
+          obj.in (),
+          ACE_TRY_ENV
+        );
+    ACE_TRY_CHECK;
+    return 1;
+  }
+  ACE_CATCHANY
+  {
+    // do nothing
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA::OperationDescription &_tao_aggregate)
+{
+  if (
+    (strm << _tao_aggregate.name.in ()) &&
+    (strm << _tao_aggregate.id.in ()) &&
+    (strm << _tao_aggregate.defined_in.in ()) &&
+    (strm << _tao_aggregate.version.in ()) &&
+    (strm << _tao_aggregate.result.in ()) &&
+    (strm << _tao_aggregate.mode) &&
+    (strm << _tao_aggregate.contexts) &&
+    (strm << _tao_aggregate.parameters) &&
+    (strm << _tao_aggregate.exceptions)
+  )
+    return 1;
+  else
+    return 0;
+  
+}
+
+ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA::OperationDescription &_tao_aggregate)
+{
+  if (
+    (strm >> _tao_aggregate.name.out ()) &&
+    (strm >> _tao_aggregate.id.out ()) &&
+    (strm >> _tao_aggregate.defined_in.out ()) &&
+    (strm >> _tao_aggregate.version.out ()) &&
+    (strm >> _tao_aggregate.result.out ()) &&
+    (strm >> _tao_aggregate.mode) &&
+    (strm >> _tao_aggregate.contexts) &&
+    (strm >> _tao_aggregate.parameters) &&
+    (strm >> _tao_aggregate.exceptions)
+  )
+    return 1;
+  else
+    return 0;
+  
+}
+
+
+#if !defined _TAO_CDR_OP_CORBA_RepositoryIdSeq_I_
+#define _TAO_CDR_OP_CORBA_RepositoryIdSeq_I_
+
+CORBA::Boolean TAO_IFR_Client_Export operator<< (
+    TAO_OutputCDR &,
+    const CORBA::RepositoryIdSeq &
+  );
+CORBA::Boolean TAO_IFR_Client_Export operator>> (
+    TAO_InputCDR &,
+    CORBA::RepositoryIdSeq &
+  );
+
+#endif /* _TAO_CDR_OP_CORBA_RepositoryIdSeq_I_ */
+
+
+#if !defined _TAO_CDR_OP_CORBA_OpDescriptionSeq_I_
+#define _TAO_CDR_OP_CORBA_OpDescriptionSeq_I_
+
+CORBA::Boolean TAO_IFR_Client_Export operator<< (
+    TAO_OutputCDR &,
+    const CORBA::OpDescriptionSeq &
+  );
+CORBA::Boolean TAO_IFR_Client_Export operator>> (
+    TAO_InputCDR &,
+    CORBA::OpDescriptionSeq &
+  );
+
+#endif /* _TAO_CDR_OP_CORBA_OpDescriptionSeq_I_ */
+
+
+#if !defined _TAO_CDR_OP_CORBA_AttrDescriptionSeq_I_
+#define _TAO_CDR_OP_CORBA_AttrDescriptionSeq_I_
+
+CORBA::Boolean TAO_IFR_Client_Export operator<< (
+    TAO_OutputCDR &,
+    const CORBA::AttrDescriptionSeq &
+  );
+CORBA::Boolean TAO_IFR_Client_Export operator>> (
+    TAO_InputCDR &,
+    CORBA::AttrDescriptionSeq &
+  );
+
+#endif /* _TAO_CDR_OP_CORBA_AttrDescriptionSeq_I_ */
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &,
+    const CORBA::InterfaceDef_ptr
+  );
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &,
+    CORBA::InterfaceDef_ptr &
+  );
+
+ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA::InterfaceDef::FullInterfaceDescription &_tao_aggregate)
+{
+  if (
+    (strm << _tao_aggregate.name.in ()) &&
+    (strm << _tao_aggregate.id.in ()) &&
+    (strm << _tao_aggregate.defined_in.in ()) &&
+    (strm << _tao_aggregate.version.in ()) &&
+    (strm << _tao_aggregate.operations) &&
+    (strm << _tao_aggregate.attributes) &&
+    (strm << _tao_aggregate.base_interfaces) &&
+    (strm << _tao_aggregate.type.in ())
+  )
+    return 1;
+  else
+    return 0;
+  
+}
+
+ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA::InterfaceDef::FullInterfaceDescription &_tao_aggregate)
+{
+  if (
+    (strm >> _tao_aggregate.name.out ()) &&
+    (strm >> _tao_aggregate.id.out ()) &&
+    (strm >> _tao_aggregate.defined_in.out ()) &&
+    (strm >> _tao_aggregate.version.out ()) &&
+    (strm >> _tao_aggregate.operations) &&
+    (strm >> _tao_aggregate.attributes) &&
+    (strm >> _tao_aggregate.base_interfaces) &&
+    (strm >> _tao_aggregate.type.out ())
+  )
+    return 1;
+  else
+    return 0;
+  
+}
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &strm,
+    const CORBA::InterfaceDef_ptr _tao_objref
+  )
+{
+  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
+  return (strm << _tao_corba_obj);
+}
+
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &strm,
+    CORBA::InterfaceDef_ptr &_tao_objref
+  )
+{
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::Object_var obj;
+    if ((strm >> obj.inout ()) == 0)
+      return 0;
+    // narrow to the right type
+    _tao_objref =
+      CORBA::InterfaceDef::_unchecked_narrow (
+          obj.in (),
+          ACE_TRY_ENV
+        );
+    ACE_TRY_CHECK;
+    return 1;
+  }
+  ACE_CATCHANY
+  {
+    // do nothing
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA::InterfaceDescription &_tao_aggregate)
+{
+  if (
+    (strm << _tao_aggregate.name.in ()) &&
+    (strm << _tao_aggregate.id.in ()) &&
+    (strm << _tao_aggregate.defined_in.in ()) &&
+    (strm << _tao_aggregate.version.in ()) &&
+    (strm << _tao_aggregate.base_interfaces)
+  )
+    return 1;
+  else
+    return 0;
+  
+}
+
+ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA::InterfaceDescription &_tao_aggregate)
+{
+  if (
+    (strm >> _tao_aggregate.name.out ()) &&
+    (strm >> _tao_aggregate.id.out ()) &&
+    (strm >> _tao_aggregate.defined_in.out ()) &&
+    (strm >> _tao_aggregate.version.out ()) &&
+    (strm >> _tao_aggregate.base_interfaces)
+  )
+    return 1;
+  else
+    return 0;
+  
+}
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &,
+    const CORBA::AbstractInterfaceDef_ptr
+  );
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &,
+    CORBA::AbstractInterfaceDef_ptr &
+  );
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &strm,
+    const CORBA::AbstractInterfaceDef_ptr _tao_objref
+  )
+{
+  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
+  return (strm << _tao_corba_obj);
+}
+
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &strm,
+    CORBA::AbstractInterfaceDef_ptr &_tao_objref
+  )
+{
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::Object_var obj;
+    if ((strm >> obj.inout ()) == 0)
+      return 0;
+    // narrow to the right type
+    _tao_objref =
+      CORBA::AbstractInterfaceDef::_unchecked_narrow (
+          obj.in (),
+          ACE_TRY_ENV
+        );
+    ACE_TRY_CHECK;
+    return 1;
+  }
+  ACE_CATCHANY
+  {
+    // do nothing
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &,
+    const CORBA::LocalInterfaceDef_ptr
+  );
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &,
+    CORBA::LocalInterfaceDef_ptr &
+  );
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &strm,
+    const CORBA::LocalInterfaceDef_ptr _tao_objref
+  )
+{
+  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
+  return (strm << _tao_corba_obj);
+}
+
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &strm,
+    CORBA::LocalInterfaceDef_ptr &_tao_objref
+  )
+{
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::Object_var obj;
+    if ((strm >> obj.inout ()) == 0)
+      return 0;
+    // narrow to the right type
+    _tao_objref =
+      CORBA::LocalInterfaceDef::_unchecked_narrow (
+          obj.in (),
+          ACE_TRY_ENV
+        );
+    ACE_TRY_CHECK;
+    return 1;
+  }
+  ACE_CATCHANY
+  {
+    // do nothing
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
diff --git a/TAO/tao/IFR_Client/IFR_Client_Adapter_Impl.cpp b/TAO/tao/IFR_Client/IFR_Client_Adapter_Impl.cpp
index 0fe94923af8..b97412253ed 100644
--- a/TAO/tao/IFR_Client/IFR_Client_Adapter_Impl.cpp
+++ b/TAO/tao/IFR_Client/IFR_Client_Adapter_Impl.cpp
@@ -1,8 +1,9 @@
 // $Id$
 
 #include "IFR_Client_Adapter_Impl.h"
-#include "InterfaceC.h"
+#include "IFR_ExtendedC.h"
 #include "tao/ORB_Core.h"
+#include "tao/Invocation.h"
 
 ACE_RCSID(IFR_Client, IFR_Client_Adapter_Impl, "$Id$")
 
@@ -13,7 +14,7 @@ TAO_IFR_Client_Adapter_Impl::~TAO_IFR_Client_Adapter_Impl (void)
 CORBA::Boolean 
 TAO_IFR_Client_Adapter_Impl::interfacedef_cdr_insert (
     TAO_OutputCDR &cdr,
-    IR_InterfaceDef *object_type
+    CORBA_InterfaceDef_ptr object_type
   )
 {
   return cdr << object_type;
@@ -22,13 +23,21 @@ TAO_IFR_Client_Adapter_Impl::interfacedef_cdr_insert (
 void 
 TAO_IFR_Client_Adapter_Impl::interfacedef_any_insert (
     CORBA_Any &any,
-    IR_InterfaceDef *object_type
+    CORBA_InterfaceDef_ptr object_type
   )
 {
   any <<= object_type;
 }
 
-IR_InterfaceDef *
+void
+TAO_IFR_Client_Adapter_Impl::dispose (
+    CORBA_InterfaceDef_ptr orphan
+  )
+{
+  CORBA::release (orphan);
+}
+
+CORBA_InterfaceDef_ptr
 TAO_IFR_Client_Adapter_Impl::get_interface (
     CORBA::ORB_ptr orb,
     const char *repo_id,
@@ -38,56 +47,116 @@ TAO_IFR_Client_Adapter_Impl::get_interface (
   CORBA::Object_var obj =
     orb->resolve_initial_references ("InterfaceRepository",
                                      ACE_TRY_ENV);
-  ACE_CHECK_RETURN (IR_InterfaceDef::_nil ());
+  ACE_CHECK_RETURN (CORBA_InterfaceDef::_nil ());
 
-  IR_Repository_var repo = IR_Repository::_narrow (obj.in (),
-                                                   ACE_TRY_ENV);
-  ACE_CHECK_RETURN (IR_InterfaceDef::_nil ());
+  if (CORBA::is_nil (obj.in ()))
+    {
+      ACE_THROW_RETURN (CORBA::INTF_REPOS (),
+                        CORBA_InterfaceDef::_nil ());
+    }
+
+  CORBA_Repository_var repo = 
+    CORBA_Repository::_narrow (obj.in (),
+                               ACE_TRY_ENV);
+  ACE_CHECK_RETURN (CORBA_InterfaceDef::_nil ());
 
-  IR_Contained_var result = repo->lookup_id (repo_id,
-                                             ACE_TRY_ENV);
-  ACE_CHECK_RETURN (IR_InterfaceDef::_nil ());
+  if (CORBA::is_nil (repo.in ()))
+    {
+      ACE_THROW_RETURN (CORBA::INTF_REPOS (),
+                        CORBA_InterfaceDef::_nil ());
+    }
+
+  CORBA_Contained_var result = repo->lookup_id (repo_id,
+                                                ACE_TRY_ENV);
+  ACE_CHECK_RETURN (CORBA_InterfaceDef::_nil ());
 
   if (CORBA::is_nil (result.in ()))
     {
-      return IR_InterfaceDef::_nil ();
+      return CORBA_InterfaceDef::_nil ();
     }
   else
     {
-      return IR_InterfaceDef::_narrow (result.in (),
-                                       ACE_TRY_ENV);
+      return CORBA_InterfaceDef::_narrow (result.in (),
+                                          ACE_TRY_ENV);
     }
 }
 
-CORBA_IRObject_ptr 
-TAO_IFR_Client_Adapter_Impl::get_interface_def (
-    CORBA::ORB_ptr orb,
-    const char *repo_id,
-    CORBA::Environment &ACE_TRY_ENV
+CORBA_InterfaceDef_ptr 
+TAO_IFR_Client_Adapter_Impl::get_interface_remote (
+    const CORBA::Object_ptr target,
+    CORBA_Environment &ACE_TRY_ENV
   )
 {
-  CORBA::Object_var obj =
-    orb->resolve_initial_references ("InterfaceRepository",
-                                     ACE_TRY_ENV);
-  ACE_CHECK_RETURN (CORBA_IRObject::_nil ());
+  CORBA_InterfaceDef_ptr _tao_retval = CORBA_InterfaceDef::_nil ();
+  CORBA_InterfaceDef_var _tao_safe_retval (_tao_retval);
+
+  ACE_TRY
+    {
+      // Must catch exceptions, if the server raises a
+      // CORBA::OBJECT_NOT_EXIST then we must return 1, instead of
+      // propagating the exception.
+      TAO_Stub *istub = target->_stubobj ();
+      if (istub == 0)
+        ACE_THROW_RETURN (CORBA::INTERNAL (
+                            CORBA_SystemException::_tao_minor_code (
+                              TAO_DEFAULT_MINOR_CODE,
+                              EINVAL),
+                            CORBA::COMPLETED_NO),
+                          _tao_retval);
 
-  IR_Repository_var repo = IR_Repository::_narrow (obj.in (),
-                                                   ACE_TRY_ENV);
-  ACE_CHECK_RETURN (CORBA_IRObject::_nil ());
+      TAO_GIOP_Twoway_Invocation _tao_call (istub,
+                                            "_interface",
+                                            10,
+                                            1,
+                                            istub->orb_core ());
 
-  IR_Contained_var result = repo->lookup_id (repo_id,
-                                             ACE_TRY_ENV);
-  ACE_CHECK_RETURN (CORBA_IRObject::_nil ());
+      for (;;)
+        {
+          _tao_call.start (ACE_TRY_ENV);
+          ACE_TRY_CHECK;
 
-  if (CORBA::is_nil (result.in ()))
+          CORBA::Short flag = TAO_TWOWAY_RESPONSE_FLAG;
+
+          _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
+                                    ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+
+          int _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+
+          if (_invoke_status == TAO_INVOKE_RESTART)
+            {
+              _tao_call.restart_flag (1);
+              continue;
+            }
+
+          ACE_ASSERT (_invoke_status != TAO_INVOKE_EXCEPTION);
+          if (_invoke_status != TAO_INVOKE_OK)
+            {
+              ACE_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE,
+                                                CORBA::COMPLETED_YES),
+                                CORBA_InterfaceDef::_nil ());
+            }
+          break;
+        }
+      TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+      if (!(
+            (_tao_in >> _tao_safe_retval.inout ())
+            ))
+        ACE_THROW_RETURN (CORBA::MARSHAL (), CORBA_InterfaceDef::_nil ());
+    }
+  ACE_CATCH (CORBA::OBJECT_NOT_EXIST, ex)
     {
-      return CORBA_IRObject::_nil ();
+      return CORBA_InterfaceDef::_nil ();
     }
-  else
+  ACE_CATCHANY
     {
-      return CORBA_IRObject::_narrow (result.in (),
-                                      ACE_TRY_ENV);
+      ACE_RE_THROW;
     }
+  ACE_ENDTRY;
+
+  return _tao_safe_retval._retn ();
 }
 
 // *********************************************************************
@@ -97,20 +166,22 @@ TAO_IFR_Client_Adapter_Impl::get_interface_def (
 static const CORBA::Long _oc_CORBA_Identifier[] =
 {
   TAO_ENCAP_BYTE_ORDER, // byte order
-  25,
-  ACE_NTOHL (0x49444c3a),
-  ACE_NTOHL (0x434f5242),
-  ACE_NTOHL (0x412f4964),
-  ACE_NTOHL (0x656e7469),
-  ACE_NTOHL (0x66696572),
-  ACE_NTOHL (0x3a312e30),
-  ACE_NTOHL (0xfdfdfd),  // repository ID = IDL:CORBA/Identifier:1.0
+  33,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x434f5242), 
+  ACE_NTOHL (0x412f4964), 
+  ACE_NTOHL (0x656e7469), 
+  ACE_NTOHL (0x66696572), 
+  ACE_NTOHL (0x3a312e30), 
+  ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
   11,
-  ACE_NTOHL (0x4964656e),
-  ACE_NTOHL (0x74696669),
-  ACE_NTOHL (0x657200fd),  // name = Identifier
-  CORBA::tk_string,
-  0, // string length
+  ACE_NTOHL (0x4964656e), 
+  ACE_NTOHL (0x74696669), 
+  ACE_NTOHL (0x65720000),  // name = Identifier
+  CORBA::tk_string, 
+  0U, // string length
 };
 
 static CORBA::TypeCode _tc_TAO_tc_CORBA_Identifier (
@@ -124,15 +195,17 @@ static CORBA::TypeCode _tc_TAO_tc_CORBA_Identifier (
 static const CORBA::Long _oc_CORBA_ScopedName[] =
 {
   TAO_ENCAP_BYTE_ORDER, // byte order
-  25, 
+  33,
   ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
   ACE_NTOHL (0x434f5242), 
   ACE_NTOHL (0x412f5363), 
   ACE_NTOHL (0x6f706564), 
   ACE_NTOHL (0x4e616d65), 
   ACE_NTOHL (0x3a312e30), 
-  ACE_NTOHL (0x0),  // repository ID = IDL:CORBA/ScopedName:1.0
-  11, 
+  ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/ScopedName:1.0
+  11,
   ACE_NTOHL (0x53636f70), 
   ACE_NTOHL (0x65644e61), 
   ACE_NTOHL (0x6d650000),  // name = ScopedName
@@ -151,21 +224,23 @@ static CORBA::TypeCode _tc_TAO_tc_CORBA_ScopedName (
 static const CORBA::Long _oc_CORBA_RepositoryId[] =
 {
   TAO_ENCAP_BYTE_ORDER, // byte order
-  27,
-  ACE_NTOHL (0x49444c3a),
-  ACE_NTOHL (0x434f5242),
-  ACE_NTOHL (0x412f5265),
-  ACE_NTOHL (0x706f7369),
-  ACE_NTOHL (0x746f7279),
-  ACE_NTOHL (0x49643a31),
-  ACE_NTOHL (0x2e3000fd),  // repository ID = IDL:CORBA/RepositoryId:1.0
+  35,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x434f5242), 
+  ACE_NTOHL (0x412f5265), 
+  ACE_NTOHL (0x706f7369), 
+  ACE_NTOHL (0x746f7279), 
+  ACE_NTOHL (0x49643a31), 
+  ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
   13,
-  ACE_NTOHL (0x5265706f),
-  ACE_NTOHL (0x7369746f),
-  ACE_NTOHL (0x72794964),
-  ACE_NTOHL (0xfdfdfd),  // name = RepositoryId
-  CORBA::tk_string,
-  0, // string length
+  ACE_NTOHL (0x5265706f), 
+  ACE_NTOHL (0x7369746f), 
+  ACE_NTOHL (0x72794964), 
+  ACE_NTOHL (0x0),  // name = RepositoryId
+  CORBA::tk_string, 
+  0U, // string length
 };
 
 static CORBA::TypeCode _tc_TAO_tc_CORBA_RepositoryId (
@@ -176,32 +251,6 @@ static CORBA::TypeCode _tc_TAO_tc_CORBA_RepositoryId (
     sizeof (CORBA::RepositoryId)
   );
 
-static const CORBA::Long _oc_CORBA_IRObject[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  31, 
-  ACE_NTOHL (0x49444c3a), 
-  ACE_NTOHL (0x6f6d672e), 
-  ACE_NTOHL (0x6f72672f), 
-  ACE_NTOHL (0x434f5242), 
-  ACE_NTOHL (0x412f4952), 
-  ACE_NTOHL (0x4f626a65), 
-  ACE_NTOHL (0x63743a31), 
-  ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/IRObject:1.0
-  9, 
-  ACE_NTOHL (0x49524f62), 
-  ACE_NTOHL (0x6a656374), 
-  ACE_NTOHL (0x0),  // name = IRObject
-};
-
-static CORBA::TypeCode _tc_TAO_tc_CORBA_IRObject (
-    CORBA::tk_objref, 
-    sizeof (_oc_CORBA_IRObject), 
-    (char *) &_oc_CORBA_IRObject,
-    0, 
-    sizeof (CORBA_IRObject)
-  );
-
 static const CORBA::Long _oc_CORBA_Visibility[] =
 {
   TAO_ENCAP_BYTE_ORDER, // byte order
@@ -255,6 +304,5587 @@ static CORBA::TypeCode _tc_TAO_tc_CORBA_ValueModifier (
     sizeof (CORBA::ValueModifier)
   );
 
+static const CORBA::Long _oc_CORBA_DefinitionKind[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  37,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x434f5242), 
+  ACE_NTOHL (0x412f4465), 
+  ACE_NTOHL (0x66696e69), 
+  ACE_NTOHL (0x74696f6e), 
+  ACE_NTOHL (0x4b696e64), 
+  ACE_NTOHL (0x3a312e30), 
+  ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/DefinitionKind:1.0
+  15,
+  ACE_NTOHL (0x44656669), 
+  ACE_NTOHL (0x6e697469), 
+  ACE_NTOHL (0x6f6e4b69), 
+  ACE_NTOHL (0x6e640000),  // name = DefinitionKind
+  26, // member count
+  8,
+  ACE_NTOHL (0x646b5f6e), 
+  ACE_NTOHL (0x6f6e6500),  // name = dk_none
+  7,
+  ACE_NTOHL (0x646b5f61), 
+  ACE_NTOHL (0x6c6c0000),  // name = dk_all
+  13,
+  ACE_NTOHL (0x646b5f41), 
+  ACE_NTOHL (0x74747269), 
+  ACE_NTOHL (0x62757465), 
+  ACE_NTOHL (0x0),  // name = dk_Attribute
+  12,
+  ACE_NTOHL (0x646b5f43), 
+  ACE_NTOHL (0x6f6e7374), 
+  ACE_NTOHL (0x616e7400),  // name = dk_Constant
+  13,
+  ACE_NTOHL (0x646b5f45), 
+  ACE_NTOHL (0x78636570), 
+  ACE_NTOHL (0x74696f6e), 
+  ACE_NTOHL (0x0),  // name = dk_Exception
+  13,
+  ACE_NTOHL (0x646b5f49), 
+  ACE_NTOHL (0x6e746572), 
+  ACE_NTOHL (0x66616365), 
+  ACE_NTOHL (0x0),  // name = dk_Interface
+  10,
+  ACE_NTOHL (0x646b5f4d), 
+  ACE_NTOHL (0x6f64756c), 
+  ACE_NTOHL (0x65000000),  // name = dk_Module
+  13,
+  ACE_NTOHL (0x646b5f4f), 
+  ACE_NTOHL (0x70657261), 
+  ACE_NTOHL (0x74696f6e), 
+  ACE_NTOHL (0x0),  // name = dk_Operation
+  11,
+  ACE_NTOHL (0x646b5f54), 
+  ACE_NTOHL (0x79706564), 
+  ACE_NTOHL (0x65660000),  // name = dk_Typedef
+  9,
+  ACE_NTOHL (0x646b5f41), 
+  ACE_NTOHL (0x6c696173), 
+  ACE_NTOHL (0x0),  // name = dk_Alias
+  10,
+  ACE_NTOHL (0x646b5f53), 
+  ACE_NTOHL (0x74727563), 
+  ACE_NTOHL (0x74000000),  // name = dk_Struct
+  9,
+  ACE_NTOHL (0x646b5f55), 
+  ACE_NTOHL (0x6e696f6e), 
+  ACE_NTOHL (0x0),  // name = dk_Union
+  8,
+  ACE_NTOHL (0x646b5f45), 
+  ACE_NTOHL (0x6e756d00),  // name = dk_Enum
+  13,
+  ACE_NTOHL (0x646b5f50), 
+  ACE_NTOHL (0x72696d69), 
+  ACE_NTOHL (0x74697665), 
+  ACE_NTOHL (0x0),  // name = dk_Primitive
+  10,
+  ACE_NTOHL (0x646b5f53), 
+  ACE_NTOHL (0x7472696e), 
+  ACE_NTOHL (0x67000000),  // name = dk_String
+  12,
+  ACE_NTOHL (0x646b5f53), 
+  ACE_NTOHL (0x65717565), 
+  ACE_NTOHL (0x6e636500),  // name = dk_Sequence
+  9,
+  ACE_NTOHL (0x646b5f41), 
+  ACE_NTOHL (0x72726179), 
+  ACE_NTOHL (0x0),  // name = dk_Array
+  14,
+  ACE_NTOHL (0x646b5f52), 
+  ACE_NTOHL (0x65706f73), 
+  ACE_NTOHL (0x69746f72), 
+  ACE_NTOHL (0x79000000),  // name = dk_Repository
+  11,
+  ACE_NTOHL (0x646b5f57), 
+  ACE_NTOHL (0x73747269), 
+  ACE_NTOHL (0x6e670000),  // name = dk_Wstring
+  9,
+  ACE_NTOHL (0x646b5f46), 
+  ACE_NTOHL (0x69786564), 
+  ACE_NTOHL (0x0),  // name = dk_Fixed
+  9,
+  ACE_NTOHL (0x646b5f56), 
+  ACE_NTOHL (0x616c7565), 
+  ACE_NTOHL (0x0),  // name = dk_Value
+  12,
+  ACE_NTOHL (0x646b5f56), 
+  ACE_NTOHL (0x616c7565), 
+  ACE_NTOHL (0x426f7800),  // name = dk_ValueBox
+  15,
+  ACE_NTOHL (0x646b5f56), 
+  ACE_NTOHL (0x616c7565), 
+  ACE_NTOHL (0x4d656d62), 
+  ACE_NTOHL (0x65720000),  // name = dk_ValueMember
+  10,
+  ACE_NTOHL (0x646b5f4e), 
+  ACE_NTOHL (0x61746976), 
+  ACE_NTOHL (0x65000000),  // name = dk_Native
+  21,
+  ACE_NTOHL (0x646b5f41), 
+  ACE_NTOHL (0x62737472), 
+  ACE_NTOHL (0x61637449), 
+  ACE_NTOHL (0x6e746572), 
+  ACE_NTOHL (0x66616365), 
+  ACE_NTOHL (0x0),  // name = dk_AbstractInterface
+  18,
+  ACE_NTOHL (0x646b5f4c), 
+  ACE_NTOHL (0x6f63616c), 
+  ACE_NTOHL (0x496e7465), 
+  ACE_NTOHL (0x72666163), 
+  ACE_NTOHL (0x65000000),  // name = dk_LocalInterface
+};
+
+static CORBA::TypeCode _tc_TAO_tc_CORBA_DefinitionKind (
+    CORBA::tk_enum,
+    sizeof (_oc_CORBA_DefinitionKind),
+    (char *) &_oc_CORBA_DefinitionKind,
+    0,
+    sizeof (CORBA::DefinitionKind)
+  );
+
+static const CORBA::Long _oc_CORBA_IRObject[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  31, 
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x434f5242), 
+  ACE_NTOHL (0x412f4952), 
+  ACE_NTOHL (0x4f626a65), 
+  ACE_NTOHL (0x63743a31), 
+  ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/IRObject:1.0
+  9, 
+  ACE_NTOHL (0x49524f62), 
+  ACE_NTOHL (0x6a656374), 
+  ACE_NTOHL (0x0),  // name = IRObject
+};
+
+static CORBA::TypeCode _tc_TAO_tc_CORBA_IRObject (
+    CORBA::tk_objref, 
+    sizeof (_oc_CORBA_IRObject), 
+    (char *) &_oc_CORBA_IRObject,
+    0, 
+    sizeof (CORBA_IRObject)
+  );
+
+static const CORBA::Long _oc_CORBA_VersionSpec[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  34,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x434f5242), 
+  ACE_NTOHL (0x412f5665), 
+  ACE_NTOHL (0x7273696f), 
+  ACE_NTOHL (0x6e537065), 
+  ACE_NTOHL (0x633a312e), 
+  ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/VersionSpec:1.0
+  12,
+  ACE_NTOHL (0x56657273), 
+  ACE_NTOHL (0x696f6e53), 
+  ACE_NTOHL (0x70656300),  // name = VersionSpec
+  CORBA::tk_string, 
+  0U, // string length
+};
+
+static CORBA::TypeCode _tc_TAO_tc_CORBA_VersionSpec (
+    CORBA::tk_alias,
+    sizeof (_oc_CORBA_VersionSpec),
+    (char *) &_oc_CORBA_VersionSpec,
+    0,
+    sizeof (CORBA::VersionSpec)
+  );
+
+static const CORBA::Long _oc_CORBA_Contained[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  32,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x434f5242), 
+  ACE_NTOHL (0x412f436f), 
+  ACE_NTOHL (0x6e746169), 
+  ACE_NTOHL (0x6e65643a), 
+  ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/Contained:1.0
+  10,
+  ACE_NTOHL (0x436f6e74), 
+  ACE_NTOHL (0x61696e65), 
+  ACE_NTOHL (0x64000000),  // name = Contained
+};
+
+static CORBA::TypeCode _tc_TAO_tc_CORBA_Contained (
+    CORBA::tk_objref,
+    sizeof (_oc_CORBA_Contained),
+    (char *) &_oc_CORBA_Contained,
+    0,
+    sizeof (CORBA::Contained)
+  );
+
+static const CORBA::Long _oc_CORBA_ContainedSeq[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  35,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x434f5242), 
+  ACE_NTOHL (0x412f436f), 
+  ACE_NTOHL (0x6e746169), 
+  ACE_NTOHL (0x6e656453), 
+  ACE_NTOHL (0x65713a31), 
+  ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/ContainedSeq:1.0
+  13,
+  ACE_NTOHL (0x436f6e74), 
+  ACE_NTOHL (0x61696e65), 
+  ACE_NTOHL (0x64536571), 
+  ACE_NTOHL (0x0),  // name = ContainedSeq
+  CORBA::tk_sequence, // typecode kind
+  72, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    CORBA::tk_objref, // typecode kind
+    56, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      32,
+      ACE_NTOHL (0x49444c3a), 
+      ACE_NTOHL (0x6f6d672e), 
+      ACE_NTOHL (0x6f72672f), 
+      ACE_NTOHL (0x434f5242), 
+      ACE_NTOHL (0x412f436f), 
+      ACE_NTOHL (0x6e746169), 
+      ACE_NTOHL (0x6e65643a), 
+      ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/Contained:1.0
+      10,
+      ACE_NTOHL (0x436f6e74), 
+      ACE_NTOHL (0x61696e65), 
+      ACE_NTOHL (0x64000000),  // name = Contained
+
+    0U,
+
+};
+
+static CORBA::TypeCode _tc_TAO_tc_CORBA_ContainedSeq (
+    CORBA::tk_alias,
+    sizeof (_oc_CORBA_ContainedSeq),
+    (char *) &_oc_CORBA_ContainedSeq,
+    0,
+    sizeof (CORBA::ContainedSeq)
+  );
+
+static const CORBA::Long _oc_CORBA_InterfaceDefSeq[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  38,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x434f5242), 
+  ACE_NTOHL (0x412f496e), 
+  ACE_NTOHL (0x74657266), 
+  ACE_NTOHL (0x61636544), 
+  ACE_NTOHL (0x65665365), 
+  ACE_NTOHL (0x713a312e), 
+  ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/InterfaceDefSeq:1.0
+  16,
+  ACE_NTOHL (0x496e7465), 
+  ACE_NTOHL (0x72666163), 
+  ACE_NTOHL (0x65446566), 
+  ACE_NTOHL (0x53657100),  // name = InterfaceDefSeq
+  CORBA::tk_sequence, // typecode kind
+  80, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    CORBA::tk_objref, // typecode kind
+    64, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      35,
+      ACE_NTOHL (0x49444c3a), 
+      ACE_NTOHL (0x6f6d672e), 
+      ACE_NTOHL (0x6f72672f), 
+      ACE_NTOHL (0x434f5242), 
+      ACE_NTOHL (0x412f496e), 
+      ACE_NTOHL (0x74657266), 
+      ACE_NTOHL (0x61636544), 
+      ACE_NTOHL (0x65663a31), 
+      ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/InterfaceDef:1.0
+      13,
+      ACE_NTOHL (0x496e7465), 
+      ACE_NTOHL (0x72666163), 
+      ACE_NTOHL (0x65446566), 
+      ACE_NTOHL (0x0),  // name = InterfaceDef
+
+    0U,
+
+};
+
+static CORBA::TypeCode _tc_TAO_tc_CORBA_InterfaceDefSeq (
+    CORBA::tk_alias,
+    sizeof (_oc_CORBA_InterfaceDefSeq),
+    (char *) &_oc_CORBA_InterfaceDefSeq,
+    0,
+    sizeof (CORBA::InterfaceDefSeq)
+  );
+
+static const CORBA::Long _oc_CORBA_AbstractInterfaceDefSeq[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  46,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x434f5242), 
+  ACE_NTOHL (0x412f4162), 
+  ACE_NTOHL (0x73747261), 
+  ACE_NTOHL (0x6374496e), 
+  ACE_NTOHL (0x74657266), 
+  ACE_NTOHL (0x61636544), 
+  ACE_NTOHL (0x65665365), 
+  ACE_NTOHL (0x713a312e), 
+  ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/AbstractInterfaceDefSeq:1.0
+  24,
+  ACE_NTOHL (0x41627374), 
+  ACE_NTOHL (0x72616374), 
+  ACE_NTOHL (0x496e7465), 
+  ACE_NTOHL (0x72666163), 
+  ACE_NTOHL (0x65446566), 
+  ACE_NTOHL (0x53657100),  // name = AbstractInterfaceDefSeq
+  CORBA::tk_sequence, // typecode kind
+  96, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    CORBA::tk_objref, // typecode kind
+    80, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      43,
+      ACE_NTOHL (0x49444c3a), 
+      ACE_NTOHL (0x6f6d672e), 
+      ACE_NTOHL (0x6f72672f), 
+      ACE_NTOHL (0x434f5242), 
+      ACE_NTOHL (0x412f4162), 
+      ACE_NTOHL (0x73747261), 
+      ACE_NTOHL (0x6374496e), 
+      ACE_NTOHL (0x74657266), 
+      ACE_NTOHL (0x61636544), 
+      ACE_NTOHL (0x65663a31), 
+      ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/AbstractInterfaceDef:1.0
+      21,
+      ACE_NTOHL (0x41627374), 
+      ACE_NTOHL (0x72616374), 
+      ACE_NTOHL (0x496e7465), 
+      ACE_NTOHL (0x72666163), 
+      ACE_NTOHL (0x65446566), 
+      ACE_NTOHL (0x0),  // name = AbstractInterfaceDef
+
+    0U,
+
+};
+
+static CORBA::TypeCode _tc_TAO_tc_CORBA_AbstractInterfaceDefSeq (
+    CORBA::tk_alias,
+    sizeof (_oc_CORBA_AbstractInterfaceDefSeq),
+    (char *) &_oc_CORBA_AbstractInterfaceDefSeq,
+    0,
+    sizeof (CORBA::AbstractInterfaceDefSeq)
+  );
+
+static const CORBA::Long _oc_CORBA_LocalInterfaceDefSeq[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  43,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x434f5242), 
+  ACE_NTOHL (0x412f4c6f), 
+  ACE_NTOHL (0x63616c49), 
+  ACE_NTOHL (0x6e746572), 
+  ACE_NTOHL (0x66616365), 
+  ACE_NTOHL (0x44656653), 
+  ACE_NTOHL (0x65713a31), 
+  ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/LocalInterfaceDefSeq:1.0
+  21,
+  ACE_NTOHL (0x4c6f6361), 
+  ACE_NTOHL (0x6c496e74), 
+  ACE_NTOHL (0x65726661), 
+  ACE_NTOHL (0x63654465), 
+  ACE_NTOHL (0x66536571), 
+  ACE_NTOHL (0x0),  // name = LocalInterfaceDefSeq
+  CORBA::tk_sequence, // typecode kind
+  88, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    CORBA::tk_objref, // typecode kind
+    72, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      40,
+      ACE_NTOHL (0x49444c3a), 
+      ACE_NTOHL (0x6f6d672e), 
+      ACE_NTOHL (0x6f72672f), 
+      ACE_NTOHL (0x434f5242), 
+      ACE_NTOHL (0x412f4c6f), 
+      ACE_NTOHL (0x63616c49), 
+      ACE_NTOHL (0x6e746572), 
+      ACE_NTOHL (0x66616365), 
+      ACE_NTOHL (0x4465663a), 
+      ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/LocalInterfaceDef:1.0
+      18,
+      ACE_NTOHL (0x4c6f6361), 
+      ACE_NTOHL (0x6c496e74), 
+      ACE_NTOHL (0x65726661), 
+      ACE_NTOHL (0x63654465), 
+      ACE_NTOHL (0x66000000),  // name = LocalInterfaceDef
+
+    0U,
+
+};
+
+static CORBA::TypeCode _tc_TAO_tc_CORBA_LocalInterfaceDefSeq (
+    CORBA::tk_alias,
+    sizeof (_oc_CORBA_LocalInterfaceDefSeq),
+    (char *) &_oc_CORBA_LocalInterfaceDefSeq,
+    0,
+    sizeof (CORBA::LocalInterfaceDefSeq)
+  );
+
+static const CORBA::Long _oc_CORBA_StructMember[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  35,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x434f5242), 
+  ACE_NTOHL (0x412f5374), 
+  ACE_NTOHL (0x72756374), 
+  ACE_NTOHL (0x4d656d62), 
+  ACE_NTOHL (0x65723a31), 
+  ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/StructMember:1.0
+  13,
+  ACE_NTOHL (0x53747275), 
+  ACE_NTOHL (0x63744d65), 
+  ACE_NTOHL (0x6d626572), 
+  ACE_NTOHL (0x0),  // name = StructMember
+  3, // member count
+  5,
+  ACE_NTOHL (0x6e616d65), 
+  ACE_NTOHL (0x0),  // name = name
+  CORBA::tk_alias, // typecode kind for typedefs
+  68, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    33,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x434f5242), 
+    ACE_NTOHL (0x412f4964), 
+    ACE_NTOHL (0x656e7469), 
+    ACE_NTOHL (0x66696572), 
+    ACE_NTOHL (0x3a312e30), 
+    ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+    11,
+    ACE_NTOHL (0x4964656e), 
+    ACE_NTOHL (0x74696669), 
+    ACE_NTOHL (0x65720000),  // name = Identifier
+    CORBA::tk_string, 
+    0U, // string length
+
+  5,
+  ACE_NTOHL (0x74797065), 
+  ACE_NTOHL (0x0),  // name = type
+  CORBA::tk_TypeCode,
+
+  9,
+  ACE_NTOHL (0x74797065), 
+  ACE_NTOHL (0x5f646566), 
+  ACE_NTOHL (0x0),  // name = type_def
+  CORBA::tk_objref, // typecode kind
+  52, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    30,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x434f5242), 
+    ACE_NTOHL (0x412f4944), 
+    ACE_NTOHL (0x4c547970), 
+    ACE_NTOHL (0x653a312e), 
+    ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/IDLType:1.0
+    8,
+    ACE_NTOHL (0x49444c54), 
+    ACE_NTOHL (0x79706500),  // name = IDLType
+
+};
+
+static CORBA::TypeCode _tc_TAO_tc_CORBA_StructMember (
+    CORBA::tk_struct,
+    sizeof (_oc_CORBA_StructMember),
+    (char *) &_oc_CORBA_StructMember,
+    0,
+    sizeof (CORBA::StructMember)
+  );
+
+static const CORBA::Long _oc_CORBA_StructMemberSeq[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  38,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x434f5242), 
+  ACE_NTOHL (0x412f5374), 
+  ACE_NTOHL (0x72756374), 
+  ACE_NTOHL (0x4d656d62), 
+  ACE_NTOHL (0x65725365), 
+  ACE_NTOHL (0x713a312e), 
+  ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/StructMemberSeq:1.0
+  16,
+  ACE_NTOHL (0x53747275), 
+  ACE_NTOHL (0x63744d65), 
+  ACE_NTOHL (0x6d626572), 
+  ACE_NTOHL (0x53657100),  // name = StructMemberSeq
+  CORBA::tk_sequence, // typecode kind
+  264, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    CORBA::tk_struct, // typecode kind
+    248, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      35,
+      ACE_NTOHL (0x49444c3a), 
+      ACE_NTOHL (0x6f6d672e), 
+      ACE_NTOHL (0x6f72672f), 
+      ACE_NTOHL (0x434f5242), 
+      ACE_NTOHL (0x412f5374), 
+      ACE_NTOHL (0x72756374), 
+      ACE_NTOHL (0x4d656d62), 
+      ACE_NTOHL (0x65723a31), 
+      ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/StructMember:1.0
+      13,
+      ACE_NTOHL (0x53747275), 
+      ACE_NTOHL (0x63744d65), 
+      ACE_NTOHL (0x6d626572), 
+      ACE_NTOHL (0x0),  // name = StructMember
+      3, // member count
+      5,
+      ACE_NTOHL (0x6e616d65), 
+      ACE_NTOHL (0x0),  // name = name
+      CORBA::tk_alias, // typecode kind for typedefs
+      68, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        33,
+        ACE_NTOHL (0x49444c3a), 
+        ACE_NTOHL (0x6f6d672e), 
+        ACE_NTOHL (0x6f72672f), 
+        ACE_NTOHL (0x434f5242), 
+        ACE_NTOHL (0x412f4964), 
+        ACE_NTOHL (0x656e7469), 
+        ACE_NTOHL (0x66696572), 
+        ACE_NTOHL (0x3a312e30), 
+        ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+        11,
+        ACE_NTOHL (0x4964656e), 
+        ACE_NTOHL (0x74696669), 
+        ACE_NTOHL (0x65720000),  // name = Identifier
+        CORBA::tk_string, 
+        0U, // string length
+
+      5,
+      ACE_NTOHL (0x74797065), 
+      ACE_NTOHL (0x0),  // name = type
+      CORBA::tk_TypeCode,
+
+      9,
+      ACE_NTOHL (0x74797065), 
+      ACE_NTOHL (0x5f646566), 
+      ACE_NTOHL (0x0),  // name = type_def
+      CORBA::tk_objref, // typecode kind
+      52, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        30,
+        ACE_NTOHL (0x49444c3a), 
+        ACE_NTOHL (0x6f6d672e), 
+        ACE_NTOHL (0x6f72672f), 
+        ACE_NTOHL (0x434f5242), 
+        ACE_NTOHL (0x412f4944), 
+        ACE_NTOHL (0x4c547970), 
+        ACE_NTOHL (0x653a312e), 
+        ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/IDLType:1.0
+        8,
+        ACE_NTOHL (0x49444c54), 
+        ACE_NTOHL (0x79706500),  // name = IDLType
+
+
+    0U,
+
+};
+
+static CORBA::TypeCode _tc_TAO_tc_CORBA_StructMemberSeq (
+    CORBA::tk_alias,
+    sizeof (_oc_CORBA_StructMemberSeq),
+    (char *) &_oc_CORBA_StructMemberSeq,
+    0,
+    sizeof (CORBA::StructMemberSeq)
+  );
+
+static const CORBA::Long _oc_CORBA_Initializer[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  34,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x434f5242), 
+  ACE_NTOHL (0x412f496e), 
+  ACE_NTOHL (0x69746961), 
+  ACE_NTOHL (0x6c697a65), 
+  ACE_NTOHL (0x723a312e), 
+  ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/Initializer:1.0
+  12,
+  ACE_NTOHL (0x496e6974), 
+  ACE_NTOHL (0x69616c69), 
+  ACE_NTOHL (0x7a657200),  // name = Initializer
+  2, // member count
+  8,
+  ACE_NTOHL (0x6d656d62), 
+  ACE_NTOHL (0x65727300),  // name = members
+  CORBA::tk_alias, // typecode kind for typedefs
+  340, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    38,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x434f5242), 
+    ACE_NTOHL (0x412f5374), 
+    ACE_NTOHL (0x72756374), 
+    ACE_NTOHL (0x4d656d62), 
+    ACE_NTOHL (0x65725365), 
+    ACE_NTOHL (0x713a312e), 
+    ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/StructMemberSeq:1.0
+    16,
+    ACE_NTOHL (0x53747275), 
+    ACE_NTOHL (0x63744d65), 
+    ACE_NTOHL (0x6d626572), 
+    ACE_NTOHL (0x53657100),  // name = StructMemberSeq
+    CORBA::tk_sequence, // typecode kind
+    264, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      CORBA::tk_struct, // typecode kind
+      248, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        35,
+        ACE_NTOHL (0x49444c3a), 
+        ACE_NTOHL (0x6f6d672e), 
+        ACE_NTOHL (0x6f72672f), 
+        ACE_NTOHL (0x434f5242), 
+        ACE_NTOHL (0x412f5374), 
+        ACE_NTOHL (0x72756374), 
+        ACE_NTOHL (0x4d656d62), 
+        ACE_NTOHL (0x65723a31), 
+        ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/StructMember:1.0
+        13,
+        ACE_NTOHL (0x53747275), 
+        ACE_NTOHL (0x63744d65), 
+        ACE_NTOHL (0x6d626572), 
+        ACE_NTOHL (0x0),  // name = StructMember
+        3, // member count
+        5,
+        ACE_NTOHL (0x6e616d65), 
+        ACE_NTOHL (0x0),  // name = name
+        CORBA::tk_alias, // typecode kind for typedefs
+        68, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          33,
+          ACE_NTOHL (0x49444c3a), 
+          ACE_NTOHL (0x6f6d672e), 
+          ACE_NTOHL (0x6f72672f), 
+          ACE_NTOHL (0x434f5242), 
+          ACE_NTOHL (0x412f4964), 
+          ACE_NTOHL (0x656e7469), 
+          ACE_NTOHL (0x66696572), 
+          ACE_NTOHL (0x3a312e30), 
+          ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+          11,
+          ACE_NTOHL (0x4964656e), 
+          ACE_NTOHL (0x74696669), 
+          ACE_NTOHL (0x65720000),  // name = Identifier
+          CORBA::tk_string, 
+          0U, // string length
+
+        5,
+        ACE_NTOHL (0x74797065), 
+        ACE_NTOHL (0x0),  // name = type
+        CORBA::tk_TypeCode,
+
+        9,
+        ACE_NTOHL (0x74797065), 
+        ACE_NTOHL (0x5f646566), 
+        ACE_NTOHL (0x0),  // name = type_def
+        CORBA::tk_objref, // typecode kind
+        52, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          30,
+          ACE_NTOHL (0x49444c3a), 
+          ACE_NTOHL (0x6f6d672e), 
+          ACE_NTOHL (0x6f72672f), 
+          ACE_NTOHL (0x434f5242), 
+          ACE_NTOHL (0x412f4944), 
+          ACE_NTOHL (0x4c547970), 
+          ACE_NTOHL (0x653a312e), 
+          ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/IDLType:1.0
+          8,
+          ACE_NTOHL (0x49444c54), 
+          ACE_NTOHL (0x79706500),  // name = IDLType
+
+
+      0U,
+
+
+  5,
+  ACE_NTOHL (0x6e616d65), 
+  ACE_NTOHL (0x0),  // name = name
+  CORBA::tk_alias, // typecode kind for typedefs
+  68, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    33,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x434f5242), 
+    ACE_NTOHL (0x412f4964), 
+    ACE_NTOHL (0x656e7469), 
+    ACE_NTOHL (0x66696572), 
+    ACE_NTOHL (0x3a312e30), 
+    ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+    11,
+    ACE_NTOHL (0x4964656e), 
+    ACE_NTOHL (0x74696669), 
+    ACE_NTOHL (0x65720000),  // name = Identifier
+    CORBA::tk_string, 
+    0U, // string length
+
+};
+
+static CORBA::TypeCode _tc_TAO_tc_CORBA_Initializer (
+    CORBA::tk_struct,
+    sizeof (_oc_CORBA_Initializer),
+    (char *) &_oc_CORBA_Initializer,
+    0,
+    sizeof (CORBA::Initializer)
+  );
+
+static const CORBA::Long _oc_CORBA_InitializerSeq[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  37,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x434f5242), 
+  ACE_NTOHL (0x412f496e), 
+  ACE_NTOHL (0x69746961), 
+  ACE_NTOHL (0x6c697a65), 
+  ACE_NTOHL (0x72536571), 
+  ACE_NTOHL (0x3a312e30), 
+  ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/InitializerSeq:1.0
+  15,
+  ACE_NTOHL (0x496e6974), 
+  ACE_NTOHL (0x69616c69), 
+  ACE_NTOHL (0x7a657253), 
+  ACE_NTOHL (0x65710000),  // name = InitializerSeq
+  CORBA::tk_sequence, // typecode kind
+  528, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    CORBA::tk_struct, // typecode kind
+    512, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      34,
+      ACE_NTOHL (0x49444c3a), 
+      ACE_NTOHL (0x6f6d672e), 
+      ACE_NTOHL (0x6f72672f), 
+      ACE_NTOHL (0x434f5242), 
+      ACE_NTOHL (0x412f496e), 
+      ACE_NTOHL (0x69746961), 
+      ACE_NTOHL (0x6c697a65), 
+      ACE_NTOHL (0x723a312e), 
+      ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/Initializer:1.0
+      12,
+      ACE_NTOHL (0x496e6974), 
+      ACE_NTOHL (0x69616c69), 
+      ACE_NTOHL (0x7a657200),  // name = Initializer
+      2, // member count
+      8,
+      ACE_NTOHL (0x6d656d62), 
+      ACE_NTOHL (0x65727300),  // name = members
+      CORBA::tk_alias, // typecode kind for typedefs
+      340, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        38,
+        ACE_NTOHL (0x49444c3a), 
+        ACE_NTOHL (0x6f6d672e), 
+        ACE_NTOHL (0x6f72672f), 
+        ACE_NTOHL (0x434f5242), 
+        ACE_NTOHL (0x412f5374), 
+        ACE_NTOHL (0x72756374), 
+        ACE_NTOHL (0x4d656d62), 
+        ACE_NTOHL (0x65725365), 
+        ACE_NTOHL (0x713a312e), 
+        ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/StructMemberSeq:1.0
+        16,
+        ACE_NTOHL (0x53747275), 
+        ACE_NTOHL (0x63744d65), 
+        ACE_NTOHL (0x6d626572), 
+        ACE_NTOHL (0x53657100),  // name = StructMemberSeq
+        CORBA::tk_sequence, // typecode kind
+        264, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          CORBA::tk_struct, // typecode kind
+          248, // encapsulation length
+            TAO_ENCAP_BYTE_ORDER, // byte order
+            35,
+            ACE_NTOHL (0x49444c3a), 
+            ACE_NTOHL (0x6f6d672e), 
+            ACE_NTOHL (0x6f72672f), 
+            ACE_NTOHL (0x434f5242), 
+            ACE_NTOHL (0x412f5374), 
+            ACE_NTOHL (0x72756374), 
+            ACE_NTOHL (0x4d656d62), 
+            ACE_NTOHL (0x65723a31), 
+            ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/StructMember:1.0
+            13,
+            ACE_NTOHL (0x53747275), 
+            ACE_NTOHL (0x63744d65), 
+            ACE_NTOHL (0x6d626572), 
+            ACE_NTOHL (0x0),  // name = StructMember
+            3, // member count
+            5,
+            ACE_NTOHL (0x6e616d65), 
+            ACE_NTOHL (0x0),  // name = name
+            CORBA::tk_alias, // typecode kind for typedefs
+            68, // encapsulation length
+              TAO_ENCAP_BYTE_ORDER, // byte order
+              33,
+              ACE_NTOHL (0x49444c3a), 
+              ACE_NTOHL (0x6f6d672e), 
+              ACE_NTOHL (0x6f72672f), 
+              ACE_NTOHL (0x434f5242), 
+              ACE_NTOHL (0x412f4964), 
+              ACE_NTOHL (0x656e7469), 
+              ACE_NTOHL (0x66696572), 
+              ACE_NTOHL (0x3a312e30), 
+              ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+              11,
+              ACE_NTOHL (0x4964656e), 
+              ACE_NTOHL (0x74696669), 
+              ACE_NTOHL (0x65720000),  // name = Identifier
+              CORBA::tk_string, 
+              0U, // string length
+
+            5,
+            ACE_NTOHL (0x74797065), 
+            ACE_NTOHL (0x0),  // name = type
+            CORBA::tk_TypeCode,
+
+            9,
+            ACE_NTOHL (0x74797065), 
+            ACE_NTOHL (0x5f646566), 
+            ACE_NTOHL (0x0),  // name = type_def
+            CORBA::tk_objref, // typecode kind
+            52, // encapsulation length
+              TAO_ENCAP_BYTE_ORDER, // byte order
+              30,
+              ACE_NTOHL (0x49444c3a), 
+              ACE_NTOHL (0x6f6d672e), 
+              ACE_NTOHL (0x6f72672f), 
+              ACE_NTOHL (0x434f5242), 
+              ACE_NTOHL (0x412f4944), 
+              ACE_NTOHL (0x4c547970), 
+              ACE_NTOHL (0x653a312e), 
+              ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/IDLType:1.0
+              8,
+              ACE_NTOHL (0x49444c54), 
+              ACE_NTOHL (0x79706500),  // name = IDLType
+
+
+          0U,
+
+
+      5,
+      ACE_NTOHL (0x6e616d65), 
+      ACE_NTOHL (0x0),  // name = name
+      CORBA::tk_alias, // typecode kind for typedefs
+      68, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        33,
+        ACE_NTOHL (0x49444c3a), 
+        ACE_NTOHL (0x6f6d672e), 
+        ACE_NTOHL (0x6f72672f), 
+        ACE_NTOHL (0x434f5242), 
+        ACE_NTOHL (0x412f4964), 
+        ACE_NTOHL (0x656e7469), 
+        ACE_NTOHL (0x66696572), 
+        ACE_NTOHL (0x3a312e30), 
+        ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+        11,
+        ACE_NTOHL (0x4964656e), 
+        ACE_NTOHL (0x74696669), 
+        ACE_NTOHL (0x65720000),  // name = Identifier
+        CORBA::tk_string, 
+        0U, // string length
+
+
+    0U,
+
+};
+
+static CORBA::TypeCode _tc_TAO_tc_CORBA_InitializerSeq (
+    CORBA::tk_alias,
+    sizeof (_oc_CORBA_InitializerSeq),
+    (char *) &_oc_CORBA_InitializerSeq,
+    0,
+    sizeof (CORBA::InitializerSeq)
+  );
+
+static const CORBA::Long _oc_CORBA_UnionMember[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  34,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x434f5242), 
+  ACE_NTOHL (0x412f556e), 
+  ACE_NTOHL (0x696f6e4d), 
+  ACE_NTOHL (0x656d6265), 
+  ACE_NTOHL (0x723a312e), 
+  ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/UnionMember:1.0
+  12,
+  ACE_NTOHL (0x556e696f), 
+  ACE_NTOHL (0x6e4d656d), 
+  ACE_NTOHL (0x62657200),  // name = UnionMember
+  4, // member count
+  5,
+  ACE_NTOHL (0x6e616d65), 
+  ACE_NTOHL (0x0),  // name = name
+  CORBA::tk_alias, // typecode kind for typedefs
+  68, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    33,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x434f5242), 
+    ACE_NTOHL (0x412f4964), 
+    ACE_NTOHL (0x656e7469), 
+    ACE_NTOHL (0x66696572), 
+    ACE_NTOHL (0x3a312e30), 
+    ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+    11,
+    ACE_NTOHL (0x4964656e), 
+    ACE_NTOHL (0x74696669), 
+    ACE_NTOHL (0x65720000),  // name = Identifier
+    CORBA::tk_string, 
+    0U, // string length
+
+  6,
+  ACE_NTOHL (0x6c616265), 
+  ACE_NTOHL (0x6c000000),  // name = label
+  CORBA::tk_any,
+
+  5,
+  ACE_NTOHL (0x74797065), 
+  ACE_NTOHL (0x0),  // name = type
+  CORBA::tk_TypeCode,
+
+  9,
+  ACE_NTOHL (0x74797065), 
+  ACE_NTOHL (0x5f646566), 
+  ACE_NTOHL (0x0),  // name = type_def
+  CORBA::tk_objref, // typecode kind
+  52, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    30,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x434f5242), 
+    ACE_NTOHL (0x412f4944), 
+    ACE_NTOHL (0x4c547970), 
+    ACE_NTOHL (0x653a312e), 
+    ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/IDLType:1.0
+    8,
+    ACE_NTOHL (0x49444c54), 
+    ACE_NTOHL (0x79706500),  // name = IDLType
+
+};
+
+static CORBA::TypeCode _tc_TAO_tc_CORBA_UnionMember (
+    CORBA::tk_struct,
+    sizeof (_oc_CORBA_UnionMember),
+    (char *) &_oc_CORBA_UnionMember,
+    0,
+    sizeof (CORBA::UnionMember)
+  );
+
+static const CORBA::Long _oc_CORBA_UnionMemberSeq[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  37,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x434f5242), 
+  ACE_NTOHL (0x412f556e), 
+  ACE_NTOHL (0x696f6e4d), 
+  ACE_NTOHL (0x656d6265), 
+  ACE_NTOHL (0x72536571), 
+  ACE_NTOHL (0x3a312e30), 
+  ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/UnionMemberSeq:1.0
+  15,
+  ACE_NTOHL (0x556e696f), 
+  ACE_NTOHL (0x6e4d656d), 
+  ACE_NTOHL (0x62657253), 
+  ACE_NTOHL (0x65710000),  // name = UnionMemberSeq
+  CORBA::tk_sequence, // typecode kind
+  276, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    CORBA::tk_struct, // typecode kind
+    260, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      34,
+      ACE_NTOHL (0x49444c3a), 
+      ACE_NTOHL (0x6f6d672e), 
+      ACE_NTOHL (0x6f72672f), 
+      ACE_NTOHL (0x434f5242), 
+      ACE_NTOHL (0x412f556e), 
+      ACE_NTOHL (0x696f6e4d), 
+      ACE_NTOHL (0x656d6265), 
+      ACE_NTOHL (0x723a312e), 
+      ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/UnionMember:1.0
+      12,
+      ACE_NTOHL (0x556e696f), 
+      ACE_NTOHL (0x6e4d656d), 
+      ACE_NTOHL (0x62657200),  // name = UnionMember
+      4, // member count
+      5,
+      ACE_NTOHL (0x6e616d65), 
+      ACE_NTOHL (0x0),  // name = name
+      CORBA::tk_alias, // typecode kind for typedefs
+      68, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        33,
+        ACE_NTOHL (0x49444c3a), 
+        ACE_NTOHL (0x6f6d672e), 
+        ACE_NTOHL (0x6f72672f), 
+        ACE_NTOHL (0x434f5242), 
+        ACE_NTOHL (0x412f4964), 
+        ACE_NTOHL (0x656e7469), 
+        ACE_NTOHL (0x66696572), 
+        ACE_NTOHL (0x3a312e30), 
+        ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+        11,
+        ACE_NTOHL (0x4964656e), 
+        ACE_NTOHL (0x74696669), 
+        ACE_NTOHL (0x65720000),  // name = Identifier
+        CORBA::tk_string, 
+        0U, // string length
+
+      6,
+      ACE_NTOHL (0x6c616265), 
+      ACE_NTOHL (0x6c000000),  // name = label
+      CORBA::tk_any,
+
+      5,
+      ACE_NTOHL (0x74797065), 
+      ACE_NTOHL (0x0),  // name = type
+      CORBA::tk_TypeCode,
+
+      9,
+      ACE_NTOHL (0x74797065), 
+      ACE_NTOHL (0x5f646566), 
+      ACE_NTOHL (0x0),  // name = type_def
+      CORBA::tk_objref, // typecode kind
+      52, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        30,
+        ACE_NTOHL (0x49444c3a), 
+        ACE_NTOHL (0x6f6d672e), 
+        ACE_NTOHL (0x6f72672f), 
+        ACE_NTOHL (0x434f5242), 
+        ACE_NTOHL (0x412f4944), 
+        ACE_NTOHL (0x4c547970), 
+        ACE_NTOHL (0x653a312e), 
+        ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/IDLType:1.0
+        8,
+        ACE_NTOHL (0x49444c54), 
+        ACE_NTOHL (0x79706500),  // name = IDLType
+
+
+    0U,
+
+};
+
+static CORBA::TypeCode _tc_TAO_tc_CORBA_UnionMemberSeq (
+    CORBA::tk_alias,
+    sizeof (_oc_CORBA_UnionMemberSeq),
+    (char *) &_oc_CORBA_UnionMemberSeq,
+    0,
+    sizeof (CORBA::UnionMemberSeq)
+  );
+
+static const CORBA::Long _oc_CORBA_EnumMemberSeq[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  36,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x434f5242), 
+  ACE_NTOHL (0x412f456e), 
+  ACE_NTOHL (0x756d4d65), 
+  ACE_NTOHL (0x6d626572), 
+  ACE_NTOHL (0x5365713a), 
+  ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/EnumMemberSeq:1.0
+  14,
+  ACE_NTOHL (0x456e756d), 
+  ACE_NTOHL (0x4d656d62), 
+  ACE_NTOHL (0x65725365), 
+  ACE_NTOHL (0x71000000),  // name = EnumMemberSeq
+  CORBA::tk_sequence, // typecode kind
+  84, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    CORBA::tk_alias, // typecode kind for typedefs
+    68, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      33,
+      ACE_NTOHL (0x49444c3a), 
+      ACE_NTOHL (0x6f6d672e), 
+      ACE_NTOHL (0x6f72672f), 
+      ACE_NTOHL (0x434f5242), 
+      ACE_NTOHL (0x412f4964), 
+      ACE_NTOHL (0x656e7469), 
+      ACE_NTOHL (0x66696572), 
+      ACE_NTOHL (0x3a312e30), 
+      ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+      11,
+      ACE_NTOHL (0x4964656e), 
+      ACE_NTOHL (0x74696669), 
+      ACE_NTOHL (0x65720000),  // name = Identifier
+      CORBA::tk_string, 
+      0U, // string length
+
+    0U,
+
+};
+
+static CORBA::TypeCode _tc_TAO_tc_CORBA_EnumMemberSeq (
+    CORBA::tk_alias,
+    sizeof (_oc_CORBA_EnumMemberSeq),
+    (char *) &_oc_CORBA_EnumMemberSeq,
+    0,
+    sizeof (CORBA::EnumMemberSeq)
+  );
+
+static const CORBA::Long _oc_CORBA_Container[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  32,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x434f5242), 
+  ACE_NTOHL (0x412f436f), 
+  ACE_NTOHL (0x6e746169), 
+  ACE_NTOHL (0x6e65723a), 
+  ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/Container:1.0
+  10,
+  ACE_NTOHL (0x436f6e74), 
+  ACE_NTOHL (0x61696e65), 
+  ACE_NTOHL (0x72000000),  // name = Container
+};
+
+static CORBA::TypeCode _tc_TAO_tc_CORBA_Container (
+    CORBA::tk_objref,
+    sizeof (_oc_CORBA_Container),
+    (char *) &_oc_CORBA_Container,
+    0,
+    sizeof (CORBA::Container)
+  );
+
+static const CORBA::Long _oc_CORBA_IDLType[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  30,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x434f5242), 
+  ACE_NTOHL (0x412f4944), 
+  ACE_NTOHL (0x4c547970), 
+  ACE_NTOHL (0x653a312e), 
+  ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/IDLType:1.0
+  8,
+  ACE_NTOHL (0x49444c54), 
+  ACE_NTOHL (0x79706500),  // name = IDLType
+};
+
+static CORBA::TypeCode _tc_TAO_tc_CORBA_IDLType (
+    CORBA::tk_objref,
+    sizeof (_oc_CORBA_IDLType),
+    (char *) &_oc_CORBA_IDLType,
+    0,
+    sizeof (CORBA::IDLType)
+  );
+
+static const CORBA::Long _oc_CORBA_TypedefDef[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  33,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x434f5242), 
+  ACE_NTOHL (0x412f5479), 
+  ACE_NTOHL (0x70656465), 
+  ACE_NTOHL (0x66446566), 
+  ACE_NTOHL (0x3a312e30), 
+  ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/TypedefDef:1.0
+  11,
+  ACE_NTOHL (0x54797065), 
+  ACE_NTOHL (0x64656644), 
+  ACE_NTOHL (0x65660000),  // name = TypedefDef
+};
+
+static CORBA::TypeCode _tc_TAO_tc_CORBA_TypedefDef (
+    CORBA::tk_objref,
+    sizeof (_oc_CORBA_TypedefDef),
+    (char *) &_oc_CORBA_TypedefDef,
+    0,
+    sizeof (CORBA::TypedefDef)
+  );
+
+static const CORBA::Long _oc_CORBA_TypeDescription[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  38,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x434f5242), 
+  ACE_NTOHL (0x412f5479), 
+  ACE_NTOHL (0x70654465), 
+  ACE_NTOHL (0x73637269), 
+  ACE_NTOHL (0x7074696f), 
+  ACE_NTOHL (0x6e3a312e), 
+  ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/TypeDescription:1.0
+  16,
+  ACE_NTOHL (0x54797065), 
+  ACE_NTOHL (0x44657363), 
+  ACE_NTOHL (0x72697074), 
+  ACE_NTOHL (0x696f6e00),  // name = TypeDescription
+  5, // member count
+  5,
+  ACE_NTOHL (0x6e616d65), 
+  ACE_NTOHL (0x0),  // name = name
+  CORBA::tk_alias, // typecode kind for typedefs
+  68, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    33,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x434f5242), 
+    ACE_NTOHL (0x412f4964), 
+    ACE_NTOHL (0x656e7469), 
+    ACE_NTOHL (0x66696572), 
+    ACE_NTOHL (0x3a312e30), 
+    ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+    11,
+    ACE_NTOHL (0x4964656e), 
+    ACE_NTOHL (0x74696669), 
+    ACE_NTOHL (0x65720000),  // name = Identifier
+    CORBA::tk_string, 
+    0U, // string length
+
+  3,
+  ACE_NTOHL (0x69640000),  // name = id
+  CORBA::tk_alias, // typecode kind for typedefs
+  72, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    35,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x434f5242), 
+    ACE_NTOHL (0x412f5265), 
+    ACE_NTOHL (0x706f7369), 
+    ACE_NTOHL (0x746f7279), 
+    ACE_NTOHL (0x49643a31), 
+    ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+    13,
+    ACE_NTOHL (0x5265706f), 
+    ACE_NTOHL (0x7369746f), 
+    ACE_NTOHL (0x72794964), 
+    ACE_NTOHL (0x0),  // name = RepositoryId
+    CORBA::tk_string, 
+    0U, // string length
+
+  11,
+  ACE_NTOHL (0x64656669), 
+  ACE_NTOHL (0x6e65645f), 
+  ACE_NTOHL (0x696e0000),  // name = defined_in
+  CORBA::tk_alias, // typecode kind for typedefs
+  72, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    35,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x434f5242), 
+    ACE_NTOHL (0x412f5265), 
+    ACE_NTOHL (0x706f7369), 
+    ACE_NTOHL (0x746f7279), 
+    ACE_NTOHL (0x49643a31), 
+    ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+    13,
+    ACE_NTOHL (0x5265706f), 
+    ACE_NTOHL (0x7369746f), 
+    ACE_NTOHL (0x72794964), 
+    ACE_NTOHL (0x0),  // name = RepositoryId
+    CORBA::tk_string, 
+    0U, // string length
+
+  8,
+  ACE_NTOHL (0x76657273), 
+  ACE_NTOHL (0x696f6e00),  // name = version
+  CORBA::tk_alias, // typecode kind for typedefs
+  68, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    34,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x434f5242), 
+    ACE_NTOHL (0x412f5665), 
+    ACE_NTOHL (0x7273696f), 
+    ACE_NTOHL (0x6e537065), 
+    ACE_NTOHL (0x633a312e), 
+    ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/VersionSpec:1.0
+    12,
+    ACE_NTOHL (0x56657273), 
+    ACE_NTOHL (0x696f6e53), 
+    ACE_NTOHL (0x70656300),  // name = VersionSpec
+    CORBA::tk_string, 
+    0U, // string length
+
+  5,
+  ACE_NTOHL (0x74797065), 
+  ACE_NTOHL (0x0),  // name = type
+  CORBA::tk_TypeCode,
+
+};
+
+static CORBA::TypeCode _tc_TAO_tc_CORBA_TypeDescription (
+    CORBA::tk_struct,
+    sizeof (_oc_CORBA_TypeDescription),
+    (char *) &_oc_CORBA_TypeDescription,
+    0,
+    sizeof (CORBA::TypeDescription)
+  );
+
+static const CORBA::Long _oc_CORBA_PrimitiveKind[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  36,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x434f5242), 
+  ACE_NTOHL (0x412f5072), 
+  ACE_NTOHL (0x696d6974), 
+  ACE_NTOHL (0x6976654b), 
+  ACE_NTOHL (0x696e643a), 
+  ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/PrimitiveKind:1.0
+  14,
+  ACE_NTOHL (0x5072696d), 
+  ACE_NTOHL (0x69746976), 
+  ACE_NTOHL (0x654b696e), 
+  ACE_NTOHL (0x64000000),  // name = PrimitiveKind
+  22, // member count
+  8,
+  ACE_NTOHL (0x706b5f6e), 
+  ACE_NTOHL (0x756c6c00),  // name = pk_null
+  8,
+  ACE_NTOHL (0x706b5f76), 
+  ACE_NTOHL (0x6f696400),  // name = pk_void
+  9,
+  ACE_NTOHL (0x706b5f73), 
+  ACE_NTOHL (0x686f7274), 
+  ACE_NTOHL (0x0),  // name = pk_short
+  8,
+  ACE_NTOHL (0x706b5f6c), 
+  ACE_NTOHL (0x6f6e6700),  // name = pk_long
+  10,
+  ACE_NTOHL (0x706b5f75), 
+  ACE_NTOHL (0x73686f72), 
+  ACE_NTOHL (0x74000000),  // name = pk_ushort
+  9,
+  ACE_NTOHL (0x706b5f75), 
+  ACE_NTOHL (0x6c6f6e67), 
+  ACE_NTOHL (0x0),  // name = pk_ulong
+  9,
+  ACE_NTOHL (0x706b5f66), 
+  ACE_NTOHL (0x6c6f6174), 
+  ACE_NTOHL (0x0),  // name = pk_float
+  10,
+  ACE_NTOHL (0x706b5f64), 
+  ACE_NTOHL (0x6f75626c), 
+  ACE_NTOHL (0x65000000),  // name = pk_double
+  11,
+  ACE_NTOHL (0x706b5f62), 
+  ACE_NTOHL (0x6f6f6c65), 
+  ACE_NTOHL (0x616e0000),  // name = pk_boolean
+  8,
+  ACE_NTOHL (0x706b5f63), 
+  ACE_NTOHL (0x68617200),  // name = pk_char
+  9,
+  ACE_NTOHL (0x706b5f6f), 
+  ACE_NTOHL (0x63746574), 
+  ACE_NTOHL (0x0),  // name = pk_octet
+  7,
+  ACE_NTOHL (0x706b5f61), 
+  ACE_NTOHL (0x6e790000),  // name = pk_any
+  12,
+  ACE_NTOHL (0x706b5f54), 
+  ACE_NTOHL (0x79706543), 
+  ACE_NTOHL (0x6f646500),  // name = pk_TypeCode
+  13,
+  ACE_NTOHL (0x706b5f50), 
+  ACE_NTOHL (0x72696e63), 
+  ACE_NTOHL (0x6970616c), 
+  ACE_NTOHL (0x0),  // name = pk_Principal
+  10,
+  ACE_NTOHL (0x706b5f73), 
+  ACE_NTOHL (0x7472696e), 
+  ACE_NTOHL (0x67000000),  // name = pk_string
+  10,
+  ACE_NTOHL (0x706b5f6f), 
+  ACE_NTOHL (0x626a7265), 
+  ACE_NTOHL (0x66000000),  // name = pk_objref
+  12,
+  ACE_NTOHL (0x706b5f6c), 
+  ACE_NTOHL (0x6f6e676c), 
+  ACE_NTOHL (0x6f6e6700),  // name = pk_longlong
+  13,
+  ACE_NTOHL (0x706b5f75), 
+  ACE_NTOHL (0x6c6f6e67), 
+  ACE_NTOHL (0x6c6f6e67), 
+  ACE_NTOHL (0x0),  // name = pk_ulonglong
+  14,
+  ACE_NTOHL (0x706b5f6c), 
+  ACE_NTOHL (0x6f6e6764), 
+  ACE_NTOHL (0x6f75626c), 
+  ACE_NTOHL (0x65000000),  // name = pk_longdouble
+  9,
+  ACE_NTOHL (0x706b5f77), 
+  ACE_NTOHL (0x63686172), 
+  ACE_NTOHL (0x0),  // name = pk_wchar
+  11,
+  ACE_NTOHL (0x706b5f77), 
+  ACE_NTOHL (0x73747269), 
+  ACE_NTOHL (0x6e670000),  // name = pk_wstring
+  14,
+  ACE_NTOHL (0x706b5f76), 
+  ACE_NTOHL (0x616c7565), 
+  ACE_NTOHL (0x5f626173), 
+  ACE_NTOHL (0x65000000),  // name = pk_value_base
+};
+
+static CORBA::TypeCode _tc_TAO_tc_CORBA_PrimitiveKind (
+    CORBA::tk_enum,
+    sizeof (_oc_CORBA_PrimitiveKind),
+    (char *) &_oc_CORBA_PrimitiveKind,
+    0,
+    sizeof (CORBA::PrimitiveKind)
+  );
+
+static const CORBA::Long _oc_CORBA_Repository[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  33,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x434f5242), 
+  ACE_NTOHL (0x412f5265), 
+  ACE_NTOHL (0x706f7369), 
+  ACE_NTOHL (0x746f7279), 
+  ACE_NTOHL (0x3a312e30), 
+  ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Repository:1.0
+  11,
+  ACE_NTOHL (0x5265706f), 
+  ACE_NTOHL (0x7369746f), 
+  ACE_NTOHL (0x72790000),  // name = Repository
+};
+
+static CORBA::TypeCode _tc_TAO_tc_CORBA_Repository (
+    CORBA::tk_objref,
+    sizeof (_oc_CORBA_Repository),
+    (char *) &_oc_CORBA_Repository,
+    0,
+    sizeof (CORBA::Repository)
+  );
+
+static const CORBA::Long _oc_CORBA_ModuleDef[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  32,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x434f5242), 
+  ACE_NTOHL (0x412f4d6f), 
+  ACE_NTOHL (0x64756c65), 
+  ACE_NTOHL (0x4465663a), 
+  ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/ModuleDef:1.0
+  10,
+  ACE_NTOHL (0x4d6f6475), 
+  ACE_NTOHL (0x6c654465), 
+  ACE_NTOHL (0x66000000),  // name = ModuleDef
+};
+
+static CORBA::TypeCode _tc_TAO_tc_CORBA_ModuleDef (
+    CORBA::tk_objref,
+    sizeof (_oc_CORBA_ModuleDef),
+    (char *) &_oc_CORBA_ModuleDef,
+    0,
+    sizeof (CORBA::ModuleDef)
+  );
+
+static const CORBA::Long _oc_CORBA_ModuleDescription[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  40,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x434f5242), 
+  ACE_NTOHL (0x412f4d6f), 
+  ACE_NTOHL (0x64756c65), 
+  ACE_NTOHL (0x44657363), 
+  ACE_NTOHL (0x72697074), 
+  ACE_NTOHL (0x696f6e3a), 
+  ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/ModuleDescription:1.0
+  18,
+  ACE_NTOHL (0x4d6f6475), 
+  ACE_NTOHL (0x6c654465), 
+  ACE_NTOHL (0x73637269), 
+  ACE_NTOHL (0x7074696f), 
+  ACE_NTOHL (0x6e000000),  // name = ModuleDescription
+  4, // member count
+  5,
+  ACE_NTOHL (0x6e616d65), 
+  ACE_NTOHL (0x0),  // name = name
+  CORBA::tk_alias, // typecode kind for typedefs
+  68, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    33,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x434f5242), 
+    ACE_NTOHL (0x412f4964), 
+    ACE_NTOHL (0x656e7469), 
+    ACE_NTOHL (0x66696572), 
+    ACE_NTOHL (0x3a312e30), 
+    ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+    11,
+    ACE_NTOHL (0x4964656e), 
+    ACE_NTOHL (0x74696669), 
+    ACE_NTOHL (0x65720000),  // name = Identifier
+    CORBA::tk_string, 
+    0U, // string length
+
+  3,
+  ACE_NTOHL (0x69640000),  // name = id
+  CORBA::tk_alias, // typecode kind for typedefs
+  72, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    35,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x434f5242), 
+    ACE_NTOHL (0x412f5265), 
+    ACE_NTOHL (0x706f7369), 
+    ACE_NTOHL (0x746f7279), 
+    ACE_NTOHL (0x49643a31), 
+    ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+    13,
+    ACE_NTOHL (0x5265706f), 
+    ACE_NTOHL (0x7369746f), 
+    ACE_NTOHL (0x72794964), 
+    ACE_NTOHL (0x0),  // name = RepositoryId
+    CORBA::tk_string, 
+    0U, // string length
+
+  11,
+  ACE_NTOHL (0x64656669), 
+  ACE_NTOHL (0x6e65645f), 
+  ACE_NTOHL (0x696e0000),  // name = defined_in
+  CORBA::tk_alias, // typecode kind for typedefs
+  72, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    35,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x434f5242), 
+    ACE_NTOHL (0x412f5265), 
+    ACE_NTOHL (0x706f7369), 
+    ACE_NTOHL (0x746f7279), 
+    ACE_NTOHL (0x49643a31), 
+    ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+    13,
+    ACE_NTOHL (0x5265706f), 
+    ACE_NTOHL (0x7369746f), 
+    ACE_NTOHL (0x72794964), 
+    ACE_NTOHL (0x0),  // name = RepositoryId
+    CORBA::tk_string, 
+    0U, // string length
+
+  8,
+  ACE_NTOHL (0x76657273), 
+  ACE_NTOHL (0x696f6e00),  // name = version
+  CORBA::tk_alias, // typecode kind for typedefs
+  68, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    34,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x434f5242), 
+    ACE_NTOHL (0x412f5665), 
+    ACE_NTOHL (0x7273696f), 
+    ACE_NTOHL (0x6e537065), 
+    ACE_NTOHL (0x633a312e), 
+    ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/VersionSpec:1.0
+    12,
+    ACE_NTOHL (0x56657273), 
+    ACE_NTOHL (0x696f6e53), 
+    ACE_NTOHL (0x70656300),  // name = VersionSpec
+    CORBA::tk_string, 
+    0U, // string length
+
+};
+
+static CORBA::TypeCode _tc_TAO_tc_CORBA_ModuleDescription (
+    CORBA::tk_struct,
+    sizeof (_oc_CORBA_ModuleDescription),
+    (char *) &_oc_CORBA_ModuleDescription,
+    0,
+    sizeof (CORBA::ModuleDescription)
+  );
+
+static const CORBA::Long _oc_CORBA_ConstantDef[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  34,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x434f5242), 
+  ACE_NTOHL (0x412f436f), 
+  ACE_NTOHL (0x6e737461), 
+  ACE_NTOHL (0x6e744465), 
+  ACE_NTOHL (0x663a312e), 
+  ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/ConstantDef:1.0
+  12,
+  ACE_NTOHL (0x436f6e73), 
+  ACE_NTOHL (0x74616e74), 
+  ACE_NTOHL (0x44656600),  // name = ConstantDef
+};
+
+static CORBA::TypeCode _tc_TAO_tc_CORBA_ConstantDef (
+    CORBA::tk_objref,
+    sizeof (_oc_CORBA_ConstantDef),
+    (char *) &_oc_CORBA_ConstantDef,
+    0,
+    sizeof (CORBA::ConstantDef)
+  );
+
+static const CORBA::Long _oc_CORBA_ConstantDescription[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  42,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x434f5242), 
+  ACE_NTOHL (0x412f436f), 
+  ACE_NTOHL (0x6e737461), 
+  ACE_NTOHL (0x6e744465), 
+  ACE_NTOHL (0x73637269), 
+  ACE_NTOHL (0x7074696f), 
+  ACE_NTOHL (0x6e3a312e), 
+  ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/ConstantDescription:1.0
+  20,
+  ACE_NTOHL (0x436f6e73), 
+  ACE_NTOHL (0x74616e74), 
+  ACE_NTOHL (0x44657363), 
+  ACE_NTOHL (0x72697074), 
+  ACE_NTOHL (0x696f6e00),  // name = ConstantDescription
+  6, // member count
+  5,
+  ACE_NTOHL (0x6e616d65), 
+  ACE_NTOHL (0x0),  // name = name
+  CORBA::tk_alias, // typecode kind for typedefs
+  68, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    33,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x434f5242), 
+    ACE_NTOHL (0x412f4964), 
+    ACE_NTOHL (0x656e7469), 
+    ACE_NTOHL (0x66696572), 
+    ACE_NTOHL (0x3a312e30), 
+    ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+    11,
+    ACE_NTOHL (0x4964656e), 
+    ACE_NTOHL (0x74696669), 
+    ACE_NTOHL (0x65720000),  // name = Identifier
+    CORBA::tk_string, 
+    0U, // string length
+
+  3,
+  ACE_NTOHL (0x69640000),  // name = id
+  CORBA::tk_alias, // typecode kind for typedefs
+  72, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    35,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x434f5242), 
+    ACE_NTOHL (0x412f5265), 
+    ACE_NTOHL (0x706f7369), 
+    ACE_NTOHL (0x746f7279), 
+    ACE_NTOHL (0x49643a31), 
+    ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+    13,
+    ACE_NTOHL (0x5265706f), 
+    ACE_NTOHL (0x7369746f), 
+    ACE_NTOHL (0x72794964), 
+    ACE_NTOHL (0x0),  // name = RepositoryId
+    CORBA::tk_string, 
+    0U, // string length
+
+  11,
+  ACE_NTOHL (0x64656669), 
+  ACE_NTOHL (0x6e65645f), 
+  ACE_NTOHL (0x696e0000),  // name = defined_in
+  CORBA::tk_alias, // typecode kind for typedefs
+  72, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    35,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x434f5242), 
+    ACE_NTOHL (0x412f5265), 
+    ACE_NTOHL (0x706f7369), 
+    ACE_NTOHL (0x746f7279), 
+    ACE_NTOHL (0x49643a31), 
+    ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+    13,
+    ACE_NTOHL (0x5265706f), 
+    ACE_NTOHL (0x7369746f), 
+    ACE_NTOHL (0x72794964), 
+    ACE_NTOHL (0x0),  // name = RepositoryId
+    CORBA::tk_string, 
+    0U, // string length
+
+  8,
+  ACE_NTOHL (0x76657273), 
+  ACE_NTOHL (0x696f6e00),  // name = version
+  CORBA::tk_alias, // typecode kind for typedefs
+  68, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    34,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x434f5242), 
+    ACE_NTOHL (0x412f5665), 
+    ACE_NTOHL (0x7273696f), 
+    ACE_NTOHL (0x6e537065), 
+    ACE_NTOHL (0x633a312e), 
+    ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/VersionSpec:1.0
+    12,
+    ACE_NTOHL (0x56657273), 
+    ACE_NTOHL (0x696f6e53), 
+    ACE_NTOHL (0x70656300),  // name = VersionSpec
+    CORBA::tk_string, 
+    0U, // string length
+
+  5,
+  ACE_NTOHL (0x74797065), 
+  ACE_NTOHL (0x0),  // name = type
+  CORBA::tk_TypeCode,
+
+  6,
+  ACE_NTOHL (0x76616c75), 
+  ACE_NTOHL (0x65000000),  // name = value
+  CORBA::tk_any,
+
+};
+
+static CORBA::TypeCode _tc_TAO_tc_CORBA_ConstantDescription (
+    CORBA::tk_struct,
+    sizeof (_oc_CORBA_ConstantDescription),
+    (char *) &_oc_CORBA_ConstantDescription,
+    0,
+    sizeof (CORBA::ConstantDescription)
+  );
+
+static const CORBA::Long _oc_CORBA_StructDef[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  32,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x434f5242), 
+  ACE_NTOHL (0x412f5374), 
+  ACE_NTOHL (0x72756374), 
+  ACE_NTOHL (0x4465663a), 
+  ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/StructDef:1.0
+  10,
+  ACE_NTOHL (0x53747275), 
+  ACE_NTOHL (0x63744465), 
+  ACE_NTOHL (0x66000000),  // name = StructDef
+};
+
+static CORBA::TypeCode _tc_TAO_tc_CORBA_StructDef (
+    CORBA::tk_objref,
+    sizeof (_oc_CORBA_StructDef),
+    (char *) &_oc_CORBA_StructDef,
+    0,
+    sizeof (CORBA::StructDef)
+  );
+
+static const CORBA::Long _oc_CORBA_UnionDef[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  31,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x434f5242), 
+  ACE_NTOHL (0x412f556e), 
+  ACE_NTOHL (0x696f6e44), 
+  ACE_NTOHL (0x65663a31), 
+  ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/UnionDef:1.0
+  9,
+  ACE_NTOHL (0x556e696f), 
+  ACE_NTOHL (0x6e446566), 
+  ACE_NTOHL (0x0),  // name = UnionDef
+};
+
+static CORBA::TypeCode _tc_TAO_tc_CORBA_UnionDef (
+    CORBA::tk_objref,
+    sizeof (_oc_CORBA_UnionDef),
+    (char *) &_oc_CORBA_UnionDef,
+    0,
+    sizeof (CORBA::UnionDef)
+  );
+
+static const CORBA::Long _oc_CORBA_EnumDef[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  30,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x434f5242), 
+  ACE_NTOHL (0x412f456e), 
+  ACE_NTOHL (0x756d4465), 
+  ACE_NTOHL (0x663a312e), 
+  ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/EnumDef:1.0
+  8,
+  ACE_NTOHL (0x456e756d), 
+  ACE_NTOHL (0x44656600),  // name = EnumDef
+};
+
+static CORBA::TypeCode _tc_TAO_tc_CORBA_EnumDef (
+    CORBA::tk_objref,
+    sizeof (_oc_CORBA_EnumDef),
+    (char *) &_oc_CORBA_EnumDef,
+    0,
+    sizeof (CORBA::EnumDef)
+  );
+
+static const CORBA::Long _oc_CORBA_AliasDef[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  31,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x434f5242), 
+  ACE_NTOHL (0x412f416c), 
+  ACE_NTOHL (0x69617344), 
+  ACE_NTOHL (0x65663a31), 
+  ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/AliasDef:1.0
+  9,
+  ACE_NTOHL (0x416c6961), 
+  ACE_NTOHL (0x73446566), 
+  ACE_NTOHL (0x0),  // name = AliasDef
+};
+
+static CORBA::TypeCode _tc_TAO_tc_CORBA_AliasDef (
+    CORBA::tk_objref,
+    sizeof (_oc_CORBA_AliasDef),
+    (char *) &_oc_CORBA_AliasDef,
+    0,
+    sizeof (CORBA::AliasDef)
+  );
+
+static const CORBA::Long _oc_CORBA_NativeDef[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  32,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x434f5242), 
+  ACE_NTOHL (0x412f4e61), 
+  ACE_NTOHL (0x74697665), 
+  ACE_NTOHL (0x4465663a), 
+  ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/NativeDef:1.0
+  10,
+  ACE_NTOHL (0x4e617469), 
+  ACE_NTOHL (0x76654465), 
+  ACE_NTOHL (0x66000000),  // name = NativeDef
+};
+
+static CORBA::TypeCode _tc_TAO_tc_CORBA_NativeDef (
+    CORBA::tk_objref,
+    sizeof (_oc_CORBA_NativeDef),
+    (char *) &_oc_CORBA_NativeDef,
+    0,
+    sizeof (CORBA::NativeDef)
+  );
+
+static const CORBA::Long _oc_CORBA_PrimitiveDef[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  35,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x434f5242), 
+  ACE_NTOHL (0x412f5072), 
+  ACE_NTOHL (0x696d6974), 
+  ACE_NTOHL (0x69766544), 
+  ACE_NTOHL (0x65663a31), 
+  ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/PrimitiveDef:1.0
+  13,
+  ACE_NTOHL (0x5072696d), 
+  ACE_NTOHL (0x69746976), 
+  ACE_NTOHL (0x65446566), 
+  ACE_NTOHL (0x0),  // name = PrimitiveDef
+};
+
+static CORBA::TypeCode _tc_TAO_tc_CORBA_PrimitiveDef (
+    CORBA::tk_objref,
+    sizeof (_oc_CORBA_PrimitiveDef),
+    (char *) &_oc_CORBA_PrimitiveDef,
+    0,
+    sizeof (CORBA::PrimitiveDef)
+  );
+
+static const CORBA::Long _oc_CORBA_StringDef[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  32,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x434f5242), 
+  ACE_NTOHL (0x412f5374), 
+  ACE_NTOHL (0x72696e67), 
+  ACE_NTOHL (0x4465663a), 
+  ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/StringDef:1.0
+  10,
+  ACE_NTOHL (0x53747269), 
+  ACE_NTOHL (0x6e674465), 
+  ACE_NTOHL (0x66000000),  // name = StringDef
+};
+
+static CORBA::TypeCode _tc_TAO_tc_CORBA_StringDef (
+    CORBA::tk_objref,
+    sizeof (_oc_CORBA_StringDef),
+    (char *) &_oc_CORBA_StringDef,
+    0,
+    sizeof (CORBA::StringDef)
+  );
+
+static const CORBA::Long _oc_CORBA_WstringDef[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  33,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x434f5242), 
+  ACE_NTOHL (0x412f5773), 
+  ACE_NTOHL (0x7472696e), 
+  ACE_NTOHL (0x67446566), 
+  ACE_NTOHL (0x3a312e30), 
+  ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/WstringDef:1.0
+  11,
+  ACE_NTOHL (0x57737472), 
+  ACE_NTOHL (0x696e6744), 
+  ACE_NTOHL (0x65660000),  // name = WstringDef
+};
+
+static CORBA::TypeCode _tc_TAO_tc_CORBA_WstringDef (
+    CORBA::tk_objref,
+    sizeof (_oc_CORBA_WstringDef),
+    (char *) &_oc_CORBA_WstringDef,
+    0,
+    sizeof (CORBA::WstringDef)
+  );
+
+static const CORBA::Long _oc_CORBA_SequenceDef[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  34,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x434f5242), 
+  ACE_NTOHL (0x412f5365), 
+  ACE_NTOHL (0x7175656e), 
+  ACE_NTOHL (0x63654465), 
+  ACE_NTOHL (0x663a312e), 
+  ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/SequenceDef:1.0
+  12,
+  ACE_NTOHL (0x53657175), 
+  ACE_NTOHL (0x656e6365), 
+  ACE_NTOHL (0x44656600),  // name = SequenceDef
+};
+
+static CORBA::TypeCode _tc_TAO_tc_CORBA_SequenceDef (
+    CORBA::tk_objref,
+    sizeof (_oc_CORBA_SequenceDef),
+    (char *) &_oc_CORBA_SequenceDef,
+    0,
+    sizeof (CORBA::SequenceDef)
+  );
+
+static const CORBA::Long _oc_CORBA_ArrayDef[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  31,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x434f5242), 
+  ACE_NTOHL (0x412f4172), 
+  ACE_NTOHL (0x72617944), 
+  ACE_NTOHL (0x65663a31), 
+  ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/ArrayDef:1.0
+  9,
+  ACE_NTOHL (0x41727261), 
+  ACE_NTOHL (0x79446566), 
+  ACE_NTOHL (0x0),  // name = ArrayDef
+};
+
+static CORBA::TypeCode _tc_TAO_tc_CORBA_ArrayDef (
+    CORBA::tk_objref,
+    sizeof (_oc_CORBA_ArrayDef),
+    (char *) &_oc_CORBA_ArrayDef,
+    0,
+    sizeof (CORBA::ArrayDef)
+  );
+
+static const CORBA::Long _oc_CORBA_ExceptionDef[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  35,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x434f5242), 
+  ACE_NTOHL (0x412f4578), 
+  ACE_NTOHL (0x63657074), 
+  ACE_NTOHL (0x696f6e44), 
+  ACE_NTOHL (0x65663a31), 
+  ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/ExceptionDef:1.0
+  13,
+  ACE_NTOHL (0x45786365), 
+  ACE_NTOHL (0x7074696f), 
+  ACE_NTOHL (0x6e446566), 
+  ACE_NTOHL (0x0),  // name = ExceptionDef
+};
+
+static CORBA::TypeCode _tc_TAO_tc_CORBA_ExceptionDef (
+    CORBA::tk_objref,
+    sizeof (_oc_CORBA_ExceptionDef),
+    (char *) &_oc_CORBA_ExceptionDef,
+    0,
+    sizeof (CORBA::ExceptionDef)
+  );
+
+static const CORBA::Long _oc_CORBA_ExceptionDescription[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  43,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x434f5242), 
+  ACE_NTOHL (0x412f4578), 
+  ACE_NTOHL (0x63657074), 
+  ACE_NTOHL (0x696f6e44), 
+  ACE_NTOHL (0x65736372), 
+  ACE_NTOHL (0x69707469), 
+  ACE_NTOHL (0x6f6e3a31), 
+  ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/ExceptionDescription:1.0
+  21,
+  ACE_NTOHL (0x45786365), 
+  ACE_NTOHL (0x7074696f), 
+  ACE_NTOHL (0x6e446573), 
+  ACE_NTOHL (0x63726970), 
+  ACE_NTOHL (0x74696f6e), 
+  ACE_NTOHL (0x0),  // name = ExceptionDescription
+  5, // member count
+  5,
+  ACE_NTOHL (0x6e616d65), 
+  ACE_NTOHL (0x0),  // name = name
+  CORBA::tk_alias, // typecode kind for typedefs
+  68, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    33,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x434f5242), 
+    ACE_NTOHL (0x412f4964), 
+    ACE_NTOHL (0x656e7469), 
+    ACE_NTOHL (0x66696572), 
+    ACE_NTOHL (0x3a312e30), 
+    ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+    11,
+    ACE_NTOHL (0x4964656e), 
+    ACE_NTOHL (0x74696669), 
+    ACE_NTOHL (0x65720000),  // name = Identifier
+    CORBA::tk_string, 
+    0U, // string length
+
+  3,
+  ACE_NTOHL (0x69640000),  // name = id
+  CORBA::tk_alias, // typecode kind for typedefs
+  72, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    35,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x434f5242), 
+    ACE_NTOHL (0x412f5265), 
+    ACE_NTOHL (0x706f7369), 
+    ACE_NTOHL (0x746f7279), 
+    ACE_NTOHL (0x49643a31), 
+    ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+    13,
+    ACE_NTOHL (0x5265706f), 
+    ACE_NTOHL (0x7369746f), 
+    ACE_NTOHL (0x72794964), 
+    ACE_NTOHL (0x0),  // name = RepositoryId
+    CORBA::tk_string, 
+    0U, // string length
+
+  11,
+  ACE_NTOHL (0x64656669), 
+  ACE_NTOHL (0x6e65645f), 
+  ACE_NTOHL (0x696e0000),  // name = defined_in
+  CORBA::tk_alias, // typecode kind for typedefs
+  72, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    35,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x434f5242), 
+    ACE_NTOHL (0x412f5265), 
+    ACE_NTOHL (0x706f7369), 
+    ACE_NTOHL (0x746f7279), 
+    ACE_NTOHL (0x49643a31), 
+    ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+    13,
+    ACE_NTOHL (0x5265706f), 
+    ACE_NTOHL (0x7369746f), 
+    ACE_NTOHL (0x72794964), 
+    ACE_NTOHL (0x0),  // name = RepositoryId
+    CORBA::tk_string, 
+    0U, // string length
+
+  8,
+  ACE_NTOHL (0x76657273), 
+  ACE_NTOHL (0x696f6e00),  // name = version
+  CORBA::tk_alias, // typecode kind for typedefs
+  68, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    34,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x434f5242), 
+    ACE_NTOHL (0x412f5665), 
+    ACE_NTOHL (0x7273696f), 
+    ACE_NTOHL (0x6e537065), 
+    ACE_NTOHL (0x633a312e), 
+    ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/VersionSpec:1.0
+    12,
+    ACE_NTOHL (0x56657273), 
+    ACE_NTOHL (0x696f6e53), 
+    ACE_NTOHL (0x70656300),  // name = VersionSpec
+    CORBA::tk_string, 
+    0U, // string length
+
+  5,
+  ACE_NTOHL (0x74797065), 
+  ACE_NTOHL (0x0),  // name = type
+  CORBA::tk_TypeCode,
+
+};
+
+static CORBA::TypeCode _tc_TAO_tc_CORBA_ExceptionDescription (
+    CORBA::tk_struct,
+    sizeof (_oc_CORBA_ExceptionDescription),
+    (char *) &_oc_CORBA_ExceptionDescription,
+    0,
+    sizeof (CORBA::ExceptionDescription)
+  );
+
+static const CORBA::Long _oc_CORBA_ExceptionDefSeq[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  38,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x434f5242), 
+  ACE_NTOHL (0x412f4578), 
+  ACE_NTOHL (0x63657074), 
+  ACE_NTOHL (0x696f6e44), 
+  ACE_NTOHL (0x65665365), 
+  ACE_NTOHL (0x713a312e), 
+  ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/ExceptionDefSeq:1.0
+  16,
+  ACE_NTOHL (0x45786365), 
+  ACE_NTOHL (0x7074696f), 
+  ACE_NTOHL (0x6e446566), 
+  ACE_NTOHL (0x53657100),  // name = ExceptionDefSeq
+  CORBA::tk_sequence, // typecode kind
+  80, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    CORBA::tk_objref, // typecode kind
+    64, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      35,
+      ACE_NTOHL (0x49444c3a), 
+      ACE_NTOHL (0x6f6d672e), 
+      ACE_NTOHL (0x6f72672f), 
+      ACE_NTOHL (0x434f5242), 
+      ACE_NTOHL (0x412f4578), 
+      ACE_NTOHL (0x63657074), 
+      ACE_NTOHL (0x696f6e44), 
+      ACE_NTOHL (0x65663a31), 
+      ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/ExceptionDef:1.0
+      13,
+      ACE_NTOHL (0x45786365), 
+      ACE_NTOHL (0x7074696f), 
+      ACE_NTOHL (0x6e446566), 
+      ACE_NTOHL (0x0),  // name = ExceptionDef
+
+    0U,
+
+};
+
+static CORBA::TypeCode _tc_TAO_tc_CORBA_ExceptionDefSeq (
+    CORBA::tk_alias,
+    sizeof (_oc_CORBA_ExceptionDefSeq),
+    (char *) &_oc_CORBA_ExceptionDefSeq,
+    0,
+    sizeof (CORBA::ExceptionDefSeq)
+  );
+
+static const CORBA::Long _oc_CORBA_ExcDescriptionSeq[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  40,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x434f5242), 
+  ACE_NTOHL (0x412f4578), 
+  ACE_NTOHL (0x63446573), 
+  ACE_NTOHL (0x63726970), 
+  ACE_NTOHL (0x74696f6e), 
+  ACE_NTOHL (0x5365713a), 
+  ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/ExcDescriptionSeq:1.0
+  18,
+  ACE_NTOHL (0x45786344), 
+  ACE_NTOHL (0x65736372), 
+  ACE_NTOHL (0x69707469), 
+  ACE_NTOHL (0x6f6e5365), 
+  ACE_NTOHL (0x71000000),  // name = ExcDescriptionSeq
+  CORBA::tk_sequence, // typecode kind
+  476, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    CORBA::tk_struct, // typecode kind
+    460, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      43,
+      ACE_NTOHL (0x49444c3a), 
+      ACE_NTOHL (0x6f6d672e), 
+      ACE_NTOHL (0x6f72672f), 
+      ACE_NTOHL (0x434f5242), 
+      ACE_NTOHL (0x412f4578), 
+      ACE_NTOHL (0x63657074), 
+      ACE_NTOHL (0x696f6e44), 
+      ACE_NTOHL (0x65736372), 
+      ACE_NTOHL (0x69707469), 
+      ACE_NTOHL (0x6f6e3a31), 
+      ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/ExceptionDescription:1.0
+      21,
+      ACE_NTOHL (0x45786365), 
+      ACE_NTOHL (0x7074696f), 
+      ACE_NTOHL (0x6e446573), 
+      ACE_NTOHL (0x63726970), 
+      ACE_NTOHL (0x74696f6e), 
+      ACE_NTOHL (0x0),  // name = ExceptionDescription
+      5, // member count
+      5,
+      ACE_NTOHL (0x6e616d65), 
+      ACE_NTOHL (0x0),  // name = name
+      CORBA::tk_alias, // typecode kind for typedefs
+      68, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        33,
+        ACE_NTOHL (0x49444c3a), 
+        ACE_NTOHL (0x6f6d672e), 
+        ACE_NTOHL (0x6f72672f), 
+        ACE_NTOHL (0x434f5242), 
+        ACE_NTOHL (0x412f4964), 
+        ACE_NTOHL (0x656e7469), 
+        ACE_NTOHL (0x66696572), 
+        ACE_NTOHL (0x3a312e30), 
+        ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+        11,
+        ACE_NTOHL (0x4964656e), 
+        ACE_NTOHL (0x74696669), 
+        ACE_NTOHL (0x65720000),  // name = Identifier
+        CORBA::tk_string, 
+        0U, // string length
+
+      3,
+      ACE_NTOHL (0x69640000),  // name = id
+      CORBA::tk_alias, // typecode kind for typedefs
+      72, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        35,
+        ACE_NTOHL (0x49444c3a), 
+        ACE_NTOHL (0x6f6d672e), 
+        ACE_NTOHL (0x6f72672f), 
+        ACE_NTOHL (0x434f5242), 
+        ACE_NTOHL (0x412f5265), 
+        ACE_NTOHL (0x706f7369), 
+        ACE_NTOHL (0x746f7279), 
+        ACE_NTOHL (0x49643a31), 
+        ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+        13,
+        ACE_NTOHL (0x5265706f), 
+        ACE_NTOHL (0x7369746f), 
+        ACE_NTOHL (0x72794964), 
+        ACE_NTOHL (0x0),  // name = RepositoryId
+        CORBA::tk_string, 
+        0U, // string length
+
+      11,
+      ACE_NTOHL (0x64656669), 
+      ACE_NTOHL (0x6e65645f), 
+      ACE_NTOHL (0x696e0000),  // name = defined_in
+      CORBA::tk_alias, // typecode kind for typedefs
+      72, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        35,
+        ACE_NTOHL (0x49444c3a), 
+        ACE_NTOHL (0x6f6d672e), 
+        ACE_NTOHL (0x6f72672f), 
+        ACE_NTOHL (0x434f5242), 
+        ACE_NTOHL (0x412f5265), 
+        ACE_NTOHL (0x706f7369), 
+        ACE_NTOHL (0x746f7279), 
+        ACE_NTOHL (0x49643a31), 
+        ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+        13,
+        ACE_NTOHL (0x5265706f), 
+        ACE_NTOHL (0x7369746f), 
+        ACE_NTOHL (0x72794964), 
+        ACE_NTOHL (0x0),  // name = RepositoryId
+        CORBA::tk_string, 
+        0U, // string length
+
+      8,
+      ACE_NTOHL (0x76657273), 
+      ACE_NTOHL (0x696f6e00),  // name = version
+      CORBA::tk_alias, // typecode kind for typedefs
+      68, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        34,
+        ACE_NTOHL (0x49444c3a), 
+        ACE_NTOHL (0x6f6d672e), 
+        ACE_NTOHL (0x6f72672f), 
+        ACE_NTOHL (0x434f5242), 
+        ACE_NTOHL (0x412f5665), 
+        ACE_NTOHL (0x7273696f), 
+        ACE_NTOHL (0x6e537065), 
+        ACE_NTOHL (0x633a312e), 
+        ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/VersionSpec:1.0
+        12,
+        ACE_NTOHL (0x56657273), 
+        ACE_NTOHL (0x696f6e53), 
+        ACE_NTOHL (0x70656300),  // name = VersionSpec
+        CORBA::tk_string, 
+        0U, // string length
+
+      5,
+      ACE_NTOHL (0x74797065), 
+      ACE_NTOHL (0x0),  // name = type
+      CORBA::tk_TypeCode,
+
+
+    0U,
+
+};
+
+static CORBA::TypeCode _tc_TAO_tc_CORBA_ExcDescriptionSeq (
+    CORBA::tk_alias,
+    sizeof (_oc_CORBA_ExcDescriptionSeq),
+    (char *) &_oc_CORBA_ExcDescriptionSeq,
+    0,
+    sizeof (CORBA::ExcDescriptionSeq)
+  );
+
+static const CORBA::Long _oc_CORBA_AttributeMode[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  36,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x434f5242), 
+  ACE_NTOHL (0x412f4174), 
+  ACE_NTOHL (0x74726962), 
+  ACE_NTOHL (0x7574654d), 
+  ACE_NTOHL (0x6f64653a), 
+  ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/AttributeMode:1.0
+  14,
+  ACE_NTOHL (0x41747472), 
+  ACE_NTOHL (0x69627574), 
+  ACE_NTOHL (0x654d6f64), 
+  ACE_NTOHL (0x65000000),  // name = AttributeMode
+  2, // member count
+  12,
+  ACE_NTOHL (0x41545452), 
+  ACE_NTOHL (0x5f4e4f52), 
+  ACE_NTOHL (0x4d414c00),  // name = ATTR_NORMAL
+  14,
+  ACE_NTOHL (0x41545452), 
+  ACE_NTOHL (0x5f524541), 
+  ACE_NTOHL (0x444f4e4c), 
+  ACE_NTOHL (0x59000000),  // name = ATTR_READONLY
+};
+
+static CORBA::TypeCode _tc_TAO_tc_CORBA_AttributeMode (
+    CORBA::tk_enum,
+    sizeof (_oc_CORBA_AttributeMode),
+    (char *) &_oc_CORBA_AttributeMode,
+    0,
+    sizeof (CORBA::AttributeMode)
+  );
+
+static const CORBA::Long _oc_CORBA_AttributeDef[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  35,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x434f5242), 
+  ACE_NTOHL (0x412f4174), 
+  ACE_NTOHL (0x74726962), 
+  ACE_NTOHL (0x75746544), 
+  ACE_NTOHL (0x65663a31), 
+  ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/AttributeDef:1.0
+  13,
+  ACE_NTOHL (0x41747472), 
+  ACE_NTOHL (0x69627574), 
+  ACE_NTOHL (0x65446566), 
+  ACE_NTOHL (0x0),  // name = AttributeDef
+};
+
+static CORBA::TypeCode _tc_TAO_tc_CORBA_AttributeDef (
+    CORBA::tk_objref,
+    sizeof (_oc_CORBA_AttributeDef),
+    (char *) &_oc_CORBA_AttributeDef,
+    0,
+    sizeof (CORBA::AttributeDef)
+  );
+
+static const CORBA::Long _oc_CORBA_AttributeDescription[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  43,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x434f5242), 
+  ACE_NTOHL (0x412f4174), 
+  ACE_NTOHL (0x74726962), 
+  ACE_NTOHL (0x75746544), 
+  ACE_NTOHL (0x65736372), 
+  ACE_NTOHL (0x69707469), 
+  ACE_NTOHL (0x6f6e3a31), 
+  ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/AttributeDescription:1.0
+  21,
+  ACE_NTOHL (0x41747472), 
+  ACE_NTOHL (0x69627574), 
+  ACE_NTOHL (0x65446573), 
+  ACE_NTOHL (0x63726970), 
+  ACE_NTOHL (0x74696f6e), 
+  ACE_NTOHL (0x0),  // name = AttributeDescription
+  6, // member count
+  5,
+  ACE_NTOHL (0x6e616d65), 
+  ACE_NTOHL (0x0),  // name = name
+  CORBA::tk_alias, // typecode kind for typedefs
+  68, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    33,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x434f5242), 
+    ACE_NTOHL (0x412f4964), 
+    ACE_NTOHL (0x656e7469), 
+    ACE_NTOHL (0x66696572), 
+    ACE_NTOHL (0x3a312e30), 
+    ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+    11,
+    ACE_NTOHL (0x4964656e), 
+    ACE_NTOHL (0x74696669), 
+    ACE_NTOHL (0x65720000),  // name = Identifier
+    CORBA::tk_string, 
+    0U, // string length
+
+  3,
+  ACE_NTOHL (0x69640000),  // name = id
+  CORBA::tk_alias, // typecode kind for typedefs
+  72, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    35,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x434f5242), 
+    ACE_NTOHL (0x412f5265), 
+    ACE_NTOHL (0x706f7369), 
+    ACE_NTOHL (0x746f7279), 
+    ACE_NTOHL (0x49643a31), 
+    ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+    13,
+    ACE_NTOHL (0x5265706f), 
+    ACE_NTOHL (0x7369746f), 
+    ACE_NTOHL (0x72794964), 
+    ACE_NTOHL (0x0),  // name = RepositoryId
+    CORBA::tk_string, 
+    0U, // string length
+
+  11,
+  ACE_NTOHL (0x64656669), 
+  ACE_NTOHL (0x6e65645f), 
+  ACE_NTOHL (0x696e0000),  // name = defined_in
+  CORBA::tk_alias, // typecode kind for typedefs
+  72, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    35,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x434f5242), 
+    ACE_NTOHL (0x412f5265), 
+    ACE_NTOHL (0x706f7369), 
+    ACE_NTOHL (0x746f7279), 
+    ACE_NTOHL (0x49643a31), 
+    ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+    13,
+    ACE_NTOHL (0x5265706f), 
+    ACE_NTOHL (0x7369746f), 
+    ACE_NTOHL (0x72794964), 
+    ACE_NTOHL (0x0),  // name = RepositoryId
+    CORBA::tk_string, 
+    0U, // string length
+
+  8,
+  ACE_NTOHL (0x76657273), 
+  ACE_NTOHL (0x696f6e00),  // name = version
+  CORBA::tk_alias, // typecode kind for typedefs
+  68, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    34,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x434f5242), 
+    ACE_NTOHL (0x412f5665), 
+    ACE_NTOHL (0x7273696f), 
+    ACE_NTOHL (0x6e537065), 
+    ACE_NTOHL (0x633a312e), 
+    ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/VersionSpec:1.0
+    12,
+    ACE_NTOHL (0x56657273), 
+    ACE_NTOHL (0x696f6e53), 
+    ACE_NTOHL (0x70656300),  // name = VersionSpec
+    CORBA::tk_string, 
+    0U, // string length
+
+  5,
+  ACE_NTOHL (0x74797065), 
+  ACE_NTOHL (0x0),  // name = type
+  CORBA::tk_TypeCode,
+
+  5,
+  ACE_NTOHL (0x6d6f6465), 
+  ACE_NTOHL (0x0),  // name = mode
+  CORBA::tk_enum, // typecode kind
+  104, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    36,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x434f5242), 
+    ACE_NTOHL (0x412f4174), 
+    ACE_NTOHL (0x74726962), 
+    ACE_NTOHL (0x7574654d), 
+    ACE_NTOHL (0x6f64653a), 
+    ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/AttributeMode:1.0
+    14,
+    ACE_NTOHL (0x41747472), 
+    ACE_NTOHL (0x69627574), 
+    ACE_NTOHL (0x654d6f64), 
+    ACE_NTOHL (0x65000000),  // name = AttributeMode
+    2, // member count
+    12,
+    ACE_NTOHL (0x41545452), 
+    ACE_NTOHL (0x5f4e4f52), 
+    ACE_NTOHL (0x4d414c00),  // name = ATTR_NORMAL
+    14,
+    ACE_NTOHL (0x41545452), 
+    ACE_NTOHL (0x5f524541), 
+    ACE_NTOHL (0x444f4e4c), 
+    ACE_NTOHL (0x59000000),  // name = ATTR_READONLY
+
+};
+
+static CORBA::TypeCode _tc_TAO_tc_CORBA_AttributeDescription (
+    CORBA::tk_struct,
+    sizeof (_oc_CORBA_AttributeDescription),
+    (char *) &_oc_CORBA_AttributeDescription,
+    0,
+    sizeof (CORBA::AttributeDescription)
+  );
+
+static const CORBA::Long _oc_CORBA_OperationMode[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  36,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x434f5242), 
+  ACE_NTOHL (0x412f4f70), 
+  ACE_NTOHL (0x65726174), 
+  ACE_NTOHL (0x696f6e4d), 
+  ACE_NTOHL (0x6f64653a), 
+  ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/OperationMode:1.0
+  14,
+  ACE_NTOHL (0x4f706572), 
+  ACE_NTOHL (0x6174696f), 
+  ACE_NTOHL (0x6e4d6f64), 
+  ACE_NTOHL (0x65000000),  // name = OperationMode
+  2, // member count
+  10,
+  ACE_NTOHL (0x4f505f4e), 
+  ACE_NTOHL (0x4f524d41), 
+  ACE_NTOHL (0x4c000000),  // name = OP_NORMAL
+  10,
+  ACE_NTOHL (0x4f505f4f), 
+  ACE_NTOHL (0x4e455741), 
+  ACE_NTOHL (0x59000000),  // name = OP_ONEWAY
+};
+
+static CORBA::TypeCode _tc_TAO_tc_CORBA_OperationMode (
+    CORBA::tk_enum,
+    sizeof (_oc_CORBA_OperationMode),
+    (char *) &_oc_CORBA_OperationMode,
+    0,
+    sizeof (CORBA::OperationMode)
+  );
+
+static const CORBA::Long _oc_CORBA_ParameterMode[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  36,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x434f5242), 
+  ACE_NTOHL (0x412f5061), 
+  ACE_NTOHL (0x72616d65), 
+  ACE_NTOHL (0x7465724d), 
+  ACE_NTOHL (0x6f64653a), 
+  ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/ParameterMode:1.0
+  14,
+  ACE_NTOHL (0x50617261), 
+  ACE_NTOHL (0x6d657465), 
+  ACE_NTOHL (0x724d6f64), 
+  ACE_NTOHL (0x65000000),  // name = ParameterMode
+  3, // member count
+  9,
+  ACE_NTOHL (0x50415241), 
+  ACE_NTOHL (0x4d5f494e), 
+  ACE_NTOHL (0x0),  // name = PARAM_IN
+  10,
+  ACE_NTOHL (0x50415241), 
+  ACE_NTOHL (0x4d5f4f55), 
+  ACE_NTOHL (0x54000000),  // name = PARAM_OUT
+  12,
+  ACE_NTOHL (0x50415241), 
+  ACE_NTOHL (0x4d5f494e), 
+  ACE_NTOHL (0x4f555400),  // name = PARAM_INOUT
+};
+
+static CORBA::TypeCode _tc_TAO_tc_CORBA_ParameterMode (
+    CORBA::tk_enum,
+    sizeof (_oc_CORBA_ParameterMode),
+    (char *) &_oc_CORBA_ParameterMode,
+    0,
+    sizeof (CORBA::ParameterMode)
+  );
+
+static const CORBA::Long _oc_CORBA_ParameterDescription[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  43,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x434f5242), 
+  ACE_NTOHL (0x412f5061), 
+  ACE_NTOHL (0x72616d65), 
+  ACE_NTOHL (0x74657244), 
+  ACE_NTOHL (0x65736372), 
+  ACE_NTOHL (0x69707469), 
+  ACE_NTOHL (0x6f6e3a31), 
+  ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/ParameterDescription:1.0
+  21,
+  ACE_NTOHL (0x50617261), 
+  ACE_NTOHL (0x6d657465), 
+  ACE_NTOHL (0x72446573), 
+  ACE_NTOHL (0x63726970), 
+  ACE_NTOHL (0x74696f6e), 
+  ACE_NTOHL (0x0),  // name = ParameterDescription
+  4, // member count
+  5,
+  ACE_NTOHL (0x6e616d65), 
+  ACE_NTOHL (0x0),  // name = name
+  CORBA::tk_alias, // typecode kind for typedefs
+  68, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    33,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x434f5242), 
+    ACE_NTOHL (0x412f4964), 
+    ACE_NTOHL (0x656e7469), 
+    ACE_NTOHL (0x66696572), 
+    ACE_NTOHL (0x3a312e30), 
+    ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+    11,
+    ACE_NTOHL (0x4964656e), 
+    ACE_NTOHL (0x74696669), 
+    ACE_NTOHL (0x65720000),  // name = Identifier
+    CORBA::tk_string, 
+    0U, // string length
+
+  5,
+  ACE_NTOHL (0x74797065), 
+  ACE_NTOHL (0x0),  // name = type
+  CORBA::tk_TypeCode,
+
+  9,
+  ACE_NTOHL (0x74797065), 
+  ACE_NTOHL (0x5f646566), 
+  ACE_NTOHL (0x0),  // name = type_def
+  CORBA::tk_objref, // typecode kind
+  52, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    30,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x434f5242), 
+    ACE_NTOHL (0x412f4944), 
+    ACE_NTOHL (0x4c547970), 
+    ACE_NTOHL (0x653a312e), 
+    ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/IDLType:1.0
+    8,
+    ACE_NTOHL (0x49444c54), 
+    ACE_NTOHL (0x79706500),  // name = IDLType
+
+  5,
+  ACE_NTOHL (0x6d6f6465), 
+  ACE_NTOHL (0x0),  // name = mode
+  CORBA::tk_enum, // typecode kind
+  116, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    36,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x434f5242), 
+    ACE_NTOHL (0x412f5061), 
+    ACE_NTOHL (0x72616d65), 
+    ACE_NTOHL (0x7465724d), 
+    ACE_NTOHL (0x6f64653a), 
+    ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/ParameterMode:1.0
+    14,
+    ACE_NTOHL (0x50617261), 
+    ACE_NTOHL (0x6d657465), 
+    ACE_NTOHL (0x724d6f64), 
+    ACE_NTOHL (0x65000000),  // name = ParameterMode
+    3, // member count
+    9,
+    ACE_NTOHL (0x50415241), 
+    ACE_NTOHL (0x4d5f494e), 
+    ACE_NTOHL (0x0),  // name = PARAM_IN
+    10,
+    ACE_NTOHL (0x50415241), 
+    ACE_NTOHL (0x4d5f4f55), 
+    ACE_NTOHL (0x54000000),  // name = PARAM_OUT
+    12,
+    ACE_NTOHL (0x50415241), 
+    ACE_NTOHL (0x4d5f494e), 
+    ACE_NTOHL (0x4f555400),  // name = PARAM_INOUT
+
+};
+
+static CORBA::TypeCode _tc_TAO_tc_CORBA_ParameterDescription (
+    CORBA::tk_struct,
+    sizeof (_oc_CORBA_ParameterDescription),
+    (char *) &_oc_CORBA_ParameterDescription,
+    0,
+    sizeof (CORBA::ParameterDescription)
+  );
+
+static const CORBA::Long _oc_CORBA_ParDescriptionSeq[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  40,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x434f5242), 
+  ACE_NTOHL (0x412f5061), 
+  ACE_NTOHL (0x72446573), 
+  ACE_NTOHL (0x63726970), 
+  ACE_NTOHL (0x74696f6e), 
+  ACE_NTOHL (0x5365713a), 
+  ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/ParDescriptionSeq:1.0
+  18,
+  ACE_NTOHL (0x50617244), 
+  ACE_NTOHL (0x65736372), 
+  ACE_NTOHL (0x69707469), 
+  ACE_NTOHL (0x6f6e5365), 
+  ACE_NTOHL (0x71000000),  // name = ParDescriptionSeq
+  CORBA::tk_sequence, // typecode kind
+  416, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    CORBA::tk_struct, // typecode kind
+    400, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      43,
+      ACE_NTOHL (0x49444c3a), 
+      ACE_NTOHL (0x6f6d672e), 
+      ACE_NTOHL (0x6f72672f), 
+      ACE_NTOHL (0x434f5242), 
+      ACE_NTOHL (0x412f5061), 
+      ACE_NTOHL (0x72616d65), 
+      ACE_NTOHL (0x74657244), 
+      ACE_NTOHL (0x65736372), 
+      ACE_NTOHL (0x69707469), 
+      ACE_NTOHL (0x6f6e3a31), 
+      ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/ParameterDescription:1.0
+      21,
+      ACE_NTOHL (0x50617261), 
+      ACE_NTOHL (0x6d657465), 
+      ACE_NTOHL (0x72446573), 
+      ACE_NTOHL (0x63726970), 
+      ACE_NTOHL (0x74696f6e), 
+      ACE_NTOHL (0x0),  // name = ParameterDescription
+      4, // member count
+      5,
+      ACE_NTOHL (0x6e616d65), 
+      ACE_NTOHL (0x0),  // name = name
+      CORBA::tk_alias, // typecode kind for typedefs
+      68, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        33,
+        ACE_NTOHL (0x49444c3a), 
+        ACE_NTOHL (0x6f6d672e), 
+        ACE_NTOHL (0x6f72672f), 
+        ACE_NTOHL (0x434f5242), 
+        ACE_NTOHL (0x412f4964), 
+        ACE_NTOHL (0x656e7469), 
+        ACE_NTOHL (0x66696572), 
+        ACE_NTOHL (0x3a312e30), 
+        ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+        11,
+        ACE_NTOHL (0x4964656e), 
+        ACE_NTOHL (0x74696669), 
+        ACE_NTOHL (0x65720000),  // name = Identifier
+        CORBA::tk_string, 
+        0U, // string length
+
+      5,
+      ACE_NTOHL (0x74797065), 
+      ACE_NTOHL (0x0),  // name = type
+      CORBA::tk_TypeCode,
+
+      9,
+      ACE_NTOHL (0x74797065), 
+      ACE_NTOHL (0x5f646566), 
+      ACE_NTOHL (0x0),  // name = type_def
+      CORBA::tk_objref, // typecode kind
+      52, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        30,
+        ACE_NTOHL (0x49444c3a), 
+        ACE_NTOHL (0x6f6d672e), 
+        ACE_NTOHL (0x6f72672f), 
+        ACE_NTOHL (0x434f5242), 
+        ACE_NTOHL (0x412f4944), 
+        ACE_NTOHL (0x4c547970), 
+        ACE_NTOHL (0x653a312e), 
+        ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/IDLType:1.0
+        8,
+        ACE_NTOHL (0x49444c54), 
+        ACE_NTOHL (0x79706500),  // name = IDLType
+
+      5,
+      ACE_NTOHL (0x6d6f6465), 
+      ACE_NTOHL (0x0),  // name = mode
+      CORBA::tk_enum, // typecode kind
+      116, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        36,
+        ACE_NTOHL (0x49444c3a), 
+        ACE_NTOHL (0x6f6d672e), 
+        ACE_NTOHL (0x6f72672f), 
+        ACE_NTOHL (0x434f5242), 
+        ACE_NTOHL (0x412f5061), 
+        ACE_NTOHL (0x72616d65), 
+        ACE_NTOHL (0x7465724d), 
+        ACE_NTOHL (0x6f64653a), 
+        ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/ParameterMode:1.0
+        14,
+        ACE_NTOHL (0x50617261), 
+        ACE_NTOHL (0x6d657465), 
+        ACE_NTOHL (0x724d6f64), 
+        ACE_NTOHL (0x65000000),  // name = ParameterMode
+        3, // member count
+        9,
+        ACE_NTOHL (0x50415241), 
+        ACE_NTOHL (0x4d5f494e), 
+        ACE_NTOHL (0x0),  // name = PARAM_IN
+        10,
+        ACE_NTOHL (0x50415241), 
+        ACE_NTOHL (0x4d5f4f55), 
+        ACE_NTOHL (0x54000000),  // name = PARAM_OUT
+        12,
+        ACE_NTOHL (0x50415241), 
+        ACE_NTOHL (0x4d5f494e), 
+        ACE_NTOHL (0x4f555400),  // name = PARAM_INOUT
+
+
+    0U,
+
+};
+
+static CORBA::TypeCode _tc_TAO_tc_CORBA_ParDescriptionSeq (
+    CORBA::tk_alias,
+    sizeof (_oc_CORBA_ParDescriptionSeq),
+    (char *) &_oc_CORBA_ParDescriptionSeq,
+    0,
+    sizeof (CORBA::ParDescriptionSeq)
+  );
+
+static const CORBA::Long _oc_CORBA_ContextIdentifier[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  40,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x434f5242), 
+  ACE_NTOHL (0x412f436f), 
+  ACE_NTOHL (0x6e746578), 
+  ACE_NTOHL (0x74496465), 
+  ACE_NTOHL (0x6e746966), 
+  ACE_NTOHL (0x6965723a), 
+  ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/ContextIdentifier:1.0
+  18,
+  ACE_NTOHL (0x436f6e74), 
+  ACE_NTOHL (0x65787449), 
+  ACE_NTOHL (0x64656e74), 
+  ACE_NTOHL (0x69666965), 
+  ACE_NTOHL (0x72000000),  // name = ContextIdentifier
+  CORBA::tk_alias, // typecode kind for typedefs
+  68, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    33,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x434f5242), 
+    ACE_NTOHL (0x412f4964), 
+    ACE_NTOHL (0x656e7469), 
+    ACE_NTOHL (0x66696572), 
+    ACE_NTOHL (0x3a312e30), 
+    ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+    11,
+    ACE_NTOHL (0x4964656e), 
+    ACE_NTOHL (0x74696669), 
+    ACE_NTOHL (0x65720000),  // name = Identifier
+    CORBA::tk_string, 
+    0U, // string length
+
+};
+
+static CORBA::TypeCode _tc_TAO_tc_CORBA_ContextIdentifier (
+    CORBA::tk_alias,
+    sizeof (_oc_CORBA_ContextIdentifier),
+    (char *) &_oc_CORBA_ContextIdentifier,
+    0,
+    sizeof (CORBA::ContextIdentifier)
+  );
+
+static const CORBA::Long _oc_CORBA_ContextIdSeq[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  35,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x434f5242), 
+  ACE_NTOHL (0x412f436f), 
+  ACE_NTOHL (0x6e746578), 
+  ACE_NTOHL (0x74496453), 
+  ACE_NTOHL (0x65713a31), 
+  ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/ContextIdSeq:1.0
+  13,
+  ACE_NTOHL (0x436f6e74), 
+  ACE_NTOHL (0x65787449), 
+  ACE_NTOHL (0x64536571), 
+  ACE_NTOHL (0x0),  // name = ContextIdSeq
+  CORBA::tk_sequence, // typecode kind
+  164, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    CORBA::tk_alias, // typecode kind for typedefs
+    148, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      40,
+      ACE_NTOHL (0x49444c3a), 
+      ACE_NTOHL (0x6f6d672e), 
+      ACE_NTOHL (0x6f72672f), 
+      ACE_NTOHL (0x434f5242), 
+      ACE_NTOHL (0x412f436f), 
+      ACE_NTOHL (0x6e746578), 
+      ACE_NTOHL (0x74496465), 
+      ACE_NTOHL (0x6e746966), 
+      ACE_NTOHL (0x6965723a), 
+      ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/ContextIdentifier:1.0
+      18,
+      ACE_NTOHL (0x436f6e74), 
+      ACE_NTOHL (0x65787449), 
+      ACE_NTOHL (0x64656e74), 
+      ACE_NTOHL (0x69666965), 
+      ACE_NTOHL (0x72000000),  // name = ContextIdentifier
+      CORBA::tk_alias, // typecode kind for typedefs
+      68, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        33,
+        ACE_NTOHL (0x49444c3a), 
+        ACE_NTOHL (0x6f6d672e), 
+        ACE_NTOHL (0x6f72672f), 
+        ACE_NTOHL (0x434f5242), 
+        ACE_NTOHL (0x412f4964), 
+        ACE_NTOHL (0x656e7469), 
+        ACE_NTOHL (0x66696572), 
+        ACE_NTOHL (0x3a312e30), 
+        ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+        11,
+        ACE_NTOHL (0x4964656e), 
+        ACE_NTOHL (0x74696669), 
+        ACE_NTOHL (0x65720000),  // name = Identifier
+        CORBA::tk_string, 
+        0U, // string length
+
+
+    0U,
+
+};
+
+static CORBA::TypeCode _tc_TAO_tc_CORBA_ContextIdSeq (
+    CORBA::tk_alias,
+    sizeof (_oc_CORBA_ContextIdSeq),
+    (char *) &_oc_CORBA_ContextIdSeq,
+    0,
+    sizeof (CORBA::ContextIdSeq)
+  );
+
+static const CORBA::Long _oc_CORBA_OperationDef[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  35,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x434f5242), 
+  ACE_NTOHL (0x412f4f70), 
+  ACE_NTOHL (0x65726174), 
+  ACE_NTOHL (0x696f6e44), 
+  ACE_NTOHL (0x65663a31), 
+  ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/OperationDef:1.0
+  13,
+  ACE_NTOHL (0x4f706572), 
+  ACE_NTOHL (0x6174696f), 
+  ACE_NTOHL (0x6e446566), 
+  ACE_NTOHL (0x0),  // name = OperationDef
+};
+
+static CORBA::TypeCode _tc_TAO_tc_CORBA_OperationDef (
+    CORBA::tk_objref,
+    sizeof (_oc_CORBA_OperationDef),
+    (char *) &_oc_CORBA_OperationDef,
+    0,
+    sizeof (CORBA::OperationDef)
+  );
+
+static const CORBA::Long _oc_CORBA_OperationDescription[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  43,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x434f5242), 
+  ACE_NTOHL (0x412f4f70), 
+  ACE_NTOHL (0x65726174), 
+  ACE_NTOHL (0x696f6e44), 
+  ACE_NTOHL (0x65736372), 
+  ACE_NTOHL (0x69707469), 
+  ACE_NTOHL (0x6f6e3a31), 
+  ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/OperationDescription:1.0
+  21,
+  ACE_NTOHL (0x4f706572), 
+  ACE_NTOHL (0x6174696f), 
+  ACE_NTOHL (0x6e446573), 
+  ACE_NTOHL (0x63726970), 
+  ACE_NTOHL (0x74696f6e), 
+  ACE_NTOHL (0x0),  // name = OperationDescription
+  9, // member count
+  5,
+  ACE_NTOHL (0x6e616d65), 
+  ACE_NTOHL (0x0),  // name = name
+  CORBA::tk_alias, // typecode kind for typedefs
+  68, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    33,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x434f5242), 
+    ACE_NTOHL (0x412f4964), 
+    ACE_NTOHL (0x656e7469), 
+    ACE_NTOHL (0x66696572), 
+    ACE_NTOHL (0x3a312e30), 
+    ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+    11,
+    ACE_NTOHL (0x4964656e), 
+    ACE_NTOHL (0x74696669), 
+    ACE_NTOHL (0x65720000),  // name = Identifier
+    CORBA::tk_string, 
+    0U, // string length
+
+  3,
+  ACE_NTOHL (0x69640000),  // name = id
+  CORBA::tk_alias, // typecode kind for typedefs
+  72, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    35,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x434f5242), 
+    ACE_NTOHL (0x412f5265), 
+    ACE_NTOHL (0x706f7369), 
+    ACE_NTOHL (0x746f7279), 
+    ACE_NTOHL (0x49643a31), 
+    ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+    13,
+    ACE_NTOHL (0x5265706f), 
+    ACE_NTOHL (0x7369746f), 
+    ACE_NTOHL (0x72794964), 
+    ACE_NTOHL (0x0),  // name = RepositoryId
+    CORBA::tk_string, 
+    0U, // string length
+
+  11,
+  ACE_NTOHL (0x64656669), 
+  ACE_NTOHL (0x6e65645f), 
+  ACE_NTOHL (0x696e0000),  // name = defined_in
+  CORBA::tk_alias, // typecode kind for typedefs
+  72, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    35,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x434f5242), 
+    ACE_NTOHL (0x412f5265), 
+    ACE_NTOHL (0x706f7369), 
+    ACE_NTOHL (0x746f7279), 
+    ACE_NTOHL (0x49643a31), 
+    ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+    13,
+    ACE_NTOHL (0x5265706f), 
+    ACE_NTOHL (0x7369746f), 
+    ACE_NTOHL (0x72794964), 
+    ACE_NTOHL (0x0),  // name = RepositoryId
+    CORBA::tk_string, 
+    0U, // string length
+
+  8,
+  ACE_NTOHL (0x76657273), 
+  ACE_NTOHL (0x696f6e00),  // name = version
+  CORBA::tk_alias, // typecode kind for typedefs
+  68, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    34,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x434f5242), 
+    ACE_NTOHL (0x412f5665), 
+    ACE_NTOHL (0x7273696f), 
+    ACE_NTOHL (0x6e537065), 
+    ACE_NTOHL (0x633a312e), 
+    ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/VersionSpec:1.0
+    12,
+    ACE_NTOHL (0x56657273), 
+    ACE_NTOHL (0x696f6e53), 
+    ACE_NTOHL (0x70656300),  // name = VersionSpec
+    CORBA::tk_string, 
+    0U, // string length
+
+  7,
+  ACE_NTOHL (0x72657375), 
+  ACE_NTOHL (0x6c740000),  // name = result
+  CORBA::tk_TypeCode,
+
+  5,
+  ACE_NTOHL (0x6d6f6465), 
+  ACE_NTOHL (0x0),  // name = mode
+  CORBA::tk_enum, // typecode kind
+  100, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    36,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x434f5242), 
+    ACE_NTOHL (0x412f4f70), 
+    ACE_NTOHL (0x65726174), 
+    ACE_NTOHL (0x696f6e4d), 
+    ACE_NTOHL (0x6f64653a), 
+    ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/OperationMode:1.0
+    14,
+    ACE_NTOHL (0x4f706572), 
+    ACE_NTOHL (0x6174696f), 
+    ACE_NTOHL (0x6e4d6f64), 
+    ACE_NTOHL (0x65000000),  // name = OperationMode
+    2, // member count
+    10,
+    ACE_NTOHL (0x4f505f4e), 
+    ACE_NTOHL (0x4f524d41), 
+    ACE_NTOHL (0x4c000000),  // name = OP_NORMAL
+    10,
+    ACE_NTOHL (0x4f505f4f), 
+    ACE_NTOHL (0x4e455741), 
+    ACE_NTOHL (0x59000000),  // name = OP_ONEWAY
+
+  9,
+  ACE_NTOHL (0x636f6e74), 
+  ACE_NTOHL (0x65787473), 
+  ACE_NTOHL (0x0),  // name = contexts
+  CORBA::tk_alias, // typecode kind for typedefs
+  236, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    35,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x434f5242), 
+    ACE_NTOHL (0x412f436f), 
+    ACE_NTOHL (0x6e746578), 
+    ACE_NTOHL (0x74496453), 
+    ACE_NTOHL (0x65713a31), 
+    ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/ContextIdSeq:1.0
+    13,
+    ACE_NTOHL (0x436f6e74), 
+    ACE_NTOHL (0x65787449), 
+    ACE_NTOHL (0x64536571), 
+    ACE_NTOHL (0x0),  // name = ContextIdSeq
+    CORBA::tk_sequence, // typecode kind
+    164, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      CORBA::tk_alias, // typecode kind for typedefs
+      148, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        40,
+        ACE_NTOHL (0x49444c3a), 
+        ACE_NTOHL (0x6f6d672e), 
+        ACE_NTOHL (0x6f72672f), 
+        ACE_NTOHL (0x434f5242), 
+        ACE_NTOHL (0x412f436f), 
+        ACE_NTOHL (0x6e746578), 
+        ACE_NTOHL (0x74496465), 
+        ACE_NTOHL (0x6e746966), 
+        ACE_NTOHL (0x6965723a), 
+        ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/ContextIdentifier:1.0
+        18,
+        ACE_NTOHL (0x436f6e74), 
+        ACE_NTOHL (0x65787449), 
+        ACE_NTOHL (0x64656e74), 
+        ACE_NTOHL (0x69666965), 
+        ACE_NTOHL (0x72000000),  // name = ContextIdentifier
+        CORBA::tk_alias, // typecode kind for typedefs
+        68, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          33,
+          ACE_NTOHL (0x49444c3a), 
+          ACE_NTOHL (0x6f6d672e), 
+          ACE_NTOHL (0x6f72672f), 
+          ACE_NTOHL (0x434f5242), 
+          ACE_NTOHL (0x412f4964), 
+          ACE_NTOHL (0x656e7469), 
+          ACE_NTOHL (0x66696572), 
+          ACE_NTOHL (0x3a312e30), 
+          ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+          11,
+          ACE_NTOHL (0x4964656e), 
+          ACE_NTOHL (0x74696669), 
+          ACE_NTOHL (0x65720000),  // name = Identifier
+          CORBA::tk_string, 
+          0U, // string length
+
+
+      0U,
+
+
+  11,
+  ACE_NTOHL (0x70617261), 
+  ACE_NTOHL (0x6d657465), 
+  ACE_NTOHL (0x72730000),  // name = parameters
+  CORBA::tk_alias, // typecode kind for typedefs
+  496, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    40,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x434f5242), 
+    ACE_NTOHL (0x412f5061), 
+    ACE_NTOHL (0x72446573), 
+    ACE_NTOHL (0x63726970), 
+    ACE_NTOHL (0x74696f6e), 
+    ACE_NTOHL (0x5365713a), 
+    ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/ParDescriptionSeq:1.0
+    18,
+    ACE_NTOHL (0x50617244), 
+    ACE_NTOHL (0x65736372), 
+    ACE_NTOHL (0x69707469), 
+    ACE_NTOHL (0x6f6e5365), 
+    ACE_NTOHL (0x71000000),  // name = ParDescriptionSeq
+    CORBA::tk_sequence, // typecode kind
+    416, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      CORBA::tk_struct, // typecode kind
+      400, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        43,
+        ACE_NTOHL (0x49444c3a), 
+        ACE_NTOHL (0x6f6d672e), 
+        ACE_NTOHL (0x6f72672f), 
+        ACE_NTOHL (0x434f5242), 
+        ACE_NTOHL (0x412f5061), 
+        ACE_NTOHL (0x72616d65), 
+        ACE_NTOHL (0x74657244), 
+        ACE_NTOHL (0x65736372), 
+        ACE_NTOHL (0x69707469), 
+        ACE_NTOHL (0x6f6e3a31), 
+        ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/ParameterDescription:1.0
+        21,
+        ACE_NTOHL (0x50617261), 
+        ACE_NTOHL (0x6d657465), 
+        ACE_NTOHL (0x72446573), 
+        ACE_NTOHL (0x63726970), 
+        ACE_NTOHL (0x74696f6e), 
+        ACE_NTOHL (0x0),  // name = ParameterDescription
+        4, // member count
+        5,
+        ACE_NTOHL (0x6e616d65), 
+        ACE_NTOHL (0x0),  // name = name
+        CORBA::tk_alias, // typecode kind for typedefs
+        68, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          33,
+          ACE_NTOHL (0x49444c3a), 
+          ACE_NTOHL (0x6f6d672e), 
+          ACE_NTOHL (0x6f72672f), 
+          ACE_NTOHL (0x434f5242), 
+          ACE_NTOHL (0x412f4964), 
+          ACE_NTOHL (0x656e7469), 
+          ACE_NTOHL (0x66696572), 
+          ACE_NTOHL (0x3a312e30), 
+          ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+          11,
+          ACE_NTOHL (0x4964656e), 
+          ACE_NTOHL (0x74696669), 
+          ACE_NTOHL (0x65720000),  // name = Identifier
+          CORBA::tk_string, 
+          0U, // string length
+
+        5,
+        ACE_NTOHL (0x74797065), 
+        ACE_NTOHL (0x0),  // name = type
+        CORBA::tk_TypeCode,
+
+        9,
+        ACE_NTOHL (0x74797065), 
+        ACE_NTOHL (0x5f646566), 
+        ACE_NTOHL (0x0),  // name = type_def
+        CORBA::tk_objref, // typecode kind
+        52, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          30,
+          ACE_NTOHL (0x49444c3a), 
+          ACE_NTOHL (0x6f6d672e), 
+          ACE_NTOHL (0x6f72672f), 
+          ACE_NTOHL (0x434f5242), 
+          ACE_NTOHL (0x412f4944), 
+          ACE_NTOHL (0x4c547970), 
+          ACE_NTOHL (0x653a312e), 
+          ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/IDLType:1.0
+          8,
+          ACE_NTOHL (0x49444c54), 
+          ACE_NTOHL (0x79706500),  // name = IDLType
+
+        5,
+        ACE_NTOHL (0x6d6f6465), 
+        ACE_NTOHL (0x0),  // name = mode
+        CORBA::tk_enum, // typecode kind
+        116, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          36,
+          ACE_NTOHL (0x49444c3a), 
+          ACE_NTOHL (0x6f6d672e), 
+          ACE_NTOHL (0x6f72672f), 
+          ACE_NTOHL (0x434f5242), 
+          ACE_NTOHL (0x412f5061), 
+          ACE_NTOHL (0x72616d65), 
+          ACE_NTOHL (0x7465724d), 
+          ACE_NTOHL (0x6f64653a), 
+          ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/ParameterMode:1.0
+          14,
+          ACE_NTOHL (0x50617261), 
+          ACE_NTOHL (0x6d657465), 
+          ACE_NTOHL (0x724d6f64), 
+          ACE_NTOHL (0x65000000),  // name = ParameterMode
+          3, // member count
+          9,
+          ACE_NTOHL (0x50415241), 
+          ACE_NTOHL (0x4d5f494e), 
+          ACE_NTOHL (0x0),  // name = PARAM_IN
+          10,
+          ACE_NTOHL (0x50415241), 
+          ACE_NTOHL (0x4d5f4f55), 
+          ACE_NTOHL (0x54000000),  // name = PARAM_OUT
+          12,
+          ACE_NTOHL (0x50415241), 
+          ACE_NTOHL (0x4d5f494e), 
+          ACE_NTOHL (0x4f555400),  // name = PARAM_INOUT
+
+
+      0U,
+
+
+  11,
+  ACE_NTOHL (0x65786365), 
+  ACE_NTOHL (0x7074696f), 
+  ACE_NTOHL (0x6e730000),  // name = exceptions
+  CORBA::tk_alias, // typecode kind for typedefs
+  556, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    40,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x434f5242), 
+    ACE_NTOHL (0x412f4578), 
+    ACE_NTOHL (0x63446573), 
+    ACE_NTOHL (0x63726970), 
+    ACE_NTOHL (0x74696f6e), 
+    ACE_NTOHL (0x5365713a), 
+    ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/ExcDescriptionSeq:1.0
+    18,
+    ACE_NTOHL (0x45786344), 
+    ACE_NTOHL (0x65736372), 
+    ACE_NTOHL (0x69707469), 
+    ACE_NTOHL (0x6f6e5365), 
+    ACE_NTOHL (0x71000000),  // name = ExcDescriptionSeq
+    CORBA::tk_sequence, // typecode kind
+    476, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      CORBA::tk_struct, // typecode kind
+      460, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        43,
+        ACE_NTOHL (0x49444c3a), 
+        ACE_NTOHL (0x6f6d672e), 
+        ACE_NTOHL (0x6f72672f), 
+        ACE_NTOHL (0x434f5242), 
+        ACE_NTOHL (0x412f4578), 
+        ACE_NTOHL (0x63657074), 
+        ACE_NTOHL (0x696f6e44), 
+        ACE_NTOHL (0x65736372), 
+        ACE_NTOHL (0x69707469), 
+        ACE_NTOHL (0x6f6e3a31), 
+        ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/ExceptionDescription:1.0
+        21,
+        ACE_NTOHL (0x45786365), 
+        ACE_NTOHL (0x7074696f), 
+        ACE_NTOHL (0x6e446573), 
+        ACE_NTOHL (0x63726970), 
+        ACE_NTOHL (0x74696f6e), 
+        ACE_NTOHL (0x0),  // name = ExceptionDescription
+        5, // member count
+        5,
+        ACE_NTOHL (0x6e616d65), 
+        ACE_NTOHL (0x0),  // name = name
+        CORBA::tk_alias, // typecode kind for typedefs
+        68, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          33,
+          ACE_NTOHL (0x49444c3a), 
+          ACE_NTOHL (0x6f6d672e), 
+          ACE_NTOHL (0x6f72672f), 
+          ACE_NTOHL (0x434f5242), 
+          ACE_NTOHL (0x412f4964), 
+          ACE_NTOHL (0x656e7469), 
+          ACE_NTOHL (0x66696572), 
+          ACE_NTOHL (0x3a312e30), 
+          ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+          11,
+          ACE_NTOHL (0x4964656e), 
+          ACE_NTOHL (0x74696669), 
+          ACE_NTOHL (0x65720000),  // name = Identifier
+          CORBA::tk_string, 
+          0U, // string length
+
+        3,
+        ACE_NTOHL (0x69640000),  // name = id
+        CORBA::tk_alias, // typecode kind for typedefs
+        72, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          35,
+          ACE_NTOHL (0x49444c3a), 
+          ACE_NTOHL (0x6f6d672e), 
+          ACE_NTOHL (0x6f72672f), 
+          ACE_NTOHL (0x434f5242), 
+          ACE_NTOHL (0x412f5265), 
+          ACE_NTOHL (0x706f7369), 
+          ACE_NTOHL (0x746f7279), 
+          ACE_NTOHL (0x49643a31), 
+          ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+          13,
+          ACE_NTOHL (0x5265706f), 
+          ACE_NTOHL (0x7369746f), 
+          ACE_NTOHL (0x72794964), 
+          ACE_NTOHL (0x0),  // name = RepositoryId
+          CORBA::tk_string, 
+          0U, // string length
+
+        11,
+        ACE_NTOHL (0x64656669), 
+        ACE_NTOHL (0x6e65645f), 
+        ACE_NTOHL (0x696e0000),  // name = defined_in
+        CORBA::tk_alias, // typecode kind for typedefs
+        72, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          35,
+          ACE_NTOHL (0x49444c3a), 
+          ACE_NTOHL (0x6f6d672e), 
+          ACE_NTOHL (0x6f72672f), 
+          ACE_NTOHL (0x434f5242), 
+          ACE_NTOHL (0x412f5265), 
+          ACE_NTOHL (0x706f7369), 
+          ACE_NTOHL (0x746f7279), 
+          ACE_NTOHL (0x49643a31), 
+          ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+          13,
+          ACE_NTOHL (0x5265706f), 
+          ACE_NTOHL (0x7369746f), 
+          ACE_NTOHL (0x72794964), 
+          ACE_NTOHL (0x0),  // name = RepositoryId
+          CORBA::tk_string, 
+          0U, // string length
+
+        8,
+        ACE_NTOHL (0x76657273), 
+        ACE_NTOHL (0x696f6e00),  // name = version
+        CORBA::tk_alias, // typecode kind for typedefs
+        68, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          34,
+          ACE_NTOHL (0x49444c3a), 
+          ACE_NTOHL (0x6f6d672e), 
+          ACE_NTOHL (0x6f72672f), 
+          ACE_NTOHL (0x434f5242), 
+          ACE_NTOHL (0x412f5665), 
+          ACE_NTOHL (0x7273696f), 
+          ACE_NTOHL (0x6e537065), 
+          ACE_NTOHL (0x633a312e), 
+          ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/VersionSpec:1.0
+          12,
+          ACE_NTOHL (0x56657273), 
+          ACE_NTOHL (0x696f6e53), 
+          ACE_NTOHL (0x70656300),  // name = VersionSpec
+          CORBA::tk_string, 
+          0U, // string length
+
+        5,
+        ACE_NTOHL (0x74797065), 
+        ACE_NTOHL (0x0),  // name = type
+        CORBA::tk_TypeCode,
+
+
+      0U,
+
+
+};
+
+static CORBA::TypeCode _tc_TAO_tc_CORBA_OperationDescription (
+    CORBA::tk_struct,
+    sizeof (_oc_CORBA_OperationDescription),
+    (char *) &_oc_CORBA_OperationDescription,
+    0,
+    sizeof (CORBA::OperationDescription)
+  );
+
+static const CORBA::Long _oc_CORBA_RepositoryIdSeq[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  38,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x434f5242), 
+  ACE_NTOHL (0x412f5265), 
+  ACE_NTOHL (0x706f7369), 
+  ACE_NTOHL (0x746f7279), 
+  ACE_NTOHL (0x49645365), 
+  ACE_NTOHL (0x713a312e), 
+  ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/RepositoryIdSeq:1.0
+  16,
+  ACE_NTOHL (0x5265706f), 
+  ACE_NTOHL (0x7369746f), 
+  ACE_NTOHL (0x72794964), 
+  ACE_NTOHL (0x53657100),  // name = RepositoryIdSeq
+  CORBA::tk_sequence, // typecode kind
+  88, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    CORBA::tk_alias, // typecode kind for typedefs
+    72, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      35,
+      ACE_NTOHL (0x49444c3a), 
+      ACE_NTOHL (0x6f6d672e), 
+      ACE_NTOHL (0x6f72672f), 
+      ACE_NTOHL (0x434f5242), 
+      ACE_NTOHL (0x412f5265), 
+      ACE_NTOHL (0x706f7369), 
+      ACE_NTOHL (0x746f7279), 
+      ACE_NTOHL (0x49643a31), 
+      ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+      13,
+      ACE_NTOHL (0x5265706f), 
+      ACE_NTOHL (0x7369746f), 
+      ACE_NTOHL (0x72794964), 
+      ACE_NTOHL (0x0),  // name = RepositoryId
+      CORBA::tk_string, 
+      0U, // string length
+
+    0U,
+
+};
+
+static CORBA::TypeCode _tc_TAO_tc_CORBA_RepositoryIdSeq (
+    CORBA::tk_alias,
+    sizeof (_oc_CORBA_RepositoryIdSeq),
+    (char *) &_oc_CORBA_RepositoryIdSeq,
+    0,
+    sizeof (CORBA::RepositoryIdSeq)
+  );
+
+static const CORBA::Long _oc_CORBA_OpDescriptionSeq[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  39,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x434f5242), 
+  ACE_NTOHL (0x412f4f70), 
+  ACE_NTOHL (0x44657363), 
+  ACE_NTOHL (0x72697074), 
+  ACE_NTOHL (0x696f6e53), 
+  ACE_NTOHL (0x65713a31), 
+  ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/OpDescriptionSeq:1.0
+  17,
+  ACE_NTOHL (0x4f704465), 
+  ACE_NTOHL (0x73637269), 
+  ACE_NTOHL (0x7074696f), 
+  ACE_NTOHL (0x6e536571), 
+  ACE_NTOHL (0x0),  // name = OpDescriptionSeq
+  CORBA::tk_sequence, // typecode kind
+  1956, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    CORBA::tk_struct, // typecode kind
+    1940, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      43,
+      ACE_NTOHL (0x49444c3a), 
+      ACE_NTOHL (0x6f6d672e), 
+      ACE_NTOHL (0x6f72672f), 
+      ACE_NTOHL (0x434f5242), 
+      ACE_NTOHL (0x412f4f70), 
+      ACE_NTOHL (0x65726174), 
+      ACE_NTOHL (0x696f6e44), 
+      ACE_NTOHL (0x65736372), 
+      ACE_NTOHL (0x69707469), 
+      ACE_NTOHL (0x6f6e3a31), 
+      ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/OperationDescription:1.0
+      21,
+      ACE_NTOHL (0x4f706572), 
+      ACE_NTOHL (0x6174696f), 
+      ACE_NTOHL (0x6e446573), 
+      ACE_NTOHL (0x63726970), 
+      ACE_NTOHL (0x74696f6e), 
+      ACE_NTOHL (0x0),  // name = OperationDescription
+      9, // member count
+      5,
+      ACE_NTOHL (0x6e616d65), 
+      ACE_NTOHL (0x0),  // name = name
+      CORBA::tk_alias, // typecode kind for typedefs
+      68, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        33,
+        ACE_NTOHL (0x49444c3a), 
+        ACE_NTOHL (0x6f6d672e), 
+        ACE_NTOHL (0x6f72672f), 
+        ACE_NTOHL (0x434f5242), 
+        ACE_NTOHL (0x412f4964), 
+        ACE_NTOHL (0x656e7469), 
+        ACE_NTOHL (0x66696572), 
+        ACE_NTOHL (0x3a312e30), 
+        ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+        11,
+        ACE_NTOHL (0x4964656e), 
+        ACE_NTOHL (0x74696669), 
+        ACE_NTOHL (0x65720000),  // name = Identifier
+        CORBA::tk_string, 
+        0U, // string length
+
+      3,
+      ACE_NTOHL (0x69640000),  // name = id
+      CORBA::tk_alias, // typecode kind for typedefs
+      72, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        35,
+        ACE_NTOHL (0x49444c3a), 
+        ACE_NTOHL (0x6f6d672e), 
+        ACE_NTOHL (0x6f72672f), 
+        ACE_NTOHL (0x434f5242), 
+        ACE_NTOHL (0x412f5265), 
+        ACE_NTOHL (0x706f7369), 
+        ACE_NTOHL (0x746f7279), 
+        ACE_NTOHL (0x49643a31), 
+        ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+        13,
+        ACE_NTOHL (0x5265706f), 
+        ACE_NTOHL (0x7369746f), 
+        ACE_NTOHL (0x72794964), 
+        ACE_NTOHL (0x0),  // name = RepositoryId
+        CORBA::tk_string, 
+        0U, // string length
+
+      11,
+      ACE_NTOHL (0x64656669), 
+      ACE_NTOHL (0x6e65645f), 
+      ACE_NTOHL (0x696e0000),  // name = defined_in
+      CORBA::tk_alias, // typecode kind for typedefs
+      72, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        35,
+        ACE_NTOHL (0x49444c3a), 
+        ACE_NTOHL (0x6f6d672e), 
+        ACE_NTOHL (0x6f72672f), 
+        ACE_NTOHL (0x434f5242), 
+        ACE_NTOHL (0x412f5265), 
+        ACE_NTOHL (0x706f7369), 
+        ACE_NTOHL (0x746f7279), 
+        ACE_NTOHL (0x49643a31), 
+        ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+        13,
+        ACE_NTOHL (0x5265706f), 
+        ACE_NTOHL (0x7369746f), 
+        ACE_NTOHL (0x72794964), 
+        ACE_NTOHL (0x0),  // name = RepositoryId
+        CORBA::tk_string, 
+        0U, // string length
+
+      8,
+      ACE_NTOHL (0x76657273), 
+      ACE_NTOHL (0x696f6e00),  // name = version
+      CORBA::tk_alias, // typecode kind for typedefs
+      68, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        34,
+        ACE_NTOHL (0x49444c3a), 
+        ACE_NTOHL (0x6f6d672e), 
+        ACE_NTOHL (0x6f72672f), 
+        ACE_NTOHL (0x434f5242), 
+        ACE_NTOHL (0x412f5665), 
+        ACE_NTOHL (0x7273696f), 
+        ACE_NTOHL (0x6e537065), 
+        ACE_NTOHL (0x633a312e), 
+        ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/VersionSpec:1.0
+        12,
+        ACE_NTOHL (0x56657273), 
+        ACE_NTOHL (0x696f6e53), 
+        ACE_NTOHL (0x70656300),  // name = VersionSpec
+        CORBA::tk_string, 
+        0U, // string length
+
+      7,
+      ACE_NTOHL (0x72657375), 
+      ACE_NTOHL (0x6c740000),  // name = result
+      CORBA::tk_TypeCode,
+
+      5,
+      ACE_NTOHL (0x6d6f6465), 
+      ACE_NTOHL (0x0),  // name = mode
+      CORBA::tk_enum, // typecode kind
+      100, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        36,
+        ACE_NTOHL (0x49444c3a), 
+        ACE_NTOHL (0x6f6d672e), 
+        ACE_NTOHL (0x6f72672f), 
+        ACE_NTOHL (0x434f5242), 
+        ACE_NTOHL (0x412f4f70), 
+        ACE_NTOHL (0x65726174), 
+        ACE_NTOHL (0x696f6e4d), 
+        ACE_NTOHL (0x6f64653a), 
+        ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/OperationMode:1.0
+        14,
+        ACE_NTOHL (0x4f706572), 
+        ACE_NTOHL (0x6174696f), 
+        ACE_NTOHL (0x6e4d6f64), 
+        ACE_NTOHL (0x65000000),  // name = OperationMode
+        2, // member count
+        10,
+        ACE_NTOHL (0x4f505f4e), 
+        ACE_NTOHL (0x4f524d41), 
+        ACE_NTOHL (0x4c000000),  // name = OP_NORMAL
+        10,
+        ACE_NTOHL (0x4f505f4f), 
+        ACE_NTOHL (0x4e455741), 
+        ACE_NTOHL (0x59000000),  // name = OP_ONEWAY
+
+      9,
+      ACE_NTOHL (0x636f6e74), 
+      ACE_NTOHL (0x65787473), 
+      ACE_NTOHL (0x0),  // name = contexts
+      CORBA::tk_alias, // typecode kind for typedefs
+      236, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        35,
+        ACE_NTOHL (0x49444c3a), 
+        ACE_NTOHL (0x6f6d672e), 
+        ACE_NTOHL (0x6f72672f), 
+        ACE_NTOHL (0x434f5242), 
+        ACE_NTOHL (0x412f436f), 
+        ACE_NTOHL (0x6e746578), 
+        ACE_NTOHL (0x74496453), 
+        ACE_NTOHL (0x65713a31), 
+        ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/ContextIdSeq:1.0
+        13,
+        ACE_NTOHL (0x436f6e74), 
+        ACE_NTOHL (0x65787449), 
+        ACE_NTOHL (0x64536571), 
+        ACE_NTOHL (0x0),  // name = ContextIdSeq
+        CORBA::tk_sequence, // typecode kind
+        164, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          CORBA::tk_alias, // typecode kind for typedefs
+          148, // encapsulation length
+            TAO_ENCAP_BYTE_ORDER, // byte order
+            40,
+            ACE_NTOHL (0x49444c3a), 
+            ACE_NTOHL (0x6f6d672e), 
+            ACE_NTOHL (0x6f72672f), 
+            ACE_NTOHL (0x434f5242), 
+            ACE_NTOHL (0x412f436f), 
+            ACE_NTOHL (0x6e746578), 
+            ACE_NTOHL (0x74496465), 
+            ACE_NTOHL (0x6e746966), 
+            ACE_NTOHL (0x6965723a), 
+            ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/ContextIdentifier:1.0
+            18,
+            ACE_NTOHL (0x436f6e74), 
+            ACE_NTOHL (0x65787449), 
+            ACE_NTOHL (0x64656e74), 
+            ACE_NTOHL (0x69666965), 
+            ACE_NTOHL (0x72000000),  // name = ContextIdentifier
+            CORBA::tk_alias, // typecode kind for typedefs
+            68, // encapsulation length
+              TAO_ENCAP_BYTE_ORDER, // byte order
+              33,
+              ACE_NTOHL (0x49444c3a), 
+              ACE_NTOHL (0x6f6d672e), 
+              ACE_NTOHL (0x6f72672f), 
+              ACE_NTOHL (0x434f5242), 
+              ACE_NTOHL (0x412f4964), 
+              ACE_NTOHL (0x656e7469), 
+              ACE_NTOHL (0x66696572), 
+              ACE_NTOHL (0x3a312e30), 
+              ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+              11,
+              ACE_NTOHL (0x4964656e), 
+              ACE_NTOHL (0x74696669), 
+              ACE_NTOHL (0x65720000),  // name = Identifier
+              CORBA::tk_string, 
+              0U, // string length
+
+
+          0U,
+
+
+      11,
+      ACE_NTOHL (0x70617261), 
+      ACE_NTOHL (0x6d657465), 
+      ACE_NTOHL (0x72730000),  // name = parameters
+      CORBA::tk_alias, // typecode kind for typedefs
+      496, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        40,
+        ACE_NTOHL (0x49444c3a), 
+        ACE_NTOHL (0x6f6d672e), 
+        ACE_NTOHL (0x6f72672f), 
+        ACE_NTOHL (0x434f5242), 
+        ACE_NTOHL (0x412f5061), 
+        ACE_NTOHL (0x72446573), 
+        ACE_NTOHL (0x63726970), 
+        ACE_NTOHL (0x74696f6e), 
+        ACE_NTOHL (0x5365713a), 
+        ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/ParDescriptionSeq:1.0
+        18,
+        ACE_NTOHL (0x50617244), 
+        ACE_NTOHL (0x65736372), 
+        ACE_NTOHL (0x69707469), 
+        ACE_NTOHL (0x6f6e5365), 
+        ACE_NTOHL (0x71000000),  // name = ParDescriptionSeq
+        CORBA::tk_sequence, // typecode kind
+        416, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          CORBA::tk_struct, // typecode kind
+          400, // encapsulation length
+            TAO_ENCAP_BYTE_ORDER, // byte order
+            43,
+            ACE_NTOHL (0x49444c3a), 
+            ACE_NTOHL (0x6f6d672e), 
+            ACE_NTOHL (0x6f72672f), 
+            ACE_NTOHL (0x434f5242), 
+            ACE_NTOHL (0x412f5061), 
+            ACE_NTOHL (0x72616d65), 
+            ACE_NTOHL (0x74657244), 
+            ACE_NTOHL (0x65736372), 
+            ACE_NTOHL (0x69707469), 
+            ACE_NTOHL (0x6f6e3a31), 
+            ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/ParameterDescription:1.0
+            21,
+            ACE_NTOHL (0x50617261), 
+            ACE_NTOHL (0x6d657465), 
+            ACE_NTOHL (0x72446573), 
+            ACE_NTOHL (0x63726970), 
+            ACE_NTOHL (0x74696f6e), 
+            ACE_NTOHL (0x0),  // name = ParameterDescription
+            4, // member count
+            5,
+            ACE_NTOHL (0x6e616d65), 
+            ACE_NTOHL (0x0),  // name = name
+            CORBA::tk_alias, // typecode kind for typedefs
+            68, // encapsulation length
+              TAO_ENCAP_BYTE_ORDER, // byte order
+              33,
+              ACE_NTOHL (0x49444c3a), 
+              ACE_NTOHL (0x6f6d672e), 
+              ACE_NTOHL (0x6f72672f), 
+              ACE_NTOHL (0x434f5242), 
+              ACE_NTOHL (0x412f4964), 
+              ACE_NTOHL (0x656e7469), 
+              ACE_NTOHL (0x66696572), 
+              ACE_NTOHL (0x3a312e30), 
+              ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+              11,
+              ACE_NTOHL (0x4964656e), 
+              ACE_NTOHL (0x74696669), 
+              ACE_NTOHL (0x65720000),  // name = Identifier
+              CORBA::tk_string, 
+              0U, // string length
+
+            5,
+            ACE_NTOHL (0x74797065), 
+            ACE_NTOHL (0x0),  // name = type
+            CORBA::tk_TypeCode,
+
+            9,
+            ACE_NTOHL (0x74797065), 
+            ACE_NTOHL (0x5f646566), 
+            ACE_NTOHL (0x0),  // name = type_def
+            CORBA::tk_objref, // typecode kind
+            52, // encapsulation length
+              TAO_ENCAP_BYTE_ORDER, // byte order
+              30,
+              ACE_NTOHL (0x49444c3a), 
+              ACE_NTOHL (0x6f6d672e), 
+              ACE_NTOHL (0x6f72672f), 
+              ACE_NTOHL (0x434f5242), 
+              ACE_NTOHL (0x412f4944), 
+              ACE_NTOHL (0x4c547970), 
+              ACE_NTOHL (0x653a312e), 
+              ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/IDLType:1.0
+              8,
+              ACE_NTOHL (0x49444c54), 
+              ACE_NTOHL (0x79706500),  // name = IDLType
+
+            5,
+            ACE_NTOHL (0x6d6f6465), 
+            ACE_NTOHL (0x0),  // name = mode
+            CORBA::tk_enum, // typecode kind
+            116, // encapsulation length
+              TAO_ENCAP_BYTE_ORDER, // byte order
+              36,
+              ACE_NTOHL (0x49444c3a), 
+              ACE_NTOHL (0x6f6d672e), 
+              ACE_NTOHL (0x6f72672f), 
+              ACE_NTOHL (0x434f5242), 
+              ACE_NTOHL (0x412f5061), 
+              ACE_NTOHL (0x72616d65), 
+              ACE_NTOHL (0x7465724d), 
+              ACE_NTOHL (0x6f64653a), 
+              ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/ParameterMode:1.0
+              14,
+              ACE_NTOHL (0x50617261), 
+              ACE_NTOHL (0x6d657465), 
+              ACE_NTOHL (0x724d6f64), 
+              ACE_NTOHL (0x65000000),  // name = ParameterMode
+              3, // member count
+              9,
+              ACE_NTOHL (0x50415241), 
+              ACE_NTOHL (0x4d5f494e), 
+              ACE_NTOHL (0x0),  // name = PARAM_IN
+              10,
+              ACE_NTOHL (0x50415241), 
+              ACE_NTOHL (0x4d5f4f55), 
+              ACE_NTOHL (0x54000000),  // name = PARAM_OUT
+              12,
+              ACE_NTOHL (0x50415241), 
+              ACE_NTOHL (0x4d5f494e), 
+              ACE_NTOHL (0x4f555400),  // name = PARAM_INOUT
+
+
+          0U,
+
+
+      11,
+      ACE_NTOHL (0x65786365), 
+      ACE_NTOHL (0x7074696f), 
+      ACE_NTOHL (0x6e730000),  // name = exceptions
+      CORBA::tk_alias, // typecode kind for typedefs
+      556, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        40,
+        ACE_NTOHL (0x49444c3a), 
+        ACE_NTOHL (0x6f6d672e), 
+        ACE_NTOHL (0x6f72672f), 
+        ACE_NTOHL (0x434f5242), 
+        ACE_NTOHL (0x412f4578), 
+        ACE_NTOHL (0x63446573), 
+        ACE_NTOHL (0x63726970), 
+        ACE_NTOHL (0x74696f6e), 
+        ACE_NTOHL (0x5365713a), 
+        ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/ExcDescriptionSeq:1.0
+        18,
+        ACE_NTOHL (0x45786344), 
+        ACE_NTOHL (0x65736372), 
+        ACE_NTOHL (0x69707469), 
+        ACE_NTOHL (0x6f6e5365), 
+        ACE_NTOHL (0x71000000),  // name = ExcDescriptionSeq
+        CORBA::tk_sequence, // typecode kind
+        476, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          CORBA::tk_struct, // typecode kind
+          460, // encapsulation length
+            TAO_ENCAP_BYTE_ORDER, // byte order
+            43,
+            ACE_NTOHL (0x49444c3a), 
+            ACE_NTOHL (0x6f6d672e), 
+            ACE_NTOHL (0x6f72672f), 
+            ACE_NTOHL (0x434f5242), 
+            ACE_NTOHL (0x412f4578), 
+            ACE_NTOHL (0x63657074), 
+            ACE_NTOHL (0x696f6e44), 
+            ACE_NTOHL (0x65736372), 
+            ACE_NTOHL (0x69707469), 
+            ACE_NTOHL (0x6f6e3a31), 
+            ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/ExceptionDescription:1.0
+            21,
+            ACE_NTOHL (0x45786365), 
+            ACE_NTOHL (0x7074696f), 
+            ACE_NTOHL (0x6e446573), 
+            ACE_NTOHL (0x63726970), 
+            ACE_NTOHL (0x74696f6e), 
+            ACE_NTOHL (0x0),  // name = ExceptionDescription
+            5, // member count
+            5,
+            ACE_NTOHL (0x6e616d65), 
+            ACE_NTOHL (0x0),  // name = name
+            CORBA::tk_alias, // typecode kind for typedefs
+            68, // encapsulation length
+              TAO_ENCAP_BYTE_ORDER, // byte order
+              33,
+              ACE_NTOHL (0x49444c3a), 
+              ACE_NTOHL (0x6f6d672e), 
+              ACE_NTOHL (0x6f72672f), 
+              ACE_NTOHL (0x434f5242), 
+              ACE_NTOHL (0x412f4964), 
+              ACE_NTOHL (0x656e7469), 
+              ACE_NTOHL (0x66696572), 
+              ACE_NTOHL (0x3a312e30), 
+              ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+              11,
+              ACE_NTOHL (0x4964656e), 
+              ACE_NTOHL (0x74696669), 
+              ACE_NTOHL (0x65720000),  // name = Identifier
+              CORBA::tk_string, 
+              0U, // string length
+
+            3,
+            ACE_NTOHL (0x69640000),  // name = id
+            CORBA::tk_alias, // typecode kind for typedefs
+            72, // encapsulation length
+              TAO_ENCAP_BYTE_ORDER, // byte order
+              35,
+              ACE_NTOHL (0x49444c3a), 
+              ACE_NTOHL (0x6f6d672e), 
+              ACE_NTOHL (0x6f72672f), 
+              ACE_NTOHL (0x434f5242), 
+              ACE_NTOHL (0x412f5265), 
+              ACE_NTOHL (0x706f7369), 
+              ACE_NTOHL (0x746f7279), 
+              ACE_NTOHL (0x49643a31), 
+              ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+              13,
+              ACE_NTOHL (0x5265706f), 
+              ACE_NTOHL (0x7369746f), 
+              ACE_NTOHL (0x72794964), 
+              ACE_NTOHL (0x0),  // name = RepositoryId
+              CORBA::tk_string, 
+              0U, // string length
+
+            11,
+            ACE_NTOHL (0x64656669), 
+            ACE_NTOHL (0x6e65645f), 
+            ACE_NTOHL (0x696e0000),  // name = defined_in
+            CORBA::tk_alias, // typecode kind for typedefs
+            72, // encapsulation length
+              TAO_ENCAP_BYTE_ORDER, // byte order
+              35,
+              ACE_NTOHL (0x49444c3a), 
+              ACE_NTOHL (0x6f6d672e), 
+              ACE_NTOHL (0x6f72672f), 
+              ACE_NTOHL (0x434f5242), 
+              ACE_NTOHL (0x412f5265), 
+              ACE_NTOHL (0x706f7369), 
+              ACE_NTOHL (0x746f7279), 
+              ACE_NTOHL (0x49643a31), 
+              ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+              13,
+              ACE_NTOHL (0x5265706f), 
+              ACE_NTOHL (0x7369746f), 
+              ACE_NTOHL (0x72794964), 
+              ACE_NTOHL (0x0),  // name = RepositoryId
+              CORBA::tk_string, 
+              0U, // string length
+
+            8,
+            ACE_NTOHL (0x76657273), 
+            ACE_NTOHL (0x696f6e00),  // name = version
+            CORBA::tk_alias, // typecode kind for typedefs
+            68, // encapsulation length
+              TAO_ENCAP_BYTE_ORDER, // byte order
+              34,
+              ACE_NTOHL (0x49444c3a), 
+              ACE_NTOHL (0x6f6d672e), 
+              ACE_NTOHL (0x6f72672f), 
+              ACE_NTOHL (0x434f5242), 
+              ACE_NTOHL (0x412f5665), 
+              ACE_NTOHL (0x7273696f), 
+              ACE_NTOHL (0x6e537065), 
+              ACE_NTOHL (0x633a312e), 
+              ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/VersionSpec:1.0
+              12,
+              ACE_NTOHL (0x56657273), 
+              ACE_NTOHL (0x696f6e53), 
+              ACE_NTOHL (0x70656300),  // name = VersionSpec
+              CORBA::tk_string, 
+              0U, // string length
+
+            5,
+            ACE_NTOHL (0x74797065), 
+            ACE_NTOHL (0x0),  // name = type
+            CORBA::tk_TypeCode,
+
+
+          0U,
+
+
+
+    0U,
+
+};
+
+static CORBA::TypeCode _tc_TAO_tc_CORBA_OpDescriptionSeq (
+    CORBA::tk_alias,
+    sizeof (_oc_CORBA_OpDescriptionSeq),
+    (char *) &_oc_CORBA_OpDescriptionSeq,
+    0,
+    sizeof (CORBA::OpDescriptionSeq)
+  );
+
+static const CORBA::Long _oc_CORBA_AttrDescriptionSeq[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  41,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x434f5242), 
+  ACE_NTOHL (0x412f4174), 
+  ACE_NTOHL (0x74724465), 
+  ACE_NTOHL (0x73637269), 
+  ACE_NTOHL (0x7074696f), 
+  ACE_NTOHL (0x6e536571), 
+  ACE_NTOHL (0x3a312e30), 
+  ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/AttrDescriptionSeq:1.0
+  19,
+  ACE_NTOHL (0x41747472), 
+  ACE_NTOHL (0x44657363), 
+  ACE_NTOHL (0x72697074), 
+  ACE_NTOHL (0x696f6e53), 
+  ACE_NTOHL (0x65710000),  // name = AttrDescriptionSeq
+  CORBA::tk_sequence, // typecode kind
+  600, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    CORBA::tk_struct, // typecode kind
+    584, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      43,
+      ACE_NTOHL (0x49444c3a), 
+      ACE_NTOHL (0x6f6d672e), 
+      ACE_NTOHL (0x6f72672f), 
+      ACE_NTOHL (0x434f5242), 
+      ACE_NTOHL (0x412f4174), 
+      ACE_NTOHL (0x74726962), 
+      ACE_NTOHL (0x75746544), 
+      ACE_NTOHL (0x65736372), 
+      ACE_NTOHL (0x69707469), 
+      ACE_NTOHL (0x6f6e3a31), 
+      ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/AttributeDescription:1.0
+      21,
+      ACE_NTOHL (0x41747472), 
+      ACE_NTOHL (0x69627574), 
+      ACE_NTOHL (0x65446573), 
+      ACE_NTOHL (0x63726970), 
+      ACE_NTOHL (0x74696f6e), 
+      ACE_NTOHL (0x0),  // name = AttributeDescription
+      6, // member count
+      5,
+      ACE_NTOHL (0x6e616d65), 
+      ACE_NTOHL (0x0),  // name = name
+      CORBA::tk_alias, // typecode kind for typedefs
+      68, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        33,
+        ACE_NTOHL (0x49444c3a), 
+        ACE_NTOHL (0x6f6d672e), 
+        ACE_NTOHL (0x6f72672f), 
+        ACE_NTOHL (0x434f5242), 
+        ACE_NTOHL (0x412f4964), 
+        ACE_NTOHL (0x656e7469), 
+        ACE_NTOHL (0x66696572), 
+        ACE_NTOHL (0x3a312e30), 
+        ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+        11,
+        ACE_NTOHL (0x4964656e), 
+        ACE_NTOHL (0x74696669), 
+        ACE_NTOHL (0x65720000),  // name = Identifier
+        CORBA::tk_string, 
+        0U, // string length
+
+      3,
+      ACE_NTOHL (0x69640000),  // name = id
+      CORBA::tk_alias, // typecode kind for typedefs
+      72, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        35,
+        ACE_NTOHL (0x49444c3a), 
+        ACE_NTOHL (0x6f6d672e), 
+        ACE_NTOHL (0x6f72672f), 
+        ACE_NTOHL (0x434f5242), 
+        ACE_NTOHL (0x412f5265), 
+        ACE_NTOHL (0x706f7369), 
+        ACE_NTOHL (0x746f7279), 
+        ACE_NTOHL (0x49643a31), 
+        ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+        13,
+        ACE_NTOHL (0x5265706f), 
+        ACE_NTOHL (0x7369746f), 
+        ACE_NTOHL (0x72794964), 
+        ACE_NTOHL (0x0),  // name = RepositoryId
+        CORBA::tk_string, 
+        0U, // string length
+
+      11,
+      ACE_NTOHL (0x64656669), 
+      ACE_NTOHL (0x6e65645f), 
+      ACE_NTOHL (0x696e0000),  // name = defined_in
+      CORBA::tk_alias, // typecode kind for typedefs
+      72, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        35,
+        ACE_NTOHL (0x49444c3a), 
+        ACE_NTOHL (0x6f6d672e), 
+        ACE_NTOHL (0x6f72672f), 
+        ACE_NTOHL (0x434f5242), 
+        ACE_NTOHL (0x412f5265), 
+        ACE_NTOHL (0x706f7369), 
+        ACE_NTOHL (0x746f7279), 
+        ACE_NTOHL (0x49643a31), 
+        ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+        13,
+        ACE_NTOHL (0x5265706f), 
+        ACE_NTOHL (0x7369746f), 
+        ACE_NTOHL (0x72794964), 
+        ACE_NTOHL (0x0),  // name = RepositoryId
+        CORBA::tk_string, 
+        0U, // string length
+
+      8,
+      ACE_NTOHL (0x76657273), 
+      ACE_NTOHL (0x696f6e00),  // name = version
+      CORBA::tk_alias, // typecode kind for typedefs
+      68, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        34,
+        ACE_NTOHL (0x49444c3a), 
+        ACE_NTOHL (0x6f6d672e), 
+        ACE_NTOHL (0x6f72672f), 
+        ACE_NTOHL (0x434f5242), 
+        ACE_NTOHL (0x412f5665), 
+        ACE_NTOHL (0x7273696f), 
+        ACE_NTOHL (0x6e537065), 
+        ACE_NTOHL (0x633a312e), 
+        ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/VersionSpec:1.0
+        12,
+        ACE_NTOHL (0x56657273), 
+        ACE_NTOHL (0x696f6e53), 
+        ACE_NTOHL (0x70656300),  // name = VersionSpec
+        CORBA::tk_string, 
+        0U, // string length
+
+      5,
+      ACE_NTOHL (0x74797065), 
+      ACE_NTOHL (0x0),  // name = type
+      CORBA::tk_TypeCode,
+
+      5,
+      ACE_NTOHL (0x6d6f6465), 
+      ACE_NTOHL (0x0),  // name = mode
+      CORBA::tk_enum, // typecode kind
+      104, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        36,
+        ACE_NTOHL (0x49444c3a), 
+        ACE_NTOHL (0x6f6d672e), 
+        ACE_NTOHL (0x6f72672f), 
+        ACE_NTOHL (0x434f5242), 
+        ACE_NTOHL (0x412f4174), 
+        ACE_NTOHL (0x74726962), 
+        ACE_NTOHL (0x7574654d), 
+        ACE_NTOHL (0x6f64653a), 
+        ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/AttributeMode:1.0
+        14,
+        ACE_NTOHL (0x41747472), 
+        ACE_NTOHL (0x69627574), 
+        ACE_NTOHL (0x654d6f64), 
+        ACE_NTOHL (0x65000000),  // name = AttributeMode
+        2, // member count
+        12,
+        ACE_NTOHL (0x41545452), 
+        ACE_NTOHL (0x5f4e4f52), 
+        ACE_NTOHL (0x4d414c00),  // name = ATTR_NORMAL
+        14,
+        ACE_NTOHL (0x41545452), 
+        ACE_NTOHL (0x5f524541), 
+        ACE_NTOHL (0x444f4e4c), 
+        ACE_NTOHL (0x59000000),  // name = ATTR_READONLY
+
+
+    0U,
+
+};
+
+static CORBA::TypeCode _tc_TAO_tc_CORBA_AttrDescriptionSeq (
+    CORBA::tk_alias,
+    sizeof (_oc_CORBA_AttrDescriptionSeq),
+    (char *) &_oc_CORBA_AttrDescriptionSeq,
+    0,
+    sizeof (CORBA::AttrDescriptionSeq)
+  );
+
+static const CORBA::Long _oc_CORBA_InterfaceDef[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  35,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x434f5242), 
+  ACE_NTOHL (0x412f496e), 
+  ACE_NTOHL (0x74657266), 
+  ACE_NTOHL (0x61636544), 
+  ACE_NTOHL (0x65663a31), 
+  ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/InterfaceDef:1.0
+  13,
+  ACE_NTOHL (0x496e7465), 
+  ACE_NTOHL (0x72666163), 
+  ACE_NTOHL (0x65446566), 
+  ACE_NTOHL (0x0),  // name = InterfaceDef
+};
+
+static CORBA::TypeCode _tc_TAO_tc_CORBA_InterfaceDef (
+    CORBA::tk_objref,
+    sizeof (_oc_CORBA_InterfaceDef),
+    (char *) &_oc_CORBA_InterfaceDef,
+    0,
+    sizeof (CORBA::InterfaceDef)
+  );
+
+static const CORBA::Long _oc_CORBA_InterfaceDescription[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  43,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x434f5242), 
+  ACE_NTOHL (0x412f496e), 
+  ACE_NTOHL (0x74657266), 
+  ACE_NTOHL (0x61636544), 
+  ACE_NTOHL (0x65736372), 
+  ACE_NTOHL (0x69707469), 
+  ACE_NTOHL (0x6f6e3a31), 
+  ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/InterfaceDescription:1.0
+  21,
+  ACE_NTOHL (0x496e7465), 
+  ACE_NTOHL (0x72666163), 
+  ACE_NTOHL (0x65446573), 
+  ACE_NTOHL (0x63726970), 
+  ACE_NTOHL (0x74696f6e), 
+  ACE_NTOHL (0x0),  // name = InterfaceDescription
+  5, // member count
+  5,
+  ACE_NTOHL (0x6e616d65), 
+  ACE_NTOHL (0x0),  // name = name
+  CORBA::tk_alias, // typecode kind for typedefs
+  68, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    33,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x434f5242), 
+    ACE_NTOHL (0x412f4964), 
+    ACE_NTOHL (0x656e7469), 
+    ACE_NTOHL (0x66696572), 
+    ACE_NTOHL (0x3a312e30), 
+    ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+    11,
+    ACE_NTOHL (0x4964656e), 
+    ACE_NTOHL (0x74696669), 
+    ACE_NTOHL (0x65720000),  // name = Identifier
+    CORBA::tk_string, 
+    0U, // string length
+
+  3,
+  ACE_NTOHL (0x69640000),  // name = id
+  CORBA::tk_alias, // typecode kind for typedefs
+  72, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    35,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x434f5242), 
+    ACE_NTOHL (0x412f5265), 
+    ACE_NTOHL (0x706f7369), 
+    ACE_NTOHL (0x746f7279), 
+    ACE_NTOHL (0x49643a31), 
+    ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+    13,
+    ACE_NTOHL (0x5265706f), 
+    ACE_NTOHL (0x7369746f), 
+    ACE_NTOHL (0x72794964), 
+    ACE_NTOHL (0x0),  // name = RepositoryId
+    CORBA::tk_string, 
+    0U, // string length
+
+  11,
+  ACE_NTOHL (0x64656669), 
+  ACE_NTOHL (0x6e65645f), 
+  ACE_NTOHL (0x696e0000),  // name = defined_in
+  CORBA::tk_alias, // typecode kind for typedefs
+  72, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    35,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x434f5242), 
+    ACE_NTOHL (0x412f5265), 
+    ACE_NTOHL (0x706f7369), 
+    ACE_NTOHL (0x746f7279), 
+    ACE_NTOHL (0x49643a31), 
+    ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+    13,
+    ACE_NTOHL (0x5265706f), 
+    ACE_NTOHL (0x7369746f), 
+    ACE_NTOHL (0x72794964), 
+    ACE_NTOHL (0x0),  // name = RepositoryId
+    CORBA::tk_string, 
+    0U, // string length
+
+  8,
+  ACE_NTOHL (0x76657273), 
+  ACE_NTOHL (0x696f6e00),  // name = version
+  CORBA::tk_alias, // typecode kind for typedefs
+  68, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    34,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x434f5242), 
+    ACE_NTOHL (0x412f5665), 
+    ACE_NTOHL (0x7273696f), 
+    ACE_NTOHL (0x6e537065), 
+    ACE_NTOHL (0x633a312e), 
+    ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/VersionSpec:1.0
+    12,
+    ACE_NTOHL (0x56657273), 
+    ACE_NTOHL (0x696f6e53), 
+    ACE_NTOHL (0x70656300),  // name = VersionSpec
+    CORBA::tk_string, 
+    0U, // string length
+
+  16,
+  ACE_NTOHL (0x62617365), 
+  ACE_NTOHL (0x5f696e74), 
+  ACE_NTOHL (0x65726661), 
+  ACE_NTOHL (0x63657300),  // name = base_interfaces
+  CORBA::tk_alias, // typecode kind for typedefs
+  164, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    38,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x434f5242), 
+    ACE_NTOHL (0x412f5265), 
+    ACE_NTOHL (0x706f7369), 
+    ACE_NTOHL (0x746f7279), 
+    ACE_NTOHL (0x49645365), 
+    ACE_NTOHL (0x713a312e), 
+    ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/RepositoryIdSeq:1.0
+    16,
+    ACE_NTOHL (0x5265706f), 
+    ACE_NTOHL (0x7369746f), 
+    ACE_NTOHL (0x72794964), 
+    ACE_NTOHL (0x53657100),  // name = RepositoryIdSeq
+    CORBA::tk_sequence, // typecode kind
+    88, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      CORBA::tk_alias, // typecode kind for typedefs
+      72, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        35,
+        ACE_NTOHL (0x49444c3a), 
+        ACE_NTOHL (0x6f6d672e), 
+        ACE_NTOHL (0x6f72672f), 
+        ACE_NTOHL (0x434f5242), 
+        ACE_NTOHL (0x412f5265), 
+        ACE_NTOHL (0x706f7369), 
+        ACE_NTOHL (0x746f7279), 
+        ACE_NTOHL (0x49643a31), 
+        ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+        13,
+        ACE_NTOHL (0x5265706f), 
+        ACE_NTOHL (0x7369746f), 
+        ACE_NTOHL (0x72794964), 
+        ACE_NTOHL (0x0),  // name = RepositoryId
+        CORBA::tk_string, 
+        0U, // string length
+
+      0U,
+
+
+};
+
+static CORBA::TypeCode _tc_TAO_tc_CORBA_InterfaceDescription (
+    CORBA::tk_struct,
+    sizeof (_oc_CORBA_InterfaceDescription),
+    (char *) &_oc_CORBA_InterfaceDescription,
+    0,
+    sizeof (CORBA::InterfaceDescription)
+  );
+
+static const CORBA::Long _oc_CORBA_AbstractInterfaceDef[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  43,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x434f5242), 
+  ACE_NTOHL (0x412f4162), 
+  ACE_NTOHL (0x73747261), 
+  ACE_NTOHL (0x6374496e), 
+  ACE_NTOHL (0x74657266), 
+  ACE_NTOHL (0x61636544), 
+  ACE_NTOHL (0x65663a31), 
+  ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/AbstractInterfaceDef:1.0
+  21,
+  ACE_NTOHL (0x41627374), 
+  ACE_NTOHL (0x72616374), 
+  ACE_NTOHL (0x496e7465), 
+  ACE_NTOHL (0x72666163), 
+  ACE_NTOHL (0x65446566), 
+  ACE_NTOHL (0x0),  // name = AbstractInterfaceDef
+};
+
+static CORBA::TypeCode _tc_TAO_tc_CORBA_AbstractInterfaceDef (
+    CORBA::tk_objref,
+    sizeof (_oc_CORBA_AbstractInterfaceDef),
+    (char *) &_oc_CORBA_AbstractInterfaceDef,
+    0,
+    sizeof (CORBA::AbstractInterfaceDef)
+  );
+
+static const CORBA::Long _oc_CORBA_LocalInterfaceDef[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  40,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x434f5242), 
+  ACE_NTOHL (0x412f4c6f), 
+  ACE_NTOHL (0x63616c49), 
+  ACE_NTOHL (0x6e746572), 
+  ACE_NTOHL (0x66616365), 
+  ACE_NTOHL (0x4465663a), 
+  ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/LocalInterfaceDef:1.0
+  18,
+  ACE_NTOHL (0x4c6f6361), 
+  ACE_NTOHL (0x6c496e74), 
+  ACE_NTOHL (0x65726661), 
+  ACE_NTOHL (0x63654465), 
+  ACE_NTOHL (0x66000000),  // name = LocalInterfaceDef
+};
+
+static CORBA::TypeCode _tc_TAO_tc_CORBA_LocalInterfaceDef (
+    CORBA::tk_objref,
+    sizeof (_oc_CORBA_LocalInterfaceDef),
+    (char *) &_oc_CORBA_LocalInterfaceDef,
+    0,
+    sizeof (CORBA::LocalInterfaceDef)
+  );
+
+static const CORBA::Long _oc_CORBA_FixedDef[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  31,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x434f5242), 
+  ACE_NTOHL (0x412f4669), 
+  ACE_NTOHL (0x78656444), 
+  ACE_NTOHL (0x65663a31), 
+  ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/FixedDef:1.0
+  9,
+  ACE_NTOHL (0x46697865), 
+  ACE_NTOHL (0x64446566), 
+  ACE_NTOHL (0x0),  // name = FixedDef
+};
+
+static CORBA::TypeCode _tc_TAO_tc_CORBA_FixedDef (
+    CORBA::tk_objref,
+    sizeof (_oc_CORBA_FixedDef),
+    (char *) &_oc_CORBA_FixedDef,
+    0,
+    sizeof (CORBA::FixedDef)
+  );
+
+static const CORBA::Long _oc_CORBA_ValueDefSeq[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  34,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x434f5242), 
+  ACE_NTOHL (0x412f5661), 
+  ACE_NTOHL (0x6c756544), 
+  ACE_NTOHL (0x65665365), 
+  ACE_NTOHL (0x713a312e), 
+  ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/ValueDefSeq:1.0
+  12,
+  ACE_NTOHL (0x56616c75), 
+  ACE_NTOHL (0x65446566), 
+  ACE_NTOHL (0x53657100),  // name = ValueDefSeq
+  CORBA::tk_sequence, // typecode kind
+  72, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    CORBA::tk_objref, // typecode kind
+    56, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      31,
+      ACE_NTOHL (0x49444c3a), 
+      ACE_NTOHL (0x6f6d672e), 
+      ACE_NTOHL (0x6f72672f), 
+      ACE_NTOHL (0x434f5242), 
+      ACE_NTOHL (0x412f5661), 
+      ACE_NTOHL (0x6c756544), 
+      ACE_NTOHL (0x65663a31), 
+      ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/ValueDef:1.0
+      9,
+      ACE_NTOHL (0x56616c75), 
+      ACE_NTOHL (0x65446566), 
+      ACE_NTOHL (0x0),  // name = ValueDef
+
+    0U,
+
+};
+
+static CORBA::TypeCode _tc_TAO_tc_CORBA_ValueDefSeq (
+    CORBA::tk_alias,
+    sizeof (_oc_CORBA_ValueDefSeq),
+    (char *) &_oc_CORBA_ValueDefSeq,
+    0,
+    sizeof (CORBA::ValueDefSeq)
+  );
+
+static const CORBA::Long _oc_CORBA_ValueMember[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  34,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x434f5242), 
+  ACE_NTOHL (0x412f5661), 
+  ACE_NTOHL (0x6c75654d), 
+  ACE_NTOHL (0x656d6265), 
+  ACE_NTOHL (0x723a312e), 
+  ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/ValueMember:1.0
+  12,
+  ACE_NTOHL (0x56616c75), 
+  ACE_NTOHL (0x654d656d), 
+  ACE_NTOHL (0x62657200),  // name = ValueMember
+  7, // member count
+  5,
+  ACE_NTOHL (0x6e616d65), 
+  ACE_NTOHL (0x0),  // name = name
+  CORBA::tk_alias, // typecode kind for typedefs
+  68, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    33,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x434f5242), 
+    ACE_NTOHL (0x412f4964), 
+    ACE_NTOHL (0x656e7469), 
+    ACE_NTOHL (0x66696572), 
+    ACE_NTOHL (0x3a312e30), 
+    ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+    11,
+    ACE_NTOHL (0x4964656e), 
+    ACE_NTOHL (0x74696669), 
+    ACE_NTOHL (0x65720000),  // name = Identifier
+    CORBA::tk_string, 
+    0U, // string length
+
+  3,
+  ACE_NTOHL (0x69640000),  // name = id
+  CORBA::tk_alias, // typecode kind for typedefs
+  72, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    35,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x434f5242), 
+    ACE_NTOHL (0x412f5265), 
+    ACE_NTOHL (0x706f7369), 
+    ACE_NTOHL (0x746f7279), 
+    ACE_NTOHL (0x49643a31), 
+    ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+    13,
+    ACE_NTOHL (0x5265706f), 
+    ACE_NTOHL (0x7369746f), 
+    ACE_NTOHL (0x72794964), 
+    ACE_NTOHL (0x0),  // name = RepositoryId
+    CORBA::tk_string, 
+    0U, // string length
+
+  11,
+  ACE_NTOHL (0x64656669), 
+  ACE_NTOHL (0x6e65645f), 
+  ACE_NTOHL (0x696e0000),  // name = defined_in
+  CORBA::tk_alias, // typecode kind for typedefs
+  72, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    35,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x434f5242), 
+    ACE_NTOHL (0x412f5265), 
+    ACE_NTOHL (0x706f7369), 
+    ACE_NTOHL (0x746f7279), 
+    ACE_NTOHL (0x49643a31), 
+    ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+    13,
+    ACE_NTOHL (0x5265706f), 
+    ACE_NTOHL (0x7369746f), 
+    ACE_NTOHL (0x72794964), 
+    ACE_NTOHL (0x0),  // name = RepositoryId
+    CORBA::tk_string, 
+    0U, // string length
+
+  8,
+  ACE_NTOHL (0x76657273), 
+  ACE_NTOHL (0x696f6e00),  // name = version
+  CORBA::tk_alias, // typecode kind for typedefs
+  68, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    34,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x434f5242), 
+    ACE_NTOHL (0x412f5665), 
+    ACE_NTOHL (0x7273696f), 
+    ACE_NTOHL (0x6e537065), 
+    ACE_NTOHL (0x633a312e), 
+    ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/VersionSpec:1.0
+    12,
+    ACE_NTOHL (0x56657273), 
+    ACE_NTOHL (0x696f6e53), 
+    ACE_NTOHL (0x70656300),  // name = VersionSpec
+    CORBA::tk_string, 
+    0U, // string length
+
+  5,
+  ACE_NTOHL (0x74797065), 
+  ACE_NTOHL (0x0),  // name = type
+  CORBA::tk_TypeCode,
+
+  9,
+  ACE_NTOHL (0x74797065), 
+  ACE_NTOHL (0x5f646566), 
+  ACE_NTOHL (0x0),  // name = type_def
+  CORBA::tk_objref, // typecode kind
+  52, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    30,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x434f5242), 
+    ACE_NTOHL (0x412f4944), 
+    ACE_NTOHL (0x4c547970), 
+    ACE_NTOHL (0x653a312e), 
+    ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/IDLType:1.0
+    8,
+    ACE_NTOHL (0x49444c54), 
+    ACE_NTOHL (0x79706500),  // name = IDLType
+
+  7,
+  ACE_NTOHL (0x61636365), 
+  ACE_NTOHL (0x73730000),  // name = access
+  CORBA::tk_alias, // typecode kind for typedefs
+  64, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    33,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x434f5242), 
+    ACE_NTOHL (0x412f5669), 
+    ACE_NTOHL (0x73696269), 
+    ACE_NTOHL (0x6c697479), 
+    ACE_NTOHL (0x3a312e30), 
+    ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Visibility:1.0
+    11,
+    ACE_NTOHL (0x56697369), 
+    ACE_NTOHL (0x62696c69), 
+    ACE_NTOHL (0x74790000),  // name = Visibility
+    CORBA::tk_short,
+
+
+};
+
+static CORBA::TypeCode _tc_TAO_tc_CORBA_ValueMember (
+    CORBA::tk_struct,
+    sizeof (_oc_CORBA_ValueMember),
+    (char *) &_oc_CORBA_ValueMember,
+    0,
+    sizeof (CORBA::ValueMember)
+  );
+
+static const CORBA::Long _oc_CORBA_ValueMemberSeq[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  37,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x434f5242), 
+  ACE_NTOHL (0x412f5661), 
+  ACE_NTOHL (0x6c75654d), 
+  ACE_NTOHL (0x656d6265), 
+  ACE_NTOHL (0x72536571), 
+  ACE_NTOHL (0x3a312e30), 
+  ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/ValueMemberSeq:1.0
+  15,
+  ACE_NTOHL (0x56616c75), 
+  ACE_NTOHL (0x654d656d), 
+  ACE_NTOHL (0x62657253), 
+  ACE_NTOHL (0x65710000),  // name = ValueMemberSeq
+  CORBA::tk_sequence, // typecode kind
+  616, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    CORBA::tk_struct, // typecode kind
+    600, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      34,
+      ACE_NTOHL (0x49444c3a), 
+      ACE_NTOHL (0x6f6d672e), 
+      ACE_NTOHL (0x6f72672f), 
+      ACE_NTOHL (0x434f5242), 
+      ACE_NTOHL (0x412f5661), 
+      ACE_NTOHL (0x6c75654d), 
+      ACE_NTOHL (0x656d6265), 
+      ACE_NTOHL (0x723a312e), 
+      ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/ValueMember:1.0
+      12,
+      ACE_NTOHL (0x56616c75), 
+      ACE_NTOHL (0x654d656d), 
+      ACE_NTOHL (0x62657200),  // name = ValueMember
+      7, // member count
+      5,
+      ACE_NTOHL (0x6e616d65), 
+      ACE_NTOHL (0x0),  // name = name
+      CORBA::tk_alias, // typecode kind for typedefs
+      68, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        33,
+        ACE_NTOHL (0x49444c3a), 
+        ACE_NTOHL (0x6f6d672e), 
+        ACE_NTOHL (0x6f72672f), 
+        ACE_NTOHL (0x434f5242), 
+        ACE_NTOHL (0x412f4964), 
+        ACE_NTOHL (0x656e7469), 
+        ACE_NTOHL (0x66696572), 
+        ACE_NTOHL (0x3a312e30), 
+        ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+        11,
+        ACE_NTOHL (0x4964656e), 
+        ACE_NTOHL (0x74696669), 
+        ACE_NTOHL (0x65720000),  // name = Identifier
+        CORBA::tk_string, 
+        0U, // string length
+
+      3,
+      ACE_NTOHL (0x69640000),  // name = id
+      CORBA::tk_alias, // typecode kind for typedefs
+      72, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        35,
+        ACE_NTOHL (0x49444c3a), 
+        ACE_NTOHL (0x6f6d672e), 
+        ACE_NTOHL (0x6f72672f), 
+        ACE_NTOHL (0x434f5242), 
+        ACE_NTOHL (0x412f5265), 
+        ACE_NTOHL (0x706f7369), 
+        ACE_NTOHL (0x746f7279), 
+        ACE_NTOHL (0x49643a31), 
+        ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+        13,
+        ACE_NTOHL (0x5265706f), 
+        ACE_NTOHL (0x7369746f), 
+        ACE_NTOHL (0x72794964), 
+        ACE_NTOHL (0x0),  // name = RepositoryId
+        CORBA::tk_string, 
+        0U, // string length
+
+      11,
+      ACE_NTOHL (0x64656669), 
+      ACE_NTOHL (0x6e65645f), 
+      ACE_NTOHL (0x696e0000),  // name = defined_in
+      CORBA::tk_alias, // typecode kind for typedefs
+      72, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        35,
+        ACE_NTOHL (0x49444c3a), 
+        ACE_NTOHL (0x6f6d672e), 
+        ACE_NTOHL (0x6f72672f), 
+        ACE_NTOHL (0x434f5242), 
+        ACE_NTOHL (0x412f5265), 
+        ACE_NTOHL (0x706f7369), 
+        ACE_NTOHL (0x746f7279), 
+        ACE_NTOHL (0x49643a31), 
+        ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+        13,
+        ACE_NTOHL (0x5265706f), 
+        ACE_NTOHL (0x7369746f), 
+        ACE_NTOHL (0x72794964), 
+        ACE_NTOHL (0x0),  // name = RepositoryId
+        CORBA::tk_string, 
+        0U, // string length
+
+      8,
+      ACE_NTOHL (0x76657273), 
+      ACE_NTOHL (0x696f6e00),  // name = version
+      CORBA::tk_alias, // typecode kind for typedefs
+      68, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        34,
+        ACE_NTOHL (0x49444c3a), 
+        ACE_NTOHL (0x6f6d672e), 
+        ACE_NTOHL (0x6f72672f), 
+        ACE_NTOHL (0x434f5242), 
+        ACE_NTOHL (0x412f5665), 
+        ACE_NTOHL (0x7273696f), 
+        ACE_NTOHL (0x6e537065), 
+        ACE_NTOHL (0x633a312e), 
+        ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/VersionSpec:1.0
+        12,
+        ACE_NTOHL (0x56657273), 
+        ACE_NTOHL (0x696f6e53), 
+        ACE_NTOHL (0x70656300),  // name = VersionSpec
+        CORBA::tk_string, 
+        0U, // string length
+
+      5,
+      ACE_NTOHL (0x74797065), 
+      ACE_NTOHL (0x0),  // name = type
+      CORBA::tk_TypeCode,
+
+      9,
+      ACE_NTOHL (0x74797065), 
+      ACE_NTOHL (0x5f646566), 
+      ACE_NTOHL (0x0),  // name = type_def
+      CORBA::tk_objref, // typecode kind
+      52, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        30,
+        ACE_NTOHL (0x49444c3a), 
+        ACE_NTOHL (0x6f6d672e), 
+        ACE_NTOHL (0x6f72672f), 
+        ACE_NTOHL (0x434f5242), 
+        ACE_NTOHL (0x412f4944), 
+        ACE_NTOHL (0x4c547970), 
+        ACE_NTOHL (0x653a312e), 
+        ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/IDLType:1.0
+        8,
+        ACE_NTOHL (0x49444c54), 
+        ACE_NTOHL (0x79706500),  // name = IDLType
+
+      7,
+      ACE_NTOHL (0x61636365), 
+      ACE_NTOHL (0x73730000),  // name = access
+      CORBA::tk_alias, // typecode kind for typedefs
+      64, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        33,
+        ACE_NTOHL (0x49444c3a), 
+        ACE_NTOHL (0x6f6d672e), 
+        ACE_NTOHL (0x6f72672f), 
+        ACE_NTOHL (0x434f5242), 
+        ACE_NTOHL (0x412f5669), 
+        ACE_NTOHL (0x73696269), 
+        ACE_NTOHL (0x6c697479), 
+        ACE_NTOHL (0x3a312e30), 
+        ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Visibility:1.0
+        11,
+        ACE_NTOHL (0x56697369), 
+        ACE_NTOHL (0x62696c69), 
+        ACE_NTOHL (0x74790000),  // name = Visibility
+        CORBA::tk_short,
+
+
+
+    0U,
+
+};
+
+static CORBA::TypeCode _tc_TAO_tc_CORBA_ValueMemberSeq (
+    CORBA::tk_alias,
+    sizeof (_oc_CORBA_ValueMemberSeq),
+    (char *) &_oc_CORBA_ValueMemberSeq,
+    0,
+    sizeof (CORBA::ValueMemberSeq)
+  );
+
+static const CORBA::Long _oc_CORBA_ValueMemberDef[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  37,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x434f5242), 
+  ACE_NTOHL (0x412f5661), 
+  ACE_NTOHL (0x6c75654d), 
+  ACE_NTOHL (0x656d6265), 
+  ACE_NTOHL (0x72446566), 
+  ACE_NTOHL (0x3a312e30), 
+  ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/ValueMemberDef:1.0
+  15,
+  ACE_NTOHL (0x56616c75), 
+  ACE_NTOHL (0x654d656d), 
+  ACE_NTOHL (0x62657244), 
+  ACE_NTOHL (0x65660000),  // name = ValueMemberDef
+};
+
+static CORBA::TypeCode _tc_TAO_tc_CORBA_ValueMemberDef (
+    CORBA::tk_objref,
+    sizeof (_oc_CORBA_ValueMemberDef),
+    (char *) &_oc_CORBA_ValueMemberDef,
+    0,
+    sizeof (CORBA::ValueMemberDef)
+  );
+
+static const CORBA::Long _oc_CORBA_ValueDef[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  31,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x434f5242), 
+  ACE_NTOHL (0x412f5661), 
+  ACE_NTOHL (0x6c756544), 
+  ACE_NTOHL (0x65663a31), 
+  ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/ValueDef:1.0
+  9,
+  ACE_NTOHL (0x56616c75), 
+  ACE_NTOHL (0x65446566), 
+  ACE_NTOHL (0x0),  // name = ValueDef
+};
+
+static CORBA::TypeCode _tc_TAO_tc_CORBA_ValueDef (
+    CORBA::tk_objref,
+    sizeof (_oc_CORBA_ValueDef),
+    (char *) &_oc_CORBA_ValueDef,
+    0,
+    sizeof (CORBA::ValueDef)
+  );
+
+static const CORBA::Long _oc_CORBA_ValueDescription[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  39,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x434f5242), 
+  ACE_NTOHL (0x412f5661), 
+  ACE_NTOHL (0x6c756544), 
+  ACE_NTOHL (0x65736372), 
+  ACE_NTOHL (0x69707469), 
+  ACE_NTOHL (0x6f6e3a31), 
+  ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/ValueDescription:1.0
+  17,
+  ACE_NTOHL (0x56616c75), 
+  ACE_NTOHL (0x65446573), 
+  ACE_NTOHL (0x63726970), 
+  ACE_NTOHL (0x74696f6e), 
+  ACE_NTOHL (0x0),  // name = ValueDescription
+  10, // member count
+  5,
+  ACE_NTOHL (0x6e616d65), 
+  ACE_NTOHL (0x0),  // name = name
+  CORBA::tk_alias, // typecode kind for typedefs
+  68, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    33,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x434f5242), 
+    ACE_NTOHL (0x412f4964), 
+    ACE_NTOHL (0x656e7469), 
+    ACE_NTOHL (0x66696572), 
+    ACE_NTOHL (0x3a312e30), 
+    ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+    11,
+    ACE_NTOHL (0x4964656e), 
+    ACE_NTOHL (0x74696669), 
+    ACE_NTOHL (0x65720000),  // name = Identifier
+    CORBA::tk_string, 
+    0U, // string length
+
+  3,
+  ACE_NTOHL (0x69640000),  // name = id
+  CORBA::tk_alias, // typecode kind for typedefs
+  72, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    35,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x434f5242), 
+    ACE_NTOHL (0x412f5265), 
+    ACE_NTOHL (0x706f7369), 
+    ACE_NTOHL (0x746f7279), 
+    ACE_NTOHL (0x49643a31), 
+    ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+    13,
+    ACE_NTOHL (0x5265706f), 
+    ACE_NTOHL (0x7369746f), 
+    ACE_NTOHL (0x72794964), 
+    ACE_NTOHL (0x0),  // name = RepositoryId
+    CORBA::tk_string, 
+    0U, // string length
+
+  12,
+  ACE_NTOHL (0x69735f61), 
+  ACE_NTOHL (0x62737472), 
+  ACE_NTOHL (0x61637400),  // name = is_abstract
+  CORBA::tk_boolean,
+
+  10,
+  ACE_NTOHL (0x69735f63), 
+  ACE_NTOHL (0x7573746f), 
+  ACE_NTOHL (0x6d000000),  // name = is_custom
+  CORBA::tk_boolean,
+
+  11,
+  ACE_NTOHL (0x64656669), 
+  ACE_NTOHL (0x6e65645f), 
+  ACE_NTOHL (0x696e0000),  // name = defined_in
+  CORBA::tk_alias, // typecode kind for typedefs
+  72, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    35,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x434f5242), 
+    ACE_NTOHL (0x412f5265), 
+    ACE_NTOHL (0x706f7369), 
+    ACE_NTOHL (0x746f7279), 
+    ACE_NTOHL (0x49643a31), 
+    ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+    13,
+    ACE_NTOHL (0x5265706f), 
+    ACE_NTOHL (0x7369746f), 
+    ACE_NTOHL (0x72794964), 
+    ACE_NTOHL (0x0),  // name = RepositoryId
+    CORBA::tk_string, 
+    0U, // string length
+
+  8,
+  ACE_NTOHL (0x76657273), 
+  ACE_NTOHL (0x696f6e00),  // name = version
+  CORBA::tk_alias, // typecode kind for typedefs
+  68, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    34,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x434f5242), 
+    ACE_NTOHL (0x412f5665), 
+    ACE_NTOHL (0x7273696f), 
+    ACE_NTOHL (0x6e537065), 
+    ACE_NTOHL (0x633a312e), 
+    ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/VersionSpec:1.0
+    12,
+    ACE_NTOHL (0x56657273), 
+    ACE_NTOHL (0x696f6e53), 
+    ACE_NTOHL (0x70656300),  // name = VersionSpec
+    CORBA::tk_string, 
+    0U, // string length
+
+  21,
+  ACE_NTOHL (0x73757070), 
+  ACE_NTOHL (0x6f727465), 
+  ACE_NTOHL (0x645f696e), 
+  ACE_NTOHL (0x74657266), 
+  ACE_NTOHL (0x61636573), 
+  ACE_NTOHL (0x0),  // name = supported_interfaces
+  CORBA::tk_alias, // typecode kind for typedefs
+  164, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    38,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x434f5242), 
+    ACE_NTOHL (0x412f5265), 
+    ACE_NTOHL (0x706f7369), 
+    ACE_NTOHL (0x746f7279), 
+    ACE_NTOHL (0x49645365), 
+    ACE_NTOHL (0x713a312e), 
+    ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/RepositoryIdSeq:1.0
+    16,
+    ACE_NTOHL (0x5265706f), 
+    ACE_NTOHL (0x7369746f), 
+    ACE_NTOHL (0x72794964), 
+    ACE_NTOHL (0x53657100),  // name = RepositoryIdSeq
+    CORBA::tk_sequence, // typecode kind
+    88, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      CORBA::tk_alias, // typecode kind for typedefs
+      72, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        35,
+        ACE_NTOHL (0x49444c3a), 
+        ACE_NTOHL (0x6f6d672e), 
+        ACE_NTOHL (0x6f72672f), 
+        ACE_NTOHL (0x434f5242), 
+        ACE_NTOHL (0x412f5265), 
+        ACE_NTOHL (0x706f7369), 
+        ACE_NTOHL (0x746f7279), 
+        ACE_NTOHL (0x49643a31), 
+        ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+        13,
+        ACE_NTOHL (0x5265706f), 
+        ACE_NTOHL (0x7369746f), 
+        ACE_NTOHL (0x72794964), 
+        ACE_NTOHL (0x0),  // name = RepositoryId
+        CORBA::tk_string, 
+        0U, // string length
+
+      0U,
+
+
+  21,
+  ACE_NTOHL (0x61627374), 
+  ACE_NTOHL (0x72616374), 
+  ACE_NTOHL (0x5f626173), 
+  ACE_NTOHL (0x655f7661), 
+  ACE_NTOHL (0x6c756573), 
+  ACE_NTOHL (0x0),  // name = abstract_base_values
+  CORBA::tk_alias, // typecode kind for typedefs
+  164, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    38,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x434f5242), 
+    ACE_NTOHL (0x412f5265), 
+    ACE_NTOHL (0x706f7369), 
+    ACE_NTOHL (0x746f7279), 
+    ACE_NTOHL (0x49645365), 
+    ACE_NTOHL (0x713a312e), 
+    ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/RepositoryIdSeq:1.0
+    16,
+    ACE_NTOHL (0x5265706f), 
+    ACE_NTOHL (0x7369746f), 
+    ACE_NTOHL (0x72794964), 
+    ACE_NTOHL (0x53657100),  // name = RepositoryIdSeq
+    CORBA::tk_sequence, // typecode kind
+    88, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      CORBA::tk_alias, // typecode kind for typedefs
+      72, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        35,
+        ACE_NTOHL (0x49444c3a), 
+        ACE_NTOHL (0x6f6d672e), 
+        ACE_NTOHL (0x6f72672f), 
+        ACE_NTOHL (0x434f5242), 
+        ACE_NTOHL (0x412f5265), 
+        ACE_NTOHL (0x706f7369), 
+        ACE_NTOHL (0x746f7279), 
+        ACE_NTOHL (0x49643a31), 
+        ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+        13,
+        ACE_NTOHL (0x5265706f), 
+        ACE_NTOHL (0x7369746f), 
+        ACE_NTOHL (0x72794964), 
+        ACE_NTOHL (0x0),  // name = RepositoryId
+        CORBA::tk_string, 
+        0U, // string length
+
+      0U,
+
+
+  15,
+  ACE_NTOHL (0x69735f74), 
+  ACE_NTOHL (0x72756e63), 
+  ACE_NTOHL (0x61746162), 
+  ACE_NTOHL (0x6c650000),  // name = is_truncatable
+  CORBA::tk_boolean,
+
+  11,
+  ACE_NTOHL (0x62617365), 
+  ACE_NTOHL (0x5f76616c), 
+  ACE_NTOHL (0x75650000),  // name = base_value
+  CORBA::tk_alias, // typecode kind for typedefs
+  72, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    35,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x434f5242), 
+    ACE_NTOHL (0x412f5265), 
+    ACE_NTOHL (0x706f7369), 
+    ACE_NTOHL (0x746f7279), 
+    ACE_NTOHL (0x49643a31), 
+    ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+    13,
+    ACE_NTOHL (0x5265706f), 
+    ACE_NTOHL (0x7369746f), 
+    ACE_NTOHL (0x72794964), 
+    ACE_NTOHL (0x0),  // name = RepositoryId
+    CORBA::tk_string, 
+    0U, // string length
+
+};
+
+static CORBA::TypeCode _tc_TAO_tc_CORBA_ValueDescription (
+    CORBA::tk_struct,
+    sizeof (_oc_CORBA_ValueDescription),
+    (char *) &_oc_CORBA_ValueDescription,
+    0,
+    sizeof (CORBA::ValueDescription)
+  );
+
+static const CORBA::Long _oc_CORBA_ValueBoxDef[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  34,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x434f5242), 
+  ACE_NTOHL (0x412f5661), 
+  ACE_NTOHL (0x6c756542), 
+  ACE_NTOHL (0x6f784465), 
+  ACE_NTOHL (0x663a312e), 
+  ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/ValueBoxDef:1.0
+  12,
+  ACE_NTOHL (0x56616c75), 
+  ACE_NTOHL (0x65426f78), 
+  ACE_NTOHL (0x44656600),  // name = ValueBoxDef
+};
+
+static CORBA::TypeCode _tc_TAO_tc_CORBA_ValueBoxDef (
+    CORBA::tk_objref,
+    sizeof (_oc_CORBA_ValueBoxDef),
+    (char *) &_oc_CORBA_ValueBoxDef,
+    0,
+    sizeof (CORBA::ValueBoxDef)
+  );
+
 // *********************************************************************
 
 // Initialization and registration of dynamic service object.
@@ -268,6 +5898,72 @@ TAO_IFR_Client_Adapter_Impl::Initializer (void)
   CORBA::_tc_IRObject = &_tc_TAO_tc_CORBA_IRObject;
   CORBA::_tc_Visibility = &_tc_TAO_tc_CORBA_Visibility;
   CORBA::_tc_ValueModifier = &_tc_TAO_tc_CORBA_ValueModifier;
+  CORBA::_tc_DefinitionKind = &_tc_TAO_tc_CORBA_DefinitionKind;
+  CORBA::_tc_VersionSpec = &_tc_TAO_tc_CORBA_VersionSpec;
+  CORBA::_tc_Contained = &_tc_TAO_tc_CORBA_Contained;
+  CORBA::_tc_ContainedSeq = &_tc_TAO_tc_CORBA_ContainedSeq;
+  CORBA::_tc_InterfaceDefSeq = &_tc_TAO_tc_CORBA_InterfaceDefSeq;
+  CORBA::_tc_AbstractInterfaceDefSeq = 
+    &_tc_TAO_tc_CORBA_AbstractInterfaceDefSeq;
+  CORBA::_tc_LocalInterfaceDefSeq = &_tc_TAO_tc_CORBA_LocalInterfaceDefSeq;
+  CORBA::_tc_StructMember = &_tc_TAO_tc_CORBA_StructMember;
+  CORBA::_tc_StructMemberSeq = &_tc_TAO_tc_CORBA_StructMemberSeq;
+  CORBA::_tc_Initializer = &_tc_TAO_tc_CORBA_Initializer;
+  CORBA::_tc_InitializerSeq = &_tc_TAO_tc_CORBA_InitializerSeq;
+  CORBA::_tc_UnionMember = &_tc_TAO_tc_CORBA_UnionMember;
+  CORBA::_tc_UnionMemberSeq = &_tc_TAO_tc_CORBA_UnionMemberSeq;
+  CORBA::_tc_EnumMemberSeq = &_tc_TAO_tc_CORBA_EnumMemberSeq;
+  CORBA::_tc_Container = &_tc_TAO_tc_CORBA_Container;
+  CORBA::_tc_IDLType = &_tc_TAO_tc_CORBA_IDLType;
+  CORBA::_tc_TypedefDef = &_tc_TAO_tc_CORBA_TypedefDef;
+  CORBA::_tc_TypeDescription = &_tc_TAO_tc_CORBA_TypeDescription;
+  CORBA::_tc_PrimitiveKind = &_tc_TAO_tc_CORBA_PrimitiveKind;
+  CORBA::_tc_Repository = &_tc_TAO_tc_CORBA_Repository;
+  CORBA::_tc_ModuleDef = &_tc_TAO_tc_CORBA_ModuleDef;
+  CORBA::_tc_ModuleDescription = &_tc_TAO_tc_CORBA_ModuleDescription;
+  CORBA::_tc_ConstantDef = &_tc_TAO_tc_CORBA_ConstantDef;
+  CORBA::_tc_ConstantDescription = &_tc_TAO_tc_CORBA_ConstantDescription;
+  CORBA::_tc_StructDef = &_tc_TAO_tc_CORBA_StructDef;
+  CORBA::_tc_UnionDef = &_tc_TAO_tc_CORBA_UnionDef;
+  CORBA::_tc_EnumDef = &_tc_TAO_tc_CORBA_EnumDef;
+  CORBA::_tc_AliasDef = &_tc_TAO_tc_CORBA_AliasDef;
+  CORBA::_tc_NativeDef = &_tc_TAO_tc_CORBA_NativeDef;
+  CORBA::_tc_PrimitiveDef = &_tc_TAO_tc_CORBA_PrimitiveDef;
+  CORBA::_tc_StringDef = &_tc_TAO_tc_CORBA_StringDef;
+  CORBA::_tc_WstringDef = &_tc_TAO_tc_CORBA_WstringDef;
+  CORBA::_tc_SequenceDef = &_tc_TAO_tc_CORBA_SequenceDef;
+  CORBA::_tc_ArrayDef = &_tc_TAO_tc_CORBA_ArrayDef;
+  CORBA::_tc_ExceptionDef = &_tc_TAO_tc_CORBA_ExceptionDef;
+  CORBA::_tc_ExceptionDescription = &_tc_TAO_tc_CORBA_ExceptionDescription;
+  CORBA::_tc_ExceptionDefSeq = &_tc_TAO_tc_CORBA_ExceptionDefSeq;
+  CORBA::_tc_ExcDescriptionSeq = &_tc_TAO_tc_CORBA_ExcDescriptionSeq;
+  CORBA::_tc_AttributeMode = &_tc_TAO_tc_CORBA_AttributeMode;
+  CORBA::_tc_AttributeDef = &_tc_TAO_tc_CORBA_AttributeDef;
+  CORBA::_tc_AttributeDescription = &_tc_TAO_tc_CORBA_AttributeDescription;
+  CORBA::_tc_OperationMode = &_tc_TAO_tc_CORBA_OperationMode;
+  CORBA::_tc_ParameterMode = &_tc_TAO_tc_CORBA_ParameterMode;
+  CORBA::_tc_ParameterDescription = &_tc_TAO_tc_CORBA_ParameterDescription;
+  CORBA::_tc_ParDescriptionSeq = &_tc_TAO_tc_CORBA_ParDescriptionSeq;
+  CORBA::_tc_ContextIdentifier = &_tc_TAO_tc_CORBA_ContextIdentifier;
+  CORBA::_tc_ContextIdSeq = &_tc_TAO_tc_CORBA_ContextIdSeq;
+  CORBA::_tc_OperationDef = &_tc_TAO_tc_CORBA_OperationDef;
+  CORBA::_tc_OperationDescription = &_tc_TAO_tc_CORBA_OperationDescription;
+  CORBA::_tc_RepositoryIdSeq = &_tc_TAO_tc_CORBA_RepositoryIdSeq;
+  CORBA::_tc_OpDescriptionSeq = &_tc_TAO_tc_CORBA_OpDescriptionSeq;
+  CORBA::_tc_AttrDescriptionSeq = &_tc_TAO_tc_CORBA_AttrDescriptionSeq;
+  CORBA::_tc_InterfaceDef = &_tc_TAO_tc_CORBA_InterfaceDef;
+  CORBA::_tc_InterfaceDescription = &_tc_TAO_tc_CORBA_InterfaceDescription;
+  CORBA::_tc_AbstractInterfaceDef = &_tc_TAO_tc_CORBA_AbstractInterfaceDef;
+  CORBA::_tc_LocalInterfaceDef = &_tc_TAO_tc_CORBA_LocalInterfaceDef;
+
+  CORBA::_tc_FixedDef = &_tc_TAO_tc_CORBA_FixedDef;
+  CORBA::_tc_ValueDefSeq = &_tc_TAO_tc_CORBA_ValueDefSeq;
+  CORBA::_tc_ValueMember = &_tc_TAO_tc_CORBA_ValueMember;
+  CORBA::_tc_ValueMemberSeq = &_tc_TAO_tc_CORBA_ValueMemberSeq;
+  CORBA::_tc_ValueMemberDef = &_tc_TAO_tc_CORBA_ValueMemberDef;
+  CORBA::_tc_ValueDef = &_tc_TAO_tc_CORBA_ValueDef;
+  CORBA::_tc_ValueDescription = &_tc_TAO_tc_CORBA_ValueDescription;
+  CORBA::_tc_ValueBoxDef = &_tc_TAO_tc_CORBA_ValueBoxDef;
 
   TAO_ORB_Core::ifr_client_adapter_name ("Concrete_IFR_Client_Adapter");
 
diff --git a/TAO/tao/IFR_Client/IFR_Client_Adapter_Impl.h b/TAO/tao/IFR_Client/IFR_Client_Adapter_Impl.h
index 043d78f9c1b..917cf3c6562 100644
--- a/TAO/tao/IFR_Client/IFR_Client_Adapter_Impl.h
+++ b/TAO/tao/IFR_Client/IFR_Client_Adapter_Impl.h
@@ -41,26 +41,27 @@ public:
 
   virtual CORBA::Boolean interfacedef_cdr_insert (
       TAO_OutputCDR &cdr,
-      IR_InterfaceDef *object_type
+      CORBA_InterfaceDef_ptr object_type
     );
 
   virtual void interfacedef_any_insert (
       CORBA_Any &any,
-      IR_InterfaceDef *object_type
+      CORBA_InterfaceDef_ptr object_type
     );
 
-  virtual IR_InterfaceDef *get_interface (
-      CORBA::ORB_ptr orb,
-      const char *repo_id,
-      CORBA::Environment &ACE_TRY_ENV = 
-        TAO_default_environment ()
+  virtual void dispose (
+      CORBA_InterfaceDef_ptr orphan
     );
 
-  virtual CORBA_IRObject_ptr get_interface_def (
+  virtual CORBA_InterfaceDef_ptr get_interface (
       CORBA::ORB_ptr orb,
       const char *repo_id,
-      CORBA::Environment &ACE_TRY_ENV = 
-        TAO_default_environment ()
+      CORBA::Environment &ACE_TRY_ENV
+    );
+
+  virtual CORBA_InterfaceDef_ptr get_interface_remote (
+      const CORBA::Object_ptr target,
+      CORBA_Environment &ACE_TRY_ENV
     );
 
   // Used to force the initialization of the ORB code.
diff --git a/TAO/tao/IFR_Client/IFR_Components.pidl b/TAO/tao/IFR_Client/IFR_Components.pidl
new file mode 100644
index 00000000000..aee440cf962
--- /dev/null
+++ b/TAO/tao/IFR_Client/IFR_Components.pidl
@@ -0,0 +1,333 @@
+//
+// $Id$
+//
+// ================================================================
+//
+// = LIBRARY
+//   TAO_IFR_Client
+//
+// = FILENAME
+//   IFR_Components.pidl
+//
+// = DESCRIPTION
+//   This file was used to generate the code in IFR_ComponentsC.{h,i,cpp}.
+//   The original file Interface.idl was split into four pieces, to
+//   keep the generated files to a manageable size and reduce build
+//   time. This IDL file contains all the interfaces and other data
+//   types related to CORBA components.
+//
+//   The command used to generate code from this IDL file is:
+//
+//     tao_idl -o orig -Ge 1 \
+//          -Wb,export_macro=TAO_IFR_Client_Export \
+//          -Wb,export_include=ifr_client_export.h \
+//          -Wb,pre_include="ace/pre.h" \
+//          -Wb,post_include="ace/post.h" \
+//          IFR_Components.pidl
+//
+//   To regenerate the skeleton files IFR_ComponentsS.{h,i,cpp} and 
+//   IFR_ComponentsS_T.{h,i.cpp} in ACE_ROOT/TAO/orbsvcs/IFR_Service,
+//   use the command
+//
+//     tao_idl -o ../../orbsvcs/IFR_Service/orig -Ge 1 \
+//          -Wb,pre_include="ace/pre.h" \
+//          -Wb,post_include="ace/post.h" \
+//          IFR_Components.pidl
+//
+// ================================================================
+
+#ifndef _IFR_COMPONENTS_IDL_
+#define _IFR_COMPONENTS_IDL_
+
+#include "IFR_Extended.pidl"
+
+#pragma prefix "omg.org"
+
+module IR
+{
+  enum 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
+  };
+
+  typedef string Identifier;
+  typedef string ScopedName;
+  typedef string RepositoryId;
+  typedef sequence<RepositoryId> RepositoryIdSeq;
+  typedef string VersionSpec;
+
+  interface ComponentDef;
+  typedef sequence <ComponentDef> ComponentDefSeq;
+  interface ProvidesDef;
+  typedef sequence <ProvidesDef> ProvidesDefSeq;
+  interface UsesDef;
+  typedef sequence <UsesDef> UsesDefSeq;
+  interface HomeDef;
+  typedef sequence <HomeDef> HomeDefSeq;
+  interface EventDef;
+  interface EmitsDef;
+  typedef sequence <EmitsDef> EmitsDefSeq;
+  interface PublishesDef;
+  typedef sequence <PublishesDef> PublishesDefSeq;
+  interface ConsumesDef;
+  typedef sequence <ConsumesDef> ConsumesDefSeq;
+  interface FactoryDef;
+  typedef sequence <FactoryDef> FactoryDefSeq;
+  interface FinderDef;
+  typedef sequence <FinderDef> FinderDefSeq;
+  interface PrimaryKeyDef;
+
+  interface ComponentRepository : CORBA::Repository
+  {
+    ComponentDef create_component (
+        in RepositoryId id,
+        in Identifier name,
+        in VersionSpec version,
+        in ComponentDef base_component,
+        in CORBA::InterfaceDefSeq supports_interfaces
+      );
+    HomeDef create_home (
+        in RepositoryId id,
+        in Identifier name,
+        in VersionSpec version,
+        in HomeDef base_home,
+        in ComponentDef managed_component,
+        in CORBA::ValueDef primary_key
+      );
+  };
+
+  interface ProvidesDef : CORBA::Contained 
+  {
+    // read interface
+    readonly attribute CORBA::InterfaceDef interface_type;
+  };
+
+  struct ProvidesDescription 
+  {
+    Identifier name;
+    RepositoryId id;
+    RepositoryId defined_in;
+    VersionSpec version;
+    CORBA::InterfaceDef interface_type;
+  };
+
+  interface UsesDef : CORBA::Contained 
+  {
+    // read interface
+    readonly attribute CORBA::InterfaceDef interface_type;
+    readonly attribute boolean is_multiple;
+  };
+
+  struct UsesDescription 
+  {
+    Identifier name;
+    RepositoryId id;
+    RepositoryId defined_in;
+    VersionSpec version;
+    CORBA::InterfaceDef interface_type;
+    boolean is_multiple;
+  };
+
+  typedef sequence <ProvidesDescription> ProvidesDescSeq;
+  typedef sequence <UsesDescription> UsesDescSeq;
+
+  interface EventDef : CORBA::Contained 
+  { // abstract - never instantiated
+    // read interface
+    boolean is_a (in RepositoryId event_id);
+    readonly attribute CORBA::ValueDef event;
+  };
+
+  struct EventDescription 
+  {
+    Identifier name;
+    RepositoryId id;
+    RepositoryId defined_in;
+    VersionSpec version;
+    CORBA::ValueDef value;
+  };
+
+  interface EmitsDef : EventDef 
+  {
+  };
+
+  interface PublishesDef : EventDef 
+  {
+  };
+
+  interface ConsumesDef : EventDef 
+  {
+  };
+
+  interface ComponentDef : CORBA::InterfaceDef 
+  {
+    // read/write interface
+    attribute CORBA::InterfaceDefSeq supported_interfaces;
+    // read interface
+    readonly attribute ComponentDef base_component;
+    readonly attribute ProvidesDefSeq provides_interfaces;
+    readonly attribute UsesDefSeq uses_interfaces;
+    readonly attribute EmitsDefSeq emits_events;
+    readonly attribute PublishesDefSeq publishes_events;
+    readonly attribute ConsumesDefSeq consumes_events;
+    readonly attribute boolean is_basic;
+    // write interface
+    ProvidesDef create_provides (
+        in RepositoryId id,
+        in Identifier name,
+        in VersionSpec version,
+        in CORBA::InterfaceDef interface_type
+      );
+    UsesDef create_uses (
+        in RepositoryId id,
+        in Identifier name,
+        in VersionSpec version,
+        in CORBA::InterfaceDef interface_type,
+        in boolean is_multiple
+      );
+    EmitsDef create_emits (
+        in RepositoryId id,
+        in Identifier name,
+        in VersionSpec version,
+        in CORBA::ValueDef value
+      );
+    PublishesDef create_publishes (
+        in RepositoryId id,
+        in Identifier name,
+        in VersionSpec version,
+        in CORBA::ValueDef value
+      );
+    ConsumesDef create_consumes (
+        in RepositoryId id,
+        in Identifier name,
+        in VersionSpec version,
+        in CORBA::ValueDef value
+      );
+  };
+
+  struct ComponentDescription 
+  {
+    Identifier name;
+    RepositoryId id;
+    RepositoryId defined_in;
+    VersionSpec version;
+    RepositoryId base_component;
+    RepositoryIdSeq supports_interfaces;
+    ProvidesDefSeq provides_interfaces;
+    UsesDefSeq uses_interfaces;
+    CORBA::AttrDescriptionSeq attributes;
+    EmitsDefSeq emits_events;
+    PublishesDefSeq publishes_events;
+    ConsumesDefSeq consumes_events;
+    boolean is_basic;
+  };
+
+  interface PrimaryKeyDef : CORBA::Contained 
+  {
+    // read interface
+    boolean is_a (in RepositoryId primary_key_id);
+    readonly attribute CORBA::ValueDef primary_key;
+  };
+
+  struct PrimaryKeyDescription 
+  {
+    Identifier name;
+    RepositoryId id;
+    RepositoryId defined_in;
+    VersionSpec version;
+    CORBA::ValueDef primary_key;
+  };
+
+  interface FactoryDef : CORBA::OperationDef 
+  { // only PARAM_IN parameters
+  };
+
+  interface FinderDef : CORBA::OperationDef 
+  { // only PARAM_IN parameters
+  };
+
+  interface HomeDef : CORBA::InterfaceDef 
+  {
+    // read operations
+    readonly attribute HomeDef base_home;
+    readonly attribute ComponentDef managed_component;
+    readonly attribute PrimaryKeyDef primary_key;
+    readonly attribute FactoryDefSeq factories;
+    readonly attribute FinderDefSeq finders;
+    readonly attribute boolean is_basic;
+    // write interfaces
+    PrimaryKeyDef create_primary_key (
+        in RepositoryId id,
+        in Identifier name,
+        in VersionSpec version,
+        in CORBA::ValueDef primary_key
+      );
+    FactoryDef create_factory (
+        in RepositoryId id,
+        in Identifier name,
+        in VersionSpec version,
+        in CORBA::ParDescriptionSeq params, // only PARAM_INs
+        in CORBA::ExceptionDefSeq exceptions
+      );
+    FinderDef create_finder (
+        in RepositoryId id,
+        in Identifier name,
+        in VersionSpec version,
+        in CORBA::ParDescriptionSeq params, // only PARAM_INs
+        in CORBA::ExceptionDefSeq exceptions
+      );
+  };
+
+  struct HomeDescription 
+  {
+    Identifier name;
+    RepositoryId id;
+    RepositoryId defined_in;
+    VersionSpec version;
+    RepositoryId base_home;
+    RepositoryId managed_component;
+    PrimaryKeyDef primary_key_def;
+    FactoryDefSeq factories;
+    FinderDefSeq finders;
+    CORBA::OpDescriptionSeq operations;
+    CORBA::AttrDescriptionSeq attributes;
+    boolean is_basic;
+  };
+};
+
+#pragma prefix ""
+
+#endif /* _IFR_COMPONENTS_IDL_ */
diff --git a/TAO/tao/IFR_Client/IFR_ComponentsC.cpp b/TAO/tao/IFR_Client/IFR_ComponentsC.cpp
new file mode 100644
index 00000000000..c7d1984a274
--- /dev/null
+++ b/TAO/tao/IFR_Client/IFR_ComponentsC.cpp
@@ -0,0 +1,19241 @@
+// -*- C++ -*-
+//
+// $Id$
+
+// ****  Code generated by the The ACE ORB (TAO) IDL Compiler ****
+// TAO and the TAO IDL Compiler have been developed by:
+//       Center for Distributed Object Computing
+//       Washington University
+//       St. Louis, MO
+//       USA
+//       http://www.cs.wustl.edu/~schmidt/doc-center.html
+// and
+//       Distributed Object Computing Laboratory
+//       University of California at Irvine
+//       Irvine, CA
+//       USA
+//       http://doc.ece.uci.edu/
+//
+// Information about TAO is available at:
+//     http://www.cs.wustl.edu/~schmidt/TAO.html
+
+#include "IFR_ComponentsC.h"
+
+#if TAO_HAS_INTERCEPTORS == 1
+#include "tao/RequestInfo_Util.h"
+#endif  /* TAO_HAS_INTERCEPTORS == 1 */
+
+#if defined (__BORLANDC__)
+#pragma option -w-rvl -w-rch -w-ccc -w-aus
+#endif /* __BORLANDC__ */
+
+#if !defined (__ACE_INLINE__)
+#include "IFR_ComponentsC.i"
+#endif /* !defined INLINE */
+
+static const CORBA::Long _oc_IR_DefinitionKind[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  34,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x49522f44), 
+  ACE_NTOHL (0x6566696e), 
+  ACE_NTOHL (0x6974696f), 
+  ACE_NTOHL (0x6e4b696e), 
+  ACE_NTOHL (0x643a312e), 
+  ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/DefinitionKind:1.0
+  15,
+  ACE_NTOHL (0x44656669), 
+  ACE_NTOHL (0x6e697469), 
+  ACE_NTOHL (0x6f6e4b69), 
+  ACE_NTOHL (0x6e640000),  // name = DefinitionKind
+  34, // member count
+  8,
+  ACE_NTOHL (0x646b5f6e), 
+  ACE_NTOHL (0x6f6e6500),  // name = dk_none
+  7,
+  ACE_NTOHL (0x646b5f61), 
+  ACE_NTOHL (0x6c6c0000),  // name = dk_all
+  13,
+  ACE_NTOHL (0x646b5f41), 
+  ACE_NTOHL (0x74747269), 
+  ACE_NTOHL (0x62757465), 
+  ACE_NTOHL (0x0),  // name = dk_Attribute
+  12,
+  ACE_NTOHL (0x646b5f43), 
+  ACE_NTOHL (0x6f6e7374), 
+  ACE_NTOHL (0x616e7400),  // name = dk_Constant
+  13,
+  ACE_NTOHL (0x646b5f45), 
+  ACE_NTOHL (0x78636570), 
+  ACE_NTOHL (0x74696f6e), 
+  ACE_NTOHL (0x0),  // name = dk_Exception
+  13,
+  ACE_NTOHL (0x646b5f49), 
+  ACE_NTOHL (0x6e746572), 
+  ACE_NTOHL (0x66616365), 
+  ACE_NTOHL (0x0),  // name = dk_Interface
+  10,
+  ACE_NTOHL (0x646b5f4d), 
+  ACE_NTOHL (0x6f64756c), 
+  ACE_NTOHL (0x65000000),  // name = dk_Module
+  13,
+  ACE_NTOHL (0x646b5f4f), 
+  ACE_NTOHL (0x70657261), 
+  ACE_NTOHL (0x74696f6e), 
+  ACE_NTOHL (0x0),  // name = dk_Operation
+  11,
+  ACE_NTOHL (0x646b5f54), 
+  ACE_NTOHL (0x79706564), 
+  ACE_NTOHL (0x65660000),  // name = dk_Typedef
+  9,
+  ACE_NTOHL (0x646b5f41), 
+  ACE_NTOHL (0x6c696173), 
+  ACE_NTOHL (0x0),  // name = dk_Alias
+  10,
+  ACE_NTOHL (0x646b5f53), 
+  ACE_NTOHL (0x74727563), 
+  ACE_NTOHL (0x74000000),  // name = dk_Struct
+  9,
+  ACE_NTOHL (0x646b5f55), 
+  ACE_NTOHL (0x6e696f6e), 
+  ACE_NTOHL (0x0),  // name = dk_Union
+  8,
+  ACE_NTOHL (0x646b5f45), 
+  ACE_NTOHL (0x6e756d00),  // name = dk_Enum
+  13,
+  ACE_NTOHL (0x646b5f50), 
+  ACE_NTOHL (0x72696d69), 
+  ACE_NTOHL (0x74697665), 
+  ACE_NTOHL (0x0),  // name = dk_Primitive
+  10,
+  ACE_NTOHL (0x646b5f53), 
+  ACE_NTOHL (0x7472696e), 
+  ACE_NTOHL (0x67000000),  // name = dk_String
+  12,
+  ACE_NTOHL (0x646b5f53), 
+  ACE_NTOHL (0x65717565), 
+  ACE_NTOHL (0x6e636500),  // name = dk_Sequence
+  9,
+  ACE_NTOHL (0x646b5f41), 
+  ACE_NTOHL (0x72726179), 
+  ACE_NTOHL (0x0),  // name = dk_Array
+  14,
+  ACE_NTOHL (0x646b5f52), 
+  ACE_NTOHL (0x65706f73), 
+  ACE_NTOHL (0x69746f72), 
+  ACE_NTOHL (0x79000000),  // name = dk_Repository
+  11,
+  ACE_NTOHL (0x646b5f57), 
+  ACE_NTOHL (0x73747269), 
+  ACE_NTOHL (0x6e670000),  // name = dk_Wstring
+  9,
+  ACE_NTOHL (0x646b5f46), 
+  ACE_NTOHL (0x69786564), 
+  ACE_NTOHL (0x0),  // name = dk_Fixed
+  9,
+  ACE_NTOHL (0x646b5f56), 
+  ACE_NTOHL (0x616c7565), 
+  ACE_NTOHL (0x0),  // name = dk_Value
+  12,
+  ACE_NTOHL (0x646b5f56), 
+  ACE_NTOHL (0x616c7565), 
+  ACE_NTOHL (0x426f7800),  // name = dk_ValueBox
+  15,
+  ACE_NTOHL (0x646b5f56), 
+  ACE_NTOHL (0x616c7565), 
+  ACE_NTOHL (0x4d656d62), 
+  ACE_NTOHL (0x65720000),  // name = dk_ValueMember
+  10,
+  ACE_NTOHL (0x646b5f4e), 
+  ACE_NTOHL (0x61746976), 
+  ACE_NTOHL (0x65000000),  // name = dk_Native
+  13,
+  ACE_NTOHL (0x646b5f43), 
+  ACE_NTOHL (0x6f6d706f), 
+  ACE_NTOHL (0x6e656e74), 
+  ACE_NTOHL (0x0),  // name = dk_Component
+  8,
+  ACE_NTOHL (0x646b5f48), 
+  ACE_NTOHL (0x6f6d6500),  // name = dk_Home
+  11,
+  ACE_NTOHL (0x646b5f46), 
+  ACE_NTOHL (0x6163746f), 
+  ACE_NTOHL (0x72790000),  // name = dk_Factory
+  10,
+  ACE_NTOHL (0x646b5f46), 
+  ACE_NTOHL (0x696e6465), 
+  ACE_NTOHL (0x72000000),  // name = dk_Finder
+  14,
+  ACE_NTOHL (0x646b5f50), 
+  ACE_NTOHL (0x72696d61), 
+  ACE_NTOHL (0x72794b65), 
+  ACE_NTOHL (0x79000000),  // name = dk_PrimaryKey
+  9,
+  ACE_NTOHL (0x646b5f45), 
+  ACE_NTOHL (0x6d697473), 
+  ACE_NTOHL (0x0),  // name = dk_Emits
+  13,
+  ACE_NTOHL (0x646b5f50), 
+  ACE_NTOHL (0x75626c69), 
+  ACE_NTOHL (0x73686573), 
+  ACE_NTOHL (0x0),  // name = dk_Publishes
+  12,
+  ACE_NTOHL (0x646b5f43), 
+  ACE_NTOHL (0x6f6e7375), 
+  ACE_NTOHL (0x6d657300),  // name = dk_Consumes
+  12,
+  ACE_NTOHL (0x646b5f50), 
+  ACE_NTOHL (0x726f7669), 
+  ACE_NTOHL (0x64657300),  // name = dk_Provides
+  8,
+  ACE_NTOHL (0x646b5f55), 
+  ACE_NTOHL (0x73657300),  // name = dk_Uses
+};
+
+static CORBA::TypeCode _tc_TAO_tc_IR_DefinitionKind (
+    CORBA::tk_enum,
+    sizeof (_oc_IR_DefinitionKind),
+    (char *) &_oc_IR_DefinitionKind,
+    0,
+    sizeof (IR::DefinitionKind)
+  );
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_DefinitionKind, &_tc_TAO_tc_IR_DefinitionKind)
+TAO_NAMESPACE_END
+
+static const CORBA::Long _oc_IR_Identifier[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  30,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x49522f49), 
+  ACE_NTOHL (0x64656e74), 
+  ACE_NTOHL (0x69666965), 
+  ACE_NTOHL (0x723a312e), 
+  ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
+  11,
+  ACE_NTOHL (0x4964656e), 
+  ACE_NTOHL (0x74696669), 
+  ACE_NTOHL (0x65720000),  // name = Identifier
+  CORBA::tk_string, 
+  0U, // string length
+};
+
+static CORBA::TypeCode _tc_TAO_tc_IR_Identifier (
+    CORBA::tk_alias,
+    sizeof (_oc_IR_Identifier),
+    (char *) &_oc_IR_Identifier,
+    0,
+    sizeof (IR::Identifier)
+  );
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_Identifier, &_tc_TAO_tc_IR_Identifier)
+TAO_NAMESPACE_END
+
+static const CORBA::Long _oc_IR_ScopedName[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  30,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x49522f53), 
+  ACE_NTOHL (0x636f7065), 
+  ACE_NTOHL (0x644e616d), 
+  ACE_NTOHL (0x653a312e), 
+  ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/ScopedName:1.0
+  11,
+  ACE_NTOHL (0x53636f70), 
+  ACE_NTOHL (0x65644e61), 
+  ACE_NTOHL (0x6d650000),  // name = ScopedName
+  CORBA::tk_string, 
+  0U, // string length
+};
+
+static CORBA::TypeCode _tc_TAO_tc_IR_ScopedName (
+    CORBA::tk_alias,
+    sizeof (_oc_IR_ScopedName),
+    (char *) &_oc_IR_ScopedName,
+    0,
+    sizeof (IR::ScopedName)
+  );
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ScopedName, &_tc_TAO_tc_IR_ScopedName)
+TAO_NAMESPACE_END
+
+static const CORBA::Long _oc_IR_RepositoryId[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  32,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x49522f52), 
+  ACE_NTOHL (0x65706f73), 
+  ACE_NTOHL (0x69746f72), 
+  ACE_NTOHL (0x7949643a), 
+  ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
+  13,
+  ACE_NTOHL (0x5265706f), 
+  ACE_NTOHL (0x7369746f), 
+  ACE_NTOHL (0x72794964), 
+  ACE_NTOHL (0x0),  // name = RepositoryId
+  CORBA::tk_string, 
+  0U, // string length
+};
+
+static CORBA::TypeCode _tc_TAO_tc_IR_RepositoryId (
+    CORBA::tk_alias,
+    sizeof (_oc_IR_RepositoryId),
+    (char *) &_oc_IR_RepositoryId,
+    0,
+    sizeof (IR::RepositoryId)
+  );
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_RepositoryId, &_tc_TAO_tc_IR_RepositoryId)
+TAO_NAMESPACE_END
+
+
+#if !defined (_IR_REPOSITORYIDSEQ_CS_)
+#define _IR_REPOSITORYIDSEQ_CS_
+
+// *************************************************************
+// IR::RepositoryIdSeq
+// *************************************************************
+
+IR::RepositoryIdSeq::RepositoryIdSeq (void)
+{}
+IR::RepositoryIdSeq::RepositoryIdSeq (CORBA::ULong max) // uses max size
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  TAO_Unbounded_String_Sequence
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_String_Sequence
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (max)
+{}
+IR::RepositoryIdSeq::RepositoryIdSeq (CORBA::ULong max, CORBA::ULong length, char * *buffer, CORBA::Boolean release)
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  TAO_Unbounded_String_Sequence
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_String_Sequence
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (max, length, buffer, release)
+{}
+IR::RepositoryIdSeq::RepositoryIdSeq (const RepositoryIdSeq &seq) // copy ctor
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  TAO_Unbounded_String_Sequence
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_String_Sequence
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (seq)
+{}
+IR::RepositoryIdSeq::~RepositoryIdSeq (void) // dtor
+{}
+void IR::RepositoryIdSeq::_tao_any_destructor (void *x)
+{
+  RepositoryIdSeq *tmp = ACE_static_cast (RepositoryIdSeq*,x);
+  delete tmp;
+}
+
+
+#endif /* end #if !defined */
+
+static const CORBA::Long _oc_IR_RepositoryIdSeq[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  35,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x49522f52), 
+  ACE_NTOHL (0x65706f73), 
+  ACE_NTOHL (0x69746f72), 
+  ACE_NTOHL (0x79496453), 
+  ACE_NTOHL (0x65713a31), 
+  ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/RepositoryIdSeq:1.0
+  16,
+  ACE_NTOHL (0x5265706f), 
+  ACE_NTOHL (0x7369746f), 
+  ACE_NTOHL (0x72794964), 
+  ACE_NTOHL (0x53657100),  // name = RepositoryIdSeq
+  CORBA::tk_sequence, // typecode kind
+  84, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    CORBA::tk_alias, // typecode kind for typedefs
+    68, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      32,
+      ACE_NTOHL (0x49444c3a), 
+      ACE_NTOHL (0x6f6d672e), 
+      ACE_NTOHL (0x6f72672f), 
+      ACE_NTOHL (0x49522f52), 
+      ACE_NTOHL (0x65706f73), 
+      ACE_NTOHL (0x69746f72), 
+      ACE_NTOHL (0x7949643a), 
+      ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
+      13,
+      ACE_NTOHL (0x5265706f), 
+      ACE_NTOHL (0x7369746f), 
+      ACE_NTOHL (0x72794964), 
+      ACE_NTOHL (0x0),  // name = RepositoryId
+      CORBA::tk_string, 
+      0U, // string length
+
+    0U,
+
+};
+
+static CORBA::TypeCode _tc_TAO_tc_IR_RepositoryIdSeq (
+    CORBA::tk_alias,
+    sizeof (_oc_IR_RepositoryIdSeq),
+    (char *) &_oc_IR_RepositoryIdSeq,
+    0,
+    sizeof (IR::RepositoryIdSeq)
+  );
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_RepositoryIdSeq, &_tc_TAO_tc_IR_RepositoryIdSeq)
+TAO_NAMESPACE_END
+
+static const CORBA::Long _oc_IR_VersionSpec[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  31,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x49522f56), 
+  ACE_NTOHL (0x65727369), 
+  ACE_NTOHL (0x6f6e5370), 
+  ACE_NTOHL (0x65633a31), 
+  ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
+  12,
+  ACE_NTOHL (0x56657273), 
+  ACE_NTOHL (0x696f6e53), 
+  ACE_NTOHL (0x70656300),  // name = VersionSpec
+  CORBA::tk_string, 
+  0U, // string length
+};
+
+static CORBA::TypeCode _tc_TAO_tc_IR_VersionSpec (
+    CORBA::tk_alias,
+    sizeof (_oc_IR_VersionSpec),
+    (char *) &_oc_IR_VersionSpec,
+    0,
+    sizeof (IR::VersionSpec)
+  );
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_VersionSpec, &_tc_TAO_tc_IR_VersionSpec)
+TAO_NAMESPACE_END
+
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_COMPONENTDEFSEQ_CS_)
+#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_COMPONENTDEFSEQ_CS_
+
+  // The Base_Sequence functions, please see tao/Sequence.h
+  void
+  IR::_TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq::_allocate_buffer (CORBA::ULong length)
+  {
+    IR::ComponentDef **tmp = 0;
+    tmp = _TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq::allocbuf (length);
+    
+    if (this->buffer_ != 0)
+    {
+      IR::ComponentDef **old = ACE_reinterpret_cast (IR::ComponentDef**, this->buffer_);
+      for (CORBA::ULong i = 0; i < this->length_; ++i)
+        if (!this->release_)
+          tmp[i] = IR::ComponentDef::_duplicate (old[i]);
+        else
+          tmp[i] = old[i];
+        
+      if (this->release_)
+        delete[] old;
+      
+    }
+    this->buffer_ = tmp;
+  }
+  
+  void
+  IR::_TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq::_deallocate_buffer (void)
+  {
+    if (this->buffer_ == 0 || this->release_ == 0)
+      return;
+    IR::ComponentDef **tmp = ACE_reinterpret_cast (IR::ComponentDef**, this->buffer_);
+    for (CORBA::ULong i = 0; i < this->length_; ++i)
+    {
+      CORBA::release (tmp[i]);
+      tmp[i] = IR::ComponentDef::_nil ();
+    }
+    _TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq::freebuf (tmp);
+    this->buffer_ = 0;
+  }
+  
+  IR::_TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq::~_TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq (void)
+  {
+    this->_deallocate_buffer ();
+  }
+  
+  void
+  IR::_TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq::_shrink_buffer (CORBA::ULong nl, CORBA::ULong ol)
+  {
+    IR::ComponentDef **tmp = ACE_reinterpret_cast (IR::ComponentDef**, this->buffer_);
+    
+    for (CORBA::ULong i = nl; i < ol; ++i)
+    {
+      CORBA::release (tmp[i]);
+      tmp[i] = IR::ComponentDef::_nil ();
+    }
+  }
+  void 
+  IR::_TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq::_downcast (
+      void* target,
+      CORBA_Object *src,
+      CORBA_Environment &ACE_TRY_ENV
+    )
+  {
+    IR::ComponentDef **tmp = ACE_static_cast (IR::ComponentDef**, target);
+    *tmp = IR::ComponentDef::_narrow (src, ACE_TRY_ENV);
+    ACE_CHECK;
+  }
+
+  CORBA_Object*
+  IR::_TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq::_upcast (void *src) const
+  {
+    IR::ComponentDef **tmp = ACE_static_cast (IR::ComponentDef**, src);
+    return *tmp;
+  }
+  
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_IR_COMPONENTDEFSEQ_CS_)
+#define _IR_COMPONENTDEFSEQ_CS_
+
+// *************************************************************
+// IR::ComponentDefSeq
+// *************************************************************
+
+IR::ComponentDefSeq::ComponentDefSeq (void)
+{}
+IR::ComponentDefSeq::ComponentDefSeq (CORBA::ULong max) // uses max size
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<IR::ComponentDef,IR::ComponentDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (max)
+{}
+IR::ComponentDefSeq::ComponentDefSeq (CORBA::ULong max, CORBA::ULong length, IR::ComponentDef_ptr *buffer, CORBA::Boolean release)
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<IR::ComponentDef,IR::ComponentDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (max, length, buffer, release)
+{}
+IR::ComponentDefSeq::ComponentDefSeq (const ComponentDefSeq &seq) // copy ctor
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<IR::ComponentDef,IR::ComponentDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (seq)
+{}
+IR::ComponentDefSeq::~ComponentDefSeq (void) // dtor
+{}
+void IR::ComponentDefSeq::_tao_any_destructor (void *x)
+{
+  ComponentDefSeq *tmp = ACE_static_cast (ComponentDefSeq*,x);
+  delete tmp;
+}
+
+
+#endif /* end #if !defined */
+
+static const CORBA::Long _oc_IR_ComponentDefSeq[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  35,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x49522f43), 
+  ACE_NTOHL (0x6f6d706f), 
+  ACE_NTOHL (0x6e656e74), 
+  ACE_NTOHL (0x44656653), 
+  ACE_NTOHL (0x65713a31), 
+  ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/ComponentDefSeq:1.0
+  16,
+  ACE_NTOHL (0x436f6d70), 
+  ACE_NTOHL (0x6f6e656e), 
+  ACE_NTOHL (0x74446566), 
+  ACE_NTOHL (0x53657100),  // name = ComponentDefSeq
+  CORBA::tk_sequence, // typecode kind
+  76, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    CORBA::tk_objref, // typecode kind
+    60, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      32,
+      ACE_NTOHL (0x49444c3a), 
+      ACE_NTOHL (0x6f6d672e), 
+      ACE_NTOHL (0x6f72672f), 
+      ACE_NTOHL (0x49522f43), 
+      ACE_NTOHL (0x6f6d706f), 
+      ACE_NTOHL (0x6e656e74), 
+      ACE_NTOHL (0x4465663a), 
+      ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ComponentDef:1.0
+      13,
+      ACE_NTOHL (0x436f6d70), 
+      ACE_NTOHL (0x6f6e656e), 
+      ACE_NTOHL (0x74446566), 
+      ACE_NTOHL (0x0),  // name = ComponentDef
+
+    0U,
+
+};
+
+static CORBA::TypeCode _tc_TAO_tc_IR_ComponentDefSeq (
+    CORBA::tk_alias,
+    sizeof (_oc_IR_ComponentDefSeq),
+    (char *) &_oc_IR_ComponentDefSeq,
+    0,
+    sizeof (IR::ComponentDefSeq)
+  );
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ComponentDefSeq, &_tc_TAO_tc_IR_ComponentDefSeq)
+TAO_NAMESPACE_END
+
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_PROVIDESDEFSEQ_CS_)
+#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_PROVIDESDEFSEQ_CS_
+
+  // The Base_Sequence functions, please see tao/Sequence.h
+  void
+  IR::_TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq::_allocate_buffer (CORBA::ULong length)
+  {
+    IR::ProvidesDef **tmp = 0;
+    tmp = _TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq::allocbuf (length);
+    
+    if (this->buffer_ != 0)
+    {
+      IR::ProvidesDef **old = ACE_reinterpret_cast (IR::ProvidesDef**, this->buffer_);
+      for (CORBA::ULong i = 0; i < this->length_; ++i)
+        if (!this->release_)
+          tmp[i] = IR::ProvidesDef::_duplicate (old[i]);
+        else
+          tmp[i] = old[i];
+        
+      if (this->release_)
+        delete[] old;
+      
+    }
+    this->buffer_ = tmp;
+  }
+  
+  void
+  IR::_TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq::_deallocate_buffer (void)
+  {
+    if (this->buffer_ == 0 || this->release_ == 0)
+      return;
+    IR::ProvidesDef **tmp = ACE_reinterpret_cast (IR::ProvidesDef**, this->buffer_);
+    for (CORBA::ULong i = 0; i < this->length_; ++i)
+    {
+      CORBA::release (tmp[i]);
+      tmp[i] = IR::ProvidesDef::_nil ();
+    }
+    _TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq::freebuf (tmp);
+    this->buffer_ = 0;
+  }
+  
+  IR::_TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq::~_TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq (void)
+  {
+    this->_deallocate_buffer ();
+  }
+  
+  void
+  IR::_TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq::_shrink_buffer (CORBA::ULong nl, CORBA::ULong ol)
+  {
+    IR::ProvidesDef **tmp = ACE_reinterpret_cast (IR::ProvidesDef**, this->buffer_);
+    
+    for (CORBA::ULong i = nl; i < ol; ++i)
+    {
+      CORBA::release (tmp[i]);
+      tmp[i] = IR::ProvidesDef::_nil ();
+    }
+  }
+  void 
+  IR::_TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq::_downcast (
+      void* target,
+      CORBA_Object *src,
+      CORBA_Environment &ACE_TRY_ENV
+    )
+  {
+    IR::ProvidesDef **tmp = ACE_static_cast (IR::ProvidesDef**, target);
+    *tmp = IR::ProvidesDef::_narrow (src, ACE_TRY_ENV);
+    ACE_CHECK;
+  }
+
+  CORBA_Object*
+  IR::_TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq::_upcast (void *src) const
+  {
+    IR::ProvidesDef **tmp = ACE_static_cast (IR::ProvidesDef**, src);
+    return *tmp;
+  }
+  
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_IR_PROVIDESDEFSEQ_CS_)
+#define _IR_PROVIDESDEFSEQ_CS_
+
+// *************************************************************
+// IR::ProvidesDefSeq
+// *************************************************************
+
+IR::ProvidesDefSeq::ProvidesDefSeq (void)
+{}
+IR::ProvidesDefSeq::ProvidesDefSeq (CORBA::ULong max) // uses max size
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<IR::ProvidesDef,IR::ProvidesDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (max)
+{}
+IR::ProvidesDefSeq::ProvidesDefSeq (CORBA::ULong max, CORBA::ULong length, IR::ProvidesDef_ptr *buffer, CORBA::Boolean release)
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<IR::ProvidesDef,IR::ProvidesDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (max, length, buffer, release)
+{}
+IR::ProvidesDefSeq::ProvidesDefSeq (const ProvidesDefSeq &seq) // copy ctor
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<IR::ProvidesDef,IR::ProvidesDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (seq)
+{}
+IR::ProvidesDefSeq::~ProvidesDefSeq (void) // dtor
+{}
+void IR::ProvidesDefSeq::_tao_any_destructor (void *x)
+{
+  ProvidesDefSeq *tmp = ACE_static_cast (ProvidesDefSeq*,x);
+  delete tmp;
+}
+
+
+#endif /* end #if !defined */
+
+static const CORBA::Long _oc_IR_ProvidesDefSeq[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  34,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x49522f50), 
+  ACE_NTOHL (0x726f7669), 
+  ACE_NTOHL (0x64657344), 
+  ACE_NTOHL (0x65665365), 
+  ACE_NTOHL (0x713a312e), 
+  ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/ProvidesDefSeq:1.0
+  15,
+  ACE_NTOHL (0x50726f76), 
+  ACE_NTOHL (0x69646573), 
+  ACE_NTOHL (0x44656653), 
+  ACE_NTOHL (0x65710000),  // name = ProvidesDefSeq
+  CORBA::tk_sequence, // typecode kind
+  72, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    CORBA::tk_objref, // typecode kind
+    56, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      31,
+      ACE_NTOHL (0x49444c3a), 
+      ACE_NTOHL (0x6f6d672e), 
+      ACE_NTOHL (0x6f72672f), 
+      ACE_NTOHL (0x49522f50), 
+      ACE_NTOHL (0x726f7669), 
+      ACE_NTOHL (0x64657344), 
+      ACE_NTOHL (0x65663a31), 
+      ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/ProvidesDef:1.0
+      12,
+      ACE_NTOHL (0x50726f76), 
+      ACE_NTOHL (0x69646573), 
+      ACE_NTOHL (0x44656600),  // name = ProvidesDef
+
+    0U,
+
+};
+
+static CORBA::TypeCode _tc_TAO_tc_IR_ProvidesDefSeq (
+    CORBA::tk_alias,
+    sizeof (_oc_IR_ProvidesDefSeq),
+    (char *) &_oc_IR_ProvidesDefSeq,
+    0,
+    sizeof (IR::ProvidesDefSeq)
+  );
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ProvidesDefSeq, &_tc_TAO_tc_IR_ProvidesDefSeq)
+TAO_NAMESPACE_END
+
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_USESDEFSEQ_CS_)
+#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_USESDEFSEQ_CS_
+
+  // The Base_Sequence functions, please see tao/Sequence.h
+  void
+  IR::_TAO_Unbounded_Object_Sequence_IR_UsesDefSeq::_allocate_buffer (CORBA::ULong length)
+  {
+    IR::UsesDef **tmp = 0;
+    tmp = _TAO_Unbounded_Object_Sequence_IR_UsesDefSeq::allocbuf (length);
+    
+    if (this->buffer_ != 0)
+    {
+      IR::UsesDef **old = ACE_reinterpret_cast (IR::UsesDef**, this->buffer_);
+      for (CORBA::ULong i = 0; i < this->length_; ++i)
+        if (!this->release_)
+          tmp[i] = IR::UsesDef::_duplicate (old[i]);
+        else
+          tmp[i] = old[i];
+        
+      if (this->release_)
+        delete[] old;
+      
+    }
+    this->buffer_ = tmp;
+  }
+  
+  void
+  IR::_TAO_Unbounded_Object_Sequence_IR_UsesDefSeq::_deallocate_buffer (void)
+  {
+    if (this->buffer_ == 0 || this->release_ == 0)
+      return;
+    IR::UsesDef **tmp = ACE_reinterpret_cast (IR::UsesDef**, this->buffer_);
+    for (CORBA::ULong i = 0; i < this->length_; ++i)
+    {
+      CORBA::release (tmp[i]);
+      tmp[i] = IR::UsesDef::_nil ();
+    }
+    _TAO_Unbounded_Object_Sequence_IR_UsesDefSeq::freebuf (tmp);
+    this->buffer_ = 0;
+  }
+  
+  IR::_TAO_Unbounded_Object_Sequence_IR_UsesDefSeq::~_TAO_Unbounded_Object_Sequence_IR_UsesDefSeq (void)
+  {
+    this->_deallocate_buffer ();
+  }
+  
+  void
+  IR::_TAO_Unbounded_Object_Sequence_IR_UsesDefSeq::_shrink_buffer (CORBA::ULong nl, CORBA::ULong ol)
+  {
+    IR::UsesDef **tmp = ACE_reinterpret_cast (IR::UsesDef**, this->buffer_);
+    
+    for (CORBA::ULong i = nl; i < ol; ++i)
+    {
+      CORBA::release (tmp[i]);
+      tmp[i] = IR::UsesDef::_nil ();
+    }
+  }
+  void 
+  IR::_TAO_Unbounded_Object_Sequence_IR_UsesDefSeq::_downcast (
+      void* target,
+      CORBA_Object *src,
+      CORBA_Environment &ACE_TRY_ENV
+    )
+  {
+    IR::UsesDef **tmp = ACE_static_cast (IR::UsesDef**, target);
+    *tmp = IR::UsesDef::_narrow (src, ACE_TRY_ENV);
+    ACE_CHECK;
+  }
+
+  CORBA_Object*
+  IR::_TAO_Unbounded_Object_Sequence_IR_UsesDefSeq::_upcast (void *src) const
+  {
+    IR::UsesDef **tmp = ACE_static_cast (IR::UsesDef**, src);
+    return *tmp;
+  }
+  
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_IR_USESDEFSEQ_CS_)
+#define _IR_USESDEFSEQ_CS_
+
+// *************************************************************
+// IR::UsesDefSeq
+// *************************************************************
+
+IR::UsesDefSeq::UsesDefSeq (void)
+{}
+IR::UsesDefSeq::UsesDefSeq (CORBA::ULong max) // uses max size
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_IR_UsesDefSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<IR::UsesDef,IR::UsesDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (max)
+{}
+IR::UsesDefSeq::UsesDefSeq (CORBA::ULong max, CORBA::ULong length, IR::UsesDef_ptr *buffer, CORBA::Boolean release)
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_IR_UsesDefSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<IR::UsesDef,IR::UsesDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (max, length, buffer, release)
+{}
+IR::UsesDefSeq::UsesDefSeq (const UsesDefSeq &seq) // copy ctor
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_IR_UsesDefSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<IR::UsesDef,IR::UsesDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (seq)
+{}
+IR::UsesDefSeq::~UsesDefSeq (void) // dtor
+{}
+void IR::UsesDefSeq::_tao_any_destructor (void *x)
+{
+  UsesDefSeq *tmp = ACE_static_cast (UsesDefSeq*,x);
+  delete tmp;
+}
+
+
+#endif /* end #if !defined */
+
+static const CORBA::Long _oc_IR_UsesDefSeq[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  30,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x49522f55), 
+  ACE_NTOHL (0x73657344), 
+  ACE_NTOHL (0x65665365), 
+  ACE_NTOHL (0x713a312e), 
+  ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/UsesDefSeq:1.0
+  11,
+  ACE_NTOHL (0x55736573), 
+  ACE_NTOHL (0x44656653), 
+  ACE_NTOHL (0x65710000),  // name = UsesDefSeq
+  CORBA::tk_sequence, // typecode kind
+  64, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    CORBA::tk_objref, // typecode kind
+    48, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      27,
+      ACE_NTOHL (0x49444c3a), 
+      ACE_NTOHL (0x6f6d672e), 
+      ACE_NTOHL (0x6f72672f), 
+      ACE_NTOHL (0x49522f55), 
+      ACE_NTOHL (0x73657344), 
+      ACE_NTOHL (0x65663a31), 
+      ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/UsesDef:1.0
+      8,
+      ACE_NTOHL (0x55736573), 
+      ACE_NTOHL (0x44656600),  // name = UsesDef
+
+    0U,
+
+};
+
+static CORBA::TypeCode _tc_TAO_tc_IR_UsesDefSeq (
+    CORBA::tk_alias,
+    sizeof (_oc_IR_UsesDefSeq),
+    (char *) &_oc_IR_UsesDefSeq,
+    0,
+    sizeof (IR::UsesDefSeq)
+  );
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_UsesDefSeq, &_tc_TAO_tc_IR_UsesDefSeq)
+TAO_NAMESPACE_END
+
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_HOMEDEFSEQ_CS_)
+#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_HOMEDEFSEQ_CS_
+
+  // The Base_Sequence functions, please see tao/Sequence.h
+  void
+  IR::_TAO_Unbounded_Object_Sequence_IR_HomeDefSeq::_allocate_buffer (CORBA::ULong length)
+  {
+    IR::HomeDef **tmp = 0;
+    tmp = _TAO_Unbounded_Object_Sequence_IR_HomeDefSeq::allocbuf (length);
+    
+    if (this->buffer_ != 0)
+    {
+      IR::HomeDef **old = ACE_reinterpret_cast (IR::HomeDef**, this->buffer_);
+      for (CORBA::ULong i = 0; i < this->length_; ++i)
+        if (!this->release_)
+          tmp[i] = IR::HomeDef::_duplicate (old[i]);
+        else
+          tmp[i] = old[i];
+        
+      if (this->release_)
+        delete[] old;
+      
+    }
+    this->buffer_ = tmp;
+  }
+  
+  void
+  IR::_TAO_Unbounded_Object_Sequence_IR_HomeDefSeq::_deallocate_buffer (void)
+  {
+    if (this->buffer_ == 0 || this->release_ == 0)
+      return;
+    IR::HomeDef **tmp = ACE_reinterpret_cast (IR::HomeDef**, this->buffer_);
+    for (CORBA::ULong i = 0; i < this->length_; ++i)
+    {
+      CORBA::release (tmp[i]);
+      tmp[i] = IR::HomeDef::_nil ();
+    }
+    _TAO_Unbounded_Object_Sequence_IR_HomeDefSeq::freebuf (tmp);
+    this->buffer_ = 0;
+  }
+  
+  IR::_TAO_Unbounded_Object_Sequence_IR_HomeDefSeq::~_TAO_Unbounded_Object_Sequence_IR_HomeDefSeq (void)
+  {
+    this->_deallocate_buffer ();
+  }
+  
+  void
+  IR::_TAO_Unbounded_Object_Sequence_IR_HomeDefSeq::_shrink_buffer (CORBA::ULong nl, CORBA::ULong ol)
+  {
+    IR::HomeDef **tmp = ACE_reinterpret_cast (IR::HomeDef**, this->buffer_);
+    
+    for (CORBA::ULong i = nl; i < ol; ++i)
+    {
+      CORBA::release (tmp[i]);
+      tmp[i] = IR::HomeDef::_nil ();
+    }
+  }
+  void 
+  IR::_TAO_Unbounded_Object_Sequence_IR_HomeDefSeq::_downcast (
+      void* target,
+      CORBA_Object *src,
+      CORBA_Environment &ACE_TRY_ENV
+    )
+  {
+    IR::HomeDef **tmp = ACE_static_cast (IR::HomeDef**, target);
+    *tmp = IR::HomeDef::_narrow (src, ACE_TRY_ENV);
+    ACE_CHECK;
+  }
+
+  CORBA_Object*
+  IR::_TAO_Unbounded_Object_Sequence_IR_HomeDefSeq::_upcast (void *src) const
+  {
+    IR::HomeDef **tmp = ACE_static_cast (IR::HomeDef**, src);
+    return *tmp;
+  }
+  
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_IR_HOMEDEFSEQ_CS_)
+#define _IR_HOMEDEFSEQ_CS_
+
+// *************************************************************
+// IR::HomeDefSeq
+// *************************************************************
+
+IR::HomeDefSeq::HomeDefSeq (void)
+{}
+IR::HomeDefSeq::HomeDefSeq (CORBA::ULong max) // uses max size
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_IR_HomeDefSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<IR::HomeDef,IR::HomeDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (max)
+{}
+IR::HomeDefSeq::HomeDefSeq (CORBA::ULong max, CORBA::ULong length, IR::HomeDef_ptr *buffer, CORBA::Boolean release)
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_IR_HomeDefSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<IR::HomeDef,IR::HomeDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (max, length, buffer, release)
+{}
+IR::HomeDefSeq::HomeDefSeq (const HomeDefSeq &seq) // copy ctor
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_IR_HomeDefSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<IR::HomeDef,IR::HomeDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (seq)
+{}
+IR::HomeDefSeq::~HomeDefSeq (void) // dtor
+{}
+void IR::HomeDefSeq::_tao_any_destructor (void *x)
+{
+  HomeDefSeq *tmp = ACE_static_cast (HomeDefSeq*,x);
+  delete tmp;
+}
+
+
+#endif /* end #if !defined */
+
+static const CORBA::Long _oc_IR_HomeDefSeq[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  30,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x49522f48), 
+  ACE_NTOHL (0x6f6d6544), 
+  ACE_NTOHL (0x65665365), 
+  ACE_NTOHL (0x713a312e), 
+  ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/HomeDefSeq:1.0
+  11,
+  ACE_NTOHL (0x486f6d65), 
+  ACE_NTOHL (0x44656653), 
+  ACE_NTOHL (0x65710000),  // name = HomeDefSeq
+  CORBA::tk_sequence, // typecode kind
+  64, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    CORBA::tk_objref, // typecode kind
+    48, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      27,
+      ACE_NTOHL (0x49444c3a), 
+      ACE_NTOHL (0x6f6d672e), 
+      ACE_NTOHL (0x6f72672f), 
+      ACE_NTOHL (0x49522f48), 
+      ACE_NTOHL (0x6f6d6544), 
+      ACE_NTOHL (0x65663a31), 
+      ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/HomeDef:1.0
+      8,
+      ACE_NTOHL (0x486f6d65), 
+      ACE_NTOHL (0x44656600),  // name = HomeDef
+
+    0U,
+
+};
+
+static CORBA::TypeCode _tc_TAO_tc_IR_HomeDefSeq (
+    CORBA::tk_alias,
+    sizeof (_oc_IR_HomeDefSeq),
+    (char *) &_oc_IR_HomeDefSeq,
+    0,
+    sizeof (IR::HomeDefSeq)
+  );
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_HomeDefSeq, &_tc_TAO_tc_IR_HomeDefSeq)
+TAO_NAMESPACE_END
+
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_EMITSDEFSEQ_CS_)
+#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_EMITSDEFSEQ_CS_
+
+  // The Base_Sequence functions, please see tao/Sequence.h
+  void
+  IR::_TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq::_allocate_buffer (CORBA::ULong length)
+  {
+    IR::EmitsDef **tmp = 0;
+    tmp = _TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq::allocbuf (length);
+    
+    if (this->buffer_ != 0)
+    {
+      IR::EmitsDef **old = ACE_reinterpret_cast (IR::EmitsDef**, this->buffer_);
+      for (CORBA::ULong i = 0; i < this->length_; ++i)
+        if (!this->release_)
+          tmp[i] = IR::EmitsDef::_duplicate (old[i]);
+        else
+          tmp[i] = old[i];
+        
+      if (this->release_)
+        delete[] old;
+      
+    }
+    this->buffer_ = tmp;
+  }
+  
+  void
+  IR::_TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq::_deallocate_buffer (void)
+  {
+    if (this->buffer_ == 0 || this->release_ == 0)
+      return;
+    IR::EmitsDef **tmp = ACE_reinterpret_cast (IR::EmitsDef**, this->buffer_);
+    for (CORBA::ULong i = 0; i < this->length_; ++i)
+    {
+      CORBA::release (tmp[i]);
+      tmp[i] = IR::EmitsDef::_nil ();
+    }
+    _TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq::freebuf (tmp);
+    this->buffer_ = 0;
+  }
+  
+  IR::_TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq::~_TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq (void)
+  {
+    this->_deallocate_buffer ();
+  }
+  
+  void
+  IR::_TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq::_shrink_buffer (CORBA::ULong nl, CORBA::ULong ol)
+  {
+    IR::EmitsDef **tmp = ACE_reinterpret_cast (IR::EmitsDef**, this->buffer_);
+    
+    for (CORBA::ULong i = nl; i < ol; ++i)
+    {
+      CORBA::release (tmp[i]);
+      tmp[i] = IR::EmitsDef::_nil ();
+    }
+  }
+  void 
+  IR::_TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq::_downcast (
+      void* target,
+      CORBA_Object *src,
+      CORBA_Environment &ACE_TRY_ENV
+    )
+  {
+    IR::EmitsDef **tmp = ACE_static_cast (IR::EmitsDef**, target);
+    *tmp = IR::EmitsDef::_narrow (src, ACE_TRY_ENV);
+    ACE_CHECK;
+  }
+
+  CORBA_Object*
+  IR::_TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq::_upcast (void *src) const
+  {
+    IR::EmitsDef **tmp = ACE_static_cast (IR::EmitsDef**, src);
+    return *tmp;
+  }
+  
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_IR_EMITSDEFSEQ_CS_)
+#define _IR_EMITSDEFSEQ_CS_
+
+// *************************************************************
+// IR::EmitsDefSeq
+// *************************************************************
+
+IR::EmitsDefSeq::EmitsDefSeq (void)
+{}
+IR::EmitsDefSeq::EmitsDefSeq (CORBA::ULong max) // uses max size
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<IR::EmitsDef,IR::EmitsDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (max)
+{}
+IR::EmitsDefSeq::EmitsDefSeq (CORBA::ULong max, CORBA::ULong length, IR::EmitsDef_ptr *buffer, CORBA::Boolean release)
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<IR::EmitsDef,IR::EmitsDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (max, length, buffer, release)
+{}
+IR::EmitsDefSeq::EmitsDefSeq (const EmitsDefSeq &seq) // copy ctor
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<IR::EmitsDef,IR::EmitsDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (seq)
+{}
+IR::EmitsDefSeq::~EmitsDefSeq (void) // dtor
+{}
+void IR::EmitsDefSeq::_tao_any_destructor (void *x)
+{
+  EmitsDefSeq *tmp = ACE_static_cast (EmitsDefSeq*,x);
+  delete tmp;
+}
+
+
+#endif /* end #if !defined */
+
+static const CORBA::Long _oc_IR_EmitsDefSeq[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  31,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x49522f45), 
+  ACE_NTOHL (0x6d697473), 
+  ACE_NTOHL (0x44656653), 
+  ACE_NTOHL (0x65713a31), 
+  ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/EmitsDefSeq:1.0
+  12,
+  ACE_NTOHL (0x456d6974), 
+  ACE_NTOHL (0x73446566), 
+  ACE_NTOHL (0x53657100),  // name = EmitsDefSeq
+  CORBA::tk_sequence, // typecode kind
+  68, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    CORBA::tk_objref, // typecode kind
+    52, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      28,
+      ACE_NTOHL (0x49444c3a), 
+      ACE_NTOHL (0x6f6d672e), 
+      ACE_NTOHL (0x6f72672f), 
+      ACE_NTOHL (0x49522f45), 
+      ACE_NTOHL (0x6d697473), 
+      ACE_NTOHL (0x4465663a), 
+      ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/EmitsDef:1.0
+      9,
+      ACE_NTOHL (0x456d6974), 
+      ACE_NTOHL (0x73446566), 
+      ACE_NTOHL (0x0),  // name = EmitsDef
+
+    0U,
+
+};
+
+static CORBA::TypeCode _tc_TAO_tc_IR_EmitsDefSeq (
+    CORBA::tk_alias,
+    sizeof (_oc_IR_EmitsDefSeq),
+    (char *) &_oc_IR_EmitsDefSeq,
+    0,
+    sizeof (IR::EmitsDefSeq)
+  );
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_EmitsDefSeq, &_tc_TAO_tc_IR_EmitsDefSeq)
+TAO_NAMESPACE_END
+
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_PUBLISHESDEFSEQ_CS_)
+#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_PUBLISHESDEFSEQ_CS_
+
+  // The Base_Sequence functions, please see tao/Sequence.h
+  void
+  IR::_TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq::_allocate_buffer (CORBA::ULong length)
+  {
+    IR::PublishesDef **tmp = 0;
+    tmp = _TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq::allocbuf (length);
+    
+    if (this->buffer_ != 0)
+    {
+      IR::PublishesDef **old = ACE_reinterpret_cast (IR::PublishesDef**, this->buffer_);
+      for (CORBA::ULong i = 0; i < this->length_; ++i)
+        if (!this->release_)
+          tmp[i] = IR::PublishesDef::_duplicate (old[i]);
+        else
+          tmp[i] = old[i];
+        
+      if (this->release_)
+        delete[] old;
+      
+    }
+    this->buffer_ = tmp;
+  }
+  
+  void
+  IR::_TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq::_deallocate_buffer (void)
+  {
+    if (this->buffer_ == 0 || this->release_ == 0)
+      return;
+    IR::PublishesDef **tmp = ACE_reinterpret_cast (IR::PublishesDef**, this->buffer_);
+    for (CORBA::ULong i = 0; i < this->length_; ++i)
+    {
+      CORBA::release (tmp[i]);
+      tmp[i] = IR::PublishesDef::_nil ();
+    }
+    _TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq::freebuf (tmp);
+    this->buffer_ = 0;
+  }
+  
+  IR::_TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq::~_TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq (void)
+  {
+    this->_deallocate_buffer ();
+  }
+  
+  void
+  IR::_TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq::_shrink_buffer (CORBA::ULong nl, CORBA::ULong ol)
+  {
+    IR::PublishesDef **tmp = ACE_reinterpret_cast (IR::PublishesDef**, this->buffer_);
+    
+    for (CORBA::ULong i = nl; i < ol; ++i)
+    {
+      CORBA::release (tmp[i]);
+      tmp[i] = IR::PublishesDef::_nil ();
+    }
+  }
+  void 
+  IR::_TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq::_downcast (
+      void* target,
+      CORBA_Object *src,
+      CORBA_Environment &ACE_TRY_ENV
+    )
+  {
+    IR::PublishesDef **tmp = ACE_static_cast (IR::PublishesDef**, target);
+    *tmp = IR::PublishesDef::_narrow (src, ACE_TRY_ENV);
+  }
+
+  CORBA_Object*
+  IR::_TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq::_upcast (void *src) const
+  {
+    IR::PublishesDef **tmp = ACE_static_cast (IR::PublishesDef**, src);
+    return *tmp;
+  }
+  
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_IR_PUBLISHESDEFSEQ_CS_)
+#define _IR_PUBLISHESDEFSEQ_CS_
+
+// *************************************************************
+// IR::PublishesDefSeq
+// *************************************************************
+
+IR::PublishesDefSeq::PublishesDefSeq (void)
+{}
+IR::PublishesDefSeq::PublishesDefSeq (CORBA::ULong max) // uses max size
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<IR::PublishesDef,IR::PublishesDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (max)
+{}
+IR::PublishesDefSeq::PublishesDefSeq (CORBA::ULong max, CORBA::ULong length, IR::PublishesDef_ptr *buffer, CORBA::Boolean release)
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<IR::PublishesDef,IR::PublishesDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (max, length, buffer, release)
+{}
+IR::PublishesDefSeq::PublishesDefSeq (const PublishesDefSeq &seq) // copy ctor
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<IR::PublishesDef,IR::PublishesDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (seq)
+{}
+IR::PublishesDefSeq::~PublishesDefSeq (void) // dtor
+{}
+void IR::PublishesDefSeq::_tao_any_destructor (void *x)
+{
+  PublishesDefSeq *tmp = ACE_static_cast (PublishesDefSeq*,x);
+  delete tmp;
+}
+
+
+#endif /* end #if !defined */
+
+static const CORBA::Long _oc_IR_PublishesDefSeq[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  35,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x49522f50), 
+  ACE_NTOHL (0x75626c69), 
+  ACE_NTOHL (0x73686573), 
+  ACE_NTOHL (0x44656653), 
+  ACE_NTOHL (0x65713a31), 
+  ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/PublishesDefSeq:1.0
+  16,
+  ACE_NTOHL (0x5075626c), 
+  ACE_NTOHL (0x69736865), 
+  ACE_NTOHL (0x73446566), 
+  ACE_NTOHL (0x53657100),  // name = PublishesDefSeq
+  CORBA::tk_sequence, // typecode kind
+  76, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    CORBA::tk_objref, // typecode kind
+    60, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      32,
+      ACE_NTOHL (0x49444c3a), 
+      ACE_NTOHL (0x6f6d672e), 
+      ACE_NTOHL (0x6f72672f), 
+      ACE_NTOHL (0x49522f50), 
+      ACE_NTOHL (0x75626c69), 
+      ACE_NTOHL (0x73686573), 
+      ACE_NTOHL (0x4465663a), 
+      ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/PublishesDef:1.0
+      13,
+      ACE_NTOHL (0x5075626c), 
+      ACE_NTOHL (0x69736865), 
+      ACE_NTOHL (0x73446566), 
+      ACE_NTOHL (0x0),  // name = PublishesDef
+
+    0U,
+
+};
+
+static CORBA::TypeCode _tc_TAO_tc_IR_PublishesDefSeq (
+    CORBA::tk_alias,
+    sizeof (_oc_IR_PublishesDefSeq),
+    (char *) &_oc_IR_PublishesDefSeq,
+    0,
+    sizeof (IR::PublishesDefSeq)
+  );
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_PublishesDefSeq, &_tc_TAO_tc_IR_PublishesDefSeq)
+TAO_NAMESPACE_END
+
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_CONSUMESDEFSEQ_CS_)
+#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_CONSUMESDEFSEQ_CS_
+
+  // The Base_Sequence functions, please see tao/Sequence.h
+  void
+  IR::_TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq::_allocate_buffer (CORBA::ULong length)
+  {
+    IR::ConsumesDef **tmp = 0;
+    tmp = _TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq::allocbuf (length);
+    
+    if (this->buffer_ != 0)
+    {
+      IR::ConsumesDef **old = ACE_reinterpret_cast (IR::ConsumesDef**, this->buffer_);
+      for (CORBA::ULong i = 0; i < this->length_; ++i)
+        if (!this->release_)
+          tmp[i] = IR::ConsumesDef::_duplicate (old[i]);
+        else
+          tmp[i] = old[i];
+        
+      if (this->release_)
+        delete[] old;
+      
+    }
+    this->buffer_ = tmp;
+  }
+  
+  void
+  IR::_TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq::_deallocate_buffer (void)
+  {
+    if (this->buffer_ == 0 || this->release_ == 0)
+      return;
+    IR::ConsumesDef **tmp = ACE_reinterpret_cast (IR::ConsumesDef**, this->buffer_);
+    for (CORBA::ULong i = 0; i < this->length_; ++i)
+    {
+      CORBA::release (tmp[i]);
+      tmp[i] = IR::ConsumesDef::_nil ();
+    }
+    _TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq::freebuf (tmp);
+    this->buffer_ = 0;
+  }
+  
+  IR::_TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq::~_TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq (void)
+  {
+    this->_deallocate_buffer ();
+  }
+  
+  void
+  IR::_TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq::_shrink_buffer (CORBA::ULong nl, CORBA::ULong ol)
+  {
+    IR::ConsumesDef **tmp = ACE_reinterpret_cast (IR::ConsumesDef**, this->buffer_);
+    
+    for (CORBA::ULong i = nl; i < ol; ++i)
+    {
+      CORBA::release (tmp[i]);
+      tmp[i] = IR::ConsumesDef::_nil ();
+    }
+  }
+  void 
+  IR::_TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq::_downcast (
+      void* target,
+      CORBA_Object *src,
+      CORBA_Environment &ACE_TRY_ENV
+    )
+  {
+    IR::ConsumesDef **tmp = ACE_static_cast (IR::ConsumesDef**, target);
+    *tmp = IR::ConsumesDef::_narrow (src, ACE_TRY_ENV);
+  }
+
+  CORBA_Object*
+  IR::_TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq::_upcast (void *src) const
+  {
+    IR::ConsumesDef **tmp = ACE_static_cast (IR::ConsumesDef**, src);
+    return *tmp;
+  }
+  
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_IR_CONSUMESDEFSEQ_CS_)
+#define _IR_CONSUMESDEFSEQ_CS_
+
+// *************************************************************
+// IR::ConsumesDefSeq
+// *************************************************************
+
+IR::ConsumesDefSeq::ConsumesDefSeq (void)
+{}
+IR::ConsumesDefSeq::ConsumesDefSeq (CORBA::ULong max) // uses max size
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<IR::ConsumesDef,IR::ConsumesDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (max)
+{}
+IR::ConsumesDefSeq::ConsumesDefSeq (CORBA::ULong max, CORBA::ULong length, IR::ConsumesDef_ptr *buffer, CORBA::Boolean release)
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<IR::ConsumesDef,IR::ConsumesDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (max, length, buffer, release)
+{}
+IR::ConsumesDefSeq::ConsumesDefSeq (const ConsumesDefSeq &seq) // copy ctor
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<IR::ConsumesDef,IR::ConsumesDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (seq)
+{}
+IR::ConsumesDefSeq::~ConsumesDefSeq (void) // dtor
+{}
+void IR::ConsumesDefSeq::_tao_any_destructor (void *x)
+{
+  ConsumesDefSeq *tmp = ACE_static_cast (ConsumesDefSeq*,x);
+  delete tmp;
+}
+
+
+#endif /* end #if !defined */
+
+static const CORBA::Long _oc_IR_ConsumesDefSeq[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  34,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x49522f43), 
+  ACE_NTOHL (0x6f6e7375), 
+  ACE_NTOHL (0x6d657344), 
+  ACE_NTOHL (0x65665365), 
+  ACE_NTOHL (0x713a312e), 
+  ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/ConsumesDefSeq:1.0
+  15,
+  ACE_NTOHL (0x436f6e73), 
+  ACE_NTOHL (0x756d6573), 
+  ACE_NTOHL (0x44656653), 
+  ACE_NTOHL (0x65710000),  // name = ConsumesDefSeq
+  CORBA::tk_sequence, // typecode kind
+  72, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    CORBA::tk_objref, // typecode kind
+    56, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      31,
+      ACE_NTOHL (0x49444c3a), 
+      ACE_NTOHL (0x6f6d672e), 
+      ACE_NTOHL (0x6f72672f), 
+      ACE_NTOHL (0x49522f43), 
+      ACE_NTOHL (0x6f6e7375), 
+      ACE_NTOHL (0x6d657344), 
+      ACE_NTOHL (0x65663a31), 
+      ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/ConsumesDef:1.0
+      12,
+      ACE_NTOHL (0x436f6e73), 
+      ACE_NTOHL (0x756d6573), 
+      ACE_NTOHL (0x44656600),  // name = ConsumesDef
+
+    0U,
+
+};
+
+static CORBA::TypeCode _tc_TAO_tc_IR_ConsumesDefSeq (
+    CORBA::tk_alias,
+    sizeof (_oc_IR_ConsumesDefSeq),
+    (char *) &_oc_IR_ConsumesDefSeq,
+    0,
+    sizeof (IR::ConsumesDefSeq)
+  );
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ConsumesDefSeq, &_tc_TAO_tc_IR_ConsumesDefSeq)
+TAO_NAMESPACE_END
+
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_FACTORYDEFSEQ_CS_)
+#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_FACTORYDEFSEQ_CS_
+
+  // The Base_Sequence functions, please see tao/Sequence.h
+  void
+  IR::_TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq::_allocate_buffer (CORBA::ULong length)
+  {
+    IR::FactoryDef **tmp = 0;
+    tmp = _TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq::allocbuf (length);
+    
+    if (this->buffer_ != 0)
+    {
+      IR::FactoryDef **old = ACE_reinterpret_cast (IR::FactoryDef**, this->buffer_);
+      for (CORBA::ULong i = 0; i < this->length_; ++i)
+        if (!this->release_)
+          tmp[i] = IR::FactoryDef::_duplicate (old[i]);
+        else
+          tmp[i] = old[i];
+        
+      if (this->release_)
+        delete[] old;
+      
+    }
+    this->buffer_ = tmp;
+  }
+  
+  void
+  IR::_TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq::_deallocate_buffer (void)
+  {
+    if (this->buffer_ == 0 || this->release_ == 0)
+      return;
+    IR::FactoryDef **tmp = ACE_reinterpret_cast (IR::FactoryDef**, this->buffer_);
+    for (CORBA::ULong i = 0; i < this->length_; ++i)
+    {
+      CORBA::release (tmp[i]);
+      tmp[i] = IR::FactoryDef::_nil ();
+    }
+    _TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq::freebuf (tmp);
+    this->buffer_ = 0;
+  }
+  
+  IR::_TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq::~_TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq (void)
+  {
+    this->_deallocate_buffer ();
+  }
+  
+  void
+  IR::_TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq::_shrink_buffer (CORBA::ULong nl, CORBA::ULong ol)
+  {
+    IR::FactoryDef **tmp = ACE_reinterpret_cast (IR::FactoryDef**, this->buffer_);
+    
+    for (CORBA::ULong i = nl; i < ol; ++i)
+    {
+      CORBA::release (tmp[i]);
+      tmp[i] = IR::FactoryDef::_nil ();
+    }
+  }
+  void 
+  IR::_TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq::_downcast (
+      void* target,
+      CORBA_Object *src,
+      CORBA_Environment &ACE_TRY_ENV
+    )
+  {
+    IR::FactoryDef **tmp = ACE_static_cast (IR::FactoryDef**, target);
+    *tmp = IR::FactoryDef::_narrow (src, ACE_TRY_ENV);
+  }
+
+  CORBA_Object*
+  IR::_TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq::_upcast (void *src) const
+  {
+    IR::FactoryDef **tmp = ACE_static_cast (IR::FactoryDef**, src);
+    return *tmp;
+  }
+  
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_IR_FACTORYDEFSEQ_CS_)
+#define _IR_FACTORYDEFSEQ_CS_
+
+// *************************************************************
+// IR::FactoryDefSeq
+// *************************************************************
+
+IR::FactoryDefSeq::FactoryDefSeq (void)
+{}
+IR::FactoryDefSeq::FactoryDefSeq (CORBA::ULong max) // uses max size
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<IR::FactoryDef,IR::FactoryDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (max)
+{}
+IR::FactoryDefSeq::FactoryDefSeq (CORBA::ULong max, CORBA::ULong length, IR::FactoryDef_ptr *buffer, CORBA::Boolean release)
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<IR::FactoryDef,IR::FactoryDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (max, length, buffer, release)
+{}
+IR::FactoryDefSeq::FactoryDefSeq (const FactoryDefSeq &seq) // copy ctor
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<IR::FactoryDef,IR::FactoryDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (seq)
+{}
+IR::FactoryDefSeq::~FactoryDefSeq (void) // dtor
+{}
+void IR::FactoryDefSeq::_tao_any_destructor (void *x)
+{
+  FactoryDefSeq *tmp = ACE_static_cast (FactoryDefSeq*,x);
+  delete tmp;
+}
+
+
+#endif /* end #if !defined */
+
+static const CORBA::Long _oc_IR_FactoryDefSeq[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  33,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x49522f46), 
+  ACE_NTOHL (0x6163746f), 
+  ACE_NTOHL (0x72794465), 
+  ACE_NTOHL (0x66536571), 
+  ACE_NTOHL (0x3a312e30), 
+  ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/FactoryDefSeq:1.0
+  14,
+  ACE_NTOHL (0x46616374), 
+  ACE_NTOHL (0x6f727944), 
+  ACE_NTOHL (0x65665365), 
+  ACE_NTOHL (0x71000000),  // name = FactoryDefSeq
+  CORBA::tk_sequence, // typecode kind
+  72, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    CORBA::tk_objref, // typecode kind
+    56, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      30,
+      ACE_NTOHL (0x49444c3a), 
+      ACE_NTOHL (0x6f6d672e), 
+      ACE_NTOHL (0x6f72672f), 
+      ACE_NTOHL (0x49522f46), 
+      ACE_NTOHL (0x6163746f), 
+      ACE_NTOHL (0x72794465), 
+      ACE_NTOHL (0x663a312e), 
+      ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/FactoryDef:1.0
+      11,
+      ACE_NTOHL (0x46616374), 
+      ACE_NTOHL (0x6f727944), 
+      ACE_NTOHL (0x65660000),  // name = FactoryDef
+
+    0U,
+
+};
+
+static CORBA::TypeCode _tc_TAO_tc_IR_FactoryDefSeq (
+    CORBA::tk_alias,
+    sizeof (_oc_IR_FactoryDefSeq),
+    (char *) &_oc_IR_FactoryDefSeq,
+    0,
+    sizeof (IR::FactoryDefSeq)
+  );
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_FactoryDefSeq, &_tc_TAO_tc_IR_FactoryDefSeq)
+TAO_NAMESPACE_END
+
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_FINDERDEFSEQ_CS_)
+#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_FINDERDEFSEQ_CS_
+
+  // The Base_Sequence functions, please see tao/Sequence.h
+  void
+  IR::_TAO_Unbounded_Object_Sequence_IR_FinderDefSeq::_allocate_buffer (CORBA::ULong length)
+  {
+    IR::FinderDef **tmp = 0;
+    tmp = _TAO_Unbounded_Object_Sequence_IR_FinderDefSeq::allocbuf (length);
+    
+    if (this->buffer_ != 0)
+    {
+      IR::FinderDef **old = ACE_reinterpret_cast (IR::FinderDef**, this->buffer_);
+      for (CORBA::ULong i = 0; i < this->length_; ++i)
+        if (!this->release_)
+          tmp[i] = IR::FinderDef::_duplicate (old[i]);
+        else
+          tmp[i] = old[i];
+        
+      if (this->release_)
+        delete[] old;
+      
+    }
+    this->buffer_ = tmp;
+  }
+  
+  void
+  IR::_TAO_Unbounded_Object_Sequence_IR_FinderDefSeq::_deallocate_buffer (void)
+  {
+    if (this->buffer_ == 0 || this->release_ == 0)
+      return;
+    IR::FinderDef **tmp = ACE_reinterpret_cast (IR::FinderDef**, this->buffer_);
+    for (CORBA::ULong i = 0; i < this->length_; ++i)
+    {
+      CORBA::release (tmp[i]);
+      tmp[i] = IR::FinderDef::_nil ();
+    }
+    _TAO_Unbounded_Object_Sequence_IR_FinderDefSeq::freebuf (tmp);
+    this->buffer_ = 0;
+  }
+  
+  IR::_TAO_Unbounded_Object_Sequence_IR_FinderDefSeq::~_TAO_Unbounded_Object_Sequence_IR_FinderDefSeq (void)
+  {
+    this->_deallocate_buffer ();
+  }
+  
+  void
+  IR::_TAO_Unbounded_Object_Sequence_IR_FinderDefSeq::_shrink_buffer (CORBA::ULong nl, CORBA::ULong ol)
+  {
+    IR::FinderDef **tmp = ACE_reinterpret_cast (IR::FinderDef**, this->buffer_);
+    
+    for (CORBA::ULong i = nl; i < ol; ++i)
+    {
+      CORBA::release (tmp[i]);
+      tmp[i] = IR::FinderDef::_nil ();
+    }
+  }
+  void 
+  IR::_TAO_Unbounded_Object_Sequence_IR_FinderDefSeq::_downcast (
+      void* target,
+      CORBA_Object *src,
+      CORBA_Environment &ACE_TRY_ENV
+    )
+  {
+    IR::FinderDef **tmp = ACE_static_cast (IR::FinderDef**, target);
+    *tmp = IR::FinderDef::_narrow (src, ACE_TRY_ENV);
+  }
+
+  CORBA_Object*
+  IR::_TAO_Unbounded_Object_Sequence_IR_FinderDefSeq::_upcast (void *src) const
+  {
+    IR::FinderDef **tmp = ACE_static_cast (IR::FinderDef**, src);
+    return *tmp;
+  }
+  
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_IR_FINDERDEFSEQ_CS_)
+#define _IR_FINDERDEFSEQ_CS_
+
+// *************************************************************
+// IR::FinderDefSeq
+// *************************************************************
+
+IR::FinderDefSeq::FinderDefSeq (void)
+{}
+IR::FinderDefSeq::FinderDefSeq (CORBA::ULong max) // uses max size
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_IR_FinderDefSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<IR::FinderDef,IR::FinderDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (max)
+{}
+IR::FinderDefSeq::FinderDefSeq (CORBA::ULong max, CORBA::ULong length, IR::FinderDef_ptr *buffer, CORBA::Boolean release)
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_IR_FinderDefSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<IR::FinderDef,IR::FinderDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (max, length, buffer, release)
+{}
+IR::FinderDefSeq::FinderDefSeq (const FinderDefSeq &seq) // copy ctor
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_IR_FinderDefSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<IR::FinderDef,IR::FinderDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (seq)
+{}
+IR::FinderDefSeq::~FinderDefSeq (void) // dtor
+{}
+void IR::FinderDefSeq::_tao_any_destructor (void *x)
+{
+  FinderDefSeq *tmp = ACE_static_cast (FinderDefSeq*,x);
+  delete tmp;
+}
+
+
+#endif /* end #if !defined */
+
+static const CORBA::Long _oc_IR_FinderDefSeq[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  32,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x49522f46), 
+  ACE_NTOHL (0x696e6465), 
+  ACE_NTOHL (0x72446566), 
+  ACE_NTOHL (0x5365713a), 
+  ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/FinderDefSeq:1.0
+  13,
+  ACE_NTOHL (0x46696e64), 
+  ACE_NTOHL (0x65724465), 
+  ACE_NTOHL (0x66536571), 
+  ACE_NTOHL (0x0),  // name = FinderDefSeq
+  CORBA::tk_sequence, // typecode kind
+  72, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    CORBA::tk_objref, // typecode kind
+    56, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      29,
+      ACE_NTOHL (0x49444c3a), 
+      ACE_NTOHL (0x6f6d672e), 
+      ACE_NTOHL (0x6f72672f), 
+      ACE_NTOHL (0x49522f46), 
+      ACE_NTOHL (0x696e6465), 
+      ACE_NTOHL (0x72446566), 
+      ACE_NTOHL (0x3a312e30), 
+      ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/FinderDef:1.0
+      10,
+      ACE_NTOHL (0x46696e64), 
+      ACE_NTOHL (0x65724465), 
+      ACE_NTOHL (0x66000000),  // name = FinderDef
+
+    0U,
+
+};
+
+static CORBA::TypeCode _tc_TAO_tc_IR_FinderDefSeq (
+    CORBA::tk_alias,
+    sizeof (_oc_IR_FinderDefSeq),
+    (char *) &_oc_IR_FinderDefSeq,
+    0,
+    sizeof (IR::FinderDefSeq)
+  );
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_FinderDefSeq, &_tc_TAO_tc_IR_FinderDefSeq)
+TAO_NAMESPACE_END
+
+
+///////////////////////////////////////////////////////////////////////
+//                Base & Remote Proxy  Implementation. 
+//
+
+IR::_TAO_ComponentRepository_Proxy_Impl::_TAO_ComponentRepository_Proxy_Impl (void)
+{}
+
+IR::_TAO_ComponentRepository_Remote_Proxy_Impl::_TAO_ComponentRepository_Remote_Proxy_Impl (void)
+{}
+
+// Remote Implementation of the IDL interface methods
+
+IR::ComponentDef_ptr IR::_TAO_ComponentRepository_Remote_Proxy_Impl::create_component (
+    CORBA_Object *_collocated_tao_target_,
+    const char * id,
+    const char * name,
+    const char * version,
+    IR::ComponentDef_ptr base_component,
+    const CORBA::InterfaceDefSeq & supports_interfaces,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  IR::ComponentDef_ptr _tao_retval = IR::ComponentDef::_nil ();
+  IR::ComponentDef_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "create_component",
+      16,
+      1,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      IR::ComponentRepository::TAO_ClientRequestInfo_IR_ComponentRepository_create_component ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        id,
+        name,
+        version,
+        base_component,
+        supports_interfaces,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+          if (!(
+                            (_tao_out << id) &&
+              (_tao_out << name) &&
+              (_tao_out << version) &&
+              (_tao_out << base_component) &&
+              (_tao_out << supports_interfaces)
+            ))
+            TAO_INTERCEPTOR_THROW_RETURN (
+              CORBA::MARSHAL (),
+              0
+            );
+            
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              IR::ComponentDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+IR::HomeDef_ptr IR::_TAO_ComponentRepository_Remote_Proxy_Impl::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,
+    CORBA::ValueDef_ptr primary_key,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  IR::HomeDef_ptr _tao_retval = IR::HomeDef::_nil ();
+  IR::HomeDef_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "create_home",
+      11,
+      1,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      IR::ComponentRepository::TAO_ClientRequestInfo_IR_ComponentRepository_create_home ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        id,
+        name,
+        version,
+        base_home,
+        managed_component,
+        primary_key,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+          if (!(
+                            (_tao_out << id) &&
+              (_tao_out << name) &&
+              (_tao_out << version) &&
+              (_tao_out << base_home) &&
+              (_tao_out << managed_component) &&
+              (_tao_out << primary_key)
+            ))
+            TAO_INTERCEPTOR_THROW_RETURN (
+              CORBA::MARSHAL (),
+              0
+            );
+            
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              IR::HomeDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+
+//
+//            End  Base & Remote  Proxy Implemeentation. 
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//           Remote & Base  Proxy Broker Implementation
+//
+
+IR::_TAO_ComponentRepository_Proxy_Broker::_TAO_ComponentRepository_Proxy_Broker (void)
+{
+}
+
+IR::_TAO_ComponentRepository_Proxy_Broker::~_TAO_ComponentRepository_Proxy_Broker (void)
+{
+}
+
+IR::_TAO_ComponentRepository_Proxy_Broker * (*IR__TAO_ComponentRepository_Proxy_Broker_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  ) = 0;
+
+// Factory Member function Implementation.
+IR::_TAO_ComponentRepository_Remote_Proxy_Broker *
+IR::_TAO_ComponentRepository_Remote_Proxy_Broker::the_TAO_ComponentRepository_Remote_Proxy_Broker (void)
+{
+  static ::IR::_TAO_ComponentRepository_Remote_Proxy_Broker remote_proxy_broker;
+  return &remote_proxy_broker;
+}
+
+IR::_TAO_ComponentRepository_Remote_Proxy_Broker::_TAO_ComponentRepository_Remote_Proxy_Broker (void)
+{
+}
+
+IR::_TAO_ComponentRepository_Remote_Proxy_Broker::~_TAO_ComponentRepository_Remote_Proxy_Broker (void)
+{
+}
+
+IR::_TAO_ComponentRepository_Proxy_Impl&
+IR::_TAO_ComponentRepository_Remote_Proxy_Broker::select_proxy (
+  ::IR::ComponentRepository *,
+  CORBA::Environment &
+)
+{
+  return this->remote_proxy_impl_;
+}
+
+
+//
+//           End Remote & Base Proxy Broker Implementation
+///////////////////////////////////////////////////////////////////////
+
+
+// default constructor
+IR::ComponentRepository::ComponentRepository (int collocated)
+{
+  this->IR_ComponentRepository_setup_collocation (collocated);
+}
+
+// destructor
+IR::ComponentRepository::~ComponentRepository (void)
+{}
+
+void
+IR::ComponentRepository::IR_ComponentRepository_setup_collocation (int collocated)
+{
+  if (collocated)
+    this->the_TAO_ComponentRepository_Proxy_Broker_ =
+      ::IR__TAO_ComponentRepository_Proxy_Broker_Factory_function_pointer (this);
+  else
+    this->the_TAO_ComponentRepository_Proxy_Broker_ =
+      ::IR::_TAO_ComponentRepository_Remote_Proxy_Broker::the_TAO_ComponentRepository_Remote_Proxy_Broker ();
+  
+  this->CORBA_Repository_setup_collocation (collocated);
+}
+
+void IR::ComponentRepository::_tao_any_destructor (void *x)
+{
+  ComponentRepository *tmp = ACE_static_cast (ComponentRepository*,x);
+  CORBA::release (tmp);
+}
+
+IR::ComponentRepository_ptr IR::ComponentRepository::_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+{
+  if (CORBA::is_nil (obj))
+    return ComponentRepository::_nil ();
+  if (! obj->_is_local ())
+    {
+      CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/IR/ComponentRepository:1.0", ACE_TRY_ENV);
+      ACE_CHECK_RETURN (ComponentRepository::_nil ());
+      if (is_a == 0)
+        return ComponentRepository::_nil ();
+    }
+  return ComponentRepository::_unchecked_narrow (obj, ACE_TRY_ENV);
+}
+
+IR::ComponentRepository_ptr IR::ComponentRepository::_unchecked_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &
+  )
+{
+  if (CORBA::is_nil (obj))
+    return ComponentRepository::_nil ();
+  if (! obj->_is_local ())
+    {
+      TAO_Stub* stub = obj->_stubobj ();
+      if (stub)
+        stub->_incr_refcnt ();
+      ComponentRepository_ptr default_proxy = ComponentRepository::_nil ();
+
+      if (
+          !CORBA::is_nil (stub->servant_orb_var ().ptr ()) &&
+          stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects () &&
+          obj->_is_collocated () &&IR__TAO_ComponentRepository_Proxy_Broker_Factory_function_pointer != 0
+        )
+      {
+        ACE_NEW_RETURN (
+          default_proxy,
+          ::IR::ComponentRepository (
+            stub,
+            1,
+            obj->_servant ()),
+            
+          ComponentRepository::_nil ());
+        }
+      if (CORBA::is_nil (default_proxy))
+        ACE_NEW_RETURN (default_proxy, ::IR::ComponentRepository (stub, 0, obj->_servant ()), ComponentRepository::_nil ());
+        return default_proxy;
+      }
+    else 
+      return
+        ACE_reinterpret_cast
+          (
+            ComponentRepository_ptr,
+              obj->_tao_QueryInterface
+                (
+                  ACE_reinterpret_cast
+                    (
+                      ptr_arith_t,
+                      &ComponentRepository::_narrow
+                    )
+                )
+          );
+}
+
+IR::ComponentRepository_ptr
+IR::ComponentRepository::_duplicate (ComponentRepository_ptr obj)
+{
+  if (!CORBA::is_nil (obj))
+    obj->_add_ref ();
+  return obj;
+}
+
+CORBA::Boolean IR::ComponentRepository::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
+{
+  if (
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/ComponentRepository:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Repository:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Container:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
+  return 1; // success using local knowledge
+  else
+    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
+}
+
+void *IR::ComponentRepository::_tao_QueryInterface (ptr_arith_t type)
+{
+  void *retv = 0;
+  if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &ACE_NESTED_CLASS (::IR, ComponentRepository)::_narrow))
+    retv = ACE_reinterpret_cast (void*, this);
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::Repository::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::Repository_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::Container::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::Container_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::IRObject::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::IRObject_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
+    retv = ACE_reinterpret_cast (void *,
+      ACE_static_cast (CORBA::Object_ptr, this));
+    
+  if (retv)
+    this->_add_ref ();
+  return retv;
+}
+
+const char* IR::ComponentRepository::_interface_repository_id (void) const
+{
+  return "IDL:omg.org/IR/ComponentRepository:1.0";
+}
+
+IR::ComponentDef_ptr IR::ComponentRepository::create_component (
+    const char * id,
+    const char * name,
+    const char * version,
+    IR::ComponentDef_ptr base_component,
+    const CORBA::InterfaceDefSeq & supports_interfaces,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_ComponentRepository_Proxy_Impl &proxy = 
+    this->the_TAO_ComponentRepository_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.create_component (
+      this,
+      id,
+      name,
+      version,
+      base_component,
+      supports_interfaces,
+      ACE_TRY_ENV
+    );
+}
+
+IR::HomeDef_ptr IR::ComponentRepository::create_home (
+    const char * id,
+    const char * name,
+    const char * version,
+    IR::HomeDef_ptr base_home,
+    IR::ComponentDef_ptr managed_component,
+    CORBA::ValueDef_ptr primary_key,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_ComponentRepository_Proxy_Impl &proxy = 
+    this->the_TAO_ComponentRepository_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.create_home (
+      this,
+      id,
+      name,
+      version,
+      base_home,
+      managed_component,
+      primary_key,
+      ACE_TRY_ENV
+    );
+}
+
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+IR::ComponentRepository::TAO_ClientRequestInfo_IR_ComponentRepository_create_component::TAO_ClientRequestInfo_IR_ComponentRepository_create_component (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const char * id,
+    const char * name,
+    const char * version,
+    IR::ComponentDef_ptr base_component,
+    const CORBA::InterfaceDefSeq & supports_interfaces,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
+    id_ (id),
+    name_ (name),
+    version_ (version),
+    base_component_ (base_component),
+    supports_interfaces_ (supports_interfaces)
+{}
+
+Dynamic::ParameterList *
+IR::ComponentRepository::TAO_ClientRequestInfo_IR_ComponentRepository_create_component::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
+    
+  CORBA::ULong length_id = parameter_list->length ();
+  parameter_list->length (length_id + 1);
+  (*parameter_list)[length_id].argument <<= id_;
+  (*parameter_list)[length_id].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_name = parameter_list->length ();
+  parameter_list->length (length_name + 1);
+  (*parameter_list)[length_name].argument <<= name_;
+  (*parameter_list)[length_name].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_version = parameter_list->length ();
+  parameter_list->length (length_version + 1);
+  (*parameter_list)[length_version].argument <<= version_;
+  (*parameter_list)[length_version].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_base_component = parameter_list->length ();
+  parameter_list->length (length_base_component + 1);
+  (*parameter_list)[length_base_component].argument <<=  this->base_component_;
+  
+  (*parameter_list)[length_base_component].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_supports_interfaces = parameter_list->length ();
+  parameter_list->length (length_supports_interfaces + 1);
+  (*parameter_list)[length_supports_interfaces].argument <<=  this->supports_interfaces_;
+  
+  (*parameter_list)[length_supports_interfaces].mode = Dynamic::PARAM_IN;
+  
+  return safe_parameter_list._retn ();
+}
+
+Dynamic::ExceptionList *
+IR::ComponentRepository::TAO_ClientRequestInfo_IR_ComponentRepository_create_component::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+IR::ComponentRepository::TAO_ClientRequestInfo_IR_ComponentRepository_create_component::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+IR::ComponentRepository::TAO_ClientRequestInfo_IR_ComponentRepository_create_component::result (IR::ComponentDef_ptr result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+IR::ComponentRepository::TAO_ClientRequestInfo_IR_ComponentRepository_create_home::TAO_ClientRequestInfo_IR_ComponentRepository_create_home (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const char * id,
+    const char * name,
+    const char * version,
+    IR::HomeDef_ptr base_home,
+    IR::ComponentDef_ptr managed_component,
+    CORBA::ValueDef_ptr primary_key,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
+    id_ (id),
+    name_ (name),
+    version_ (version),
+    base_home_ (base_home),
+    managed_component_ (managed_component),
+    primary_key_ (primary_key)
+{}
+
+Dynamic::ParameterList *
+IR::ComponentRepository::TAO_ClientRequestInfo_IR_ComponentRepository_create_home::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
+    
+  CORBA::ULong length_id = parameter_list->length ();
+  parameter_list->length (length_id + 1);
+  (*parameter_list)[length_id].argument <<= id_;
+  (*parameter_list)[length_id].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_name = parameter_list->length ();
+  parameter_list->length (length_name + 1);
+  (*parameter_list)[length_name].argument <<= name_;
+  (*parameter_list)[length_name].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_version = parameter_list->length ();
+  parameter_list->length (length_version + 1);
+  (*parameter_list)[length_version].argument <<= version_;
+  (*parameter_list)[length_version].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_base_home = parameter_list->length ();
+  parameter_list->length (length_base_home + 1);
+  (*parameter_list)[length_base_home].argument <<=  this->base_home_;
+  
+  (*parameter_list)[length_base_home].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_managed_component = parameter_list->length ();
+  parameter_list->length (length_managed_component + 1);
+  (*parameter_list)[length_managed_component].argument <<=  this->managed_component_;
+  
+  (*parameter_list)[length_managed_component].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_primary_key = parameter_list->length ();
+  parameter_list->length (length_primary_key + 1);
+  (*parameter_list)[length_primary_key].argument <<=  this->primary_key_;
+  
+  (*parameter_list)[length_primary_key].mode = Dynamic::PARAM_IN;
+  
+  return safe_parameter_list._retn ();
+}
+
+Dynamic::ExceptionList *
+IR::ComponentRepository::TAO_ClientRequestInfo_IR_ComponentRepository_create_home::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+IR::ComponentRepository::TAO_ClientRequestInfo_IR_ComponentRepository_create_home::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+IR::ComponentRepository::TAO_ClientRequestInfo_IR_ComponentRepository_create_home::result (IR::HomeDef_ptr result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+#endif /* TAO_HAS_INTERCEPTORS */
+static const CORBA::Long _oc_IR_ComponentRepository[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  39,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x49522f43), 
+  ACE_NTOHL (0x6f6d706f), 
+  ACE_NTOHL (0x6e656e74), 
+  ACE_NTOHL (0x5265706f), 
+  ACE_NTOHL (0x7369746f), 
+  ACE_NTOHL (0x72793a31), 
+  ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/ComponentRepository:1.0
+  20,
+  ACE_NTOHL (0x436f6d70), 
+  ACE_NTOHL (0x6f6e656e), 
+  ACE_NTOHL (0x74526570), 
+  ACE_NTOHL (0x6f736974), 
+  ACE_NTOHL (0x6f727900),  // name = ComponentRepository
+};
+
+static CORBA::TypeCode _tc_TAO_tc_IR_ComponentRepository (
+    CORBA::tk_objref,
+    sizeof (_oc_IR_ComponentRepository),
+    (char *) &_oc_IR_ComponentRepository,
+    0,
+    sizeof (IR::ComponentRepository)
+  );
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ComponentRepository, &_tc_TAO_tc_IR_ComponentRepository)
+TAO_NAMESPACE_END
+
+
+///////////////////////////////////////////////////////////////////////
+//                Base & Remote Proxy  Implementation. 
+//
+
+IR::_TAO_ProvidesDef_Proxy_Impl::_TAO_ProvidesDef_Proxy_Impl (void)
+{}
+
+IR::_TAO_ProvidesDef_Remote_Proxy_Impl::_TAO_ProvidesDef_Remote_Proxy_Impl (void)
+{}
+
+// Remote Implementation of the IDL interface methods
+
+CORBA::InterfaceDef_ptr IR::_TAO_ProvidesDef_Remote_Proxy_Impl::interface_type (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::InterfaceDef_ptr _tao_retval = CORBA::InterfaceDef::_nil ();
+  CORBA::InterfaceDef_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_interface_type",
+      19,
+      0,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      IR::ProvidesDef::TAO_ClientRequestInfo_IR_ProvidesDef_interface_type_get ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::InterfaceDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+
+//
+//            End  Base & Remote  Proxy Implemeentation. 
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//           Remote & Base  Proxy Broker Implementation
+//
+
+IR::_TAO_ProvidesDef_Proxy_Broker::_TAO_ProvidesDef_Proxy_Broker (void)
+{
+}
+
+IR::_TAO_ProvidesDef_Proxy_Broker::~_TAO_ProvidesDef_Proxy_Broker (void)
+{
+}
+
+IR::_TAO_ProvidesDef_Proxy_Broker * (*IR__TAO_ProvidesDef_Proxy_Broker_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  ) = 0;
+
+// Factory Member function Implementation.
+IR::_TAO_ProvidesDef_Remote_Proxy_Broker *
+IR::_TAO_ProvidesDef_Remote_Proxy_Broker::the_TAO_ProvidesDef_Remote_Proxy_Broker (void)
+{
+  static ::IR::_TAO_ProvidesDef_Remote_Proxy_Broker remote_proxy_broker;
+  return &remote_proxy_broker;
+}
+
+IR::_TAO_ProvidesDef_Remote_Proxy_Broker::_TAO_ProvidesDef_Remote_Proxy_Broker (void)
+{
+}
+
+IR::_TAO_ProvidesDef_Remote_Proxy_Broker::~_TAO_ProvidesDef_Remote_Proxy_Broker (void)
+{
+}
+
+IR::_TAO_ProvidesDef_Proxy_Impl&
+IR::_TAO_ProvidesDef_Remote_Proxy_Broker::select_proxy (
+  ::IR::ProvidesDef *,
+  CORBA::Environment &
+)
+{
+  return this->remote_proxy_impl_;
+}
+
+
+//
+//           End Remote & Base Proxy Broker Implementation
+///////////////////////////////////////////////////////////////////////
+
+
+// default constructor
+IR::ProvidesDef::ProvidesDef (int collocated)
+{
+  this->IR_ProvidesDef_setup_collocation (collocated);
+}
+
+// destructor
+IR::ProvidesDef::~ProvidesDef (void)
+{}
+
+void
+IR::ProvidesDef::IR_ProvidesDef_setup_collocation (int collocated)
+{
+  if (collocated)
+    this->the_TAO_ProvidesDef_Proxy_Broker_ =
+      ::IR__TAO_ProvidesDef_Proxy_Broker_Factory_function_pointer (this);
+  else
+    this->the_TAO_ProvidesDef_Proxy_Broker_ =
+      ::IR::_TAO_ProvidesDef_Remote_Proxy_Broker::the_TAO_ProvidesDef_Remote_Proxy_Broker ();
+  
+  this->CORBA_Contained_setup_collocation (collocated);
+}
+
+void IR::ProvidesDef::_tao_any_destructor (void *x)
+{
+  ProvidesDef *tmp = ACE_static_cast (ProvidesDef*,x);
+  CORBA::release (tmp);
+}
+
+IR::ProvidesDef_ptr IR::ProvidesDef::_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+{
+  if (CORBA::is_nil (obj))
+    return ProvidesDef::_nil ();
+  if (! obj->_is_local ())
+    {
+      CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/IR/ProvidesDef:1.0", ACE_TRY_ENV);
+      ACE_CHECK_RETURN (ProvidesDef::_nil ());
+      if (is_a == 0)
+        return ProvidesDef::_nil ();
+    }
+  return ProvidesDef::_unchecked_narrow (obj, ACE_TRY_ENV);
+}
+
+IR::ProvidesDef_ptr IR::ProvidesDef::_unchecked_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &
+  )
+{
+  if (CORBA::is_nil (obj))
+    return ProvidesDef::_nil ();
+  if (! obj->_is_local ())
+    {
+      TAO_Stub* stub = obj->_stubobj ();
+      if (stub)
+        stub->_incr_refcnt ();
+      ProvidesDef_ptr default_proxy = ProvidesDef::_nil ();
+
+      if (
+          !CORBA::is_nil (stub->servant_orb_var ().ptr ()) &&
+          stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects () &&
+          obj->_is_collocated () &&IR__TAO_ProvidesDef_Proxy_Broker_Factory_function_pointer != 0
+        )
+      {
+        ACE_NEW_RETURN (
+          default_proxy,
+          ::IR::ProvidesDef (
+            stub,
+            1,
+            obj->_servant ()),
+            
+          ProvidesDef::_nil ());
+        }
+      if (CORBA::is_nil (default_proxy))
+        ACE_NEW_RETURN (default_proxy, ::IR::ProvidesDef (stub, 0, obj->_servant ()), ProvidesDef::_nil ());
+        return default_proxy;
+      }
+    else 
+      return
+        ACE_reinterpret_cast
+          (
+            ProvidesDef_ptr,
+              obj->_tao_QueryInterface
+                (
+                  ACE_reinterpret_cast
+                    (
+                      ptr_arith_t,
+                      &ProvidesDef::_narrow
+                    )
+                )
+          );
+}
+
+IR::ProvidesDef_ptr
+IR::ProvidesDef::_duplicate (ProvidesDef_ptr obj)
+{
+  if (!CORBA::is_nil (obj))
+    obj->_add_ref ();
+  return obj;
+}
+
+CORBA::Boolean IR::ProvidesDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
+{
+  if (
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/ProvidesDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Contained:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
+  return 1; // success using local knowledge
+  else
+    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
+}
+
+void *IR::ProvidesDef::_tao_QueryInterface (ptr_arith_t type)
+{
+  void *retv = 0;
+  if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &ACE_NESTED_CLASS (::IR, ProvidesDef)::_narrow))
+    retv = ACE_reinterpret_cast (void*, this);
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::Contained::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::Contained_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::IRObject::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::IRObject_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
+    retv = ACE_reinterpret_cast (void *,
+      ACE_static_cast (CORBA::Object_ptr, this));
+    
+  if (retv)
+    this->_add_ref ();
+  return retv;
+}
+
+const char* IR::ProvidesDef::_interface_repository_id (void) const
+{
+  return "IDL:omg.org/IR/ProvidesDef:1.0";
+}
+
+CORBA::InterfaceDef_ptr IR::ProvidesDef::interface_type (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_ProvidesDef_Proxy_Impl &proxy = 
+    this->the_TAO_ProvidesDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.interface_type (
+      this,
+      ACE_TRY_ENV
+    );
+}
+
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+IR::ProvidesDef::TAO_ClientRequestInfo_IR_ProvidesDef_interface_type_get::TAO_ClientRequestInfo_IR_ProvidesDef_interface_type_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
+{}
+
+Dynamic::ParameterList *
+IR::ProvidesDef::TAO_ClientRequestInfo_IR_ProvidesDef_interface_type_get::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return parameter_list;
+}
+
+Dynamic::ExceptionList *
+IR::ProvidesDef::TAO_ClientRequestInfo_IR_ProvidesDef_interface_type_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+IR::ProvidesDef::TAO_ClientRequestInfo_IR_ProvidesDef_interface_type_get::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+IR::ProvidesDef::TAO_ClientRequestInfo_IR_ProvidesDef_interface_type_get::result (CORBA::InterfaceDef_ptr result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+#endif /* TAO_HAS_INTERCEPTORS */
+static const CORBA::Long _oc_IR_ProvidesDef[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  31,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x49522f50), 
+  ACE_NTOHL (0x726f7669), 
+  ACE_NTOHL (0x64657344), 
+  ACE_NTOHL (0x65663a31), 
+  ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/ProvidesDef:1.0
+  12,
+  ACE_NTOHL (0x50726f76), 
+  ACE_NTOHL (0x69646573), 
+  ACE_NTOHL (0x44656600),  // name = ProvidesDef
+};
+
+static CORBA::TypeCode _tc_TAO_tc_IR_ProvidesDef (
+    CORBA::tk_objref,
+    sizeof (_oc_IR_ProvidesDef),
+    (char *) &_oc_IR_ProvidesDef,
+    0,
+    sizeof (IR::ProvidesDef)
+  );
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ProvidesDef, &_tc_TAO_tc_IR_ProvidesDef)
+TAO_NAMESPACE_END
+
+static const CORBA::Long _oc_IR_ProvidesDescription[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  39,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x49522f50), 
+  ACE_NTOHL (0x726f7669), 
+  ACE_NTOHL (0x64657344), 
+  ACE_NTOHL (0x65736372), 
+  ACE_NTOHL (0x69707469), 
+  ACE_NTOHL (0x6f6e3a31), 
+  ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/ProvidesDescription:1.0
+  20,
+  ACE_NTOHL (0x50726f76), 
+  ACE_NTOHL (0x69646573), 
+  ACE_NTOHL (0x44657363), 
+  ACE_NTOHL (0x72697074), 
+  ACE_NTOHL (0x696f6e00),  // name = ProvidesDescription
+  5, // member count
+  5,
+  ACE_NTOHL (0x6e616d65), 
+  ACE_NTOHL (0x0),  // name = name
+  CORBA::tk_alias, // typecode kind for typedefs
+  64, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    30,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x49522f49), 
+    ACE_NTOHL (0x64656e74), 
+    ACE_NTOHL (0x69666965), 
+    ACE_NTOHL (0x723a312e), 
+    ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
+    11,
+    ACE_NTOHL (0x4964656e), 
+    ACE_NTOHL (0x74696669), 
+    ACE_NTOHL (0x65720000),  // name = Identifier
+    CORBA::tk_string, 
+    0U, // string length
+
+  3,
+  ACE_NTOHL (0x69640000),  // name = id
+  CORBA::tk_alias, // typecode kind for typedefs
+  68, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    32,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x49522f52), 
+    ACE_NTOHL (0x65706f73), 
+    ACE_NTOHL (0x69746f72), 
+    ACE_NTOHL (0x7949643a), 
+    ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
+    13,
+    ACE_NTOHL (0x5265706f), 
+    ACE_NTOHL (0x7369746f), 
+    ACE_NTOHL (0x72794964), 
+    ACE_NTOHL (0x0),  // name = RepositoryId
+    CORBA::tk_string, 
+    0U, // string length
+
+  11,
+  ACE_NTOHL (0x64656669), 
+  ACE_NTOHL (0x6e65645f), 
+  ACE_NTOHL (0x696e0000),  // name = defined_in
+  CORBA::tk_alias, // typecode kind for typedefs
+  68, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    32,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x49522f52), 
+    ACE_NTOHL (0x65706f73), 
+    ACE_NTOHL (0x69746f72), 
+    ACE_NTOHL (0x7949643a), 
+    ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
+    13,
+    ACE_NTOHL (0x5265706f), 
+    ACE_NTOHL (0x7369746f), 
+    ACE_NTOHL (0x72794964), 
+    ACE_NTOHL (0x0),  // name = RepositoryId
+    CORBA::tk_string, 
+    0U, // string length
+
+  8,
+  ACE_NTOHL (0x76657273), 
+  ACE_NTOHL (0x696f6e00),  // name = version
+  CORBA::tk_alias, // typecode kind for typedefs
+  64, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    31,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x49522f56), 
+    ACE_NTOHL (0x65727369), 
+    ACE_NTOHL (0x6f6e5370), 
+    ACE_NTOHL (0x65633a31), 
+    ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
+    12,
+    ACE_NTOHL (0x56657273), 
+    ACE_NTOHL (0x696f6e53), 
+    ACE_NTOHL (0x70656300),  // name = VersionSpec
+    CORBA::tk_string, 
+    0U, // string length
+
+  15,
+  ACE_NTOHL (0x696e7465), 
+  ACE_NTOHL (0x72666163), 
+  ACE_NTOHL (0x655f7479), 
+  ACE_NTOHL (0x70650000),  // name = interface_type
+  CORBA::tk_objref, // typecode kind
+  64, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    35,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x434f5242), 
+    ACE_NTOHL (0x412f496e), 
+    ACE_NTOHL (0x74657266), 
+    ACE_NTOHL (0x61636544), 
+    ACE_NTOHL (0x65663a31), 
+    ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/InterfaceDef:1.0
+    13,
+    ACE_NTOHL (0x496e7465), 
+    ACE_NTOHL (0x72666163), 
+    ACE_NTOHL (0x65446566), 
+    ACE_NTOHL (0x0),  // name = InterfaceDef
+
+};
+
+static CORBA::TypeCode _tc_TAO_tc_IR_ProvidesDescription (
+    CORBA::tk_struct,
+    sizeof (_oc_IR_ProvidesDescription),
+    (char *) &_oc_IR_ProvidesDescription,
+    0,
+    sizeof (IR::ProvidesDescription)
+  );
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ProvidesDescription, &_tc_TAO_tc_IR_ProvidesDescription)
+TAO_NAMESPACE_END
+
+void IR::ProvidesDescription::_tao_any_destructor (void *x)
+{
+  ProvidesDescription *tmp = ACE_static_cast (ProvidesDescription*,x);
+  delete tmp;
+}
+
+
+///////////////////////////////////////////////////////////////////////
+//                Base & Remote Proxy  Implementation. 
+//
+
+IR::_TAO_UsesDef_Proxy_Impl::_TAO_UsesDef_Proxy_Impl (void)
+{}
+
+IR::_TAO_UsesDef_Remote_Proxy_Impl::_TAO_UsesDef_Remote_Proxy_Impl (void)
+{}
+
+// Remote Implementation of the IDL interface methods
+
+CORBA::InterfaceDef_ptr IR::_TAO_UsesDef_Remote_Proxy_Impl::interface_type (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::InterfaceDef_ptr _tao_retval = CORBA::InterfaceDef::_nil ();
+  CORBA::InterfaceDef_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_interface_type",
+      19,
+      0,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      IR::UsesDef::TAO_ClientRequestInfo_IR_UsesDef_interface_type_get ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::InterfaceDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+CORBA::Boolean IR::_TAO_UsesDef_Remote_Proxy_Impl::is_multiple (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::Boolean _tao_retval = 0;
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), _tao_retval);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_is_multiple",
+      16,
+      0,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      IR::UsesDef::TAO_ClientRequestInfo_IR_UsesDef_is_multiple_get ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN  (_tao_retval);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                _tao_retval
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> CORBA::Any::to_boolean (_tao_retval))
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                _tao_retval
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::Boolean  _tao_retval_info = _tao_retval;
+               ri.result (_tao_retval_info);
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN  (_tao_retval);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_retval;
+}
+
+
+//
+//            End  Base & Remote  Proxy Implemeentation. 
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//           Remote & Base  Proxy Broker Implementation
+//
+
+IR::_TAO_UsesDef_Proxy_Broker::_TAO_UsesDef_Proxy_Broker (void)
+{
+}
+
+IR::_TAO_UsesDef_Proxy_Broker::~_TAO_UsesDef_Proxy_Broker (void)
+{
+}
+
+IR::_TAO_UsesDef_Proxy_Broker * (*IR__TAO_UsesDef_Proxy_Broker_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  ) = 0;
+
+// Factory Member function Implementation.
+IR::_TAO_UsesDef_Remote_Proxy_Broker *
+IR::_TAO_UsesDef_Remote_Proxy_Broker::the_TAO_UsesDef_Remote_Proxy_Broker (void)
+{
+  static ::IR::_TAO_UsesDef_Remote_Proxy_Broker remote_proxy_broker;
+  return &remote_proxy_broker;
+}
+
+IR::_TAO_UsesDef_Remote_Proxy_Broker::_TAO_UsesDef_Remote_Proxy_Broker (void)
+{
+}
+
+IR::_TAO_UsesDef_Remote_Proxy_Broker::~_TAO_UsesDef_Remote_Proxy_Broker (void)
+{
+}
+
+IR::_TAO_UsesDef_Proxy_Impl&
+IR::_TAO_UsesDef_Remote_Proxy_Broker::select_proxy (
+  ::IR::UsesDef *,
+  CORBA::Environment &
+)
+{
+  return this->remote_proxy_impl_;
+}
+
+
+//
+//           End Remote & Base Proxy Broker Implementation
+///////////////////////////////////////////////////////////////////////
+
+
+// default constructor
+IR::UsesDef::UsesDef (int collocated)
+{
+  this->IR_UsesDef_setup_collocation (collocated);
+}
+
+// destructor
+IR::UsesDef::~UsesDef (void)
+{}
+
+void
+IR::UsesDef::IR_UsesDef_setup_collocation (int collocated)
+{
+  if (collocated)
+    this->the_TAO_UsesDef_Proxy_Broker_ =
+      ::IR__TAO_UsesDef_Proxy_Broker_Factory_function_pointer (this);
+  else
+    this->the_TAO_UsesDef_Proxy_Broker_ =
+      ::IR::_TAO_UsesDef_Remote_Proxy_Broker::the_TAO_UsesDef_Remote_Proxy_Broker ();
+  
+  this->CORBA_Contained_setup_collocation (collocated);
+}
+
+void IR::UsesDef::_tao_any_destructor (void *x)
+{
+  UsesDef *tmp = ACE_static_cast (UsesDef*,x);
+  CORBA::release (tmp);
+}
+
+IR::UsesDef_ptr IR::UsesDef::_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+{
+  if (CORBA::is_nil (obj))
+    return UsesDef::_nil ();
+  if (! obj->_is_local ())
+    {
+      CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/IR/UsesDef:1.0", ACE_TRY_ENV);
+      ACE_CHECK_RETURN (UsesDef::_nil ());
+      if (is_a == 0)
+        return UsesDef::_nil ();
+    }
+  return UsesDef::_unchecked_narrow (obj, ACE_TRY_ENV);
+}
+
+IR::UsesDef_ptr IR::UsesDef::_unchecked_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &
+  )
+{
+  if (CORBA::is_nil (obj))
+    return UsesDef::_nil ();
+  if (! obj->_is_local ())
+    {
+      TAO_Stub* stub = obj->_stubobj ();
+      if (stub)
+        stub->_incr_refcnt ();
+      UsesDef_ptr default_proxy = UsesDef::_nil ();
+
+      if (
+          !CORBA::is_nil (stub->servant_orb_var ().ptr ()) &&
+          stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects () &&
+          obj->_is_collocated () &&IR__TAO_UsesDef_Proxy_Broker_Factory_function_pointer != 0
+        )
+      {
+        ACE_NEW_RETURN (
+          default_proxy,
+          ::IR::UsesDef (
+            stub,
+            1,
+            obj->_servant ()),
+            
+          UsesDef::_nil ());
+        }
+      if (CORBA::is_nil (default_proxy))
+        ACE_NEW_RETURN (default_proxy, ::IR::UsesDef (stub, 0, obj->_servant ()), UsesDef::_nil ());
+        return default_proxy;
+      }
+    else 
+      return
+        ACE_reinterpret_cast
+          (
+            UsesDef_ptr,
+              obj->_tao_QueryInterface
+                (
+                  ACE_reinterpret_cast
+                    (
+                      ptr_arith_t,
+                      &UsesDef::_narrow
+                    )
+                )
+          );
+}
+
+IR::UsesDef_ptr
+IR::UsesDef::_duplicate (UsesDef_ptr obj)
+{
+  if (!CORBA::is_nil (obj))
+    obj->_add_ref ();
+  return obj;
+}
+
+CORBA::Boolean IR::UsesDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
+{
+  if (
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/UsesDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Contained:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
+  return 1; // success using local knowledge
+  else
+    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
+}
+
+void *IR::UsesDef::_tao_QueryInterface (ptr_arith_t type)
+{
+  void *retv = 0;
+  if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &ACE_NESTED_CLASS (::IR, UsesDef)::_narrow))
+    retv = ACE_reinterpret_cast (void*, this);
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::Contained::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::Contained_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::IRObject::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::IRObject_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
+    retv = ACE_reinterpret_cast (void *,
+      ACE_static_cast (CORBA::Object_ptr, this));
+    
+  if (retv)
+    this->_add_ref ();
+  return retv;
+}
+
+const char* IR::UsesDef::_interface_repository_id (void) const
+{
+  return "IDL:omg.org/IR/UsesDef:1.0";
+}
+
+CORBA::InterfaceDef_ptr IR::UsesDef::interface_type (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_UsesDef_Proxy_Impl &proxy = 
+    this->the_TAO_UsesDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.interface_type (
+      this,
+      ACE_TRY_ENV
+    );
+}
+
+CORBA::Boolean IR::UsesDef::is_multiple (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_UsesDef_Proxy_Impl &proxy = 
+    this->the_TAO_UsesDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.is_multiple (
+      this,
+      ACE_TRY_ENV
+    );
+}
+
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+IR::UsesDef::TAO_ClientRequestInfo_IR_UsesDef_interface_type_get::TAO_ClientRequestInfo_IR_UsesDef_interface_type_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
+{}
+
+Dynamic::ParameterList *
+IR::UsesDef::TAO_ClientRequestInfo_IR_UsesDef_interface_type_get::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return parameter_list;
+}
+
+Dynamic::ExceptionList *
+IR::UsesDef::TAO_ClientRequestInfo_IR_UsesDef_interface_type_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+IR::UsesDef::TAO_ClientRequestInfo_IR_UsesDef_interface_type_get::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+IR::UsesDef::TAO_ClientRequestInfo_IR_UsesDef_interface_type_get::result (CORBA::InterfaceDef_ptr result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+IR::UsesDef::TAO_ClientRequestInfo_IR_UsesDef_is_multiple_get::TAO_ClientRequestInfo_IR_UsesDef_is_multiple_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
+{}
+
+Dynamic::ParameterList *
+IR::UsesDef::TAO_ClientRequestInfo_IR_UsesDef_is_multiple_get::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return parameter_list;
+}
+
+Dynamic::ExceptionList *
+IR::UsesDef::TAO_ClientRequestInfo_IR_UsesDef_is_multiple_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+IR::UsesDef::TAO_ClientRequestInfo_IR_UsesDef_is_multiple_get::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= CORBA::Any::from_boolean (this->_result);
+  return safe_result_any._retn ();
+}
+
+void 
+IR::UsesDef::TAO_ClientRequestInfo_IR_UsesDef_is_multiple_get::result (CORBA::Boolean result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+#endif /* TAO_HAS_INTERCEPTORS */
+static const CORBA::Long _oc_IR_UsesDef[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  27,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x49522f55), 
+  ACE_NTOHL (0x73657344), 
+  ACE_NTOHL (0x65663a31), 
+  ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/UsesDef:1.0
+  8,
+  ACE_NTOHL (0x55736573), 
+  ACE_NTOHL (0x44656600),  // name = UsesDef
+};
+
+static CORBA::TypeCode _tc_TAO_tc_IR_UsesDef (
+    CORBA::tk_objref,
+    sizeof (_oc_IR_UsesDef),
+    (char *) &_oc_IR_UsesDef,
+    0,
+    sizeof (IR::UsesDef)
+  );
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_UsesDef, &_tc_TAO_tc_IR_UsesDef)
+TAO_NAMESPACE_END
+
+static const CORBA::Long _oc_IR_UsesDescription[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  35,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x49522f55), 
+  ACE_NTOHL (0x73657344), 
+  ACE_NTOHL (0x65736372), 
+  ACE_NTOHL (0x69707469), 
+  ACE_NTOHL (0x6f6e3a31), 
+  ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/UsesDescription:1.0
+  16,
+  ACE_NTOHL (0x55736573), 
+  ACE_NTOHL (0x44657363), 
+  ACE_NTOHL (0x72697074), 
+  ACE_NTOHL (0x696f6e00),  // name = UsesDescription
+  6, // member count
+  5,
+  ACE_NTOHL (0x6e616d65), 
+  ACE_NTOHL (0x0),  // name = name
+  CORBA::tk_alias, // typecode kind for typedefs
+  64, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    30,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x49522f49), 
+    ACE_NTOHL (0x64656e74), 
+    ACE_NTOHL (0x69666965), 
+    ACE_NTOHL (0x723a312e), 
+    ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
+    11,
+    ACE_NTOHL (0x4964656e), 
+    ACE_NTOHL (0x74696669), 
+    ACE_NTOHL (0x65720000),  // name = Identifier
+    CORBA::tk_string, 
+    0U, // string length
+
+  3,
+  ACE_NTOHL (0x69640000),  // name = id
+  CORBA::tk_alias, // typecode kind for typedefs
+  68, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    32,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x49522f52), 
+    ACE_NTOHL (0x65706f73), 
+    ACE_NTOHL (0x69746f72), 
+    ACE_NTOHL (0x7949643a), 
+    ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
+    13,
+    ACE_NTOHL (0x5265706f), 
+    ACE_NTOHL (0x7369746f), 
+    ACE_NTOHL (0x72794964), 
+    ACE_NTOHL (0x0),  // name = RepositoryId
+    CORBA::tk_string, 
+    0U, // string length
+
+  11,
+  ACE_NTOHL (0x64656669), 
+  ACE_NTOHL (0x6e65645f), 
+  ACE_NTOHL (0x696e0000),  // name = defined_in
+  CORBA::tk_alias, // typecode kind for typedefs
+  68, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    32,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x49522f52), 
+    ACE_NTOHL (0x65706f73), 
+    ACE_NTOHL (0x69746f72), 
+    ACE_NTOHL (0x7949643a), 
+    ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
+    13,
+    ACE_NTOHL (0x5265706f), 
+    ACE_NTOHL (0x7369746f), 
+    ACE_NTOHL (0x72794964), 
+    ACE_NTOHL (0x0),  // name = RepositoryId
+    CORBA::tk_string, 
+    0U, // string length
+
+  8,
+  ACE_NTOHL (0x76657273), 
+  ACE_NTOHL (0x696f6e00),  // name = version
+  CORBA::tk_alias, // typecode kind for typedefs
+  64, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    31,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x49522f56), 
+    ACE_NTOHL (0x65727369), 
+    ACE_NTOHL (0x6f6e5370), 
+    ACE_NTOHL (0x65633a31), 
+    ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
+    12,
+    ACE_NTOHL (0x56657273), 
+    ACE_NTOHL (0x696f6e53), 
+    ACE_NTOHL (0x70656300),  // name = VersionSpec
+    CORBA::tk_string, 
+    0U, // string length
+
+  15,
+  ACE_NTOHL (0x696e7465), 
+  ACE_NTOHL (0x72666163), 
+  ACE_NTOHL (0x655f7479), 
+  ACE_NTOHL (0x70650000),  // name = interface_type
+  CORBA::tk_objref, // typecode kind
+  64, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    35,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x434f5242), 
+    ACE_NTOHL (0x412f496e), 
+    ACE_NTOHL (0x74657266), 
+    ACE_NTOHL (0x61636544), 
+    ACE_NTOHL (0x65663a31), 
+    ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/InterfaceDef:1.0
+    13,
+    ACE_NTOHL (0x496e7465), 
+    ACE_NTOHL (0x72666163), 
+    ACE_NTOHL (0x65446566), 
+    ACE_NTOHL (0x0),  // name = InterfaceDef
+
+  12,
+  ACE_NTOHL (0x69735f6d), 
+  ACE_NTOHL (0x756c7469), 
+  ACE_NTOHL (0x706c6500),  // name = is_multiple
+  CORBA::tk_boolean,
+
+};
+
+static CORBA::TypeCode _tc_TAO_tc_IR_UsesDescription (
+    CORBA::tk_struct,
+    sizeof (_oc_IR_UsesDescription),
+    (char *) &_oc_IR_UsesDescription,
+    0,
+    sizeof (IR::UsesDescription)
+  );
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_UsesDescription, &_tc_TAO_tc_IR_UsesDescription)
+TAO_NAMESPACE_END
+
+void IR::UsesDescription::_tao_any_destructor (void *x)
+{
+  UsesDescription *tmp = ACE_static_cast (UsesDescription*,x);
+  delete tmp;
+}
+
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_SEQUENCE_IR_PROVIDESDESCSEQ_CS_)
+#define __TAO_UNBOUNDED_SEQUENCE_IR_PROVIDESDESCSEQ_CS_
+
+  void
+  IR::_TAO_Unbounded_Sequence_IR_ProvidesDescSeq::_allocate_buffer (CORBA::ULong length)
+  {
+    IR::ProvidesDescription* tmp = 0;
+    tmp = _TAO_Unbounded_Sequence_IR_ProvidesDescSeq::allocbuf (length);
+    
+    if (this->buffer_ != 0)
+    {
+      IR::ProvidesDescription *old = ACE_reinterpret_cast (IR::ProvidesDescription *,this->buffer_);
+      
+      for (CORBA::ULong i = 0; i < this->length_; ++i)
+        tmp[i] = old[i];
+      
+      if (this->release_)
+        _TAO_Unbounded_Sequence_IR_ProvidesDescSeq::freebuf (old);
+      
+    }
+    this->buffer_ = tmp;
+  }
+  
+  void
+  IR::_TAO_Unbounded_Sequence_IR_ProvidesDescSeq::_deallocate_buffer (void)
+  {
+    if (this->buffer_ == 0 || this->release_ == 0)
+      return;
+    
+    IR::ProvidesDescription *tmp = ACE_reinterpret_cast (IR::ProvidesDescription *,this->buffer_);
+    
+    _TAO_Unbounded_Sequence_IR_ProvidesDescSeq::freebuf (tmp);
+    this->buffer_ = 0;
+  } 
+  
+  IR::_TAO_Unbounded_Sequence_IR_ProvidesDescSeq::~_TAO_Unbounded_Sequence_IR_ProvidesDescSeq (void) // Dtor.
+  {
+    this->_deallocate_buffer ();
+  }
+  
+  
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_IR_PROVIDESDESCSEQ_CS_)
+#define _IR_PROVIDESDESCSEQ_CS_
+
+// *************************************************************
+// IR::ProvidesDescSeq
+// *************************************************************
+
+IR::ProvidesDescSeq::ProvidesDescSeq (void)
+{}
+IR::ProvidesDescSeq::ProvidesDescSeq (CORBA::ULong max) // uses max size
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Sequence_IR_ProvidesDescSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<IR::ProvidesDescription>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (max)
+{}
+IR::ProvidesDescSeq::ProvidesDescSeq (CORBA::ULong max, CORBA::ULong length, IR::ProvidesDescription *buffer, CORBA::Boolean release)
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Sequence_IR_ProvidesDescSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<IR::ProvidesDescription>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (max, length, buffer, release)
+{}
+IR::ProvidesDescSeq::ProvidesDescSeq (const ProvidesDescSeq &seq) // copy ctor
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Sequence_IR_ProvidesDescSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<IR::ProvidesDescription>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (seq)
+{}
+IR::ProvidesDescSeq::~ProvidesDescSeq (void) // dtor
+{}
+void IR::ProvidesDescSeq::_tao_any_destructor (void *x)
+{
+  ProvidesDescSeq *tmp = ACE_static_cast (ProvidesDescSeq*,x);
+  delete tmp;
+}
+
+
+#endif /* end #if !defined */
+
+static const CORBA::Long _oc_IR_ProvidesDescSeq[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  35,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x49522f50), 
+  ACE_NTOHL (0x726f7669), 
+  ACE_NTOHL (0x64657344), 
+  ACE_NTOHL (0x65736353), 
+  ACE_NTOHL (0x65713a31), 
+  ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/ProvidesDescSeq:1.0
+  16,
+  ACE_NTOHL (0x50726f76), 
+  ACE_NTOHL (0x69646573), 
+  ACE_NTOHL (0x44657363), 
+  ACE_NTOHL (0x53657100),  // name = ProvidesDescSeq
+  CORBA::tk_sequence, // typecode kind
+  528, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    CORBA::tk_struct, // typecode kind
+    512, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      39,
+      ACE_NTOHL (0x49444c3a), 
+      ACE_NTOHL (0x6f6d672e), 
+      ACE_NTOHL (0x6f72672f), 
+      ACE_NTOHL (0x49522f50), 
+      ACE_NTOHL (0x726f7669), 
+      ACE_NTOHL (0x64657344), 
+      ACE_NTOHL (0x65736372), 
+      ACE_NTOHL (0x69707469), 
+      ACE_NTOHL (0x6f6e3a31), 
+      ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/ProvidesDescription:1.0
+      20,
+      ACE_NTOHL (0x50726f76), 
+      ACE_NTOHL (0x69646573), 
+      ACE_NTOHL (0x44657363), 
+      ACE_NTOHL (0x72697074), 
+      ACE_NTOHL (0x696f6e00),  // name = ProvidesDescription
+      5, // member count
+      5,
+      ACE_NTOHL (0x6e616d65), 
+      ACE_NTOHL (0x0),  // name = name
+      CORBA::tk_alias, // typecode kind for typedefs
+      64, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        30,
+        ACE_NTOHL (0x49444c3a), 
+        ACE_NTOHL (0x6f6d672e), 
+        ACE_NTOHL (0x6f72672f), 
+        ACE_NTOHL (0x49522f49), 
+        ACE_NTOHL (0x64656e74), 
+        ACE_NTOHL (0x69666965), 
+        ACE_NTOHL (0x723a312e), 
+        ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
+        11,
+        ACE_NTOHL (0x4964656e), 
+        ACE_NTOHL (0x74696669), 
+        ACE_NTOHL (0x65720000),  // name = Identifier
+        CORBA::tk_string, 
+        0U, // string length
+
+      3,
+      ACE_NTOHL (0x69640000),  // name = id
+      CORBA::tk_alias, // typecode kind for typedefs
+      68, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        32,
+        ACE_NTOHL (0x49444c3a), 
+        ACE_NTOHL (0x6f6d672e), 
+        ACE_NTOHL (0x6f72672f), 
+        ACE_NTOHL (0x49522f52), 
+        ACE_NTOHL (0x65706f73), 
+        ACE_NTOHL (0x69746f72), 
+        ACE_NTOHL (0x7949643a), 
+        ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
+        13,
+        ACE_NTOHL (0x5265706f), 
+        ACE_NTOHL (0x7369746f), 
+        ACE_NTOHL (0x72794964), 
+        ACE_NTOHL (0x0),  // name = RepositoryId
+        CORBA::tk_string, 
+        0U, // string length
+
+      11,
+      ACE_NTOHL (0x64656669), 
+      ACE_NTOHL (0x6e65645f), 
+      ACE_NTOHL (0x696e0000),  // name = defined_in
+      CORBA::tk_alias, // typecode kind for typedefs
+      68, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        32,
+        ACE_NTOHL (0x49444c3a), 
+        ACE_NTOHL (0x6f6d672e), 
+        ACE_NTOHL (0x6f72672f), 
+        ACE_NTOHL (0x49522f52), 
+        ACE_NTOHL (0x65706f73), 
+        ACE_NTOHL (0x69746f72), 
+        ACE_NTOHL (0x7949643a), 
+        ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
+        13,
+        ACE_NTOHL (0x5265706f), 
+        ACE_NTOHL (0x7369746f), 
+        ACE_NTOHL (0x72794964), 
+        ACE_NTOHL (0x0),  // name = RepositoryId
+        CORBA::tk_string, 
+        0U, // string length
+
+      8,
+      ACE_NTOHL (0x76657273), 
+      ACE_NTOHL (0x696f6e00),  // name = version
+      CORBA::tk_alias, // typecode kind for typedefs
+      64, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        31,
+        ACE_NTOHL (0x49444c3a), 
+        ACE_NTOHL (0x6f6d672e), 
+        ACE_NTOHL (0x6f72672f), 
+        ACE_NTOHL (0x49522f56), 
+        ACE_NTOHL (0x65727369), 
+        ACE_NTOHL (0x6f6e5370), 
+        ACE_NTOHL (0x65633a31), 
+        ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
+        12,
+        ACE_NTOHL (0x56657273), 
+        ACE_NTOHL (0x696f6e53), 
+        ACE_NTOHL (0x70656300),  // name = VersionSpec
+        CORBA::tk_string, 
+        0U, // string length
+
+      15,
+      ACE_NTOHL (0x696e7465), 
+      ACE_NTOHL (0x72666163), 
+      ACE_NTOHL (0x655f7479), 
+      ACE_NTOHL (0x70650000),  // name = interface_type
+      CORBA::tk_objref, // typecode kind
+      64, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        35,
+        ACE_NTOHL (0x49444c3a), 
+        ACE_NTOHL (0x6f6d672e), 
+        ACE_NTOHL (0x6f72672f), 
+        ACE_NTOHL (0x434f5242), 
+        ACE_NTOHL (0x412f496e), 
+        ACE_NTOHL (0x74657266), 
+        ACE_NTOHL (0x61636544), 
+        ACE_NTOHL (0x65663a31), 
+        ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/InterfaceDef:1.0
+        13,
+        ACE_NTOHL (0x496e7465), 
+        ACE_NTOHL (0x72666163), 
+        ACE_NTOHL (0x65446566), 
+        ACE_NTOHL (0x0),  // name = InterfaceDef
+
+
+    0U,
+
+};
+
+static CORBA::TypeCode _tc_TAO_tc_IR_ProvidesDescSeq (
+    CORBA::tk_alias,
+    sizeof (_oc_IR_ProvidesDescSeq),
+    (char *) &_oc_IR_ProvidesDescSeq,
+    0,
+    sizeof (IR::ProvidesDescSeq)
+  );
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ProvidesDescSeq, &_tc_TAO_tc_IR_ProvidesDescSeq)
+TAO_NAMESPACE_END
+
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_SEQUENCE_IR_USESDESCSEQ_CS_)
+#define __TAO_UNBOUNDED_SEQUENCE_IR_USESDESCSEQ_CS_
+
+  void
+  IR::_TAO_Unbounded_Sequence_IR_UsesDescSeq::_allocate_buffer (CORBA::ULong length)
+  {
+    IR::UsesDescription* tmp = 0;
+    tmp = _TAO_Unbounded_Sequence_IR_UsesDescSeq::allocbuf (length);
+    
+    if (this->buffer_ != 0)
+    {
+      IR::UsesDescription *old = ACE_reinterpret_cast (IR::UsesDescription *,this->buffer_);
+      
+      for (CORBA::ULong i = 0; i < this->length_; ++i)
+        tmp[i] = old[i];
+      
+      if (this->release_)
+        _TAO_Unbounded_Sequence_IR_UsesDescSeq::freebuf (old);
+      
+    }
+    this->buffer_ = tmp;
+  }
+  
+  void
+  IR::_TAO_Unbounded_Sequence_IR_UsesDescSeq::_deallocate_buffer (void)
+  {
+    if (this->buffer_ == 0 || this->release_ == 0)
+      return;
+    
+    IR::UsesDescription *tmp = ACE_reinterpret_cast (IR::UsesDescription *,this->buffer_);
+    
+    _TAO_Unbounded_Sequence_IR_UsesDescSeq::freebuf (tmp);
+    this->buffer_ = 0;
+  } 
+  
+  IR::_TAO_Unbounded_Sequence_IR_UsesDescSeq::~_TAO_Unbounded_Sequence_IR_UsesDescSeq (void) // Dtor.
+  {
+    this->_deallocate_buffer ();
+  }
+  
+  
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_IR_USESDESCSEQ_CS_)
+#define _IR_USESDESCSEQ_CS_
+
+// *************************************************************
+// IR::UsesDescSeq
+// *************************************************************
+
+IR::UsesDescSeq::UsesDescSeq (void)
+{}
+IR::UsesDescSeq::UsesDescSeq (CORBA::ULong max) // uses max size
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Sequence_IR_UsesDescSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<IR::UsesDescription>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (max)
+{}
+IR::UsesDescSeq::UsesDescSeq (CORBA::ULong max, CORBA::ULong length, IR::UsesDescription *buffer, CORBA::Boolean release)
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Sequence_IR_UsesDescSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<IR::UsesDescription>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (max, length, buffer, release)
+{}
+IR::UsesDescSeq::UsesDescSeq (const UsesDescSeq &seq) // copy ctor
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Sequence_IR_UsesDescSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<IR::UsesDescription>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (seq)
+{}
+IR::UsesDescSeq::~UsesDescSeq (void) // dtor
+{}
+void IR::UsesDescSeq::_tao_any_destructor (void *x)
+{
+  UsesDescSeq *tmp = ACE_static_cast (UsesDescSeq*,x);
+  delete tmp;
+}
+
+
+#endif /* end #if !defined */
+
+static const CORBA::Long _oc_IR_UsesDescSeq[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  31,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x49522f55), 
+  ACE_NTOHL (0x73657344), 
+  ACE_NTOHL (0x65736353), 
+  ACE_NTOHL (0x65713a31), 
+  ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/UsesDescSeq:1.0
+  12,
+  ACE_NTOHL (0x55736573), 
+  ACE_NTOHL (0x44657363), 
+  ACE_NTOHL (0x53657100),  // name = UsesDescSeq
+  CORBA::tk_sequence, // typecode kind
+  540, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    CORBA::tk_struct, // typecode kind
+    524, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      35,
+      ACE_NTOHL (0x49444c3a), 
+      ACE_NTOHL (0x6f6d672e), 
+      ACE_NTOHL (0x6f72672f), 
+      ACE_NTOHL (0x49522f55), 
+      ACE_NTOHL (0x73657344), 
+      ACE_NTOHL (0x65736372), 
+      ACE_NTOHL (0x69707469), 
+      ACE_NTOHL (0x6f6e3a31), 
+      ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/UsesDescription:1.0
+      16,
+      ACE_NTOHL (0x55736573), 
+      ACE_NTOHL (0x44657363), 
+      ACE_NTOHL (0x72697074), 
+      ACE_NTOHL (0x696f6e00),  // name = UsesDescription
+      6, // member count
+      5,
+      ACE_NTOHL (0x6e616d65), 
+      ACE_NTOHL (0x0),  // name = name
+      CORBA::tk_alias, // typecode kind for typedefs
+      64, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        30,
+        ACE_NTOHL (0x49444c3a), 
+        ACE_NTOHL (0x6f6d672e), 
+        ACE_NTOHL (0x6f72672f), 
+        ACE_NTOHL (0x49522f49), 
+        ACE_NTOHL (0x64656e74), 
+        ACE_NTOHL (0x69666965), 
+        ACE_NTOHL (0x723a312e), 
+        ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
+        11,
+        ACE_NTOHL (0x4964656e), 
+        ACE_NTOHL (0x74696669), 
+        ACE_NTOHL (0x65720000),  // name = Identifier
+        CORBA::tk_string, 
+        0U, // string length
+
+      3,
+      ACE_NTOHL (0x69640000),  // name = id
+      CORBA::tk_alias, // typecode kind for typedefs
+      68, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        32,
+        ACE_NTOHL (0x49444c3a), 
+        ACE_NTOHL (0x6f6d672e), 
+        ACE_NTOHL (0x6f72672f), 
+        ACE_NTOHL (0x49522f52), 
+        ACE_NTOHL (0x65706f73), 
+        ACE_NTOHL (0x69746f72), 
+        ACE_NTOHL (0x7949643a), 
+        ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
+        13,
+        ACE_NTOHL (0x5265706f), 
+        ACE_NTOHL (0x7369746f), 
+        ACE_NTOHL (0x72794964), 
+        ACE_NTOHL (0x0),  // name = RepositoryId
+        CORBA::tk_string, 
+        0U, // string length
+
+      11,
+      ACE_NTOHL (0x64656669), 
+      ACE_NTOHL (0x6e65645f), 
+      ACE_NTOHL (0x696e0000),  // name = defined_in
+      CORBA::tk_alias, // typecode kind for typedefs
+      68, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        32,
+        ACE_NTOHL (0x49444c3a), 
+        ACE_NTOHL (0x6f6d672e), 
+        ACE_NTOHL (0x6f72672f), 
+        ACE_NTOHL (0x49522f52), 
+        ACE_NTOHL (0x65706f73), 
+        ACE_NTOHL (0x69746f72), 
+        ACE_NTOHL (0x7949643a), 
+        ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
+        13,
+        ACE_NTOHL (0x5265706f), 
+        ACE_NTOHL (0x7369746f), 
+        ACE_NTOHL (0x72794964), 
+        ACE_NTOHL (0x0),  // name = RepositoryId
+        CORBA::tk_string, 
+        0U, // string length
+
+      8,
+      ACE_NTOHL (0x76657273), 
+      ACE_NTOHL (0x696f6e00),  // name = version
+      CORBA::tk_alias, // typecode kind for typedefs
+      64, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        31,
+        ACE_NTOHL (0x49444c3a), 
+        ACE_NTOHL (0x6f6d672e), 
+        ACE_NTOHL (0x6f72672f), 
+        ACE_NTOHL (0x49522f56), 
+        ACE_NTOHL (0x65727369), 
+        ACE_NTOHL (0x6f6e5370), 
+        ACE_NTOHL (0x65633a31), 
+        ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
+        12,
+        ACE_NTOHL (0x56657273), 
+        ACE_NTOHL (0x696f6e53), 
+        ACE_NTOHL (0x70656300),  // name = VersionSpec
+        CORBA::tk_string, 
+        0U, // string length
+
+      15,
+      ACE_NTOHL (0x696e7465), 
+      ACE_NTOHL (0x72666163), 
+      ACE_NTOHL (0x655f7479), 
+      ACE_NTOHL (0x70650000),  // name = interface_type
+      CORBA::tk_objref, // typecode kind
+      64, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        35,
+        ACE_NTOHL (0x49444c3a), 
+        ACE_NTOHL (0x6f6d672e), 
+        ACE_NTOHL (0x6f72672f), 
+        ACE_NTOHL (0x434f5242), 
+        ACE_NTOHL (0x412f496e), 
+        ACE_NTOHL (0x74657266), 
+        ACE_NTOHL (0x61636544), 
+        ACE_NTOHL (0x65663a31), 
+        ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/InterfaceDef:1.0
+        13,
+        ACE_NTOHL (0x496e7465), 
+        ACE_NTOHL (0x72666163), 
+        ACE_NTOHL (0x65446566), 
+        ACE_NTOHL (0x0),  // name = InterfaceDef
+
+      12,
+      ACE_NTOHL (0x69735f6d), 
+      ACE_NTOHL (0x756c7469), 
+      ACE_NTOHL (0x706c6500),  // name = is_multiple
+      CORBA::tk_boolean,
+
+
+    0U,
+
+};
+
+static CORBA::TypeCode _tc_TAO_tc_IR_UsesDescSeq (
+    CORBA::tk_alias,
+    sizeof (_oc_IR_UsesDescSeq),
+    (char *) &_oc_IR_UsesDescSeq,
+    0,
+    sizeof (IR::UsesDescSeq)
+  );
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_UsesDescSeq, &_tc_TAO_tc_IR_UsesDescSeq)
+TAO_NAMESPACE_END
+
+
+///////////////////////////////////////////////////////////////////////
+//                Base & Remote Proxy  Implementation. 
+//
+
+IR::_TAO_EventDef_Proxy_Impl::_TAO_EventDef_Proxy_Impl (void)
+{}
+
+IR::_TAO_EventDef_Remote_Proxy_Impl::_TAO_EventDef_Remote_Proxy_Impl (void)
+{}
+
+// Remote Implementation of the IDL interface methods
+
+CORBA::Boolean IR::_TAO_EventDef_Remote_Proxy_Impl::is_a (
+    CORBA_Object *_collocated_tao_target_,
+    const char * event_id,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::Boolean _tao_retval = 0;
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), _tao_retval);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "is_a",
+      4,
+      1,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      IR::EventDef::TAO_ClientRequestInfo_IR_EventDef_is_a ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        event_id,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN  (_tao_retval);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          
+          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+          if (!(
+                            (_tao_out << event_id)
+            ))
+            TAO_INTERCEPTOR_THROW_RETURN (
+              CORBA::MARSHAL (),
+              _tao_retval
+            );
+            
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                _tao_retval
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> CORBA::Any::to_boolean (_tao_retval))
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                _tao_retval
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::Boolean  _tao_retval_info = _tao_retval;
+               ri.result (_tao_retval_info);
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN  (_tao_retval);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_retval;
+}
+
+CORBA::ValueDef_ptr IR::_TAO_EventDef_Remote_Proxy_Impl::event (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::ValueDef_ptr _tao_retval = CORBA::ValueDef::_nil ();
+  CORBA::ValueDef_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_event",
+      10,
+      0,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      IR::EventDef::TAO_ClientRequestInfo_IR_EventDef_event_get ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::ValueDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+
+//
+//            End  Base & Remote  Proxy Implemeentation. 
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//           Remote & Base  Proxy Broker Implementation
+//
+
+IR::_TAO_EventDef_Proxy_Broker::_TAO_EventDef_Proxy_Broker (void)
+{
+}
+
+IR::_TAO_EventDef_Proxy_Broker::~_TAO_EventDef_Proxy_Broker (void)
+{
+}
+
+IR::_TAO_EventDef_Proxy_Broker * (*IR__TAO_EventDef_Proxy_Broker_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  ) = 0;
+
+// Factory Member function Implementation.
+IR::_TAO_EventDef_Remote_Proxy_Broker *
+IR::_TAO_EventDef_Remote_Proxy_Broker::the_TAO_EventDef_Remote_Proxy_Broker (void)
+{
+  static ::IR::_TAO_EventDef_Remote_Proxy_Broker remote_proxy_broker;
+  return &remote_proxy_broker;
+}
+
+IR::_TAO_EventDef_Remote_Proxy_Broker::_TAO_EventDef_Remote_Proxy_Broker (void)
+{
+}
+
+IR::_TAO_EventDef_Remote_Proxy_Broker::~_TAO_EventDef_Remote_Proxy_Broker (void)
+{
+}
+
+IR::_TAO_EventDef_Proxy_Impl&
+IR::_TAO_EventDef_Remote_Proxy_Broker::select_proxy (
+  ::IR::EventDef *,
+  CORBA::Environment &
+)
+{
+  return this->remote_proxy_impl_;
+}
+
+
+//
+//           End Remote & Base Proxy Broker Implementation
+///////////////////////////////////////////////////////////////////////
+
+
+// default constructor
+IR::EventDef::EventDef (int collocated)
+{
+  this->IR_EventDef_setup_collocation (collocated);
+}
+
+// destructor
+IR::EventDef::~EventDef (void)
+{}
+
+void
+IR::EventDef::IR_EventDef_setup_collocation (int collocated)
+{
+  if (collocated)
+    this->the_TAO_EventDef_Proxy_Broker_ =
+      ::IR__TAO_EventDef_Proxy_Broker_Factory_function_pointer (this);
+  else
+    this->the_TAO_EventDef_Proxy_Broker_ =
+      ::IR::_TAO_EventDef_Remote_Proxy_Broker::the_TAO_EventDef_Remote_Proxy_Broker ();
+  
+  this->CORBA_Contained_setup_collocation (collocated);
+}
+
+void IR::EventDef::_tao_any_destructor (void *x)
+{
+  EventDef *tmp = ACE_static_cast (EventDef*,x);
+  CORBA::release (tmp);
+}
+
+IR::EventDef_ptr IR::EventDef::_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+{
+  if (CORBA::is_nil (obj))
+    return EventDef::_nil ();
+  if (! obj->_is_local ())
+    {
+      CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/IR/EventDef:1.0", ACE_TRY_ENV);
+      ACE_CHECK_RETURN (EventDef::_nil ());
+      if (is_a == 0)
+        return EventDef::_nil ();
+    }
+  return EventDef::_unchecked_narrow (obj, ACE_TRY_ENV);
+}
+
+IR::EventDef_ptr IR::EventDef::_unchecked_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &
+  )
+{
+  if (CORBA::is_nil (obj))
+    return EventDef::_nil ();
+  if (! obj->_is_local ())
+    {
+      TAO_Stub* stub = obj->_stubobj ();
+      if (stub)
+        stub->_incr_refcnt ();
+      EventDef_ptr default_proxy = EventDef::_nil ();
+
+      if (
+          !CORBA::is_nil (stub->servant_orb_var ().ptr ()) &&
+          stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects () &&
+          obj->_is_collocated () &&IR__TAO_EventDef_Proxy_Broker_Factory_function_pointer != 0
+        )
+      {
+        ACE_NEW_RETURN (
+          default_proxy,
+          ::IR::EventDef (
+            stub,
+            1,
+            obj->_servant ()),
+            
+          EventDef::_nil ());
+        }
+      if (CORBA::is_nil (default_proxy))
+        ACE_NEW_RETURN (default_proxy, ::IR::EventDef (stub, 0, obj->_servant ()), EventDef::_nil ());
+        return default_proxy;
+      }
+    else 
+      return
+        ACE_reinterpret_cast
+          (
+            EventDef_ptr,
+              obj->_tao_QueryInterface
+                (
+                  ACE_reinterpret_cast
+                    (
+                      ptr_arith_t,
+                      &EventDef::_narrow
+                    )
+                )
+          );
+}
+
+IR::EventDef_ptr
+IR::EventDef::_duplicate (EventDef_ptr obj)
+{
+  if (!CORBA::is_nil (obj))
+    obj->_add_ref ();
+  return obj;
+}
+
+CORBA::Boolean IR::EventDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
+{
+  if (
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/EventDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Contained:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
+  return 1; // success using local knowledge
+  else
+    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
+}
+
+void *IR::EventDef::_tao_QueryInterface (ptr_arith_t type)
+{
+  void *retv = 0;
+  if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &ACE_NESTED_CLASS (::IR, EventDef)::_narrow))
+    retv = ACE_reinterpret_cast (void*, this);
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::Contained::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::Contained_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::IRObject::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::IRObject_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
+    retv = ACE_reinterpret_cast (void *,
+      ACE_static_cast (CORBA::Object_ptr, this));
+    
+  if (retv)
+    this->_add_ref ();
+  return retv;
+}
+
+const char* IR::EventDef::_interface_repository_id (void) const
+{
+  return "IDL:omg.org/IR/EventDef:1.0";
+}
+
+CORBA::Boolean IR::EventDef::is_a (
+    const char * event_id,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_EventDef_Proxy_Impl &proxy = 
+    this->the_TAO_EventDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.is_a (
+      this,
+      event_id,
+      ACE_TRY_ENV
+    );
+}
+
+CORBA::ValueDef_ptr IR::EventDef::event (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_EventDef_Proxy_Impl &proxy = 
+    this->the_TAO_EventDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.event (
+      this,
+      ACE_TRY_ENV
+    );
+}
+
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+IR::EventDef::TAO_ClientRequestInfo_IR_EventDef_is_a::TAO_ClientRequestInfo_IR_EventDef_is_a (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const char * event_id,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
+    event_id_ (event_id)
+{}
+
+Dynamic::ParameterList *
+IR::EventDef::TAO_ClientRequestInfo_IR_EventDef_is_a::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
+    
+  CORBA::ULong length_event_id = parameter_list->length ();
+  parameter_list->length (length_event_id + 1);
+  (*parameter_list)[length_event_id].argument <<= event_id_;
+  (*parameter_list)[length_event_id].mode = Dynamic::PARAM_IN;
+  
+  return safe_parameter_list._retn ();
+}
+
+Dynamic::ExceptionList *
+IR::EventDef::TAO_ClientRequestInfo_IR_EventDef_is_a::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+IR::EventDef::TAO_ClientRequestInfo_IR_EventDef_is_a::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= CORBA::Any::from_boolean (this->_result);
+  return safe_result_any._retn ();
+}
+
+void 
+IR::EventDef::TAO_ClientRequestInfo_IR_EventDef_is_a::result (CORBA::Boolean result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+IR::EventDef::TAO_ClientRequestInfo_IR_EventDef_event_get::TAO_ClientRequestInfo_IR_EventDef_event_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
+{}
+
+Dynamic::ParameterList *
+IR::EventDef::TAO_ClientRequestInfo_IR_EventDef_event_get::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return parameter_list;
+}
+
+Dynamic::ExceptionList *
+IR::EventDef::TAO_ClientRequestInfo_IR_EventDef_event_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+IR::EventDef::TAO_ClientRequestInfo_IR_EventDef_event_get::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+IR::EventDef::TAO_ClientRequestInfo_IR_EventDef_event_get::result (CORBA::ValueDef_ptr result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+#endif /* TAO_HAS_INTERCEPTORS */
+static const CORBA::Long _oc_IR_EventDef[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  28,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x49522f45), 
+  ACE_NTOHL (0x76656e74), 
+  ACE_NTOHL (0x4465663a), 
+  ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/EventDef:1.0
+  9,
+  ACE_NTOHL (0x4576656e), 
+  ACE_NTOHL (0x74446566), 
+  ACE_NTOHL (0x0),  // name = EventDef
+};
+
+static CORBA::TypeCode _tc_TAO_tc_IR_EventDef (
+    CORBA::tk_objref,
+    sizeof (_oc_IR_EventDef),
+    (char *) &_oc_IR_EventDef,
+    0,
+    sizeof (IR::EventDef)
+  );
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_EventDef, &_tc_TAO_tc_IR_EventDef)
+TAO_NAMESPACE_END
+
+static const CORBA::Long _oc_IR_EventDescription[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  36,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x49522f45), 
+  ACE_NTOHL (0x76656e74), 
+  ACE_NTOHL (0x44657363), 
+  ACE_NTOHL (0x72697074), 
+  ACE_NTOHL (0x696f6e3a), 
+  ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/EventDescription:1.0
+  17,
+  ACE_NTOHL (0x4576656e), 
+  ACE_NTOHL (0x74446573), 
+  ACE_NTOHL (0x63726970), 
+  ACE_NTOHL (0x74696f6e), 
+  ACE_NTOHL (0x0),  // name = EventDescription
+  5, // member count
+  5,
+  ACE_NTOHL (0x6e616d65), 
+  ACE_NTOHL (0x0),  // name = name
+  CORBA::tk_alias, // typecode kind for typedefs
+  64, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    30,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x49522f49), 
+    ACE_NTOHL (0x64656e74), 
+    ACE_NTOHL (0x69666965), 
+    ACE_NTOHL (0x723a312e), 
+    ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
+    11,
+    ACE_NTOHL (0x4964656e), 
+    ACE_NTOHL (0x74696669), 
+    ACE_NTOHL (0x65720000),  // name = Identifier
+    CORBA::tk_string, 
+    0U, // string length
+
+  3,
+  ACE_NTOHL (0x69640000),  // name = id
+  CORBA::tk_alias, // typecode kind for typedefs
+  68, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    32,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x49522f52), 
+    ACE_NTOHL (0x65706f73), 
+    ACE_NTOHL (0x69746f72), 
+    ACE_NTOHL (0x7949643a), 
+    ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
+    13,
+    ACE_NTOHL (0x5265706f), 
+    ACE_NTOHL (0x7369746f), 
+    ACE_NTOHL (0x72794964), 
+    ACE_NTOHL (0x0),  // name = RepositoryId
+    CORBA::tk_string, 
+    0U, // string length
+
+  11,
+  ACE_NTOHL (0x64656669), 
+  ACE_NTOHL (0x6e65645f), 
+  ACE_NTOHL (0x696e0000),  // name = defined_in
+  CORBA::tk_alias, // typecode kind for typedefs
+  68, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    32,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x49522f52), 
+    ACE_NTOHL (0x65706f73), 
+    ACE_NTOHL (0x69746f72), 
+    ACE_NTOHL (0x7949643a), 
+    ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
+    13,
+    ACE_NTOHL (0x5265706f), 
+    ACE_NTOHL (0x7369746f), 
+    ACE_NTOHL (0x72794964), 
+    ACE_NTOHL (0x0),  // name = RepositoryId
+    CORBA::tk_string, 
+    0U, // string length
+
+  8,
+  ACE_NTOHL (0x76657273), 
+  ACE_NTOHL (0x696f6e00),  // name = version
+  CORBA::tk_alias, // typecode kind for typedefs
+  64, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    31,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x49522f56), 
+    ACE_NTOHL (0x65727369), 
+    ACE_NTOHL (0x6f6e5370), 
+    ACE_NTOHL (0x65633a31), 
+    ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
+    12,
+    ACE_NTOHL (0x56657273), 
+    ACE_NTOHL (0x696f6e53), 
+    ACE_NTOHL (0x70656300),  // name = VersionSpec
+    CORBA::tk_string, 
+    0U, // string length
+
+  6,
+  ACE_NTOHL (0x76616c75), 
+  ACE_NTOHL (0x65000000),  // name = value
+  CORBA::tk_objref, // typecode kind
+  56, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    31,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x434f5242), 
+    ACE_NTOHL (0x412f5661), 
+    ACE_NTOHL (0x6c756544), 
+    ACE_NTOHL (0x65663a31), 
+    ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/ValueDef:1.0
+    9,
+    ACE_NTOHL (0x56616c75), 
+    ACE_NTOHL (0x65446566), 
+    ACE_NTOHL (0x0),  // name = ValueDef
+
+};
+
+static CORBA::TypeCode _tc_TAO_tc_IR_EventDescription (
+    CORBA::tk_struct,
+    sizeof (_oc_IR_EventDescription),
+    (char *) &_oc_IR_EventDescription,
+    0,
+    sizeof (IR::EventDescription)
+  );
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_EventDescription, &_tc_TAO_tc_IR_EventDescription)
+TAO_NAMESPACE_END
+
+void IR::EventDescription::_tao_any_destructor (void *x)
+{
+  EventDescription *tmp = ACE_static_cast (EventDescription*,x);
+  delete tmp;
+}
+
+
+///////////////////////////////////////////////////////////////////////
+//                Base & Remote Proxy  Implementation. 
+//
+
+IR::_TAO_EmitsDef_Proxy_Impl::_TAO_EmitsDef_Proxy_Impl (void)
+{}
+
+IR::_TAO_EmitsDef_Remote_Proxy_Impl::_TAO_EmitsDef_Remote_Proxy_Impl (void)
+{}
+
+// Remote Implementation of the IDL interface methods
+
+
+//
+//            End  Base & Remote  Proxy Implemeentation. 
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//           Remote & Base  Proxy Broker Implementation
+//
+
+IR::_TAO_EmitsDef_Proxy_Broker::_TAO_EmitsDef_Proxy_Broker (void)
+{
+}
+
+IR::_TAO_EmitsDef_Proxy_Broker::~_TAO_EmitsDef_Proxy_Broker (void)
+{
+}
+
+IR::_TAO_EmitsDef_Proxy_Broker * (*IR__TAO_EmitsDef_Proxy_Broker_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  ) = 0;
+
+// Factory Member function Implementation.
+IR::_TAO_EmitsDef_Remote_Proxy_Broker *
+IR::_TAO_EmitsDef_Remote_Proxy_Broker::the_TAO_EmitsDef_Remote_Proxy_Broker (void)
+{
+  static ::IR::_TAO_EmitsDef_Remote_Proxy_Broker remote_proxy_broker;
+  return &remote_proxy_broker;
+}
+
+IR::_TAO_EmitsDef_Remote_Proxy_Broker::_TAO_EmitsDef_Remote_Proxy_Broker (void)
+{
+}
+
+IR::_TAO_EmitsDef_Remote_Proxy_Broker::~_TAO_EmitsDef_Remote_Proxy_Broker (void)
+{
+}
+
+IR::_TAO_EmitsDef_Proxy_Impl&
+IR::_TAO_EmitsDef_Remote_Proxy_Broker::select_proxy (
+  ::IR::EmitsDef *,
+  CORBA::Environment &
+)
+{
+  return this->remote_proxy_impl_;
+}
+
+
+//
+//           End Remote & Base Proxy Broker Implementation
+///////////////////////////////////////////////////////////////////////
+
+
+// default constructor
+IR::EmitsDef::EmitsDef (int collocated)
+{
+  this->IR_EmitsDef_setup_collocation (collocated);
+}
+
+// destructor
+IR::EmitsDef::~EmitsDef (void)
+{}
+
+void
+IR::EmitsDef::IR_EmitsDef_setup_collocation (int collocated)
+{
+  if (collocated)
+    this->the_TAO_EmitsDef_Proxy_Broker_ =
+      ::IR__TAO_EmitsDef_Proxy_Broker_Factory_function_pointer (this);
+  else
+    this->the_TAO_EmitsDef_Proxy_Broker_ =
+      ::IR::_TAO_EmitsDef_Remote_Proxy_Broker::the_TAO_EmitsDef_Remote_Proxy_Broker ();
+  
+  this->IR_EventDef_setup_collocation (collocated);
+}
+
+void IR::EmitsDef::_tao_any_destructor (void *x)
+{
+  EmitsDef *tmp = ACE_static_cast (EmitsDef*,x);
+  CORBA::release (tmp);
+}
+
+IR::EmitsDef_ptr IR::EmitsDef::_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+{
+  if (CORBA::is_nil (obj))
+    return EmitsDef::_nil ();
+  if (! obj->_is_local ())
+    {
+      CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/IR/EmitsDef:1.0", ACE_TRY_ENV);
+      ACE_CHECK_RETURN (EmitsDef::_nil ());
+      if (is_a == 0)
+        return EmitsDef::_nil ();
+    }
+  return EmitsDef::_unchecked_narrow (obj, ACE_TRY_ENV);
+}
+
+IR::EmitsDef_ptr IR::EmitsDef::_unchecked_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &
+  )
+{
+  if (CORBA::is_nil (obj))
+    return EmitsDef::_nil ();
+  if (! obj->_is_local ())
+    {
+      TAO_Stub* stub = obj->_stubobj ();
+      if (stub)
+        stub->_incr_refcnt ();
+      EmitsDef_ptr default_proxy = EmitsDef::_nil ();
+
+      if (
+          !CORBA::is_nil (stub->servant_orb_var ().ptr ()) &&
+          stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects () &&
+          obj->_is_collocated () &&IR__TAO_EmitsDef_Proxy_Broker_Factory_function_pointer != 0
+        )
+      {
+        ACE_NEW_RETURN (
+          default_proxy,
+          ::IR::EmitsDef (
+            stub,
+            1,
+            obj->_servant ()),
+            
+          EmitsDef::_nil ());
+        }
+      if (CORBA::is_nil (default_proxy))
+        ACE_NEW_RETURN (default_proxy, ::IR::EmitsDef (stub, 0, obj->_servant ()), EmitsDef::_nil ());
+        return default_proxy;
+      }
+    else 
+      return
+        ACE_reinterpret_cast
+          (
+            EmitsDef_ptr,
+              obj->_tao_QueryInterface
+                (
+                  ACE_reinterpret_cast
+                    (
+                      ptr_arith_t,
+                      &EmitsDef::_narrow
+                    )
+                )
+          );
+}
+
+IR::EmitsDef_ptr
+IR::EmitsDef::_duplicate (EmitsDef_ptr obj)
+{
+  if (!CORBA::is_nil (obj))
+    obj->_add_ref ();
+  return obj;
+}
+
+CORBA::Boolean IR::EmitsDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
+{
+  if (
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/EmitsDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/EventDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Contained:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
+  return 1; // success using local knowledge
+  else
+    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
+}
+
+void *IR::EmitsDef::_tao_QueryInterface (ptr_arith_t type)
+{
+  void *retv = 0;
+  if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &ACE_NESTED_CLASS (::IR, EmitsDef)::_narrow))
+    retv = ACE_reinterpret_cast (void*, this);
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &ACE_NESTED_CLASS (::IR, EventDef)::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            IR::EventDef_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::Contained::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::Contained_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::IRObject::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::IRObject_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
+    retv = ACE_reinterpret_cast (void *,
+      ACE_static_cast (CORBA::Object_ptr, this));
+    
+  if (retv)
+    this->_add_ref ();
+  return retv;
+}
+
+const char* IR::EmitsDef::_interface_repository_id (void) const
+{
+  return "IDL:omg.org/IR/EmitsDef:1.0";
+}
+
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+#endif /* TAO_HAS_INTERCEPTORS */
+static const CORBA::Long _oc_IR_EmitsDef[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  28,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x49522f45), 
+  ACE_NTOHL (0x6d697473), 
+  ACE_NTOHL (0x4465663a), 
+  ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/EmitsDef:1.0
+  9,
+  ACE_NTOHL (0x456d6974), 
+  ACE_NTOHL (0x73446566), 
+  ACE_NTOHL (0x0),  // name = EmitsDef
+};
+
+static CORBA::TypeCode _tc_TAO_tc_IR_EmitsDef (
+    CORBA::tk_objref,
+    sizeof (_oc_IR_EmitsDef),
+    (char *) &_oc_IR_EmitsDef,
+    0,
+    sizeof (IR::EmitsDef)
+  );
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_EmitsDef, &_tc_TAO_tc_IR_EmitsDef)
+TAO_NAMESPACE_END
+
+
+///////////////////////////////////////////////////////////////////////
+//                Base & Remote Proxy  Implementation. 
+//
+
+IR::_TAO_PublishesDef_Proxy_Impl::_TAO_PublishesDef_Proxy_Impl (void)
+{}
+
+IR::_TAO_PublishesDef_Remote_Proxy_Impl::_TAO_PublishesDef_Remote_Proxy_Impl (void)
+{}
+
+// Remote Implementation of the IDL interface methods
+
+
+//
+//            End  Base & Remote  Proxy Implemeentation. 
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//           Remote & Base  Proxy Broker Implementation
+//
+
+IR::_TAO_PublishesDef_Proxy_Broker::_TAO_PublishesDef_Proxy_Broker (void)
+{
+}
+
+IR::_TAO_PublishesDef_Proxy_Broker::~_TAO_PublishesDef_Proxy_Broker (void)
+{
+}
+
+IR::_TAO_PublishesDef_Proxy_Broker * (*IR__TAO_PublishesDef_Proxy_Broker_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  ) = 0;
+
+// Factory Member function Implementation.
+IR::_TAO_PublishesDef_Remote_Proxy_Broker *
+IR::_TAO_PublishesDef_Remote_Proxy_Broker::the_TAO_PublishesDef_Remote_Proxy_Broker (void)
+{
+  static ::IR::_TAO_PublishesDef_Remote_Proxy_Broker remote_proxy_broker;
+  return &remote_proxy_broker;
+}
+
+IR::_TAO_PublishesDef_Remote_Proxy_Broker::_TAO_PublishesDef_Remote_Proxy_Broker (void)
+{
+}
+
+IR::_TAO_PublishesDef_Remote_Proxy_Broker::~_TAO_PublishesDef_Remote_Proxy_Broker (void)
+{
+}
+
+IR::_TAO_PublishesDef_Proxy_Impl&
+IR::_TAO_PublishesDef_Remote_Proxy_Broker::select_proxy (
+  ::IR::PublishesDef *,
+  CORBA::Environment &
+)
+{
+  return this->remote_proxy_impl_;
+}
+
+
+//
+//           End Remote & Base Proxy Broker Implementation
+///////////////////////////////////////////////////////////////////////
+
+
+// default constructor
+IR::PublishesDef::PublishesDef (int collocated)
+{
+  this->IR_PublishesDef_setup_collocation (collocated);
+}
+
+// destructor
+IR::PublishesDef::~PublishesDef (void)
+{}
+
+void
+IR::PublishesDef::IR_PublishesDef_setup_collocation (int collocated)
+{
+  if (collocated)
+    this->the_TAO_PublishesDef_Proxy_Broker_ =
+      ::IR__TAO_PublishesDef_Proxy_Broker_Factory_function_pointer (this);
+  else
+    this->the_TAO_PublishesDef_Proxy_Broker_ =
+      ::IR::_TAO_PublishesDef_Remote_Proxy_Broker::the_TAO_PublishesDef_Remote_Proxy_Broker ();
+  
+  this->IR_EventDef_setup_collocation (collocated);
+}
+
+void IR::PublishesDef::_tao_any_destructor (void *x)
+{
+  PublishesDef *tmp = ACE_static_cast (PublishesDef*,x);
+  CORBA::release (tmp);
+}
+
+IR::PublishesDef_ptr IR::PublishesDef::_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+{
+  if (CORBA::is_nil (obj))
+    return PublishesDef::_nil ();
+  if (! obj->_is_local ())
+    {
+      CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/IR/PublishesDef:1.0", ACE_TRY_ENV);
+      ACE_CHECK_RETURN (PublishesDef::_nil ());
+      if (is_a == 0)
+        return PublishesDef::_nil ();
+    }
+  return PublishesDef::_unchecked_narrow (obj, ACE_TRY_ENV);
+}
+
+IR::PublishesDef_ptr IR::PublishesDef::_unchecked_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &
+  )
+{
+  if (CORBA::is_nil (obj))
+    return PublishesDef::_nil ();
+  if (! obj->_is_local ())
+    {
+      TAO_Stub* stub = obj->_stubobj ();
+      if (stub)
+        stub->_incr_refcnt ();
+      PublishesDef_ptr default_proxy = PublishesDef::_nil ();
+
+      if (
+          !CORBA::is_nil (stub->servant_orb_var ().ptr ()) &&
+          stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects () &&
+          obj->_is_collocated () &&IR__TAO_PublishesDef_Proxy_Broker_Factory_function_pointer != 0
+        )
+      {
+        ACE_NEW_RETURN (
+          default_proxy,
+          ::IR::PublishesDef (
+            stub,
+            1,
+            obj->_servant ()),
+            
+          PublishesDef::_nil ());
+        }
+      if (CORBA::is_nil (default_proxy))
+        ACE_NEW_RETURN (default_proxy, ::IR::PublishesDef (stub, 0, obj->_servant ()), PublishesDef::_nil ());
+        return default_proxy;
+      }
+    else 
+      return
+        ACE_reinterpret_cast
+          (
+            PublishesDef_ptr,
+              obj->_tao_QueryInterface
+                (
+                  ACE_reinterpret_cast
+                    (
+                      ptr_arith_t,
+                      &PublishesDef::_narrow
+                    )
+                )
+          );
+}
+
+IR::PublishesDef_ptr
+IR::PublishesDef::_duplicate (PublishesDef_ptr obj)
+{
+  if (!CORBA::is_nil (obj))
+    obj->_add_ref ();
+  return obj;
+}
+
+CORBA::Boolean IR::PublishesDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
+{
+  if (
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/PublishesDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/EventDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Contained:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
+  return 1; // success using local knowledge
+  else
+    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
+}
+
+void *IR::PublishesDef::_tao_QueryInterface (ptr_arith_t type)
+{
+  void *retv = 0;
+  if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &ACE_NESTED_CLASS (::IR, PublishesDef)::_narrow))
+    retv = ACE_reinterpret_cast (void*, this);
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &ACE_NESTED_CLASS (::IR, EventDef)::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            IR::EventDef_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::Contained::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::Contained_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::IRObject::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::IRObject_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
+    retv = ACE_reinterpret_cast (void *,
+      ACE_static_cast (CORBA::Object_ptr, this));
+    
+  if (retv)
+    this->_add_ref ();
+  return retv;
+}
+
+const char* IR::PublishesDef::_interface_repository_id (void) const
+{
+  return "IDL:omg.org/IR/PublishesDef:1.0";
+}
+
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+#endif /* TAO_HAS_INTERCEPTORS */
+static const CORBA::Long _oc_IR_PublishesDef[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  32,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x49522f50), 
+  ACE_NTOHL (0x75626c69), 
+  ACE_NTOHL (0x73686573), 
+  ACE_NTOHL (0x4465663a), 
+  ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/PublishesDef:1.0
+  13,
+  ACE_NTOHL (0x5075626c), 
+  ACE_NTOHL (0x69736865), 
+  ACE_NTOHL (0x73446566), 
+  ACE_NTOHL (0x0),  // name = PublishesDef
+};
+
+static CORBA::TypeCode _tc_TAO_tc_IR_PublishesDef (
+    CORBA::tk_objref,
+    sizeof (_oc_IR_PublishesDef),
+    (char *) &_oc_IR_PublishesDef,
+    0,
+    sizeof (IR::PublishesDef)
+  );
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_PublishesDef, &_tc_TAO_tc_IR_PublishesDef)
+TAO_NAMESPACE_END
+
+
+///////////////////////////////////////////////////////////////////////
+//                Base & Remote Proxy  Implementation. 
+//
+
+IR::_TAO_ConsumesDef_Proxy_Impl::_TAO_ConsumesDef_Proxy_Impl (void)
+{}
+
+IR::_TAO_ConsumesDef_Remote_Proxy_Impl::_TAO_ConsumesDef_Remote_Proxy_Impl (void)
+{}
+
+// Remote Implementation of the IDL interface methods
+
+
+//
+//            End  Base & Remote  Proxy Implemeentation. 
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//           Remote & Base  Proxy Broker Implementation
+//
+
+IR::_TAO_ConsumesDef_Proxy_Broker::_TAO_ConsumesDef_Proxy_Broker (void)
+{
+}
+
+IR::_TAO_ConsumesDef_Proxy_Broker::~_TAO_ConsumesDef_Proxy_Broker (void)
+{
+}
+
+IR::_TAO_ConsumesDef_Proxy_Broker * (*IR__TAO_ConsumesDef_Proxy_Broker_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  ) = 0;
+
+// Factory Member function Implementation.
+IR::_TAO_ConsumesDef_Remote_Proxy_Broker *
+IR::_TAO_ConsumesDef_Remote_Proxy_Broker::the_TAO_ConsumesDef_Remote_Proxy_Broker (void)
+{
+  static ::IR::_TAO_ConsumesDef_Remote_Proxy_Broker remote_proxy_broker;
+  return &remote_proxy_broker;
+}
+
+IR::_TAO_ConsumesDef_Remote_Proxy_Broker::_TAO_ConsumesDef_Remote_Proxy_Broker (void)
+{
+}
+
+IR::_TAO_ConsumesDef_Remote_Proxy_Broker::~_TAO_ConsumesDef_Remote_Proxy_Broker (void)
+{
+}
+
+IR::_TAO_ConsumesDef_Proxy_Impl&
+IR::_TAO_ConsumesDef_Remote_Proxy_Broker::select_proxy (
+  ::IR::ConsumesDef *,
+  CORBA::Environment &
+)
+{
+  return this->remote_proxy_impl_;
+}
+
+
+//
+//           End Remote & Base Proxy Broker Implementation
+///////////////////////////////////////////////////////////////////////
+
+
+// default constructor
+IR::ConsumesDef::ConsumesDef (int collocated)
+{
+  this->IR_ConsumesDef_setup_collocation (collocated);
+}
+
+// destructor
+IR::ConsumesDef::~ConsumesDef (void)
+{}
+
+void
+IR::ConsumesDef::IR_ConsumesDef_setup_collocation (int collocated)
+{
+  if (collocated)
+    this->the_TAO_ConsumesDef_Proxy_Broker_ =
+      ::IR__TAO_ConsumesDef_Proxy_Broker_Factory_function_pointer (this);
+  else
+    this->the_TAO_ConsumesDef_Proxy_Broker_ =
+      ::IR::_TAO_ConsumesDef_Remote_Proxy_Broker::the_TAO_ConsumesDef_Remote_Proxy_Broker ();
+  
+  this->IR_EventDef_setup_collocation (collocated);
+}
+
+void IR::ConsumesDef::_tao_any_destructor (void *x)
+{
+  ConsumesDef *tmp = ACE_static_cast (ConsumesDef*,x);
+  CORBA::release (tmp);
+}
+
+IR::ConsumesDef_ptr IR::ConsumesDef::_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+{
+  if (CORBA::is_nil (obj))
+    return ConsumesDef::_nil ();
+  if (! obj->_is_local ())
+    {
+      CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/IR/ConsumesDef:1.0", ACE_TRY_ENV);
+      ACE_CHECK_RETURN (ConsumesDef::_nil ());
+      if (is_a == 0)
+        return ConsumesDef::_nil ();
+    }
+  return ConsumesDef::_unchecked_narrow (obj, ACE_TRY_ENV);
+}
+
+IR::ConsumesDef_ptr IR::ConsumesDef::_unchecked_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &
+  )
+{
+  if (CORBA::is_nil (obj))
+    return ConsumesDef::_nil ();
+  if (! obj->_is_local ())
+    {
+      TAO_Stub* stub = obj->_stubobj ();
+      if (stub)
+        stub->_incr_refcnt ();
+      ConsumesDef_ptr default_proxy = ConsumesDef::_nil ();
+
+      if (
+          !CORBA::is_nil (stub->servant_orb_var ().ptr ()) &&
+          stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects () &&
+          obj->_is_collocated () &&IR__TAO_ConsumesDef_Proxy_Broker_Factory_function_pointer != 0
+        )
+      {
+        ACE_NEW_RETURN (
+          default_proxy,
+          ::IR::ConsumesDef (
+            stub,
+            1,
+            obj->_servant ()),
+            
+          ConsumesDef::_nil ());
+        }
+      if (CORBA::is_nil (default_proxy))
+        ACE_NEW_RETURN (default_proxy, ::IR::ConsumesDef (stub, 0, obj->_servant ()), ConsumesDef::_nil ());
+        return default_proxy;
+      }
+    else 
+      return
+        ACE_reinterpret_cast
+          (
+            ConsumesDef_ptr,
+              obj->_tao_QueryInterface
+                (
+                  ACE_reinterpret_cast
+                    (
+                      ptr_arith_t,
+                      &ConsumesDef::_narrow
+                    )
+                )
+          );
+}
+
+IR::ConsumesDef_ptr
+IR::ConsumesDef::_duplicate (ConsumesDef_ptr obj)
+{
+  if (!CORBA::is_nil (obj))
+    obj->_add_ref ();
+  return obj;
+}
+
+CORBA::Boolean IR::ConsumesDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
+{
+  if (
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/ConsumesDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/EventDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Contained:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
+  return 1; // success using local knowledge
+  else
+    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
+}
+
+void *IR::ConsumesDef::_tao_QueryInterface (ptr_arith_t type)
+{
+  void *retv = 0;
+  if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &ACE_NESTED_CLASS (::IR, ConsumesDef)::_narrow))
+    retv = ACE_reinterpret_cast (void*, this);
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &ACE_NESTED_CLASS (::IR, EventDef)::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            IR::EventDef_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::Contained::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::Contained_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::IRObject::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::IRObject_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
+    retv = ACE_reinterpret_cast (void *,
+      ACE_static_cast (CORBA::Object_ptr, this));
+    
+  if (retv)
+    this->_add_ref ();
+  return retv;
+}
+
+const char* IR::ConsumesDef::_interface_repository_id (void) const
+{
+  return "IDL:omg.org/IR/ConsumesDef:1.0";
+}
+
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+#endif /* TAO_HAS_INTERCEPTORS */
+static const CORBA::Long _oc_IR_ConsumesDef[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  31,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x49522f43), 
+  ACE_NTOHL (0x6f6e7375), 
+  ACE_NTOHL (0x6d657344), 
+  ACE_NTOHL (0x65663a31), 
+  ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/ConsumesDef:1.0
+  12,
+  ACE_NTOHL (0x436f6e73), 
+  ACE_NTOHL (0x756d6573), 
+  ACE_NTOHL (0x44656600),  // name = ConsumesDef
+};
+
+static CORBA::TypeCode _tc_TAO_tc_IR_ConsumesDef (
+    CORBA::tk_objref,
+    sizeof (_oc_IR_ConsumesDef),
+    (char *) &_oc_IR_ConsumesDef,
+    0,
+    sizeof (IR::ConsumesDef)
+  );
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ConsumesDef, &_tc_TAO_tc_IR_ConsumesDef)
+TAO_NAMESPACE_END
+
+
+///////////////////////////////////////////////////////////////////////
+//                Base & Remote Proxy  Implementation. 
+//
+
+IR::_TAO_ComponentDef_Proxy_Impl::_TAO_ComponentDef_Proxy_Impl (void)
+{}
+
+IR::_TAO_ComponentDef_Remote_Proxy_Impl::_TAO_ComponentDef_Remote_Proxy_Impl (void)
+{}
+
+// Remote Implementation of the IDL interface methods
+
+CORBA::InterfaceDefSeq * IR::_TAO_ComponentDef_Remote_Proxy_Impl::supported_interfaces (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::InterfaceDefSeq *_tao_retval = 0;
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  ACE_NEW_RETURN (_tao_retval, CORBA::InterfaceDefSeq, _tao_retval);
+  CORBA::InterfaceDefSeq_var _tao_safe_retval (_tao_retval);
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_supported_interfaces",
+      25,
+      0,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      IR::ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_supported_interfaces_get ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::InterfaceDefSeq * _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+void IR::_TAO_ComponentDef_Remote_Proxy_Impl::supported_interfaces (
+    CORBA_Object *_collocated_tao_target_,
+    const CORBA::InterfaceDefSeq & supported_interfaces,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW (CORBA::INTERNAL ());
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_set_supported_interfaces",
+      25,
+      1,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      IR::ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_supported_interfaces_set ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        supported_interfaces,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK;
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK;
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK;
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK;
+          
+          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+          if (!(
+                            (_tao_out << supported_interfaces)
+            ))
+            TAO_INTERCEPTOR_THROW (
+              CORBA::MARSHAL ()
+            );
+            
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK;
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)
+              );
+              
+            }
+          
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK;
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK;
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  
+}
+
+IR::ComponentDef_ptr IR::_TAO_ComponentDef_Remote_Proxy_Impl::base_component (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  IR::ComponentDef_ptr _tao_retval = IR::ComponentDef::_nil ();
+  IR::ComponentDef_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_base_component",
+      19,
+      0,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      IR::ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_base_component_get ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              IR::ComponentDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+IR::ProvidesDefSeq * IR::_TAO_ComponentDef_Remote_Proxy_Impl::provides_interfaces (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  IR::ProvidesDefSeq *_tao_retval = 0;
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  ACE_NEW_RETURN (_tao_retval, IR::ProvidesDefSeq, _tao_retval);
+  IR::ProvidesDefSeq_var _tao_safe_retval (_tao_retval);
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_provides_interfaces",
+      24,
+      0,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      IR::ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_provides_interfaces_get ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              IR::ProvidesDefSeq * _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+IR::UsesDefSeq * IR::_TAO_ComponentDef_Remote_Proxy_Impl::uses_interfaces (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  IR::UsesDefSeq *_tao_retval = 0;
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  ACE_NEW_RETURN (_tao_retval, IR::UsesDefSeq, _tao_retval);
+  IR::UsesDefSeq_var _tao_safe_retval (_tao_retval);
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_uses_interfaces",
+      20,
+      0,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      IR::ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_uses_interfaces_get ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              IR::UsesDefSeq * _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+IR::EmitsDefSeq * IR::_TAO_ComponentDef_Remote_Proxy_Impl::emits_events (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  IR::EmitsDefSeq *_tao_retval = 0;
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  ACE_NEW_RETURN (_tao_retval, IR::EmitsDefSeq, _tao_retval);
+  IR::EmitsDefSeq_var _tao_safe_retval (_tao_retval);
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_emits_events",
+      17,
+      0,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      IR::ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_emits_events_get ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              IR::EmitsDefSeq * _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+IR::PublishesDefSeq * IR::_TAO_ComponentDef_Remote_Proxy_Impl::publishes_events (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  IR::PublishesDefSeq *_tao_retval = 0;
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  ACE_NEW_RETURN (_tao_retval, IR::PublishesDefSeq, _tao_retval);
+  IR::PublishesDefSeq_var _tao_safe_retval (_tao_retval);
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_publishes_events",
+      21,
+      0,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      IR::ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_publishes_events_get ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              IR::PublishesDefSeq * _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+IR::ConsumesDefSeq * IR::_TAO_ComponentDef_Remote_Proxy_Impl::consumes_events (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  IR::ConsumesDefSeq *_tao_retval = 0;
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  ACE_NEW_RETURN (_tao_retval, IR::ConsumesDefSeq, _tao_retval);
+  IR::ConsumesDefSeq_var _tao_safe_retval (_tao_retval);
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_consumes_events",
+      20,
+      0,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      IR::ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_consumes_events_get ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              IR::ConsumesDefSeq * _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+CORBA::Boolean IR::_TAO_ComponentDef_Remote_Proxy_Impl::is_basic (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::Boolean _tao_retval = 0;
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), _tao_retval);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_is_basic",
+      13,
+      0,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      IR::ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_is_basic_get ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN  (_tao_retval);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                _tao_retval
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> CORBA::Any::to_boolean (_tao_retval))
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                _tao_retval
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::Boolean  _tao_retval_info = _tao_retval;
+               ri.result (_tao_retval_info);
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN  (_tao_retval);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_retval;
+}
+
+IR::ProvidesDef_ptr IR::_TAO_ComponentDef_Remote_Proxy_Impl::create_provides (
+    CORBA_Object *_collocated_tao_target_,
+    const char * id,
+    const char * name,
+    const char * version,
+    CORBA::InterfaceDef_ptr interface_type,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  IR::ProvidesDef_ptr _tao_retval = IR::ProvidesDef::_nil ();
+  IR::ProvidesDef_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "create_provides",
+      15,
+      1,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      IR::ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_create_provides ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        id,
+        name,
+        version,
+        interface_type,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+          if (!(
+                            (_tao_out << id) &&
+              (_tao_out << name) &&
+              (_tao_out << version) &&
+              (_tao_out << interface_type)
+            ))
+            TAO_INTERCEPTOR_THROW_RETURN (
+              CORBA::MARSHAL (),
+              0
+            );
+            
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              IR::ProvidesDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+IR::UsesDef_ptr IR::_TAO_ComponentDef_Remote_Proxy_Impl::create_uses (
+    CORBA_Object *_collocated_tao_target_,
+    const char * id,
+    const char * name,
+    const char * version,
+    CORBA::InterfaceDef_ptr interface_type,
+    CORBA::Boolean is_multiple,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  IR::UsesDef_ptr _tao_retval = IR::UsesDef::_nil ();
+  IR::UsesDef_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "create_uses",
+      11,
+      1,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      IR::ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_create_uses ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        id,
+        name,
+        version,
+        interface_type,
+        is_multiple,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+          if (!(
+                            (_tao_out << id) &&
+              (_tao_out << name) &&
+              (_tao_out << version) &&
+              (_tao_out << interface_type) &&
+              (_tao_out << CORBA::Any::from_boolean (is_multiple))
+            ))
+            TAO_INTERCEPTOR_THROW_RETURN (
+              CORBA::MARSHAL (),
+              0
+            );
+            
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              IR::UsesDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+IR::EmitsDef_ptr IR::_TAO_ComponentDef_Remote_Proxy_Impl::create_emits (
+    CORBA_Object *_collocated_tao_target_,
+    const char * id,
+    const char * name,
+    const char * version,
+    CORBA::ValueDef_ptr value,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  IR::EmitsDef_ptr _tao_retval = IR::EmitsDef::_nil ();
+  IR::EmitsDef_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "create_emits",
+      12,
+      1,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      IR::ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_create_emits ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        id,
+        name,
+        version,
+        value,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+          if (!(
+                            (_tao_out << id) &&
+              (_tao_out << name) &&
+              (_tao_out << version) &&
+              (_tao_out << value)
+            ))
+            TAO_INTERCEPTOR_THROW_RETURN (
+              CORBA::MARSHAL (),
+              0
+            );
+            
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              IR::EmitsDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+IR::PublishesDef_ptr IR::_TAO_ComponentDef_Remote_Proxy_Impl::create_publishes (
+    CORBA_Object *_collocated_tao_target_,
+    const char * id,
+    const char * name,
+    const char * version,
+    CORBA::ValueDef_ptr value,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  IR::PublishesDef_ptr _tao_retval = IR::PublishesDef::_nil ();
+  IR::PublishesDef_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "create_publishes",
+      16,
+      1,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      IR::ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_create_publishes ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        id,
+        name,
+        version,
+        value,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+          if (!(
+                            (_tao_out << id) &&
+              (_tao_out << name) &&
+              (_tao_out << version) &&
+              (_tao_out << value)
+            ))
+            TAO_INTERCEPTOR_THROW_RETURN (
+              CORBA::MARSHAL (),
+              0
+            );
+            
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              IR::PublishesDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+IR::ConsumesDef_ptr IR::_TAO_ComponentDef_Remote_Proxy_Impl::create_consumes (
+    CORBA_Object *_collocated_tao_target_,
+    const char * id,
+    const char * name,
+    const char * version,
+    CORBA::ValueDef_ptr value,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  IR::ConsumesDef_ptr _tao_retval = IR::ConsumesDef::_nil ();
+  IR::ConsumesDef_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "create_consumes",
+      15,
+      1,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      IR::ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_create_consumes ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        id,
+        name,
+        version,
+        value,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+          if (!(
+                            (_tao_out << id) &&
+              (_tao_out << name) &&
+              (_tao_out << version) &&
+              (_tao_out << value)
+            ))
+            TAO_INTERCEPTOR_THROW_RETURN (
+              CORBA::MARSHAL (),
+              0
+            );
+            
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              IR::ConsumesDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+
+//
+//            End  Base & Remote  Proxy Implemeentation. 
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//           Remote & Base  Proxy Broker Implementation
+//
+
+IR::_TAO_ComponentDef_Proxy_Broker::_TAO_ComponentDef_Proxy_Broker (void)
+{
+}
+
+IR::_TAO_ComponentDef_Proxy_Broker::~_TAO_ComponentDef_Proxy_Broker (void)
+{
+}
+
+IR::_TAO_ComponentDef_Proxy_Broker * (*IR__TAO_ComponentDef_Proxy_Broker_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  ) = 0;
+
+// Factory Member function Implementation.
+IR::_TAO_ComponentDef_Remote_Proxy_Broker *
+IR::_TAO_ComponentDef_Remote_Proxy_Broker::the_TAO_ComponentDef_Remote_Proxy_Broker (void)
+{
+  static ::IR::_TAO_ComponentDef_Remote_Proxy_Broker remote_proxy_broker;
+  return &remote_proxy_broker;
+}
+
+IR::_TAO_ComponentDef_Remote_Proxy_Broker::_TAO_ComponentDef_Remote_Proxy_Broker (void)
+{
+}
+
+IR::_TAO_ComponentDef_Remote_Proxy_Broker::~_TAO_ComponentDef_Remote_Proxy_Broker (void)
+{
+}
+
+IR::_TAO_ComponentDef_Proxy_Impl&
+IR::_TAO_ComponentDef_Remote_Proxy_Broker::select_proxy (
+  ::IR::ComponentDef *,
+  CORBA::Environment &
+)
+{
+  return this->remote_proxy_impl_;
+}
+
+
+//
+//           End Remote & Base Proxy Broker Implementation
+///////////////////////////////////////////////////////////////////////
+
+
+// default constructor
+IR::ComponentDef::ComponentDef (int collocated)
+{
+  this->IR_ComponentDef_setup_collocation (collocated);
+}
+
+// destructor
+IR::ComponentDef::~ComponentDef (void)
+{}
+
+void
+IR::ComponentDef::IR_ComponentDef_setup_collocation (int collocated)
+{
+  if (collocated)
+    this->the_TAO_ComponentDef_Proxy_Broker_ =
+      ::IR__TAO_ComponentDef_Proxy_Broker_Factory_function_pointer (this);
+  else
+    this->the_TAO_ComponentDef_Proxy_Broker_ =
+      ::IR::_TAO_ComponentDef_Remote_Proxy_Broker::the_TAO_ComponentDef_Remote_Proxy_Broker ();
+  
+  this->CORBA_InterfaceDef_setup_collocation (collocated);
+}
+
+void IR::ComponentDef::_tao_any_destructor (void *x)
+{
+  ComponentDef *tmp = ACE_static_cast (ComponentDef*,x);
+  CORBA::release (tmp);
+}
+
+IR::ComponentDef_ptr IR::ComponentDef::_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+{
+  if (CORBA::is_nil (obj))
+    return ComponentDef::_nil ();
+  if (! obj->_is_local ())
+    {
+      CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/IR/ComponentDef:1.0", ACE_TRY_ENV);
+      ACE_CHECK_RETURN (ComponentDef::_nil ());
+      if (is_a == 0)
+        return ComponentDef::_nil ();
+    }
+  return ComponentDef::_unchecked_narrow (obj, ACE_TRY_ENV);
+}
+
+IR::ComponentDef_ptr IR::ComponentDef::_unchecked_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &
+  )
+{
+  if (CORBA::is_nil (obj))
+    return ComponentDef::_nil ();
+  if (! obj->_is_local ())
+    {
+      TAO_Stub* stub = obj->_stubobj ();
+      if (stub)
+        stub->_incr_refcnt ();
+      ComponentDef_ptr default_proxy = ComponentDef::_nil ();
+
+      if (
+          !CORBA::is_nil (stub->servant_orb_var ().ptr ()) &&
+          stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects () &&
+          obj->_is_collocated () &&IR__TAO_ComponentDef_Proxy_Broker_Factory_function_pointer != 0
+        )
+      {
+        ACE_NEW_RETURN (
+          default_proxy,
+          ::IR::ComponentDef (
+            stub,
+            1,
+            obj->_servant ()),
+            
+          ComponentDef::_nil ());
+        }
+      if (CORBA::is_nil (default_proxy))
+        ACE_NEW_RETURN (default_proxy, ::IR::ComponentDef (stub, 0, obj->_servant ()), ComponentDef::_nil ());
+        return default_proxy;
+      }
+    else 
+      return
+        ACE_reinterpret_cast
+          (
+            ComponentDef_ptr,
+              obj->_tao_QueryInterface
+                (
+                  ACE_reinterpret_cast
+                    (
+                      ptr_arith_t,
+                      &ComponentDef::_narrow
+                    )
+                )
+          );
+}
+
+IR::ComponentDef_ptr
+IR::ComponentDef::_duplicate (ComponentDef_ptr obj)
+{
+  if (!CORBA::is_nil (obj))
+    obj->_add_ref ();
+  return obj;
+}
+
+CORBA::Boolean IR::ComponentDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
+{
+  if (
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/ComponentDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/InterfaceDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Container:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Contained:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IDLType:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
+  return 1; // success using local knowledge
+  else
+    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
+}
+
+void *IR::ComponentDef::_tao_QueryInterface (ptr_arith_t type)
+{
+  void *retv = 0;
+  if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &ACE_NESTED_CLASS (::IR, ComponentDef)::_narrow))
+    retv = ACE_reinterpret_cast (void*, this);
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::InterfaceDef::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::InterfaceDef_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::Container::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::Container_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::Contained::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::Contained_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::IDLType::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::IDLType_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::IRObject::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::IRObject_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
+    retv = ACE_reinterpret_cast (void *,
+      ACE_static_cast (CORBA::Object_ptr, this));
+    
+  if (retv)
+    this->_add_ref ();
+  return retv;
+}
+
+const char* IR::ComponentDef::_interface_repository_id (void) const
+{
+  return "IDL:omg.org/IR/ComponentDef:1.0";
+}
+
+CORBA::InterfaceDefSeq * IR::ComponentDef::supported_interfaces (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_ComponentDef_Proxy_Impl &proxy = 
+    this->the_TAO_ComponentDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.supported_interfaces (
+      this,
+      ACE_TRY_ENV
+    );
+}
+
+void IR::ComponentDef::supported_interfaces (
+    const CORBA::InterfaceDefSeq & supported_interfaces,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_ComponentDef_Proxy_Impl &proxy = 
+    this->the_TAO_ComponentDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK;
+  
+  proxy.supported_interfaces (
+      this,
+      supported_interfaces,
+      ACE_TRY_ENV
+    );
+}
+
+IR::ComponentDef_ptr IR::ComponentDef::base_component (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_ComponentDef_Proxy_Impl &proxy = 
+    this->the_TAO_ComponentDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.base_component (
+      this,
+      ACE_TRY_ENV
+    );
+}
+
+IR::ProvidesDefSeq * IR::ComponentDef::provides_interfaces (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_ComponentDef_Proxy_Impl &proxy = 
+    this->the_TAO_ComponentDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.provides_interfaces (
+      this,
+      ACE_TRY_ENV
+    );
+}
+
+IR::UsesDefSeq * IR::ComponentDef::uses_interfaces (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_ComponentDef_Proxy_Impl &proxy = 
+    this->the_TAO_ComponentDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.uses_interfaces (
+      this,
+      ACE_TRY_ENV
+    );
+}
+
+IR::EmitsDefSeq * IR::ComponentDef::emits_events (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_ComponentDef_Proxy_Impl &proxy = 
+    this->the_TAO_ComponentDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.emits_events (
+      this,
+      ACE_TRY_ENV
+    );
+}
+
+IR::PublishesDefSeq * IR::ComponentDef::publishes_events (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_ComponentDef_Proxy_Impl &proxy = 
+    this->the_TAO_ComponentDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.publishes_events (
+      this,
+      ACE_TRY_ENV
+    );
+}
+
+IR::ConsumesDefSeq * IR::ComponentDef::consumes_events (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_ComponentDef_Proxy_Impl &proxy = 
+    this->the_TAO_ComponentDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.consumes_events (
+      this,
+      ACE_TRY_ENV
+    );
+}
+
+CORBA::Boolean IR::ComponentDef::is_basic (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_ComponentDef_Proxy_Impl &proxy = 
+    this->the_TAO_ComponentDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.is_basic (
+      this,
+      ACE_TRY_ENV
+    );
+}
+
+IR::ProvidesDef_ptr IR::ComponentDef::create_provides (
+    const char * id,
+    const char * name,
+    const char * version,
+    CORBA::InterfaceDef_ptr interface_type,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_ComponentDef_Proxy_Impl &proxy = 
+    this->the_TAO_ComponentDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.create_provides (
+      this,
+      id,
+      name,
+      version,
+      interface_type,
+      ACE_TRY_ENV
+    );
+}
+
+IR::UsesDef_ptr IR::ComponentDef::create_uses (
+    const char * id,
+    const char * name,
+    const char * version,
+    CORBA::InterfaceDef_ptr interface_type,
+    CORBA::Boolean is_multiple,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_ComponentDef_Proxy_Impl &proxy = 
+    this->the_TAO_ComponentDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.create_uses (
+      this,
+      id,
+      name,
+      version,
+      interface_type,
+      is_multiple,
+      ACE_TRY_ENV
+    );
+}
+
+IR::EmitsDef_ptr IR::ComponentDef::create_emits (
+    const char * id,
+    const char * name,
+    const char * version,
+    CORBA::ValueDef_ptr value,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_ComponentDef_Proxy_Impl &proxy = 
+    this->the_TAO_ComponentDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.create_emits (
+      this,
+      id,
+      name,
+      version,
+      value,
+      ACE_TRY_ENV
+    );
+}
+
+IR::PublishesDef_ptr IR::ComponentDef::create_publishes (
+    const char * id,
+    const char * name,
+    const char * version,
+    CORBA::ValueDef_ptr value,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_ComponentDef_Proxy_Impl &proxy = 
+    this->the_TAO_ComponentDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.create_publishes (
+      this,
+      id,
+      name,
+      version,
+      value,
+      ACE_TRY_ENV
+    );
+}
+
+IR::ConsumesDef_ptr IR::ComponentDef::create_consumes (
+    const char * id,
+    const char * name,
+    const char * version,
+    CORBA::ValueDef_ptr value,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_ComponentDef_Proxy_Impl &proxy = 
+    this->the_TAO_ComponentDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.create_consumes (
+      this,
+      id,
+      name,
+      version,
+      value,
+      ACE_TRY_ENV
+    );
+}
+
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+IR::ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_supported_interfaces_get::TAO_ClientRequestInfo_IR_ComponentDef_supported_interfaces_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
+{}
+
+Dynamic::ParameterList *
+IR::ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_supported_interfaces_get::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return parameter_list;
+}
+
+Dynamic::ExceptionList *
+IR::ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_supported_interfaces_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+IR::ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_supported_interfaces_get::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+IR::ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_supported_interfaces_get::result (CORBA::InterfaceDefSeq * result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+IR::ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_supported_interfaces_set::TAO_ClientRequestInfo_IR_ComponentDef_supported_interfaces_set (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const CORBA::InterfaceDefSeq & supported_interfaces,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
+    supported_interfaces_ (supported_interfaces)
+{}
+
+Dynamic::ParameterList *
+IR::ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_supported_interfaces_set::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
+    
+  CORBA::ULong length_supported_interfaces = parameter_list->length ();
+  parameter_list->length (length_supported_interfaces + 1);
+  (*parameter_list)[length_supported_interfaces].argument <<=  this->supported_interfaces_;
+  
+  (*parameter_list)[length_supported_interfaces].mode = Dynamic::PARAM_IN;
+  
+  return safe_parameter_list._retn ();
+}
+
+Dynamic::ExceptionList *
+IR::ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_supported_interfaces_set::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+IR::ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_supported_interfaces_set::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 1;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return result_any;
+}
+
+IR::ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_base_component_get::TAO_ClientRequestInfo_IR_ComponentDef_base_component_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
+{}
+
+Dynamic::ParameterList *
+IR::ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_base_component_get::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return parameter_list;
+}
+
+Dynamic::ExceptionList *
+IR::ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_base_component_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+IR::ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_base_component_get::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+IR::ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_base_component_get::result (IR::ComponentDef_ptr result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+IR::ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_provides_interfaces_get::TAO_ClientRequestInfo_IR_ComponentDef_provides_interfaces_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
+{}
+
+Dynamic::ParameterList *
+IR::ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_provides_interfaces_get::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return parameter_list;
+}
+
+Dynamic::ExceptionList *
+IR::ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_provides_interfaces_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+IR::ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_provides_interfaces_get::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+IR::ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_provides_interfaces_get::result (IR::ProvidesDefSeq * result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+IR::ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_uses_interfaces_get::TAO_ClientRequestInfo_IR_ComponentDef_uses_interfaces_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
+{}
+
+Dynamic::ParameterList *
+IR::ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_uses_interfaces_get::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return parameter_list;
+}
+
+Dynamic::ExceptionList *
+IR::ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_uses_interfaces_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+IR::ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_uses_interfaces_get::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+IR::ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_uses_interfaces_get::result (IR::UsesDefSeq * result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+IR::ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_emits_events_get::TAO_ClientRequestInfo_IR_ComponentDef_emits_events_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
+{}
+
+Dynamic::ParameterList *
+IR::ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_emits_events_get::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return parameter_list;
+}
+
+Dynamic::ExceptionList *
+IR::ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_emits_events_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+IR::ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_emits_events_get::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+IR::ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_emits_events_get::result (IR::EmitsDefSeq * result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+IR::ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_publishes_events_get::TAO_ClientRequestInfo_IR_ComponentDef_publishes_events_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
+{}
+
+Dynamic::ParameterList *
+IR::ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_publishes_events_get::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return parameter_list;
+}
+
+Dynamic::ExceptionList *
+IR::ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_publishes_events_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+IR::ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_publishes_events_get::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+IR::ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_publishes_events_get::result (IR::PublishesDefSeq * result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+IR::ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_consumes_events_get::TAO_ClientRequestInfo_IR_ComponentDef_consumes_events_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
+{}
+
+Dynamic::ParameterList *
+IR::ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_consumes_events_get::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return parameter_list;
+}
+
+Dynamic::ExceptionList *
+IR::ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_consumes_events_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+IR::ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_consumes_events_get::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+IR::ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_consumes_events_get::result (IR::ConsumesDefSeq * result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+IR::ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_is_basic_get::TAO_ClientRequestInfo_IR_ComponentDef_is_basic_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
+{}
+
+Dynamic::ParameterList *
+IR::ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_is_basic_get::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return parameter_list;
+}
+
+Dynamic::ExceptionList *
+IR::ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_is_basic_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+IR::ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_is_basic_get::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= CORBA::Any::from_boolean (this->_result);
+  return safe_result_any._retn ();
+}
+
+void 
+IR::ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_is_basic_get::result (CORBA::Boolean result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+IR::ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_create_provides::TAO_ClientRequestInfo_IR_ComponentDef_create_provides (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const char * id,
+    const char * name,
+    const char * version,
+    CORBA::InterfaceDef_ptr interface_type,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
+    id_ (id),
+    name_ (name),
+    version_ (version),
+    interface_type_ (interface_type)
+{}
+
+Dynamic::ParameterList *
+IR::ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_create_provides::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
+    
+  CORBA::ULong length_id = parameter_list->length ();
+  parameter_list->length (length_id + 1);
+  (*parameter_list)[length_id].argument <<= id_;
+  (*parameter_list)[length_id].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_name = parameter_list->length ();
+  parameter_list->length (length_name + 1);
+  (*parameter_list)[length_name].argument <<= name_;
+  (*parameter_list)[length_name].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_version = parameter_list->length ();
+  parameter_list->length (length_version + 1);
+  (*parameter_list)[length_version].argument <<= version_;
+  (*parameter_list)[length_version].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_interface_type = parameter_list->length ();
+  parameter_list->length (length_interface_type + 1);
+  (*parameter_list)[length_interface_type].argument <<=  this->interface_type_;
+  
+  (*parameter_list)[length_interface_type].mode = Dynamic::PARAM_IN;
+  
+  return safe_parameter_list._retn ();
+}
+
+Dynamic::ExceptionList *
+IR::ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_create_provides::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+IR::ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_create_provides::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+IR::ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_create_provides::result (IR::ProvidesDef_ptr result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+IR::ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_create_uses::TAO_ClientRequestInfo_IR_ComponentDef_create_uses (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const char * id,
+    const char * name,
+    const char * version,
+    CORBA::InterfaceDef_ptr interface_type,
+    const CORBA::Boolean & is_multiple,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
+    id_ (id),
+    name_ (name),
+    version_ (version),
+    interface_type_ (interface_type),
+    is_multiple_ (is_multiple)
+{}
+
+Dynamic::ParameterList *
+IR::ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_create_uses::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
+    
+  CORBA::ULong length_id = parameter_list->length ();
+  parameter_list->length (length_id + 1);
+  (*parameter_list)[length_id].argument <<= id_;
+  (*parameter_list)[length_id].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_name = parameter_list->length ();
+  parameter_list->length (length_name + 1);
+  (*parameter_list)[length_name].argument <<= name_;
+  (*parameter_list)[length_name].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_version = parameter_list->length ();
+  parameter_list->length (length_version + 1);
+  (*parameter_list)[length_version].argument <<= version_;
+  (*parameter_list)[length_version].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_interface_type = parameter_list->length ();
+  parameter_list->length (length_interface_type + 1);
+  (*parameter_list)[length_interface_type].argument <<=  this->interface_type_;
+  
+  (*parameter_list)[length_interface_type].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_is_multiple = parameter_list->length ();
+  parameter_list->length (length_is_multiple + 1);
+  (*parameter_list)[length_is_multiple].argument <<= CORBA::Any::from_boolean (this->is_multiple_);
+  (*parameter_list)[length_is_multiple].mode = Dynamic::PARAM_IN;
+  
+  return safe_parameter_list._retn ();
+}
+
+Dynamic::ExceptionList *
+IR::ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_create_uses::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+IR::ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_create_uses::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+IR::ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_create_uses::result (IR::UsesDef_ptr result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+IR::ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_create_emits::TAO_ClientRequestInfo_IR_ComponentDef_create_emits (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const char * id,
+    const char * name,
+    const char * version,
+    CORBA::ValueDef_ptr value,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
+    id_ (id),
+    name_ (name),
+    version_ (version),
+    value_ (value)
+{}
+
+Dynamic::ParameterList *
+IR::ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_create_emits::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
+    
+  CORBA::ULong length_id = parameter_list->length ();
+  parameter_list->length (length_id + 1);
+  (*parameter_list)[length_id].argument <<= id_;
+  (*parameter_list)[length_id].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_name = parameter_list->length ();
+  parameter_list->length (length_name + 1);
+  (*parameter_list)[length_name].argument <<= name_;
+  (*parameter_list)[length_name].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_version = parameter_list->length ();
+  parameter_list->length (length_version + 1);
+  (*parameter_list)[length_version].argument <<= version_;
+  (*parameter_list)[length_version].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_value = parameter_list->length ();
+  parameter_list->length (length_value + 1);
+  (*parameter_list)[length_value].argument <<=  this->value_;
+  
+  (*parameter_list)[length_value].mode = Dynamic::PARAM_IN;
+  
+  return safe_parameter_list._retn ();
+}
+
+Dynamic::ExceptionList *
+IR::ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_create_emits::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+IR::ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_create_emits::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+IR::ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_create_emits::result (IR::EmitsDef_ptr result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+IR::ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_create_publishes::TAO_ClientRequestInfo_IR_ComponentDef_create_publishes (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const char * id,
+    const char * name,
+    const char * version,
+    CORBA::ValueDef_ptr value,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
+    id_ (id),
+    name_ (name),
+    version_ (version),
+    value_ (value)
+{}
+
+Dynamic::ParameterList *
+IR::ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_create_publishes::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
+    
+  CORBA::ULong length_id = parameter_list->length ();
+  parameter_list->length (length_id + 1);
+  (*parameter_list)[length_id].argument <<= id_;
+  (*parameter_list)[length_id].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_name = parameter_list->length ();
+  parameter_list->length (length_name + 1);
+  (*parameter_list)[length_name].argument <<= name_;
+  (*parameter_list)[length_name].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_version = parameter_list->length ();
+  parameter_list->length (length_version + 1);
+  (*parameter_list)[length_version].argument <<= version_;
+  (*parameter_list)[length_version].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_value = parameter_list->length ();
+  parameter_list->length (length_value + 1);
+  (*parameter_list)[length_value].argument <<=  this->value_;
+  
+  (*parameter_list)[length_value].mode = Dynamic::PARAM_IN;
+  
+  return safe_parameter_list._retn ();
+}
+
+Dynamic::ExceptionList *
+IR::ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_create_publishes::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+IR::ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_create_publishes::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+IR::ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_create_publishes::result (IR::PublishesDef_ptr result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+IR::ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_create_consumes::TAO_ClientRequestInfo_IR_ComponentDef_create_consumes (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const char * id,
+    const char * name,
+    const char * version,
+    CORBA::ValueDef_ptr value,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
+    id_ (id),
+    name_ (name),
+    version_ (version),
+    value_ (value)
+{}
+
+Dynamic::ParameterList *
+IR::ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_create_consumes::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
+    
+  CORBA::ULong length_id = parameter_list->length ();
+  parameter_list->length (length_id + 1);
+  (*parameter_list)[length_id].argument <<= id_;
+  (*parameter_list)[length_id].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_name = parameter_list->length ();
+  parameter_list->length (length_name + 1);
+  (*parameter_list)[length_name].argument <<= name_;
+  (*parameter_list)[length_name].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_version = parameter_list->length ();
+  parameter_list->length (length_version + 1);
+  (*parameter_list)[length_version].argument <<= version_;
+  (*parameter_list)[length_version].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_value = parameter_list->length ();
+  parameter_list->length (length_value + 1);
+  (*parameter_list)[length_value].argument <<=  this->value_;
+  
+  (*parameter_list)[length_value].mode = Dynamic::PARAM_IN;
+  
+  return safe_parameter_list._retn ();
+}
+
+Dynamic::ExceptionList *
+IR::ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_create_consumes::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+IR::ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_create_consumes::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+IR::ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_create_consumes::result (IR::ConsumesDef_ptr result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+#endif /* TAO_HAS_INTERCEPTORS */
+static const CORBA::Long _oc_IR_ComponentDef[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  32,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x49522f43), 
+  ACE_NTOHL (0x6f6d706f), 
+  ACE_NTOHL (0x6e656e74), 
+  ACE_NTOHL (0x4465663a), 
+  ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ComponentDef:1.0
+  13,
+  ACE_NTOHL (0x436f6d70), 
+  ACE_NTOHL (0x6f6e656e), 
+  ACE_NTOHL (0x74446566), 
+  ACE_NTOHL (0x0),  // name = ComponentDef
+};
+
+static CORBA::TypeCode _tc_TAO_tc_IR_ComponentDef (
+    CORBA::tk_objref,
+    sizeof (_oc_IR_ComponentDef),
+    (char *) &_oc_IR_ComponentDef,
+    0,
+    sizeof (IR::ComponentDef)
+  );
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ComponentDef, &_tc_TAO_tc_IR_ComponentDef)
+TAO_NAMESPACE_END
+
+static const CORBA::Long _oc_IR_ComponentDescription[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  40,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x49522f43), 
+  ACE_NTOHL (0x6f6d706f), 
+  ACE_NTOHL (0x6e656e74), 
+  ACE_NTOHL (0x44657363), 
+  ACE_NTOHL (0x72697074), 
+  ACE_NTOHL (0x696f6e3a), 
+  ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ComponentDescription:1.0
+  21,
+  ACE_NTOHL (0x436f6d70), 
+  ACE_NTOHL (0x6f6e656e), 
+  ACE_NTOHL (0x74446573), 
+  ACE_NTOHL (0x63726970), 
+  ACE_NTOHL (0x74696f6e), 
+  ACE_NTOHL (0x0),  // name = ComponentDescription
+  13, // member count
+  5,
+  ACE_NTOHL (0x6e616d65), 
+  ACE_NTOHL (0x0),  // name = name
+  CORBA::tk_alias, // typecode kind for typedefs
+  64, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    30,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x49522f49), 
+    ACE_NTOHL (0x64656e74), 
+    ACE_NTOHL (0x69666965), 
+    ACE_NTOHL (0x723a312e), 
+    ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
+    11,
+    ACE_NTOHL (0x4964656e), 
+    ACE_NTOHL (0x74696669), 
+    ACE_NTOHL (0x65720000),  // name = Identifier
+    CORBA::tk_string, 
+    0U, // string length
+
+  3,
+  ACE_NTOHL (0x69640000),  // name = id
+  CORBA::tk_alias, // typecode kind for typedefs
+  68, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    32,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x49522f52), 
+    ACE_NTOHL (0x65706f73), 
+    ACE_NTOHL (0x69746f72), 
+    ACE_NTOHL (0x7949643a), 
+    ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
+    13,
+    ACE_NTOHL (0x5265706f), 
+    ACE_NTOHL (0x7369746f), 
+    ACE_NTOHL (0x72794964), 
+    ACE_NTOHL (0x0),  // name = RepositoryId
+    CORBA::tk_string, 
+    0U, // string length
+
+  11,
+  ACE_NTOHL (0x64656669), 
+  ACE_NTOHL (0x6e65645f), 
+  ACE_NTOHL (0x696e0000),  // name = defined_in
+  CORBA::tk_alias, // typecode kind for typedefs
+  68, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    32,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x49522f52), 
+    ACE_NTOHL (0x65706f73), 
+    ACE_NTOHL (0x69746f72), 
+    ACE_NTOHL (0x7949643a), 
+    ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
+    13,
+    ACE_NTOHL (0x5265706f), 
+    ACE_NTOHL (0x7369746f), 
+    ACE_NTOHL (0x72794964), 
+    ACE_NTOHL (0x0),  // name = RepositoryId
+    CORBA::tk_string, 
+    0U, // string length
+
+  8,
+  ACE_NTOHL (0x76657273), 
+  ACE_NTOHL (0x696f6e00),  // name = version
+  CORBA::tk_alias, // typecode kind for typedefs
+  64, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    31,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x49522f56), 
+    ACE_NTOHL (0x65727369), 
+    ACE_NTOHL (0x6f6e5370), 
+    ACE_NTOHL (0x65633a31), 
+    ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
+    12,
+    ACE_NTOHL (0x56657273), 
+    ACE_NTOHL (0x696f6e53), 
+    ACE_NTOHL (0x70656300),  // name = VersionSpec
+    CORBA::tk_string, 
+    0U, // string length
+
+  15,
+  ACE_NTOHL (0x62617365), 
+  ACE_NTOHL (0x5f636f6d), 
+  ACE_NTOHL (0x706f6e65), 
+  ACE_NTOHL (0x6e740000),  // name = base_component
+  CORBA::tk_alias, // typecode kind for typedefs
+  68, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    32,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x49522f52), 
+    ACE_NTOHL (0x65706f73), 
+    ACE_NTOHL (0x69746f72), 
+    ACE_NTOHL (0x7949643a), 
+    ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
+    13,
+    ACE_NTOHL (0x5265706f), 
+    ACE_NTOHL (0x7369746f), 
+    ACE_NTOHL (0x72794964), 
+    ACE_NTOHL (0x0),  // name = RepositoryId
+    CORBA::tk_string, 
+    0U, // string length
+
+  20,
+  ACE_NTOHL (0x73757070), 
+  ACE_NTOHL (0x6f727473), 
+  ACE_NTOHL (0x5f696e74), 
+  ACE_NTOHL (0x65726661), 
+  ACE_NTOHL (0x63657300),  // name = supports_interfaces
+  CORBA::tk_alias, // typecode kind for typedefs
+  156, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    35,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x49522f52), 
+    ACE_NTOHL (0x65706f73), 
+    ACE_NTOHL (0x69746f72), 
+    ACE_NTOHL (0x79496453), 
+    ACE_NTOHL (0x65713a31), 
+    ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/RepositoryIdSeq:1.0
+    16,
+    ACE_NTOHL (0x5265706f), 
+    ACE_NTOHL (0x7369746f), 
+    ACE_NTOHL (0x72794964), 
+    ACE_NTOHL (0x53657100),  // name = RepositoryIdSeq
+    CORBA::tk_sequence, // typecode kind
+    84, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      CORBA::tk_alias, // typecode kind for typedefs
+      68, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        32,
+        ACE_NTOHL (0x49444c3a), 
+        ACE_NTOHL (0x6f6d672e), 
+        ACE_NTOHL (0x6f72672f), 
+        ACE_NTOHL (0x49522f52), 
+        ACE_NTOHL (0x65706f73), 
+        ACE_NTOHL (0x69746f72), 
+        ACE_NTOHL (0x7949643a), 
+        ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
+        13,
+        ACE_NTOHL (0x5265706f), 
+        ACE_NTOHL (0x7369746f), 
+        ACE_NTOHL (0x72794964), 
+        ACE_NTOHL (0x0),  // name = RepositoryId
+        CORBA::tk_string, 
+        0U, // string length
+
+      0U,
+
+
+  20,
+  ACE_NTOHL (0x70726f76), 
+  ACE_NTOHL (0x69646573), 
+  ACE_NTOHL (0x5f696e74), 
+  ACE_NTOHL (0x65726661), 
+  ACE_NTOHL (0x63657300),  // name = provides_interfaces
+  CORBA::tk_alias, // typecode kind for typedefs
+  144, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    34,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x49522f50), 
+    ACE_NTOHL (0x726f7669), 
+    ACE_NTOHL (0x64657344), 
+    ACE_NTOHL (0x65665365), 
+    ACE_NTOHL (0x713a312e), 
+    ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/ProvidesDefSeq:1.0
+    15,
+    ACE_NTOHL (0x50726f76), 
+    ACE_NTOHL (0x69646573), 
+    ACE_NTOHL (0x44656653), 
+    ACE_NTOHL (0x65710000),  // name = ProvidesDefSeq
+    CORBA::tk_sequence, // typecode kind
+    72, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      CORBA::tk_objref, // typecode kind
+      56, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        31,
+        ACE_NTOHL (0x49444c3a), 
+        ACE_NTOHL (0x6f6d672e), 
+        ACE_NTOHL (0x6f72672f), 
+        ACE_NTOHL (0x49522f50), 
+        ACE_NTOHL (0x726f7669), 
+        ACE_NTOHL (0x64657344), 
+        ACE_NTOHL (0x65663a31), 
+        ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/ProvidesDef:1.0
+        12,
+        ACE_NTOHL (0x50726f76), 
+        ACE_NTOHL (0x69646573), 
+        ACE_NTOHL (0x44656600),  // name = ProvidesDef
+
+      0U,
+
+
+  16,
+  ACE_NTOHL (0x75736573), 
+  ACE_NTOHL (0x5f696e74), 
+  ACE_NTOHL (0x65726661), 
+  ACE_NTOHL (0x63657300),  // name = uses_interfaces
+  CORBA::tk_alias, // typecode kind for typedefs
+  128, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    30,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x49522f55), 
+    ACE_NTOHL (0x73657344), 
+    ACE_NTOHL (0x65665365), 
+    ACE_NTOHL (0x713a312e), 
+    ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/UsesDefSeq:1.0
+    11,
+    ACE_NTOHL (0x55736573), 
+    ACE_NTOHL (0x44656653), 
+    ACE_NTOHL (0x65710000),  // name = UsesDefSeq
+    CORBA::tk_sequence, // typecode kind
+    64, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      CORBA::tk_objref, // typecode kind
+      48, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        27,
+        ACE_NTOHL (0x49444c3a), 
+        ACE_NTOHL (0x6f6d672e), 
+        ACE_NTOHL (0x6f72672f), 
+        ACE_NTOHL (0x49522f55), 
+        ACE_NTOHL (0x73657344), 
+        ACE_NTOHL (0x65663a31), 
+        ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/UsesDef:1.0
+        8,
+        ACE_NTOHL (0x55736573), 
+        ACE_NTOHL (0x44656600),  // name = UsesDef
+
+      0U,
+
+
+  11,
+  ACE_NTOHL (0x61747472), 
+  ACE_NTOHL (0x69627574), 
+  ACE_NTOHL (0x65730000),  // name = attributes
+  CORBA::tk_alias, // typecode kind for typedefs
+  684, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    41,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x434f5242), 
+    ACE_NTOHL (0x412f4174), 
+    ACE_NTOHL (0x74724465), 
+    ACE_NTOHL (0x73637269), 
+    ACE_NTOHL (0x7074696f), 
+    ACE_NTOHL (0x6e536571), 
+    ACE_NTOHL (0x3a312e30), 
+    ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/AttrDescriptionSeq:1.0
+    19,
+    ACE_NTOHL (0x41747472), 
+    ACE_NTOHL (0x44657363), 
+    ACE_NTOHL (0x72697074), 
+    ACE_NTOHL (0x696f6e53), 
+    ACE_NTOHL (0x65710000),  // name = AttrDescriptionSeq
+    CORBA::tk_sequence, // typecode kind
+    600, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      CORBA::tk_struct, // typecode kind
+      584, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        43,
+        ACE_NTOHL (0x49444c3a), 
+        ACE_NTOHL (0x6f6d672e), 
+        ACE_NTOHL (0x6f72672f), 
+        ACE_NTOHL (0x434f5242), 
+        ACE_NTOHL (0x412f4174), 
+        ACE_NTOHL (0x74726962), 
+        ACE_NTOHL (0x75746544), 
+        ACE_NTOHL (0x65736372), 
+        ACE_NTOHL (0x69707469), 
+        ACE_NTOHL (0x6f6e3a31), 
+        ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/AttributeDescription:1.0
+        21,
+        ACE_NTOHL (0x41747472), 
+        ACE_NTOHL (0x69627574), 
+        ACE_NTOHL (0x65446573), 
+        ACE_NTOHL (0x63726970), 
+        ACE_NTOHL (0x74696f6e), 
+        ACE_NTOHL (0x0),  // name = AttributeDescription
+        6, // member count
+        5,
+        ACE_NTOHL (0x6e616d65), 
+        ACE_NTOHL (0x0),  // name = name
+        CORBA::tk_alias, // typecode kind for typedefs
+        68, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          33,
+          ACE_NTOHL (0x49444c3a), 
+          ACE_NTOHL (0x6f6d672e), 
+          ACE_NTOHL (0x6f72672f), 
+          ACE_NTOHL (0x434f5242), 
+          ACE_NTOHL (0x412f4964), 
+          ACE_NTOHL (0x656e7469), 
+          ACE_NTOHL (0x66696572), 
+          ACE_NTOHL (0x3a312e30), 
+          ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+          11,
+          ACE_NTOHL (0x4964656e), 
+          ACE_NTOHL (0x74696669), 
+          ACE_NTOHL (0x65720000),  // name = Identifier
+          CORBA::tk_string, 
+          0U, // string length
+
+        3,
+        ACE_NTOHL (0x69640000),  // name = id
+        CORBA::tk_alias, // typecode kind for typedefs
+        72, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          35,
+          ACE_NTOHL (0x49444c3a), 
+          ACE_NTOHL (0x6f6d672e), 
+          ACE_NTOHL (0x6f72672f), 
+          ACE_NTOHL (0x434f5242), 
+          ACE_NTOHL (0x412f5265), 
+          ACE_NTOHL (0x706f7369), 
+          ACE_NTOHL (0x746f7279), 
+          ACE_NTOHL (0x49643a31), 
+          ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+          13,
+          ACE_NTOHL (0x5265706f), 
+          ACE_NTOHL (0x7369746f), 
+          ACE_NTOHL (0x72794964), 
+          ACE_NTOHL (0x0),  // name = RepositoryId
+          CORBA::tk_string, 
+          0U, // string length
+
+        11,
+        ACE_NTOHL (0x64656669), 
+        ACE_NTOHL (0x6e65645f), 
+        ACE_NTOHL (0x696e0000),  // name = defined_in
+        CORBA::tk_alias, // typecode kind for typedefs
+        72, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          35,
+          ACE_NTOHL (0x49444c3a), 
+          ACE_NTOHL (0x6f6d672e), 
+          ACE_NTOHL (0x6f72672f), 
+          ACE_NTOHL (0x434f5242), 
+          ACE_NTOHL (0x412f5265), 
+          ACE_NTOHL (0x706f7369), 
+          ACE_NTOHL (0x746f7279), 
+          ACE_NTOHL (0x49643a31), 
+          ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+          13,
+          ACE_NTOHL (0x5265706f), 
+          ACE_NTOHL (0x7369746f), 
+          ACE_NTOHL (0x72794964), 
+          ACE_NTOHL (0x0),  // name = RepositoryId
+          CORBA::tk_string, 
+          0U, // string length
+
+        8,
+        ACE_NTOHL (0x76657273), 
+        ACE_NTOHL (0x696f6e00),  // name = version
+        CORBA::tk_alias, // typecode kind for typedefs
+        68, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          34,
+          ACE_NTOHL (0x49444c3a), 
+          ACE_NTOHL (0x6f6d672e), 
+          ACE_NTOHL (0x6f72672f), 
+          ACE_NTOHL (0x434f5242), 
+          ACE_NTOHL (0x412f5665), 
+          ACE_NTOHL (0x7273696f), 
+          ACE_NTOHL (0x6e537065), 
+          ACE_NTOHL (0x633a312e), 
+          ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/VersionSpec:1.0
+          12,
+          ACE_NTOHL (0x56657273), 
+          ACE_NTOHL (0x696f6e53), 
+          ACE_NTOHL (0x70656300),  // name = VersionSpec
+          CORBA::tk_string, 
+          0U, // string length
+
+        5,
+        ACE_NTOHL (0x74797065), 
+        ACE_NTOHL (0x0),  // name = type
+        CORBA::tk_TypeCode,
+
+        5,
+        ACE_NTOHL (0x6d6f6465), 
+        ACE_NTOHL (0x0),  // name = mode
+        CORBA::tk_enum, // typecode kind
+        104, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          36,
+          ACE_NTOHL (0x49444c3a), 
+          ACE_NTOHL (0x6f6d672e), 
+          ACE_NTOHL (0x6f72672f), 
+          ACE_NTOHL (0x434f5242), 
+          ACE_NTOHL (0x412f4174), 
+          ACE_NTOHL (0x74726962), 
+          ACE_NTOHL (0x7574654d), 
+          ACE_NTOHL (0x6f64653a), 
+          ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/AttributeMode:1.0
+          14,
+          ACE_NTOHL (0x41747472), 
+          ACE_NTOHL (0x69627574), 
+          ACE_NTOHL (0x654d6f64), 
+          ACE_NTOHL (0x65000000),  // name = AttributeMode
+          2, // member count
+          12,
+          ACE_NTOHL (0x41545452), 
+          ACE_NTOHL (0x5f4e4f52), 
+          ACE_NTOHL (0x4d414c00),  // name = ATTR_NORMAL
+          14,
+          ACE_NTOHL (0x41545452), 
+          ACE_NTOHL (0x5f524541), 
+          ACE_NTOHL (0x444f4e4c), 
+          ACE_NTOHL (0x59000000),  // name = ATTR_READONLY
+
+
+      0U,
+
+
+  13,
+  ACE_NTOHL (0x656d6974), 
+  ACE_NTOHL (0x735f6576), 
+  ACE_NTOHL (0x656e7473), 
+  ACE_NTOHL (0x0),  // name = emits_events
+  CORBA::tk_alias, // typecode kind for typedefs
+  132, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    31,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x49522f45), 
+    ACE_NTOHL (0x6d697473), 
+    ACE_NTOHL (0x44656653), 
+    ACE_NTOHL (0x65713a31), 
+    ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/EmitsDefSeq:1.0
+    12,
+    ACE_NTOHL (0x456d6974), 
+    ACE_NTOHL (0x73446566), 
+    ACE_NTOHL (0x53657100),  // name = EmitsDefSeq
+    CORBA::tk_sequence, // typecode kind
+    68, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      CORBA::tk_objref, // typecode kind
+      52, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        28,
+        ACE_NTOHL (0x49444c3a), 
+        ACE_NTOHL (0x6f6d672e), 
+        ACE_NTOHL (0x6f72672f), 
+        ACE_NTOHL (0x49522f45), 
+        ACE_NTOHL (0x6d697473), 
+        ACE_NTOHL (0x4465663a), 
+        ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/EmitsDef:1.0
+        9,
+        ACE_NTOHL (0x456d6974), 
+        ACE_NTOHL (0x73446566), 
+        ACE_NTOHL (0x0),  // name = EmitsDef
+
+      0U,
+
+
+  17,
+  ACE_NTOHL (0x7075626c), 
+  ACE_NTOHL (0x69736865), 
+  ACE_NTOHL (0x735f6576), 
+  ACE_NTOHL (0x656e7473), 
+  ACE_NTOHL (0x0),  // name = publishes_events
+  CORBA::tk_alias, // typecode kind for typedefs
+  148, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    35,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x49522f50), 
+    ACE_NTOHL (0x75626c69), 
+    ACE_NTOHL (0x73686573), 
+    ACE_NTOHL (0x44656653), 
+    ACE_NTOHL (0x65713a31), 
+    ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/PublishesDefSeq:1.0
+    16,
+    ACE_NTOHL (0x5075626c), 
+    ACE_NTOHL (0x69736865), 
+    ACE_NTOHL (0x73446566), 
+    ACE_NTOHL (0x53657100),  // name = PublishesDefSeq
+    CORBA::tk_sequence, // typecode kind
+    76, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      CORBA::tk_objref, // typecode kind
+      60, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        32,
+        ACE_NTOHL (0x49444c3a), 
+        ACE_NTOHL (0x6f6d672e), 
+        ACE_NTOHL (0x6f72672f), 
+        ACE_NTOHL (0x49522f50), 
+        ACE_NTOHL (0x75626c69), 
+        ACE_NTOHL (0x73686573), 
+        ACE_NTOHL (0x4465663a), 
+        ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/PublishesDef:1.0
+        13,
+        ACE_NTOHL (0x5075626c), 
+        ACE_NTOHL (0x69736865), 
+        ACE_NTOHL (0x73446566), 
+        ACE_NTOHL (0x0),  // name = PublishesDef
+
+      0U,
+
+
+  16,
+  ACE_NTOHL (0x636f6e73), 
+  ACE_NTOHL (0x756d6573), 
+  ACE_NTOHL (0x5f657665), 
+  ACE_NTOHL (0x6e747300),  // name = consumes_events
+  CORBA::tk_alias, // typecode kind for typedefs
+  144, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    34,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x49522f43), 
+    ACE_NTOHL (0x6f6e7375), 
+    ACE_NTOHL (0x6d657344), 
+    ACE_NTOHL (0x65665365), 
+    ACE_NTOHL (0x713a312e), 
+    ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/ConsumesDefSeq:1.0
+    15,
+    ACE_NTOHL (0x436f6e73), 
+    ACE_NTOHL (0x756d6573), 
+    ACE_NTOHL (0x44656653), 
+    ACE_NTOHL (0x65710000),  // name = ConsumesDefSeq
+    CORBA::tk_sequence, // typecode kind
+    72, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      CORBA::tk_objref, // typecode kind
+      56, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        31,
+        ACE_NTOHL (0x49444c3a), 
+        ACE_NTOHL (0x6f6d672e), 
+        ACE_NTOHL (0x6f72672f), 
+        ACE_NTOHL (0x49522f43), 
+        ACE_NTOHL (0x6f6e7375), 
+        ACE_NTOHL (0x6d657344), 
+        ACE_NTOHL (0x65663a31), 
+        ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/ConsumesDef:1.0
+        12,
+        ACE_NTOHL (0x436f6e73), 
+        ACE_NTOHL (0x756d6573), 
+        ACE_NTOHL (0x44656600),  // name = ConsumesDef
+
+      0U,
+
+
+  9,
+  ACE_NTOHL (0x69735f62), 
+  ACE_NTOHL (0x61736963), 
+  ACE_NTOHL (0x0),  // name = is_basic
+  CORBA::tk_boolean,
+
+};
+
+static CORBA::TypeCode _tc_TAO_tc_IR_ComponentDescription (
+    CORBA::tk_struct,
+    sizeof (_oc_IR_ComponentDescription),
+    (char *) &_oc_IR_ComponentDescription,
+    0,
+    sizeof (IR::ComponentDescription)
+  );
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ComponentDescription, &_tc_TAO_tc_IR_ComponentDescription)
+TAO_NAMESPACE_END
+
+void IR::ComponentDescription::_tao_any_destructor (void *x)
+{
+  ComponentDescription *tmp = ACE_static_cast (ComponentDescription*,x);
+  delete tmp;
+}
+
+
+///////////////////////////////////////////////////////////////////////
+//                Base & Remote Proxy  Implementation. 
+//
+
+IR::_TAO_PrimaryKeyDef_Proxy_Impl::_TAO_PrimaryKeyDef_Proxy_Impl (void)
+{}
+
+IR::_TAO_PrimaryKeyDef_Remote_Proxy_Impl::_TAO_PrimaryKeyDef_Remote_Proxy_Impl (void)
+{}
+
+// Remote Implementation of the IDL interface methods
+
+CORBA::Boolean IR::_TAO_PrimaryKeyDef_Remote_Proxy_Impl::is_a (
+    CORBA_Object *_collocated_tao_target_,
+    const char * primary_key_id,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::Boolean _tao_retval = 0;
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), _tao_retval);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "is_a",
+      4,
+      1,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      IR::PrimaryKeyDef::TAO_ClientRequestInfo_IR_PrimaryKeyDef_is_a ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        primary_key_id,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN  (_tao_retval);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          
+          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+          if (!(
+                            (_tao_out << primary_key_id)
+            ))
+            TAO_INTERCEPTOR_THROW_RETURN (
+              CORBA::MARSHAL (),
+              _tao_retval
+            );
+            
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                _tao_retval
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> CORBA::Any::to_boolean (_tao_retval))
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                _tao_retval
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::Boolean  _tao_retval_info = _tao_retval;
+               ri.result (_tao_retval_info);
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN  (_tao_retval);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_retval;
+}
+
+CORBA::ValueDef_ptr IR::_TAO_PrimaryKeyDef_Remote_Proxy_Impl::primary_key (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::ValueDef_ptr _tao_retval = CORBA::ValueDef::_nil ();
+  CORBA::ValueDef_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_primary_key",
+      16,
+      0,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      IR::PrimaryKeyDef::TAO_ClientRequestInfo_IR_PrimaryKeyDef_primary_key_get ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::ValueDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+
+//
+//            End  Base & Remote  Proxy Implemeentation. 
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//           Remote & Base  Proxy Broker Implementation
+//
+
+IR::_TAO_PrimaryKeyDef_Proxy_Broker::_TAO_PrimaryKeyDef_Proxy_Broker (void)
+{
+}
+
+IR::_TAO_PrimaryKeyDef_Proxy_Broker::~_TAO_PrimaryKeyDef_Proxy_Broker (void)
+{
+}
+
+IR::_TAO_PrimaryKeyDef_Proxy_Broker * (*IR__TAO_PrimaryKeyDef_Proxy_Broker_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  ) = 0;
+
+// Factory Member function Implementation.
+IR::_TAO_PrimaryKeyDef_Remote_Proxy_Broker *
+IR::_TAO_PrimaryKeyDef_Remote_Proxy_Broker::the_TAO_PrimaryKeyDef_Remote_Proxy_Broker (void)
+{
+  static ::IR::_TAO_PrimaryKeyDef_Remote_Proxy_Broker remote_proxy_broker;
+  return &remote_proxy_broker;
+}
+
+IR::_TAO_PrimaryKeyDef_Remote_Proxy_Broker::_TAO_PrimaryKeyDef_Remote_Proxy_Broker (void)
+{
+}
+
+IR::_TAO_PrimaryKeyDef_Remote_Proxy_Broker::~_TAO_PrimaryKeyDef_Remote_Proxy_Broker (void)
+{
+}
+
+IR::_TAO_PrimaryKeyDef_Proxy_Impl&
+IR::_TAO_PrimaryKeyDef_Remote_Proxy_Broker::select_proxy (
+  ::IR::PrimaryKeyDef *,
+  CORBA::Environment &
+)
+{
+  return this->remote_proxy_impl_;
+}
+
+
+//
+//           End Remote & Base Proxy Broker Implementation
+///////////////////////////////////////////////////////////////////////
+
+
+// default constructor
+IR::PrimaryKeyDef::PrimaryKeyDef (int collocated)
+{
+  this->IR_PrimaryKeyDef_setup_collocation (collocated);
+}
+
+// destructor
+IR::PrimaryKeyDef::~PrimaryKeyDef (void)
+{}
+
+void
+IR::PrimaryKeyDef::IR_PrimaryKeyDef_setup_collocation (int collocated)
+{
+  if (collocated)
+    this->the_TAO_PrimaryKeyDef_Proxy_Broker_ =
+      ::IR__TAO_PrimaryKeyDef_Proxy_Broker_Factory_function_pointer (this);
+  else
+    this->the_TAO_PrimaryKeyDef_Proxy_Broker_ =
+      ::IR::_TAO_PrimaryKeyDef_Remote_Proxy_Broker::the_TAO_PrimaryKeyDef_Remote_Proxy_Broker ();
+  
+  this->CORBA_Contained_setup_collocation (collocated);
+}
+
+void IR::PrimaryKeyDef::_tao_any_destructor (void *x)
+{
+  PrimaryKeyDef *tmp = ACE_static_cast (PrimaryKeyDef*,x);
+  CORBA::release (tmp);
+}
+
+IR::PrimaryKeyDef_ptr IR::PrimaryKeyDef::_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+{
+  if (CORBA::is_nil (obj))
+    return PrimaryKeyDef::_nil ();
+  if (! obj->_is_local ())
+    {
+      CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/IR/PrimaryKeyDef:1.0", ACE_TRY_ENV);
+      ACE_CHECK_RETURN (PrimaryKeyDef::_nil ());
+      if (is_a == 0)
+        return PrimaryKeyDef::_nil ();
+    }
+  return PrimaryKeyDef::_unchecked_narrow (obj, ACE_TRY_ENV);
+}
+
+IR::PrimaryKeyDef_ptr IR::PrimaryKeyDef::_unchecked_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &
+  )
+{
+  if (CORBA::is_nil (obj))
+    return PrimaryKeyDef::_nil ();
+  if (! obj->_is_local ())
+    {
+      TAO_Stub* stub = obj->_stubobj ();
+      if (stub)
+        stub->_incr_refcnt ();
+      PrimaryKeyDef_ptr default_proxy = PrimaryKeyDef::_nil ();
+
+      if (
+          !CORBA::is_nil (stub->servant_orb_var ().ptr ()) &&
+          stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects () &&
+          obj->_is_collocated () &&IR__TAO_PrimaryKeyDef_Proxy_Broker_Factory_function_pointer != 0
+        )
+      {
+        ACE_NEW_RETURN (
+          default_proxy,
+          ::IR::PrimaryKeyDef (
+            stub,
+            1,
+            obj->_servant ()),
+            
+          PrimaryKeyDef::_nil ());
+        }
+      if (CORBA::is_nil (default_proxy))
+        ACE_NEW_RETURN (default_proxy, ::IR::PrimaryKeyDef (stub, 0, obj->_servant ()), PrimaryKeyDef::_nil ());
+        return default_proxy;
+      }
+    else 
+      return
+        ACE_reinterpret_cast
+          (
+            PrimaryKeyDef_ptr,
+              obj->_tao_QueryInterface
+                (
+                  ACE_reinterpret_cast
+                    (
+                      ptr_arith_t,
+                      &PrimaryKeyDef::_narrow
+                    )
+                )
+          );
+}
+
+IR::PrimaryKeyDef_ptr
+IR::PrimaryKeyDef::_duplicate (PrimaryKeyDef_ptr obj)
+{
+  if (!CORBA::is_nil (obj))
+    obj->_add_ref ();
+  return obj;
+}
+
+CORBA::Boolean IR::PrimaryKeyDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
+{
+  if (
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/PrimaryKeyDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Contained:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
+  return 1; // success using local knowledge
+  else
+    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
+}
+
+void *IR::PrimaryKeyDef::_tao_QueryInterface (ptr_arith_t type)
+{
+  void *retv = 0;
+  if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &ACE_NESTED_CLASS (::IR, PrimaryKeyDef)::_narrow))
+    retv = ACE_reinterpret_cast (void*, this);
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::Contained::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::Contained_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::IRObject::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::IRObject_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
+    retv = ACE_reinterpret_cast (void *,
+      ACE_static_cast (CORBA::Object_ptr, this));
+    
+  if (retv)
+    this->_add_ref ();
+  return retv;
+}
+
+const char* IR::PrimaryKeyDef::_interface_repository_id (void) const
+{
+  return "IDL:omg.org/IR/PrimaryKeyDef:1.0";
+}
+
+CORBA::Boolean IR::PrimaryKeyDef::is_a (
+    const char * primary_key_id,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_PrimaryKeyDef_Proxy_Impl &proxy = 
+    this->the_TAO_PrimaryKeyDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.is_a (
+      this,
+      primary_key_id,
+      ACE_TRY_ENV
+    );
+}
+
+CORBA::ValueDef_ptr IR::PrimaryKeyDef::primary_key (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_PrimaryKeyDef_Proxy_Impl &proxy = 
+    this->the_TAO_PrimaryKeyDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.primary_key (
+      this,
+      ACE_TRY_ENV
+    );
+}
+
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+IR::PrimaryKeyDef::TAO_ClientRequestInfo_IR_PrimaryKeyDef_is_a::TAO_ClientRequestInfo_IR_PrimaryKeyDef_is_a (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const char * primary_key_id,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
+    primary_key_id_ (primary_key_id)
+{}
+
+Dynamic::ParameterList *
+IR::PrimaryKeyDef::TAO_ClientRequestInfo_IR_PrimaryKeyDef_is_a::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
+    
+  CORBA::ULong length_primary_key_id = parameter_list->length ();
+  parameter_list->length (length_primary_key_id + 1);
+  (*parameter_list)[length_primary_key_id].argument <<= primary_key_id_;
+  (*parameter_list)[length_primary_key_id].mode = Dynamic::PARAM_IN;
+  
+  return safe_parameter_list._retn ();
+}
+
+Dynamic::ExceptionList *
+IR::PrimaryKeyDef::TAO_ClientRequestInfo_IR_PrimaryKeyDef_is_a::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+IR::PrimaryKeyDef::TAO_ClientRequestInfo_IR_PrimaryKeyDef_is_a::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= CORBA::Any::from_boolean (this->_result);
+  return safe_result_any._retn ();
+}
+
+void 
+IR::PrimaryKeyDef::TAO_ClientRequestInfo_IR_PrimaryKeyDef_is_a::result (CORBA::Boolean result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+IR::PrimaryKeyDef::TAO_ClientRequestInfo_IR_PrimaryKeyDef_primary_key_get::TAO_ClientRequestInfo_IR_PrimaryKeyDef_primary_key_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
+{}
+
+Dynamic::ParameterList *
+IR::PrimaryKeyDef::TAO_ClientRequestInfo_IR_PrimaryKeyDef_primary_key_get::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return parameter_list;
+}
+
+Dynamic::ExceptionList *
+IR::PrimaryKeyDef::TAO_ClientRequestInfo_IR_PrimaryKeyDef_primary_key_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+IR::PrimaryKeyDef::TAO_ClientRequestInfo_IR_PrimaryKeyDef_primary_key_get::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+IR::PrimaryKeyDef::TAO_ClientRequestInfo_IR_PrimaryKeyDef_primary_key_get::result (CORBA::ValueDef_ptr result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+#endif /* TAO_HAS_INTERCEPTORS */
+static const CORBA::Long _oc_IR_PrimaryKeyDef[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  33,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x49522f50), 
+  ACE_NTOHL (0x72696d61), 
+  ACE_NTOHL (0x72794b65), 
+  ACE_NTOHL (0x79446566), 
+  ACE_NTOHL (0x3a312e30), 
+  ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/PrimaryKeyDef:1.0
+  14,
+  ACE_NTOHL (0x5072696d), 
+  ACE_NTOHL (0x6172794b), 
+  ACE_NTOHL (0x65794465), 
+  ACE_NTOHL (0x66000000),  // name = PrimaryKeyDef
+};
+
+static CORBA::TypeCode _tc_TAO_tc_IR_PrimaryKeyDef (
+    CORBA::tk_objref,
+    sizeof (_oc_IR_PrimaryKeyDef),
+    (char *) &_oc_IR_PrimaryKeyDef,
+    0,
+    sizeof (IR::PrimaryKeyDef)
+  );
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_PrimaryKeyDef, &_tc_TAO_tc_IR_PrimaryKeyDef)
+TAO_NAMESPACE_END
+
+static const CORBA::Long _oc_IR_PrimaryKeyDescription[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  41,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x49522f50), 
+  ACE_NTOHL (0x72696d61), 
+  ACE_NTOHL (0x72794b65), 
+  ACE_NTOHL (0x79446573), 
+  ACE_NTOHL (0x63726970), 
+  ACE_NTOHL (0x74696f6e), 
+  ACE_NTOHL (0x3a312e30), 
+  ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/PrimaryKeyDescription:1.0
+  22,
+  ACE_NTOHL (0x5072696d), 
+  ACE_NTOHL (0x6172794b), 
+  ACE_NTOHL (0x65794465), 
+  ACE_NTOHL (0x73637269), 
+  ACE_NTOHL (0x7074696f), 
+  ACE_NTOHL (0x6e000000),  // name = PrimaryKeyDescription
+  5, // member count
+  5,
+  ACE_NTOHL (0x6e616d65), 
+  ACE_NTOHL (0x0),  // name = name
+  CORBA::tk_alias, // typecode kind for typedefs
+  64, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    30,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x49522f49), 
+    ACE_NTOHL (0x64656e74), 
+    ACE_NTOHL (0x69666965), 
+    ACE_NTOHL (0x723a312e), 
+    ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
+    11,
+    ACE_NTOHL (0x4964656e), 
+    ACE_NTOHL (0x74696669), 
+    ACE_NTOHL (0x65720000),  // name = Identifier
+    CORBA::tk_string, 
+    0U, // string length
+
+  3,
+  ACE_NTOHL (0x69640000),  // name = id
+  CORBA::tk_alias, // typecode kind for typedefs
+  68, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    32,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x49522f52), 
+    ACE_NTOHL (0x65706f73), 
+    ACE_NTOHL (0x69746f72), 
+    ACE_NTOHL (0x7949643a), 
+    ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
+    13,
+    ACE_NTOHL (0x5265706f), 
+    ACE_NTOHL (0x7369746f), 
+    ACE_NTOHL (0x72794964), 
+    ACE_NTOHL (0x0),  // name = RepositoryId
+    CORBA::tk_string, 
+    0U, // string length
+
+  11,
+  ACE_NTOHL (0x64656669), 
+  ACE_NTOHL (0x6e65645f), 
+  ACE_NTOHL (0x696e0000),  // name = defined_in
+  CORBA::tk_alias, // typecode kind for typedefs
+  68, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    32,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x49522f52), 
+    ACE_NTOHL (0x65706f73), 
+    ACE_NTOHL (0x69746f72), 
+    ACE_NTOHL (0x7949643a), 
+    ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
+    13,
+    ACE_NTOHL (0x5265706f), 
+    ACE_NTOHL (0x7369746f), 
+    ACE_NTOHL (0x72794964), 
+    ACE_NTOHL (0x0),  // name = RepositoryId
+    CORBA::tk_string, 
+    0U, // string length
+
+  8,
+  ACE_NTOHL (0x76657273), 
+  ACE_NTOHL (0x696f6e00),  // name = version
+  CORBA::tk_alias, // typecode kind for typedefs
+  64, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    31,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x49522f56), 
+    ACE_NTOHL (0x65727369), 
+    ACE_NTOHL (0x6f6e5370), 
+    ACE_NTOHL (0x65633a31), 
+    ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
+    12,
+    ACE_NTOHL (0x56657273), 
+    ACE_NTOHL (0x696f6e53), 
+    ACE_NTOHL (0x70656300),  // name = VersionSpec
+    CORBA::tk_string, 
+    0U, // string length
+
+  12,
+  ACE_NTOHL (0x7072696d), 
+  ACE_NTOHL (0x6172795f), 
+  ACE_NTOHL (0x6b657900),  // name = primary_key
+  CORBA::tk_objref, // typecode kind
+  56, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    31,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x434f5242), 
+    ACE_NTOHL (0x412f5661), 
+    ACE_NTOHL (0x6c756544), 
+    ACE_NTOHL (0x65663a31), 
+    ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/ValueDef:1.0
+    9,
+    ACE_NTOHL (0x56616c75), 
+    ACE_NTOHL (0x65446566), 
+    ACE_NTOHL (0x0),  // name = ValueDef
+
+};
+
+static CORBA::TypeCode _tc_TAO_tc_IR_PrimaryKeyDescription (
+    CORBA::tk_struct,
+    sizeof (_oc_IR_PrimaryKeyDescription),
+    (char *) &_oc_IR_PrimaryKeyDescription,
+    0,
+    sizeof (IR::PrimaryKeyDescription)
+  );
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_PrimaryKeyDescription, &_tc_TAO_tc_IR_PrimaryKeyDescription)
+TAO_NAMESPACE_END
+
+void IR::PrimaryKeyDescription::_tao_any_destructor (void *x)
+{
+  PrimaryKeyDescription *tmp = ACE_static_cast (PrimaryKeyDescription*,x);
+  delete tmp;
+}
+
+
+///////////////////////////////////////////////////////////////////////
+//                Base & Remote Proxy  Implementation. 
+//
+
+IR::_TAO_FactoryDef_Proxy_Impl::_TAO_FactoryDef_Proxy_Impl (void)
+{}
+
+IR::_TAO_FactoryDef_Remote_Proxy_Impl::_TAO_FactoryDef_Remote_Proxy_Impl (void)
+{}
+
+// Remote Implementation of the IDL interface methods
+
+
+//
+//            End  Base & Remote  Proxy Implemeentation. 
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//           Remote & Base  Proxy Broker Implementation
+//
+
+IR::_TAO_FactoryDef_Proxy_Broker::_TAO_FactoryDef_Proxy_Broker (void)
+{
+}
+
+IR::_TAO_FactoryDef_Proxy_Broker::~_TAO_FactoryDef_Proxy_Broker (void)
+{
+}
+
+IR::_TAO_FactoryDef_Proxy_Broker * (*IR__TAO_FactoryDef_Proxy_Broker_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  ) = 0;
+
+// Factory Member function Implementation.
+IR::_TAO_FactoryDef_Remote_Proxy_Broker *
+IR::_TAO_FactoryDef_Remote_Proxy_Broker::the_TAO_FactoryDef_Remote_Proxy_Broker (void)
+{
+  static ::IR::_TAO_FactoryDef_Remote_Proxy_Broker remote_proxy_broker;
+  return &remote_proxy_broker;
+}
+
+IR::_TAO_FactoryDef_Remote_Proxy_Broker::_TAO_FactoryDef_Remote_Proxy_Broker (void)
+{
+}
+
+IR::_TAO_FactoryDef_Remote_Proxy_Broker::~_TAO_FactoryDef_Remote_Proxy_Broker (void)
+{
+}
+
+IR::_TAO_FactoryDef_Proxy_Impl&
+IR::_TAO_FactoryDef_Remote_Proxy_Broker::select_proxy (
+  ::IR::FactoryDef *,
+  CORBA::Environment &
+)
+{
+  return this->remote_proxy_impl_;
+}
+
+
+//
+//           End Remote & Base Proxy Broker Implementation
+///////////////////////////////////////////////////////////////////////
+
+
+// default constructor
+IR::FactoryDef::FactoryDef (int collocated)
+{
+  this->IR_FactoryDef_setup_collocation (collocated);
+}
+
+// destructor
+IR::FactoryDef::~FactoryDef (void)
+{}
+
+void
+IR::FactoryDef::IR_FactoryDef_setup_collocation (int collocated)
+{
+  if (collocated)
+    this->the_TAO_FactoryDef_Proxy_Broker_ =
+      ::IR__TAO_FactoryDef_Proxy_Broker_Factory_function_pointer (this);
+  else
+    this->the_TAO_FactoryDef_Proxy_Broker_ =
+      ::IR::_TAO_FactoryDef_Remote_Proxy_Broker::the_TAO_FactoryDef_Remote_Proxy_Broker ();
+  
+  this->CORBA_OperationDef_setup_collocation (collocated);
+}
+
+void IR::FactoryDef::_tao_any_destructor (void *x)
+{
+  FactoryDef *tmp = ACE_static_cast (FactoryDef*,x);
+  CORBA::release (tmp);
+}
+
+IR::FactoryDef_ptr IR::FactoryDef::_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+{
+  if (CORBA::is_nil (obj))
+    return FactoryDef::_nil ();
+  if (! obj->_is_local ())
+    {
+      CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/IR/FactoryDef:1.0", ACE_TRY_ENV);
+      ACE_CHECK_RETURN (FactoryDef::_nil ());
+      if (is_a == 0)
+        return FactoryDef::_nil ();
+    }
+  return FactoryDef::_unchecked_narrow (obj, ACE_TRY_ENV);
+}
+
+IR::FactoryDef_ptr IR::FactoryDef::_unchecked_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &
+  )
+{
+  if (CORBA::is_nil (obj))
+    return FactoryDef::_nil ();
+  if (! obj->_is_local ())
+    {
+      TAO_Stub* stub = obj->_stubobj ();
+      if (stub)
+        stub->_incr_refcnt ();
+      FactoryDef_ptr default_proxy = FactoryDef::_nil ();
+
+      if (
+          !CORBA::is_nil (stub->servant_orb_var ().ptr ()) &&
+          stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects () &&
+          obj->_is_collocated () &&IR__TAO_FactoryDef_Proxy_Broker_Factory_function_pointer != 0
+        )
+      {
+        ACE_NEW_RETURN (
+          default_proxy,
+          ::IR::FactoryDef (
+            stub,
+            1,
+            obj->_servant ()),
+            
+          FactoryDef::_nil ());
+        }
+      if (CORBA::is_nil (default_proxy))
+        ACE_NEW_RETURN (default_proxy, ::IR::FactoryDef (stub, 0, obj->_servant ()), FactoryDef::_nil ());
+        return default_proxy;
+      }
+    else 
+      return
+        ACE_reinterpret_cast
+          (
+            FactoryDef_ptr,
+              obj->_tao_QueryInterface
+                (
+                  ACE_reinterpret_cast
+                    (
+                      ptr_arith_t,
+                      &FactoryDef::_narrow
+                    )
+                )
+          );
+}
+
+IR::FactoryDef_ptr
+IR::FactoryDef::_duplicate (FactoryDef_ptr obj)
+{
+  if (!CORBA::is_nil (obj))
+    obj->_add_ref ();
+  return obj;
+}
+
+CORBA::Boolean IR::FactoryDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
+{
+  if (
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/FactoryDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/OperationDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Contained:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
+  return 1; // success using local knowledge
+  else
+    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
+}
+
+void *IR::FactoryDef::_tao_QueryInterface (ptr_arith_t type)
+{
+  void *retv = 0;
+  if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &ACE_NESTED_CLASS (::IR, FactoryDef)::_narrow))
+    retv = ACE_reinterpret_cast (void*, this);
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::OperationDef::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::OperationDef_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::Contained::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::Contained_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::IRObject::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::IRObject_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
+    retv = ACE_reinterpret_cast (void *,
+      ACE_static_cast (CORBA::Object_ptr, this));
+    
+  if (retv)
+    this->_add_ref ();
+  return retv;
+}
+
+const char* IR::FactoryDef::_interface_repository_id (void) const
+{
+  return "IDL:omg.org/IR/FactoryDef:1.0";
+}
+
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+#endif /* TAO_HAS_INTERCEPTORS */
+static const CORBA::Long _oc_IR_FactoryDef[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  30,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x49522f46), 
+  ACE_NTOHL (0x6163746f), 
+  ACE_NTOHL (0x72794465), 
+  ACE_NTOHL (0x663a312e), 
+  ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/FactoryDef:1.0
+  11,
+  ACE_NTOHL (0x46616374), 
+  ACE_NTOHL (0x6f727944), 
+  ACE_NTOHL (0x65660000),  // name = FactoryDef
+};
+
+static CORBA::TypeCode _tc_TAO_tc_IR_FactoryDef (
+    CORBA::tk_objref,
+    sizeof (_oc_IR_FactoryDef),
+    (char *) &_oc_IR_FactoryDef,
+    0,
+    sizeof (IR::FactoryDef)
+  );
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_FactoryDef, &_tc_TAO_tc_IR_FactoryDef)
+TAO_NAMESPACE_END
+
+
+///////////////////////////////////////////////////////////////////////
+//                Base & Remote Proxy  Implementation. 
+//
+
+IR::_TAO_FinderDef_Proxy_Impl::_TAO_FinderDef_Proxy_Impl (void)
+{}
+
+IR::_TAO_FinderDef_Remote_Proxy_Impl::_TAO_FinderDef_Remote_Proxy_Impl (void)
+{}
+
+// Remote Implementation of the IDL interface methods
+
+
+//
+//            End  Base & Remote  Proxy Implemeentation. 
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//           Remote & Base  Proxy Broker Implementation
+//
+
+IR::_TAO_FinderDef_Proxy_Broker::_TAO_FinderDef_Proxy_Broker (void)
+{
+}
+
+IR::_TAO_FinderDef_Proxy_Broker::~_TAO_FinderDef_Proxy_Broker (void)
+{
+}
+
+IR::_TAO_FinderDef_Proxy_Broker * (*IR__TAO_FinderDef_Proxy_Broker_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  ) = 0;
+
+// Factory Member function Implementation.
+IR::_TAO_FinderDef_Remote_Proxy_Broker *
+IR::_TAO_FinderDef_Remote_Proxy_Broker::the_TAO_FinderDef_Remote_Proxy_Broker (void)
+{
+  static ::IR::_TAO_FinderDef_Remote_Proxy_Broker remote_proxy_broker;
+  return &remote_proxy_broker;
+}
+
+IR::_TAO_FinderDef_Remote_Proxy_Broker::_TAO_FinderDef_Remote_Proxy_Broker (void)
+{
+}
+
+IR::_TAO_FinderDef_Remote_Proxy_Broker::~_TAO_FinderDef_Remote_Proxy_Broker (void)
+{
+}
+
+IR::_TAO_FinderDef_Proxy_Impl&
+IR::_TAO_FinderDef_Remote_Proxy_Broker::select_proxy (
+  ::IR::FinderDef *,
+  CORBA::Environment &
+)
+{
+  return this->remote_proxy_impl_;
+}
+
+
+//
+//           End Remote & Base Proxy Broker Implementation
+///////////////////////////////////////////////////////////////////////
+
+
+// default constructor
+IR::FinderDef::FinderDef (int collocated)
+{
+  this->IR_FinderDef_setup_collocation (collocated);
+}
+
+// destructor
+IR::FinderDef::~FinderDef (void)
+{}
+
+void
+IR::FinderDef::IR_FinderDef_setup_collocation (int collocated)
+{
+  if (collocated)
+    this->the_TAO_FinderDef_Proxy_Broker_ =
+      ::IR__TAO_FinderDef_Proxy_Broker_Factory_function_pointer (this);
+  else
+    this->the_TAO_FinderDef_Proxy_Broker_ =
+      ::IR::_TAO_FinderDef_Remote_Proxy_Broker::the_TAO_FinderDef_Remote_Proxy_Broker ();
+  
+  this->CORBA_OperationDef_setup_collocation (collocated);
+}
+
+void IR::FinderDef::_tao_any_destructor (void *x)
+{
+  FinderDef *tmp = ACE_static_cast (FinderDef*,x);
+  CORBA::release (tmp);
+}
+
+IR::FinderDef_ptr IR::FinderDef::_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+{
+  if (CORBA::is_nil (obj))
+    return FinderDef::_nil ();
+  if (! obj->_is_local ())
+    {
+      CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/IR/FinderDef:1.0", ACE_TRY_ENV);
+      ACE_CHECK_RETURN (FinderDef::_nil ());
+      if (is_a == 0)
+        return FinderDef::_nil ();
+    }
+  return FinderDef::_unchecked_narrow (obj, ACE_TRY_ENV);
+}
+
+IR::FinderDef_ptr IR::FinderDef::_unchecked_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &
+  )
+{
+  if (CORBA::is_nil (obj))
+    return FinderDef::_nil ();
+  if (! obj->_is_local ())
+    {
+      TAO_Stub* stub = obj->_stubobj ();
+      if (stub)
+        stub->_incr_refcnt ();
+      FinderDef_ptr default_proxy = FinderDef::_nil ();
+
+      if (
+          !CORBA::is_nil (stub->servant_orb_var ().ptr ()) &&
+          stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects () &&
+          obj->_is_collocated () &&IR__TAO_FinderDef_Proxy_Broker_Factory_function_pointer != 0
+        )
+      {
+        ACE_NEW_RETURN (
+          default_proxy,
+          ::IR::FinderDef (
+            stub,
+            1,
+            obj->_servant ()),
+            
+          FinderDef::_nil ());
+        }
+      if (CORBA::is_nil (default_proxy))
+        ACE_NEW_RETURN (default_proxy, ::IR::FinderDef (stub, 0, obj->_servant ()), FinderDef::_nil ());
+        return default_proxy;
+      }
+    else 
+      return
+        ACE_reinterpret_cast
+          (
+            FinderDef_ptr,
+              obj->_tao_QueryInterface
+                (
+                  ACE_reinterpret_cast
+                    (
+                      ptr_arith_t,
+                      &FinderDef::_narrow
+                    )
+                )
+          );
+}
+
+IR::FinderDef_ptr
+IR::FinderDef::_duplicate (FinderDef_ptr obj)
+{
+  if (!CORBA::is_nil (obj))
+    obj->_add_ref ();
+  return obj;
+}
+
+CORBA::Boolean IR::FinderDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
+{
+  if (
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/FinderDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/OperationDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Contained:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
+  return 1; // success using local knowledge
+  else
+    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
+}
+
+void *IR::FinderDef::_tao_QueryInterface (ptr_arith_t type)
+{
+  void *retv = 0;
+  if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &ACE_NESTED_CLASS (::IR, FinderDef)::_narrow))
+    retv = ACE_reinterpret_cast (void*, this);
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::OperationDef::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::OperationDef_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::Contained::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::Contained_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::IRObject::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::IRObject_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
+    retv = ACE_reinterpret_cast (void *,
+      ACE_static_cast (CORBA::Object_ptr, this));
+    
+  if (retv)
+    this->_add_ref ();
+  return retv;
+}
+
+const char* IR::FinderDef::_interface_repository_id (void) const
+{
+  return "IDL:omg.org/IR/FinderDef:1.0";
+}
+
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+#endif /* TAO_HAS_INTERCEPTORS */
+static const CORBA::Long _oc_IR_FinderDef[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  29,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x49522f46), 
+  ACE_NTOHL (0x696e6465), 
+  ACE_NTOHL (0x72446566), 
+  ACE_NTOHL (0x3a312e30), 
+  ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/FinderDef:1.0
+  10,
+  ACE_NTOHL (0x46696e64), 
+  ACE_NTOHL (0x65724465), 
+  ACE_NTOHL (0x66000000),  // name = FinderDef
+};
+
+static CORBA::TypeCode _tc_TAO_tc_IR_FinderDef (
+    CORBA::tk_objref,
+    sizeof (_oc_IR_FinderDef),
+    (char *) &_oc_IR_FinderDef,
+    0,
+    sizeof (IR::FinderDef)
+  );
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_FinderDef, &_tc_TAO_tc_IR_FinderDef)
+TAO_NAMESPACE_END
+
+
+///////////////////////////////////////////////////////////////////////
+//                Base & Remote Proxy  Implementation. 
+//
+
+IR::_TAO_HomeDef_Proxy_Impl::_TAO_HomeDef_Proxy_Impl (void)
+{}
+
+IR::_TAO_HomeDef_Remote_Proxy_Impl::_TAO_HomeDef_Remote_Proxy_Impl (void)
+{}
+
+// Remote Implementation of the IDL interface methods
+
+IR::HomeDef_ptr IR::_TAO_HomeDef_Remote_Proxy_Impl::base_home (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  IR::HomeDef_ptr _tao_retval = IR::HomeDef::_nil ();
+  IR::HomeDef_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_base_home",
+      14,
+      0,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      IR::HomeDef::TAO_ClientRequestInfo_IR_HomeDef_base_home_get ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              IR::HomeDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+IR::ComponentDef_ptr IR::_TAO_HomeDef_Remote_Proxy_Impl::managed_component (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  IR::ComponentDef_ptr _tao_retval = IR::ComponentDef::_nil ();
+  IR::ComponentDef_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_managed_component",
+      22,
+      0,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      IR::HomeDef::TAO_ClientRequestInfo_IR_HomeDef_managed_component_get ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              IR::ComponentDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+IR::PrimaryKeyDef_ptr IR::_TAO_HomeDef_Remote_Proxy_Impl::primary_key (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  IR::PrimaryKeyDef_ptr _tao_retval = IR::PrimaryKeyDef::_nil ();
+  IR::PrimaryKeyDef_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_primary_key",
+      16,
+      0,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      IR::HomeDef::TAO_ClientRequestInfo_IR_HomeDef_primary_key_get ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              IR::PrimaryKeyDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+IR::FactoryDefSeq * IR::_TAO_HomeDef_Remote_Proxy_Impl::factories (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  IR::FactoryDefSeq *_tao_retval = 0;
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  ACE_NEW_RETURN (_tao_retval, IR::FactoryDefSeq, _tao_retval);
+  IR::FactoryDefSeq_var _tao_safe_retval (_tao_retval);
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_factories",
+      14,
+      0,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      IR::HomeDef::TAO_ClientRequestInfo_IR_HomeDef_factories_get ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              IR::FactoryDefSeq * _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+IR::FinderDefSeq * IR::_TAO_HomeDef_Remote_Proxy_Impl::finders (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  IR::FinderDefSeq *_tao_retval = 0;
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  ACE_NEW_RETURN (_tao_retval, IR::FinderDefSeq, _tao_retval);
+  IR::FinderDefSeq_var _tao_safe_retval (_tao_retval);
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_finders",
+      12,
+      0,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      IR::HomeDef::TAO_ClientRequestInfo_IR_HomeDef_finders_get ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              IR::FinderDefSeq * _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+CORBA::Boolean IR::_TAO_HomeDef_Remote_Proxy_Impl::is_basic (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::Boolean _tao_retval = 0;
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), _tao_retval);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_is_basic",
+      13,
+      0,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      IR::HomeDef::TAO_ClientRequestInfo_IR_HomeDef_is_basic_get ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN  (_tao_retval);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                _tao_retval
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> CORBA::Any::to_boolean (_tao_retval))
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                _tao_retval
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::Boolean  _tao_retval_info = _tao_retval;
+               ri.result (_tao_retval_info);
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN  (_tao_retval);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_retval;
+}
+
+IR::PrimaryKeyDef_ptr IR::_TAO_HomeDef_Remote_Proxy_Impl::create_primary_key (
+    CORBA_Object *_collocated_tao_target_,
+    const char * id,
+    const char * name,
+    const char * version,
+    CORBA::ValueDef_ptr primary_key,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  IR::PrimaryKeyDef_ptr _tao_retval = IR::PrimaryKeyDef::_nil ();
+  IR::PrimaryKeyDef_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "create_primary_key",
+      18,
+      1,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      IR::HomeDef::TAO_ClientRequestInfo_IR_HomeDef_create_primary_key ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        id,
+        name,
+        version,
+        primary_key,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+          if (!(
+                            (_tao_out << id) &&
+              (_tao_out << name) &&
+              (_tao_out << version) &&
+              (_tao_out << primary_key)
+            ))
+            TAO_INTERCEPTOR_THROW_RETURN (
+              CORBA::MARSHAL (),
+              0
+            );
+            
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              IR::PrimaryKeyDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+IR::FactoryDef_ptr IR::_TAO_HomeDef_Remote_Proxy_Impl::create_factory (
+    CORBA_Object *_collocated_tao_target_,
+    const char * id,
+    const char * name,
+    const char * version,
+    const CORBA::ParDescriptionSeq & params,
+    const CORBA::ExceptionDefSeq & exceptions,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  IR::FactoryDef_ptr _tao_retval = IR::FactoryDef::_nil ();
+  IR::FactoryDef_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "create_factory",
+      14,
+      1,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      IR::HomeDef::TAO_ClientRequestInfo_IR_HomeDef_create_factory ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        id,
+        name,
+        version,
+        params,
+        exceptions,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+          if (!(
+                            (_tao_out << id) &&
+              (_tao_out << name) &&
+              (_tao_out << version) &&
+              (_tao_out << params) &&
+              (_tao_out << exceptions)
+            ))
+            TAO_INTERCEPTOR_THROW_RETURN (
+              CORBA::MARSHAL (),
+              0
+            );
+            
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              IR::FactoryDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+IR::FinderDef_ptr IR::_TAO_HomeDef_Remote_Proxy_Impl::create_finder (
+    CORBA_Object *_collocated_tao_target_,
+    const char * id,
+    const char * name,
+    const char * version,
+    const CORBA::ParDescriptionSeq & params,
+    const CORBA::ExceptionDefSeq & exceptions,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  IR::FinderDef_ptr _tao_retval = IR::FinderDef::_nil ();
+  IR::FinderDef_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "create_finder",
+      13,
+      1,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      IR::HomeDef::TAO_ClientRequestInfo_IR_HomeDef_create_finder ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        id,
+        name,
+        version,
+        params,
+        exceptions,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+          if (!(
+                            (_tao_out << id) &&
+              (_tao_out << name) &&
+              (_tao_out << version) &&
+              (_tao_out << params) &&
+              (_tao_out << exceptions)
+            ))
+            TAO_INTERCEPTOR_THROW_RETURN (
+              CORBA::MARSHAL (),
+              0
+            );
+            
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              IR::FinderDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+
+//
+//            End  Base & Remote  Proxy Implemeentation. 
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//           Remote & Base  Proxy Broker Implementation
+//
+
+IR::_TAO_HomeDef_Proxy_Broker::_TAO_HomeDef_Proxy_Broker (void)
+{
+}
+
+IR::_TAO_HomeDef_Proxy_Broker::~_TAO_HomeDef_Proxy_Broker (void)
+{
+}
+
+IR::_TAO_HomeDef_Proxy_Broker * (*IR__TAO_HomeDef_Proxy_Broker_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  ) = 0;
+
+// Factory Member function Implementation.
+IR::_TAO_HomeDef_Remote_Proxy_Broker *
+IR::_TAO_HomeDef_Remote_Proxy_Broker::the_TAO_HomeDef_Remote_Proxy_Broker (void)
+{
+  static ::IR::_TAO_HomeDef_Remote_Proxy_Broker remote_proxy_broker;
+  return &remote_proxy_broker;
+}
+
+IR::_TAO_HomeDef_Remote_Proxy_Broker::_TAO_HomeDef_Remote_Proxy_Broker (void)
+{
+}
+
+IR::_TAO_HomeDef_Remote_Proxy_Broker::~_TAO_HomeDef_Remote_Proxy_Broker (void)
+{
+}
+
+IR::_TAO_HomeDef_Proxy_Impl&
+IR::_TAO_HomeDef_Remote_Proxy_Broker::select_proxy (
+  ::IR::HomeDef *,
+  CORBA::Environment &
+)
+{
+  return this->remote_proxy_impl_;
+}
+
+
+//
+//           End Remote & Base Proxy Broker Implementation
+///////////////////////////////////////////////////////////////////////
+
+
+// default constructor
+IR::HomeDef::HomeDef (int collocated)
+{
+  this->IR_HomeDef_setup_collocation (collocated);
+}
+
+// destructor
+IR::HomeDef::~HomeDef (void)
+{}
+
+void
+IR::HomeDef::IR_HomeDef_setup_collocation (int collocated)
+{
+  if (collocated)
+    this->the_TAO_HomeDef_Proxy_Broker_ =
+      ::IR__TAO_HomeDef_Proxy_Broker_Factory_function_pointer (this);
+  else
+    this->the_TAO_HomeDef_Proxy_Broker_ =
+      ::IR::_TAO_HomeDef_Remote_Proxy_Broker::the_TAO_HomeDef_Remote_Proxy_Broker ();
+  
+  this->CORBA_InterfaceDef_setup_collocation (collocated);
+}
+
+void IR::HomeDef::_tao_any_destructor (void *x)
+{
+  HomeDef *tmp = ACE_static_cast (HomeDef*,x);
+  CORBA::release (tmp);
+}
+
+IR::HomeDef_ptr IR::HomeDef::_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+{
+  if (CORBA::is_nil (obj))
+    return HomeDef::_nil ();
+  if (! obj->_is_local ())
+    {
+      CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/IR/HomeDef:1.0", ACE_TRY_ENV);
+      ACE_CHECK_RETURN (HomeDef::_nil ());
+      if (is_a == 0)
+        return HomeDef::_nil ();
+    }
+  return HomeDef::_unchecked_narrow (obj, ACE_TRY_ENV);
+}
+
+IR::HomeDef_ptr IR::HomeDef::_unchecked_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &
+  )
+{
+  if (CORBA::is_nil (obj))
+    return HomeDef::_nil ();
+  if (! obj->_is_local ())
+    {
+      TAO_Stub* stub = obj->_stubobj ();
+      if (stub)
+        stub->_incr_refcnt ();
+      HomeDef_ptr default_proxy = HomeDef::_nil ();
+
+      if (
+          !CORBA::is_nil (stub->servant_orb_var ().ptr ()) &&
+          stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects () &&
+          obj->_is_collocated () &&IR__TAO_HomeDef_Proxy_Broker_Factory_function_pointer != 0
+        )
+      {
+        ACE_NEW_RETURN (
+          default_proxy,
+          ::IR::HomeDef (
+            stub,
+            1,
+            obj->_servant ()),
+            
+          HomeDef::_nil ());
+        }
+      if (CORBA::is_nil (default_proxy))
+        ACE_NEW_RETURN (default_proxy, ::IR::HomeDef (stub, 0, obj->_servant ()), HomeDef::_nil ());
+        return default_proxy;
+      }
+    else 
+      return
+        ACE_reinterpret_cast
+          (
+            HomeDef_ptr,
+              obj->_tao_QueryInterface
+                (
+                  ACE_reinterpret_cast
+                    (
+                      ptr_arith_t,
+                      &HomeDef::_narrow
+                    )
+                )
+          );
+}
+
+IR::HomeDef_ptr
+IR::HomeDef::_duplicate (HomeDef_ptr obj)
+{
+  if (!CORBA::is_nil (obj))
+    obj->_add_ref ();
+  return obj;
+}
+
+CORBA::Boolean IR::HomeDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
+{
+  if (
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/HomeDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/InterfaceDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Container:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Contained:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IDLType:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
+  return 1; // success using local knowledge
+  else
+    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
+}
+
+void *IR::HomeDef::_tao_QueryInterface (ptr_arith_t type)
+{
+  void *retv = 0;
+  if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &ACE_NESTED_CLASS (::IR, HomeDef)::_narrow))
+    retv = ACE_reinterpret_cast (void*, this);
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::InterfaceDef::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::InterfaceDef_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::Container::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::Container_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::Contained::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::Contained_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::IDLType::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::IDLType_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::IRObject::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::IRObject_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
+    retv = ACE_reinterpret_cast (void *,
+      ACE_static_cast (CORBA::Object_ptr, this));
+    
+  if (retv)
+    this->_add_ref ();
+  return retv;
+}
+
+const char* IR::HomeDef::_interface_repository_id (void) const
+{
+  return "IDL:omg.org/IR/HomeDef:1.0";
+}
+
+IR::HomeDef_ptr IR::HomeDef::base_home (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_HomeDef_Proxy_Impl &proxy = 
+    this->the_TAO_HomeDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.base_home (
+      this,
+      ACE_TRY_ENV
+    );
+}
+
+IR::ComponentDef_ptr IR::HomeDef::managed_component (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_HomeDef_Proxy_Impl &proxy = 
+    this->the_TAO_HomeDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.managed_component (
+      this,
+      ACE_TRY_ENV
+    );
+}
+
+IR::PrimaryKeyDef_ptr IR::HomeDef::primary_key (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_HomeDef_Proxy_Impl &proxy = 
+    this->the_TAO_HomeDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.primary_key (
+      this,
+      ACE_TRY_ENV
+    );
+}
+
+IR::FactoryDefSeq * IR::HomeDef::factories (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_HomeDef_Proxy_Impl &proxy = 
+    this->the_TAO_HomeDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.factories (
+      this,
+      ACE_TRY_ENV
+    );
+}
+
+IR::FinderDefSeq * IR::HomeDef::finders (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_HomeDef_Proxy_Impl &proxy = 
+    this->the_TAO_HomeDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.finders (
+      this,
+      ACE_TRY_ENV
+    );
+}
+
+CORBA::Boolean IR::HomeDef::is_basic (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_HomeDef_Proxy_Impl &proxy = 
+    this->the_TAO_HomeDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.is_basic (
+      this,
+      ACE_TRY_ENV
+    );
+}
+
+IR::PrimaryKeyDef_ptr IR::HomeDef::create_primary_key (
+    const char * id,
+    const char * name,
+    const char * version,
+    CORBA::ValueDef_ptr primary_key,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_HomeDef_Proxy_Impl &proxy = 
+    this->the_TAO_HomeDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.create_primary_key (
+      this,
+      id,
+      name,
+      version,
+      primary_key,
+      ACE_TRY_ENV
+    );
+}
+
+IR::FactoryDef_ptr IR::HomeDef::create_factory (
+    const char * id,
+    const char * name,
+    const char * version,
+    const CORBA::ParDescriptionSeq & params,
+    const CORBA::ExceptionDefSeq & exceptions,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_HomeDef_Proxy_Impl &proxy = 
+    this->the_TAO_HomeDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.create_factory (
+      this,
+      id,
+      name,
+      version,
+      params,
+      exceptions,
+      ACE_TRY_ENV
+    );
+}
+
+IR::FinderDef_ptr IR::HomeDef::create_finder (
+    const char * id,
+    const char * name,
+    const char * version,
+    const CORBA::ParDescriptionSeq & params,
+    const CORBA::ExceptionDefSeq & exceptions,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_HomeDef_Proxy_Impl &proxy = 
+    this->the_TAO_HomeDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.create_finder (
+      this,
+      id,
+      name,
+      version,
+      params,
+      exceptions,
+      ACE_TRY_ENV
+    );
+}
+
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+IR::HomeDef::TAO_ClientRequestInfo_IR_HomeDef_base_home_get::TAO_ClientRequestInfo_IR_HomeDef_base_home_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
+{}
+
+Dynamic::ParameterList *
+IR::HomeDef::TAO_ClientRequestInfo_IR_HomeDef_base_home_get::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return parameter_list;
+}
+
+Dynamic::ExceptionList *
+IR::HomeDef::TAO_ClientRequestInfo_IR_HomeDef_base_home_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+IR::HomeDef::TAO_ClientRequestInfo_IR_HomeDef_base_home_get::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+IR::HomeDef::TAO_ClientRequestInfo_IR_HomeDef_base_home_get::result (IR::HomeDef_ptr result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+IR::HomeDef::TAO_ClientRequestInfo_IR_HomeDef_managed_component_get::TAO_ClientRequestInfo_IR_HomeDef_managed_component_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
+{}
+
+Dynamic::ParameterList *
+IR::HomeDef::TAO_ClientRequestInfo_IR_HomeDef_managed_component_get::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return parameter_list;
+}
+
+Dynamic::ExceptionList *
+IR::HomeDef::TAO_ClientRequestInfo_IR_HomeDef_managed_component_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+IR::HomeDef::TAO_ClientRequestInfo_IR_HomeDef_managed_component_get::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+IR::HomeDef::TAO_ClientRequestInfo_IR_HomeDef_managed_component_get::result (IR::ComponentDef_ptr result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+IR::HomeDef::TAO_ClientRequestInfo_IR_HomeDef_primary_key_get::TAO_ClientRequestInfo_IR_HomeDef_primary_key_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
+{}
+
+Dynamic::ParameterList *
+IR::HomeDef::TAO_ClientRequestInfo_IR_HomeDef_primary_key_get::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return parameter_list;
+}
+
+Dynamic::ExceptionList *
+IR::HomeDef::TAO_ClientRequestInfo_IR_HomeDef_primary_key_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+IR::HomeDef::TAO_ClientRequestInfo_IR_HomeDef_primary_key_get::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+IR::HomeDef::TAO_ClientRequestInfo_IR_HomeDef_primary_key_get::result (IR::PrimaryKeyDef_ptr result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+IR::HomeDef::TAO_ClientRequestInfo_IR_HomeDef_factories_get::TAO_ClientRequestInfo_IR_HomeDef_factories_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
+{}
+
+Dynamic::ParameterList *
+IR::HomeDef::TAO_ClientRequestInfo_IR_HomeDef_factories_get::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return parameter_list;
+}
+
+Dynamic::ExceptionList *
+IR::HomeDef::TAO_ClientRequestInfo_IR_HomeDef_factories_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+IR::HomeDef::TAO_ClientRequestInfo_IR_HomeDef_factories_get::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+IR::HomeDef::TAO_ClientRequestInfo_IR_HomeDef_factories_get::result (IR::FactoryDefSeq * result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+IR::HomeDef::TAO_ClientRequestInfo_IR_HomeDef_finders_get::TAO_ClientRequestInfo_IR_HomeDef_finders_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
+{}
+
+Dynamic::ParameterList *
+IR::HomeDef::TAO_ClientRequestInfo_IR_HomeDef_finders_get::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return parameter_list;
+}
+
+Dynamic::ExceptionList *
+IR::HomeDef::TAO_ClientRequestInfo_IR_HomeDef_finders_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+IR::HomeDef::TAO_ClientRequestInfo_IR_HomeDef_finders_get::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+IR::HomeDef::TAO_ClientRequestInfo_IR_HomeDef_finders_get::result (IR::FinderDefSeq * result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+IR::HomeDef::TAO_ClientRequestInfo_IR_HomeDef_is_basic_get::TAO_ClientRequestInfo_IR_HomeDef_is_basic_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
+{}
+
+Dynamic::ParameterList *
+IR::HomeDef::TAO_ClientRequestInfo_IR_HomeDef_is_basic_get::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return parameter_list;
+}
+
+Dynamic::ExceptionList *
+IR::HomeDef::TAO_ClientRequestInfo_IR_HomeDef_is_basic_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+IR::HomeDef::TAO_ClientRequestInfo_IR_HomeDef_is_basic_get::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= CORBA::Any::from_boolean (this->_result);
+  return safe_result_any._retn ();
+}
+
+void 
+IR::HomeDef::TAO_ClientRequestInfo_IR_HomeDef_is_basic_get::result (CORBA::Boolean result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+IR::HomeDef::TAO_ClientRequestInfo_IR_HomeDef_create_primary_key::TAO_ClientRequestInfo_IR_HomeDef_create_primary_key (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const char * id,
+    const char * name,
+    const char * version,
+    CORBA::ValueDef_ptr primary_key,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
+    id_ (id),
+    name_ (name),
+    version_ (version),
+    primary_key_ (primary_key)
+{}
+
+Dynamic::ParameterList *
+IR::HomeDef::TAO_ClientRequestInfo_IR_HomeDef_create_primary_key::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
+    
+  CORBA::ULong length_id = parameter_list->length ();
+  parameter_list->length (length_id + 1);
+  (*parameter_list)[length_id].argument <<= id_;
+  (*parameter_list)[length_id].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_name = parameter_list->length ();
+  parameter_list->length (length_name + 1);
+  (*parameter_list)[length_name].argument <<= name_;
+  (*parameter_list)[length_name].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_version = parameter_list->length ();
+  parameter_list->length (length_version + 1);
+  (*parameter_list)[length_version].argument <<= version_;
+  (*parameter_list)[length_version].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_primary_key = parameter_list->length ();
+  parameter_list->length (length_primary_key + 1);
+  (*parameter_list)[length_primary_key].argument <<=  this->primary_key_;
+  
+  (*parameter_list)[length_primary_key].mode = Dynamic::PARAM_IN;
+  
+  return safe_parameter_list._retn ();
+}
+
+Dynamic::ExceptionList *
+IR::HomeDef::TAO_ClientRequestInfo_IR_HomeDef_create_primary_key::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+IR::HomeDef::TAO_ClientRequestInfo_IR_HomeDef_create_primary_key::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+IR::HomeDef::TAO_ClientRequestInfo_IR_HomeDef_create_primary_key::result (IR::PrimaryKeyDef_ptr result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+IR::HomeDef::TAO_ClientRequestInfo_IR_HomeDef_create_factory::TAO_ClientRequestInfo_IR_HomeDef_create_factory (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const char * id,
+    const char * name,
+    const char * version,
+    const CORBA::ParDescriptionSeq & params,
+    const CORBA::ExceptionDefSeq & exceptions,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
+    id_ (id),
+    name_ (name),
+    version_ (version),
+    params_ (params),
+    exceptions_ (exceptions)
+{}
+
+Dynamic::ParameterList *
+IR::HomeDef::TAO_ClientRequestInfo_IR_HomeDef_create_factory::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
+    
+  CORBA::ULong length_id = parameter_list->length ();
+  parameter_list->length (length_id + 1);
+  (*parameter_list)[length_id].argument <<= id_;
+  (*parameter_list)[length_id].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_name = parameter_list->length ();
+  parameter_list->length (length_name + 1);
+  (*parameter_list)[length_name].argument <<= name_;
+  (*parameter_list)[length_name].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_version = parameter_list->length ();
+  parameter_list->length (length_version + 1);
+  (*parameter_list)[length_version].argument <<= version_;
+  (*parameter_list)[length_version].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_params = parameter_list->length ();
+  parameter_list->length (length_params + 1);
+  (*parameter_list)[length_params].argument <<=  this->params_;
+  
+  (*parameter_list)[length_params].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_exceptions = parameter_list->length ();
+  parameter_list->length (length_exceptions + 1);
+  (*parameter_list)[length_exceptions].argument <<=  this->exceptions_;
+  
+  (*parameter_list)[length_exceptions].mode = Dynamic::PARAM_IN;
+  
+  return safe_parameter_list._retn ();
+}
+
+Dynamic::ExceptionList *
+IR::HomeDef::TAO_ClientRequestInfo_IR_HomeDef_create_factory::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+IR::HomeDef::TAO_ClientRequestInfo_IR_HomeDef_create_factory::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+IR::HomeDef::TAO_ClientRequestInfo_IR_HomeDef_create_factory::result (IR::FactoryDef_ptr result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+IR::HomeDef::TAO_ClientRequestInfo_IR_HomeDef_create_finder::TAO_ClientRequestInfo_IR_HomeDef_create_finder (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const char * id,
+    const char * name,
+    const char * version,
+    const CORBA::ParDescriptionSeq & params,
+    const CORBA::ExceptionDefSeq & exceptions,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
+    id_ (id),
+    name_ (name),
+    version_ (version),
+    params_ (params),
+    exceptions_ (exceptions)
+{}
+
+Dynamic::ParameterList *
+IR::HomeDef::TAO_ClientRequestInfo_IR_HomeDef_create_finder::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
+    
+  CORBA::ULong length_id = parameter_list->length ();
+  parameter_list->length (length_id + 1);
+  (*parameter_list)[length_id].argument <<= id_;
+  (*parameter_list)[length_id].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_name = parameter_list->length ();
+  parameter_list->length (length_name + 1);
+  (*parameter_list)[length_name].argument <<= name_;
+  (*parameter_list)[length_name].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_version = parameter_list->length ();
+  parameter_list->length (length_version + 1);
+  (*parameter_list)[length_version].argument <<= version_;
+  (*parameter_list)[length_version].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_params = parameter_list->length ();
+  parameter_list->length (length_params + 1);
+  (*parameter_list)[length_params].argument <<=  this->params_;
+  
+  (*parameter_list)[length_params].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_exceptions = parameter_list->length ();
+  parameter_list->length (length_exceptions + 1);
+  (*parameter_list)[length_exceptions].argument <<=  this->exceptions_;
+  
+  (*parameter_list)[length_exceptions].mode = Dynamic::PARAM_IN;
+  
+  return safe_parameter_list._retn ();
+}
+
+Dynamic::ExceptionList *
+IR::HomeDef::TAO_ClientRequestInfo_IR_HomeDef_create_finder::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+IR::HomeDef::TAO_ClientRequestInfo_IR_HomeDef_create_finder::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+IR::HomeDef::TAO_ClientRequestInfo_IR_HomeDef_create_finder::result (IR::FinderDef_ptr result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+#endif /* TAO_HAS_INTERCEPTORS */
+static const CORBA::Long _oc_IR_HomeDef[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  27,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x49522f48), 
+  ACE_NTOHL (0x6f6d6544), 
+  ACE_NTOHL (0x65663a31), 
+  ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/HomeDef:1.0
+  8,
+  ACE_NTOHL (0x486f6d65), 
+  ACE_NTOHL (0x44656600),  // name = HomeDef
+};
+
+static CORBA::TypeCode _tc_TAO_tc_IR_HomeDef (
+    CORBA::tk_objref,
+    sizeof (_oc_IR_HomeDef),
+    (char *) &_oc_IR_HomeDef,
+    0,
+    sizeof (IR::HomeDef)
+  );
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_HomeDef, &_tc_TAO_tc_IR_HomeDef)
+TAO_NAMESPACE_END
+
+static const CORBA::Long _oc_IR_HomeDescription[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  35,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x49522f48), 
+  ACE_NTOHL (0x6f6d6544), 
+  ACE_NTOHL (0x65736372), 
+  ACE_NTOHL (0x69707469), 
+  ACE_NTOHL (0x6f6e3a31), 
+  ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/HomeDescription:1.0
+  16,
+  ACE_NTOHL (0x486f6d65), 
+  ACE_NTOHL (0x44657363), 
+  ACE_NTOHL (0x72697074), 
+  ACE_NTOHL (0x696f6e00),  // name = HomeDescription
+  12, // member count
+  5,
+  ACE_NTOHL (0x6e616d65), 
+  ACE_NTOHL (0x0),  // name = name
+  CORBA::tk_alias, // typecode kind for typedefs
+  64, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    30,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x49522f49), 
+    ACE_NTOHL (0x64656e74), 
+    ACE_NTOHL (0x69666965), 
+    ACE_NTOHL (0x723a312e), 
+    ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
+    11,
+    ACE_NTOHL (0x4964656e), 
+    ACE_NTOHL (0x74696669), 
+    ACE_NTOHL (0x65720000),  // name = Identifier
+    CORBA::tk_string, 
+    0U, // string length
+
+  3,
+  ACE_NTOHL (0x69640000),  // name = id
+  CORBA::tk_alias, // typecode kind for typedefs
+  68, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    32,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x49522f52), 
+    ACE_NTOHL (0x65706f73), 
+    ACE_NTOHL (0x69746f72), 
+    ACE_NTOHL (0x7949643a), 
+    ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
+    13,
+    ACE_NTOHL (0x5265706f), 
+    ACE_NTOHL (0x7369746f), 
+    ACE_NTOHL (0x72794964), 
+    ACE_NTOHL (0x0),  // name = RepositoryId
+    CORBA::tk_string, 
+    0U, // string length
+
+  11,
+  ACE_NTOHL (0x64656669), 
+  ACE_NTOHL (0x6e65645f), 
+  ACE_NTOHL (0x696e0000),  // name = defined_in
+  CORBA::tk_alias, // typecode kind for typedefs
+  68, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    32,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x49522f52), 
+    ACE_NTOHL (0x65706f73), 
+    ACE_NTOHL (0x69746f72), 
+    ACE_NTOHL (0x7949643a), 
+    ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
+    13,
+    ACE_NTOHL (0x5265706f), 
+    ACE_NTOHL (0x7369746f), 
+    ACE_NTOHL (0x72794964), 
+    ACE_NTOHL (0x0),  // name = RepositoryId
+    CORBA::tk_string, 
+    0U, // string length
+
+  8,
+  ACE_NTOHL (0x76657273), 
+  ACE_NTOHL (0x696f6e00),  // name = version
+  CORBA::tk_alias, // typecode kind for typedefs
+  64, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    31,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x49522f56), 
+    ACE_NTOHL (0x65727369), 
+    ACE_NTOHL (0x6f6e5370), 
+    ACE_NTOHL (0x65633a31), 
+    ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
+    12,
+    ACE_NTOHL (0x56657273), 
+    ACE_NTOHL (0x696f6e53), 
+    ACE_NTOHL (0x70656300),  // name = VersionSpec
+    CORBA::tk_string, 
+    0U, // string length
+
+  10,
+  ACE_NTOHL (0x62617365), 
+  ACE_NTOHL (0x5f686f6d), 
+  ACE_NTOHL (0x65000000),  // name = base_home
+  CORBA::tk_alias, // typecode kind for typedefs
+  68, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    32,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x49522f52), 
+    ACE_NTOHL (0x65706f73), 
+    ACE_NTOHL (0x69746f72), 
+    ACE_NTOHL (0x7949643a), 
+    ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
+    13,
+    ACE_NTOHL (0x5265706f), 
+    ACE_NTOHL (0x7369746f), 
+    ACE_NTOHL (0x72794964), 
+    ACE_NTOHL (0x0),  // name = RepositoryId
+    CORBA::tk_string, 
+    0U, // string length
+
+  18,
+  ACE_NTOHL (0x6d616e61), 
+  ACE_NTOHL (0x6765645f), 
+  ACE_NTOHL (0x636f6d70), 
+  ACE_NTOHL (0x6f6e656e), 
+  ACE_NTOHL (0x74000000),  // name = managed_component
+  CORBA::tk_alias, // typecode kind for typedefs
+  68, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    32,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x49522f52), 
+    ACE_NTOHL (0x65706f73), 
+    ACE_NTOHL (0x69746f72), 
+    ACE_NTOHL (0x7949643a), 
+    ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
+    13,
+    ACE_NTOHL (0x5265706f), 
+    ACE_NTOHL (0x7369746f), 
+    ACE_NTOHL (0x72794964), 
+    ACE_NTOHL (0x0),  // name = RepositoryId
+    CORBA::tk_string, 
+    0U, // string length
+
+  16,
+  ACE_NTOHL (0x7072696d), 
+  ACE_NTOHL (0x6172795f), 
+  ACE_NTOHL (0x6b65795f), 
+  ACE_NTOHL (0x64656600),  // name = primary_key_def
+  CORBA::tk_objref, // typecode kind
+  64, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    33,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x49522f50), 
+    ACE_NTOHL (0x72696d61), 
+    ACE_NTOHL (0x72794b65), 
+    ACE_NTOHL (0x79446566), 
+    ACE_NTOHL (0x3a312e30), 
+    ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/PrimaryKeyDef:1.0
+    14,
+    ACE_NTOHL (0x5072696d), 
+    ACE_NTOHL (0x6172794b), 
+    ACE_NTOHL (0x65794465), 
+    ACE_NTOHL (0x66000000),  // name = PrimaryKeyDef
+
+  10,
+  ACE_NTOHL (0x66616374), 
+  ACE_NTOHL (0x6f726965), 
+  ACE_NTOHL (0x73000000),  // name = factories
+  CORBA::tk_alias, // typecode kind for typedefs
+  144, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    33,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x49522f46), 
+    ACE_NTOHL (0x6163746f), 
+    ACE_NTOHL (0x72794465), 
+    ACE_NTOHL (0x66536571), 
+    ACE_NTOHL (0x3a312e30), 
+    ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/FactoryDefSeq:1.0
+    14,
+    ACE_NTOHL (0x46616374), 
+    ACE_NTOHL (0x6f727944), 
+    ACE_NTOHL (0x65665365), 
+    ACE_NTOHL (0x71000000),  // name = FactoryDefSeq
+    CORBA::tk_sequence, // typecode kind
+    72, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      CORBA::tk_objref, // typecode kind
+      56, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        30,
+        ACE_NTOHL (0x49444c3a), 
+        ACE_NTOHL (0x6f6d672e), 
+        ACE_NTOHL (0x6f72672f), 
+        ACE_NTOHL (0x49522f46), 
+        ACE_NTOHL (0x6163746f), 
+        ACE_NTOHL (0x72794465), 
+        ACE_NTOHL (0x663a312e), 
+        ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/FactoryDef:1.0
+        11,
+        ACE_NTOHL (0x46616374), 
+        ACE_NTOHL (0x6f727944), 
+        ACE_NTOHL (0x65660000),  // name = FactoryDef
+
+      0U,
+
+
+  8,
+  ACE_NTOHL (0x66696e64), 
+  ACE_NTOHL (0x65727300),  // name = finders
+  CORBA::tk_alias, // typecode kind for typedefs
+  140, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    32,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x49522f46), 
+    ACE_NTOHL (0x696e6465), 
+    ACE_NTOHL (0x72446566), 
+    ACE_NTOHL (0x5365713a), 
+    ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/FinderDefSeq:1.0
+    13,
+    ACE_NTOHL (0x46696e64), 
+    ACE_NTOHL (0x65724465), 
+    ACE_NTOHL (0x66536571), 
+    ACE_NTOHL (0x0),  // name = FinderDefSeq
+    CORBA::tk_sequence, // typecode kind
+    72, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      CORBA::tk_objref, // typecode kind
+      56, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        29,
+        ACE_NTOHL (0x49444c3a), 
+        ACE_NTOHL (0x6f6d672e), 
+        ACE_NTOHL (0x6f72672f), 
+        ACE_NTOHL (0x49522f46), 
+        ACE_NTOHL (0x696e6465), 
+        ACE_NTOHL (0x72446566), 
+        ACE_NTOHL (0x3a312e30), 
+        ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/FinderDef:1.0
+        10,
+        ACE_NTOHL (0x46696e64), 
+        ACE_NTOHL (0x65724465), 
+        ACE_NTOHL (0x66000000),  // name = FinderDef
+
+      0U,
+
+
+  11,
+  ACE_NTOHL (0x6f706572), 
+  ACE_NTOHL (0x6174696f), 
+  ACE_NTOHL (0x6e730000),  // name = operations
+  CORBA::tk_alias, // typecode kind for typedefs
+  2036, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    39,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x434f5242), 
+    ACE_NTOHL (0x412f4f70), 
+    ACE_NTOHL (0x44657363), 
+    ACE_NTOHL (0x72697074), 
+    ACE_NTOHL (0x696f6e53), 
+    ACE_NTOHL (0x65713a31), 
+    ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/OpDescriptionSeq:1.0
+    17,
+    ACE_NTOHL (0x4f704465), 
+    ACE_NTOHL (0x73637269), 
+    ACE_NTOHL (0x7074696f), 
+    ACE_NTOHL (0x6e536571), 
+    ACE_NTOHL (0x0),  // name = OpDescriptionSeq
+    CORBA::tk_sequence, // typecode kind
+    1956, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      CORBA::tk_struct, // typecode kind
+      1940, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        43,
+        ACE_NTOHL (0x49444c3a), 
+        ACE_NTOHL (0x6f6d672e), 
+        ACE_NTOHL (0x6f72672f), 
+        ACE_NTOHL (0x434f5242), 
+        ACE_NTOHL (0x412f4f70), 
+        ACE_NTOHL (0x65726174), 
+        ACE_NTOHL (0x696f6e44), 
+        ACE_NTOHL (0x65736372), 
+        ACE_NTOHL (0x69707469), 
+        ACE_NTOHL (0x6f6e3a31), 
+        ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/OperationDescription:1.0
+        21,
+        ACE_NTOHL (0x4f706572), 
+        ACE_NTOHL (0x6174696f), 
+        ACE_NTOHL (0x6e446573), 
+        ACE_NTOHL (0x63726970), 
+        ACE_NTOHL (0x74696f6e), 
+        ACE_NTOHL (0x0),  // name = OperationDescription
+        9, // member count
+        5,
+        ACE_NTOHL (0x6e616d65), 
+        ACE_NTOHL (0x0),  // name = name
+        CORBA::tk_alias, // typecode kind for typedefs
+        68, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          33,
+          ACE_NTOHL (0x49444c3a), 
+          ACE_NTOHL (0x6f6d672e), 
+          ACE_NTOHL (0x6f72672f), 
+          ACE_NTOHL (0x434f5242), 
+          ACE_NTOHL (0x412f4964), 
+          ACE_NTOHL (0x656e7469), 
+          ACE_NTOHL (0x66696572), 
+          ACE_NTOHL (0x3a312e30), 
+          ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+          11,
+          ACE_NTOHL (0x4964656e), 
+          ACE_NTOHL (0x74696669), 
+          ACE_NTOHL (0x65720000),  // name = Identifier
+          CORBA::tk_string, 
+          0U, // string length
+
+        3,
+        ACE_NTOHL (0x69640000),  // name = id
+        CORBA::tk_alias, // typecode kind for typedefs
+        72, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          35,
+          ACE_NTOHL (0x49444c3a), 
+          ACE_NTOHL (0x6f6d672e), 
+          ACE_NTOHL (0x6f72672f), 
+          ACE_NTOHL (0x434f5242), 
+          ACE_NTOHL (0x412f5265), 
+          ACE_NTOHL (0x706f7369), 
+          ACE_NTOHL (0x746f7279), 
+          ACE_NTOHL (0x49643a31), 
+          ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+          13,
+          ACE_NTOHL (0x5265706f), 
+          ACE_NTOHL (0x7369746f), 
+          ACE_NTOHL (0x72794964), 
+          ACE_NTOHL (0x0),  // name = RepositoryId
+          CORBA::tk_string, 
+          0U, // string length
+
+        11,
+        ACE_NTOHL (0x64656669), 
+        ACE_NTOHL (0x6e65645f), 
+        ACE_NTOHL (0x696e0000),  // name = defined_in
+        CORBA::tk_alias, // typecode kind for typedefs
+        72, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          35,
+          ACE_NTOHL (0x49444c3a), 
+          ACE_NTOHL (0x6f6d672e), 
+          ACE_NTOHL (0x6f72672f), 
+          ACE_NTOHL (0x434f5242), 
+          ACE_NTOHL (0x412f5265), 
+          ACE_NTOHL (0x706f7369), 
+          ACE_NTOHL (0x746f7279), 
+          ACE_NTOHL (0x49643a31), 
+          ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+          13,
+          ACE_NTOHL (0x5265706f), 
+          ACE_NTOHL (0x7369746f), 
+          ACE_NTOHL (0x72794964), 
+          ACE_NTOHL (0x0),  // name = RepositoryId
+          CORBA::tk_string, 
+          0U, // string length
+
+        8,
+        ACE_NTOHL (0x76657273), 
+        ACE_NTOHL (0x696f6e00),  // name = version
+        CORBA::tk_alias, // typecode kind for typedefs
+        68, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          34,
+          ACE_NTOHL (0x49444c3a), 
+          ACE_NTOHL (0x6f6d672e), 
+          ACE_NTOHL (0x6f72672f), 
+          ACE_NTOHL (0x434f5242), 
+          ACE_NTOHL (0x412f5665), 
+          ACE_NTOHL (0x7273696f), 
+          ACE_NTOHL (0x6e537065), 
+          ACE_NTOHL (0x633a312e), 
+          ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/VersionSpec:1.0
+          12,
+          ACE_NTOHL (0x56657273), 
+          ACE_NTOHL (0x696f6e53), 
+          ACE_NTOHL (0x70656300),  // name = VersionSpec
+          CORBA::tk_string, 
+          0U, // string length
+
+        7,
+        ACE_NTOHL (0x72657375), 
+        ACE_NTOHL (0x6c740000),  // name = result
+        CORBA::tk_TypeCode,
+
+        5,
+        ACE_NTOHL (0x6d6f6465), 
+        ACE_NTOHL (0x0),  // name = mode
+        CORBA::tk_enum, // typecode kind
+        100, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          36,
+          ACE_NTOHL (0x49444c3a), 
+          ACE_NTOHL (0x6f6d672e), 
+          ACE_NTOHL (0x6f72672f), 
+          ACE_NTOHL (0x434f5242), 
+          ACE_NTOHL (0x412f4f70), 
+          ACE_NTOHL (0x65726174), 
+          ACE_NTOHL (0x696f6e4d), 
+          ACE_NTOHL (0x6f64653a), 
+          ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/OperationMode:1.0
+          14,
+          ACE_NTOHL (0x4f706572), 
+          ACE_NTOHL (0x6174696f), 
+          ACE_NTOHL (0x6e4d6f64), 
+          ACE_NTOHL (0x65000000),  // name = OperationMode
+          2, // member count
+          10,
+          ACE_NTOHL (0x4f505f4e), 
+          ACE_NTOHL (0x4f524d41), 
+          ACE_NTOHL (0x4c000000),  // name = OP_NORMAL
+          10,
+          ACE_NTOHL (0x4f505f4f), 
+          ACE_NTOHL (0x4e455741), 
+          ACE_NTOHL (0x59000000),  // name = OP_ONEWAY
+
+        9,
+        ACE_NTOHL (0x636f6e74), 
+        ACE_NTOHL (0x65787473), 
+        ACE_NTOHL (0x0),  // name = contexts
+        CORBA::tk_alias, // typecode kind for typedefs
+        236, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          35,
+          ACE_NTOHL (0x49444c3a), 
+          ACE_NTOHL (0x6f6d672e), 
+          ACE_NTOHL (0x6f72672f), 
+          ACE_NTOHL (0x434f5242), 
+          ACE_NTOHL (0x412f436f), 
+          ACE_NTOHL (0x6e746578), 
+          ACE_NTOHL (0x74496453), 
+          ACE_NTOHL (0x65713a31), 
+          ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/ContextIdSeq:1.0
+          13,
+          ACE_NTOHL (0x436f6e74), 
+          ACE_NTOHL (0x65787449), 
+          ACE_NTOHL (0x64536571), 
+          ACE_NTOHL (0x0),  // name = ContextIdSeq
+          CORBA::tk_sequence, // typecode kind
+          164, // encapsulation length
+            TAO_ENCAP_BYTE_ORDER, // byte order
+            CORBA::tk_alias, // typecode kind for typedefs
+            148, // encapsulation length
+              TAO_ENCAP_BYTE_ORDER, // byte order
+              40,
+              ACE_NTOHL (0x49444c3a), 
+              ACE_NTOHL (0x6f6d672e), 
+              ACE_NTOHL (0x6f72672f), 
+              ACE_NTOHL (0x434f5242), 
+              ACE_NTOHL (0x412f436f), 
+              ACE_NTOHL (0x6e746578), 
+              ACE_NTOHL (0x74496465), 
+              ACE_NTOHL (0x6e746966), 
+              ACE_NTOHL (0x6965723a), 
+              ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/ContextIdentifier:1.0
+              18,
+              ACE_NTOHL (0x436f6e74), 
+              ACE_NTOHL (0x65787449), 
+              ACE_NTOHL (0x64656e74), 
+              ACE_NTOHL (0x69666965), 
+              ACE_NTOHL (0x72000000),  // name = ContextIdentifier
+              CORBA::tk_alias, // typecode kind for typedefs
+              68, // encapsulation length
+                TAO_ENCAP_BYTE_ORDER, // byte order
+                33,
+                ACE_NTOHL (0x49444c3a), 
+                ACE_NTOHL (0x6f6d672e), 
+                ACE_NTOHL (0x6f72672f), 
+                ACE_NTOHL (0x434f5242), 
+                ACE_NTOHL (0x412f4964), 
+                ACE_NTOHL (0x656e7469), 
+                ACE_NTOHL (0x66696572), 
+                ACE_NTOHL (0x3a312e30), 
+                ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+                11,
+                ACE_NTOHL (0x4964656e), 
+                ACE_NTOHL (0x74696669), 
+                ACE_NTOHL (0x65720000),  // name = Identifier
+                CORBA::tk_string, 
+                0U, // string length
+
+
+            0U,
+
+
+        11,
+        ACE_NTOHL (0x70617261), 
+        ACE_NTOHL (0x6d657465), 
+        ACE_NTOHL (0x72730000),  // name = parameters
+        CORBA::tk_alias, // typecode kind for typedefs
+        496, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          40,
+          ACE_NTOHL (0x49444c3a), 
+          ACE_NTOHL (0x6f6d672e), 
+          ACE_NTOHL (0x6f72672f), 
+          ACE_NTOHL (0x434f5242), 
+          ACE_NTOHL (0x412f5061), 
+          ACE_NTOHL (0x72446573), 
+          ACE_NTOHL (0x63726970), 
+          ACE_NTOHL (0x74696f6e), 
+          ACE_NTOHL (0x5365713a), 
+          ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/ParDescriptionSeq:1.0
+          18,
+          ACE_NTOHL (0x50617244), 
+          ACE_NTOHL (0x65736372), 
+          ACE_NTOHL (0x69707469), 
+          ACE_NTOHL (0x6f6e5365), 
+          ACE_NTOHL (0x71000000),  // name = ParDescriptionSeq
+          CORBA::tk_sequence, // typecode kind
+          416, // encapsulation length
+            TAO_ENCAP_BYTE_ORDER, // byte order
+            CORBA::tk_struct, // typecode kind
+            400, // encapsulation length
+              TAO_ENCAP_BYTE_ORDER, // byte order
+              43,
+              ACE_NTOHL (0x49444c3a), 
+              ACE_NTOHL (0x6f6d672e), 
+              ACE_NTOHL (0x6f72672f), 
+              ACE_NTOHL (0x434f5242), 
+              ACE_NTOHL (0x412f5061), 
+              ACE_NTOHL (0x72616d65), 
+              ACE_NTOHL (0x74657244), 
+              ACE_NTOHL (0x65736372), 
+              ACE_NTOHL (0x69707469), 
+              ACE_NTOHL (0x6f6e3a31), 
+              ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/ParameterDescription:1.0
+              21,
+              ACE_NTOHL (0x50617261), 
+              ACE_NTOHL (0x6d657465), 
+              ACE_NTOHL (0x72446573), 
+              ACE_NTOHL (0x63726970), 
+              ACE_NTOHL (0x74696f6e), 
+              ACE_NTOHL (0x0),  // name = ParameterDescription
+              4, // member count
+              5,
+              ACE_NTOHL (0x6e616d65), 
+              ACE_NTOHL (0x0),  // name = name
+              CORBA::tk_alias, // typecode kind for typedefs
+              68, // encapsulation length
+                TAO_ENCAP_BYTE_ORDER, // byte order
+                33,
+                ACE_NTOHL (0x49444c3a), 
+                ACE_NTOHL (0x6f6d672e), 
+                ACE_NTOHL (0x6f72672f), 
+                ACE_NTOHL (0x434f5242), 
+                ACE_NTOHL (0x412f4964), 
+                ACE_NTOHL (0x656e7469), 
+                ACE_NTOHL (0x66696572), 
+                ACE_NTOHL (0x3a312e30), 
+                ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+                11,
+                ACE_NTOHL (0x4964656e), 
+                ACE_NTOHL (0x74696669), 
+                ACE_NTOHL (0x65720000),  // name = Identifier
+                CORBA::tk_string, 
+                0U, // string length
+
+              5,
+              ACE_NTOHL (0x74797065), 
+              ACE_NTOHL (0x0),  // name = type
+              CORBA::tk_TypeCode,
+
+              9,
+              ACE_NTOHL (0x74797065), 
+              ACE_NTOHL (0x5f646566), 
+              ACE_NTOHL (0x0),  // name = type_def
+              CORBA::tk_objref, // typecode kind
+              52, // encapsulation length
+                TAO_ENCAP_BYTE_ORDER, // byte order
+                30,
+                ACE_NTOHL (0x49444c3a), 
+                ACE_NTOHL (0x6f6d672e), 
+                ACE_NTOHL (0x6f72672f), 
+                ACE_NTOHL (0x434f5242), 
+                ACE_NTOHL (0x412f4944), 
+                ACE_NTOHL (0x4c547970), 
+                ACE_NTOHL (0x653a312e), 
+                ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/IDLType:1.0
+                8,
+                ACE_NTOHL (0x49444c54), 
+                ACE_NTOHL (0x79706500),  // name = IDLType
+
+              5,
+              ACE_NTOHL (0x6d6f6465), 
+              ACE_NTOHL (0x0),  // name = mode
+              CORBA::tk_enum, // typecode kind
+              116, // encapsulation length
+                TAO_ENCAP_BYTE_ORDER, // byte order
+                36,
+                ACE_NTOHL (0x49444c3a), 
+                ACE_NTOHL (0x6f6d672e), 
+                ACE_NTOHL (0x6f72672f), 
+                ACE_NTOHL (0x434f5242), 
+                ACE_NTOHL (0x412f5061), 
+                ACE_NTOHL (0x72616d65), 
+                ACE_NTOHL (0x7465724d), 
+                ACE_NTOHL (0x6f64653a), 
+                ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/ParameterMode:1.0
+                14,
+                ACE_NTOHL (0x50617261), 
+                ACE_NTOHL (0x6d657465), 
+                ACE_NTOHL (0x724d6f64), 
+                ACE_NTOHL (0x65000000),  // name = ParameterMode
+                3, // member count
+                9,
+                ACE_NTOHL (0x50415241), 
+                ACE_NTOHL (0x4d5f494e), 
+                ACE_NTOHL (0x0),  // name = PARAM_IN
+                10,
+                ACE_NTOHL (0x50415241), 
+                ACE_NTOHL (0x4d5f4f55), 
+                ACE_NTOHL (0x54000000),  // name = PARAM_OUT
+                12,
+                ACE_NTOHL (0x50415241), 
+                ACE_NTOHL (0x4d5f494e), 
+                ACE_NTOHL (0x4f555400),  // name = PARAM_INOUT
+
+
+            0U,
+
+
+        11,
+        ACE_NTOHL (0x65786365), 
+        ACE_NTOHL (0x7074696f), 
+        ACE_NTOHL (0x6e730000),  // name = exceptions
+        CORBA::tk_alias, // typecode kind for typedefs
+        556, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          40,
+          ACE_NTOHL (0x49444c3a), 
+          ACE_NTOHL (0x6f6d672e), 
+          ACE_NTOHL (0x6f72672f), 
+          ACE_NTOHL (0x434f5242), 
+          ACE_NTOHL (0x412f4578), 
+          ACE_NTOHL (0x63446573), 
+          ACE_NTOHL (0x63726970), 
+          ACE_NTOHL (0x74696f6e), 
+          ACE_NTOHL (0x5365713a), 
+          ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/ExcDescriptionSeq:1.0
+          18,
+          ACE_NTOHL (0x45786344), 
+          ACE_NTOHL (0x65736372), 
+          ACE_NTOHL (0x69707469), 
+          ACE_NTOHL (0x6f6e5365), 
+          ACE_NTOHL (0x71000000),  // name = ExcDescriptionSeq
+          CORBA::tk_sequence, // typecode kind
+          476, // encapsulation length
+            TAO_ENCAP_BYTE_ORDER, // byte order
+            CORBA::tk_struct, // typecode kind
+            460, // encapsulation length
+              TAO_ENCAP_BYTE_ORDER, // byte order
+              43,
+              ACE_NTOHL (0x49444c3a), 
+              ACE_NTOHL (0x6f6d672e), 
+              ACE_NTOHL (0x6f72672f), 
+              ACE_NTOHL (0x434f5242), 
+              ACE_NTOHL (0x412f4578), 
+              ACE_NTOHL (0x63657074), 
+              ACE_NTOHL (0x696f6e44), 
+              ACE_NTOHL (0x65736372), 
+              ACE_NTOHL (0x69707469), 
+              ACE_NTOHL (0x6f6e3a31), 
+              ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/ExceptionDescription:1.0
+              21,
+              ACE_NTOHL (0x45786365), 
+              ACE_NTOHL (0x7074696f), 
+              ACE_NTOHL (0x6e446573), 
+              ACE_NTOHL (0x63726970), 
+              ACE_NTOHL (0x74696f6e), 
+              ACE_NTOHL (0x0),  // name = ExceptionDescription
+              5, // member count
+              5,
+              ACE_NTOHL (0x6e616d65), 
+              ACE_NTOHL (0x0),  // name = name
+              CORBA::tk_alias, // typecode kind for typedefs
+              68, // encapsulation length
+                TAO_ENCAP_BYTE_ORDER, // byte order
+                33,
+                ACE_NTOHL (0x49444c3a), 
+                ACE_NTOHL (0x6f6d672e), 
+                ACE_NTOHL (0x6f72672f), 
+                ACE_NTOHL (0x434f5242), 
+                ACE_NTOHL (0x412f4964), 
+                ACE_NTOHL (0x656e7469), 
+                ACE_NTOHL (0x66696572), 
+                ACE_NTOHL (0x3a312e30), 
+                ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+                11,
+                ACE_NTOHL (0x4964656e), 
+                ACE_NTOHL (0x74696669), 
+                ACE_NTOHL (0x65720000),  // name = Identifier
+                CORBA::tk_string, 
+                0U, // string length
+
+              3,
+              ACE_NTOHL (0x69640000),  // name = id
+              CORBA::tk_alias, // typecode kind for typedefs
+              72, // encapsulation length
+                TAO_ENCAP_BYTE_ORDER, // byte order
+                35,
+                ACE_NTOHL (0x49444c3a), 
+                ACE_NTOHL (0x6f6d672e), 
+                ACE_NTOHL (0x6f72672f), 
+                ACE_NTOHL (0x434f5242), 
+                ACE_NTOHL (0x412f5265), 
+                ACE_NTOHL (0x706f7369), 
+                ACE_NTOHL (0x746f7279), 
+                ACE_NTOHL (0x49643a31), 
+                ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+                13,
+                ACE_NTOHL (0x5265706f), 
+                ACE_NTOHL (0x7369746f), 
+                ACE_NTOHL (0x72794964), 
+                ACE_NTOHL (0x0),  // name = RepositoryId
+                CORBA::tk_string, 
+                0U, // string length
+
+              11,
+              ACE_NTOHL (0x64656669), 
+              ACE_NTOHL (0x6e65645f), 
+              ACE_NTOHL (0x696e0000),  // name = defined_in
+              CORBA::tk_alias, // typecode kind for typedefs
+              72, // encapsulation length
+                TAO_ENCAP_BYTE_ORDER, // byte order
+                35,
+                ACE_NTOHL (0x49444c3a), 
+                ACE_NTOHL (0x6f6d672e), 
+                ACE_NTOHL (0x6f72672f), 
+                ACE_NTOHL (0x434f5242), 
+                ACE_NTOHL (0x412f5265), 
+                ACE_NTOHL (0x706f7369), 
+                ACE_NTOHL (0x746f7279), 
+                ACE_NTOHL (0x49643a31), 
+                ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+                13,
+                ACE_NTOHL (0x5265706f), 
+                ACE_NTOHL (0x7369746f), 
+                ACE_NTOHL (0x72794964), 
+                ACE_NTOHL (0x0),  // name = RepositoryId
+                CORBA::tk_string, 
+                0U, // string length
+
+              8,
+              ACE_NTOHL (0x76657273), 
+              ACE_NTOHL (0x696f6e00),  // name = version
+              CORBA::tk_alias, // typecode kind for typedefs
+              68, // encapsulation length
+                TAO_ENCAP_BYTE_ORDER, // byte order
+                34,
+                ACE_NTOHL (0x49444c3a), 
+                ACE_NTOHL (0x6f6d672e), 
+                ACE_NTOHL (0x6f72672f), 
+                ACE_NTOHL (0x434f5242), 
+                ACE_NTOHL (0x412f5665), 
+                ACE_NTOHL (0x7273696f), 
+                ACE_NTOHL (0x6e537065), 
+                ACE_NTOHL (0x633a312e), 
+                ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/VersionSpec:1.0
+                12,
+                ACE_NTOHL (0x56657273), 
+                ACE_NTOHL (0x696f6e53), 
+                ACE_NTOHL (0x70656300),  // name = VersionSpec
+                CORBA::tk_string, 
+                0U, // string length
+
+              5,
+              ACE_NTOHL (0x74797065), 
+              ACE_NTOHL (0x0),  // name = type
+              CORBA::tk_TypeCode,
+
+
+            0U,
+
+
+
+      0U,
+
+
+  11,
+  ACE_NTOHL (0x61747472), 
+  ACE_NTOHL (0x69627574), 
+  ACE_NTOHL (0x65730000),  // name = attributes
+  CORBA::tk_alias, // typecode kind for typedefs
+  684, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    41,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x434f5242), 
+    ACE_NTOHL (0x412f4174), 
+    ACE_NTOHL (0x74724465), 
+    ACE_NTOHL (0x73637269), 
+    ACE_NTOHL (0x7074696f), 
+    ACE_NTOHL (0x6e536571), 
+    ACE_NTOHL (0x3a312e30), 
+    ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/AttrDescriptionSeq:1.0
+    19,
+    ACE_NTOHL (0x41747472), 
+    ACE_NTOHL (0x44657363), 
+    ACE_NTOHL (0x72697074), 
+    ACE_NTOHL (0x696f6e53), 
+    ACE_NTOHL (0x65710000),  // name = AttrDescriptionSeq
+    CORBA::tk_sequence, // typecode kind
+    600, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      CORBA::tk_struct, // typecode kind
+      584, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        43,
+        ACE_NTOHL (0x49444c3a), 
+        ACE_NTOHL (0x6f6d672e), 
+        ACE_NTOHL (0x6f72672f), 
+        ACE_NTOHL (0x434f5242), 
+        ACE_NTOHL (0x412f4174), 
+        ACE_NTOHL (0x74726962), 
+        ACE_NTOHL (0x75746544), 
+        ACE_NTOHL (0x65736372), 
+        ACE_NTOHL (0x69707469), 
+        ACE_NTOHL (0x6f6e3a31), 
+        ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/AttributeDescription:1.0
+        21,
+        ACE_NTOHL (0x41747472), 
+        ACE_NTOHL (0x69627574), 
+        ACE_NTOHL (0x65446573), 
+        ACE_NTOHL (0x63726970), 
+        ACE_NTOHL (0x74696f6e), 
+        ACE_NTOHL (0x0),  // name = AttributeDescription
+        6, // member count
+        5,
+        ACE_NTOHL (0x6e616d65), 
+        ACE_NTOHL (0x0),  // name = name
+        CORBA::tk_alias, // typecode kind for typedefs
+        68, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          33,
+          ACE_NTOHL (0x49444c3a), 
+          ACE_NTOHL (0x6f6d672e), 
+          ACE_NTOHL (0x6f72672f), 
+          ACE_NTOHL (0x434f5242), 
+          ACE_NTOHL (0x412f4964), 
+          ACE_NTOHL (0x656e7469), 
+          ACE_NTOHL (0x66696572), 
+          ACE_NTOHL (0x3a312e30), 
+          ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+          11,
+          ACE_NTOHL (0x4964656e), 
+          ACE_NTOHL (0x74696669), 
+          ACE_NTOHL (0x65720000),  // name = Identifier
+          CORBA::tk_string, 
+          0U, // string length
+
+        3,
+        ACE_NTOHL (0x69640000),  // name = id
+        CORBA::tk_alias, // typecode kind for typedefs
+        72, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          35,
+          ACE_NTOHL (0x49444c3a), 
+          ACE_NTOHL (0x6f6d672e), 
+          ACE_NTOHL (0x6f72672f), 
+          ACE_NTOHL (0x434f5242), 
+          ACE_NTOHL (0x412f5265), 
+          ACE_NTOHL (0x706f7369), 
+          ACE_NTOHL (0x746f7279), 
+          ACE_NTOHL (0x49643a31), 
+          ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+          13,
+          ACE_NTOHL (0x5265706f), 
+          ACE_NTOHL (0x7369746f), 
+          ACE_NTOHL (0x72794964), 
+          ACE_NTOHL (0x0),  // name = RepositoryId
+          CORBA::tk_string, 
+          0U, // string length
+
+        11,
+        ACE_NTOHL (0x64656669), 
+        ACE_NTOHL (0x6e65645f), 
+        ACE_NTOHL (0x696e0000),  // name = defined_in
+        CORBA::tk_alias, // typecode kind for typedefs
+        72, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          35,
+          ACE_NTOHL (0x49444c3a), 
+          ACE_NTOHL (0x6f6d672e), 
+          ACE_NTOHL (0x6f72672f), 
+          ACE_NTOHL (0x434f5242), 
+          ACE_NTOHL (0x412f5265), 
+          ACE_NTOHL (0x706f7369), 
+          ACE_NTOHL (0x746f7279), 
+          ACE_NTOHL (0x49643a31), 
+          ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+          13,
+          ACE_NTOHL (0x5265706f), 
+          ACE_NTOHL (0x7369746f), 
+          ACE_NTOHL (0x72794964), 
+          ACE_NTOHL (0x0),  // name = RepositoryId
+          CORBA::tk_string, 
+          0U, // string length
+
+        8,
+        ACE_NTOHL (0x76657273), 
+        ACE_NTOHL (0x696f6e00),  // name = version
+        CORBA::tk_alias, // typecode kind for typedefs
+        68, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          34,
+          ACE_NTOHL (0x49444c3a), 
+          ACE_NTOHL (0x6f6d672e), 
+          ACE_NTOHL (0x6f72672f), 
+          ACE_NTOHL (0x434f5242), 
+          ACE_NTOHL (0x412f5665), 
+          ACE_NTOHL (0x7273696f), 
+          ACE_NTOHL (0x6e537065), 
+          ACE_NTOHL (0x633a312e), 
+          ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/VersionSpec:1.0
+          12,
+          ACE_NTOHL (0x56657273), 
+          ACE_NTOHL (0x696f6e53), 
+          ACE_NTOHL (0x70656300),  // name = VersionSpec
+          CORBA::tk_string, 
+          0U, // string length
+
+        5,
+        ACE_NTOHL (0x74797065), 
+        ACE_NTOHL (0x0),  // name = type
+        CORBA::tk_TypeCode,
+
+        5,
+        ACE_NTOHL (0x6d6f6465), 
+        ACE_NTOHL (0x0),  // name = mode
+        CORBA::tk_enum, // typecode kind
+        104, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          36,
+          ACE_NTOHL (0x49444c3a), 
+          ACE_NTOHL (0x6f6d672e), 
+          ACE_NTOHL (0x6f72672f), 
+          ACE_NTOHL (0x434f5242), 
+          ACE_NTOHL (0x412f4174), 
+          ACE_NTOHL (0x74726962), 
+          ACE_NTOHL (0x7574654d), 
+          ACE_NTOHL (0x6f64653a), 
+          ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/AttributeMode:1.0
+          14,
+          ACE_NTOHL (0x41747472), 
+          ACE_NTOHL (0x69627574), 
+          ACE_NTOHL (0x654d6f64), 
+          ACE_NTOHL (0x65000000),  // name = AttributeMode
+          2, // member count
+          12,
+          ACE_NTOHL (0x41545452), 
+          ACE_NTOHL (0x5f4e4f52), 
+          ACE_NTOHL (0x4d414c00),  // name = ATTR_NORMAL
+          14,
+          ACE_NTOHL (0x41545452), 
+          ACE_NTOHL (0x5f524541), 
+          ACE_NTOHL (0x444f4e4c), 
+          ACE_NTOHL (0x59000000),  // name = ATTR_READONLY
+
+
+      0U,
+
+
+  9,
+  ACE_NTOHL (0x69735f62), 
+  ACE_NTOHL (0x61736963), 
+  ACE_NTOHL (0x0),  // name = is_basic
+  CORBA::tk_boolean,
+
+};
+
+static CORBA::TypeCode _tc_TAO_tc_IR_HomeDescription (
+    CORBA::tk_struct,
+    sizeof (_oc_IR_HomeDescription),
+    (char *) &_oc_IR_HomeDescription,
+    0,
+    sizeof (IR::HomeDescription)
+  );
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_HomeDescription, &_tc_TAO_tc_IR_HomeDescription)
+TAO_NAMESPACE_END
+
+void IR::HomeDescription::_tao_any_destructor (void *x)
+{
+  HomeDescription *tmp = ACE_static_cast (HomeDescription*,x);
+  delete tmp;
+}
+
+void operator<<= (CORBA::Any &_tao_any, IR::DefinitionKind _tao_elem)
+{
+  TAO_OutputCDR stream;
+  stream << _tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_DefinitionKind,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin ()
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::DefinitionKind &_tao_elem)
+{
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (IR::_tc_DefinitionKind, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    TAO_InputCDR stream (
+        _tao_any._tao_get_cdr (),
+        _tao_any._tao_byte_order ()
+      );
+    if (stream >> _tao_elem)
+    {
+      return 1;
+    }
+  }
+  ACE_CATCHANY
+  {
+    return 0;
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+void operator<<= (
+    CORBA::Any &_tao_any,
+    const IR::RepositoryIdSeq &_tao_elem
+  ) // copying
+{
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        IR::_tc_RepositoryIdSeq,
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin ()
+      );
+  }
+}
+
+void operator<<= (CORBA::Any &_tao_any, IR::RepositoryIdSeq *_tao_elem) // non copying
+{
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_RepositoryIdSeq,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      IR::RepositoryIdSeq::_tao_any_destructor
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::RepositoryIdSeq *&_tao_elem)
+{
+  return _tao_any >>= ACE_const_cast(
+      const IR::RepositoryIdSeq*&,
+      _tao_elem
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR::RepositoryIdSeq *&_tao_elem)
+{
+  _tao_elem = 0;
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (IR::_tc_RepositoryIdSeq, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    if (_tao_any.any_owns_data ())
+    {
+      _tao_elem = ACE_static_cast(
+          const IR::RepositoryIdSeq*,
+          _tao_any.value ()
+        );
+      return 1;
+    }
+    else
+    {
+      IR::RepositoryIdSeq *tmp;
+      ACE_NEW_RETURN (tmp, IR::RepositoryIdSeq, 0);
+      TAO_InputCDR stream (
+          _tao_any._tao_get_cdr (),
+          _tao_any._tao_byte_order ()
+        );
+      if (stream >> *tmp)
+      {
+        ((CORBA::Any *)&_tao_any)->_tao_replace (
+            IR::_tc_RepositoryIdSeq,
+            1,
+            ACE_static_cast (void *, tmp),
+            IR::RepositoryIdSeq::_tao_any_destructor
+          );
+        _tao_elem = tmp;
+        return 1;
+      }
+      else
+      {
+        delete tmp;
+      }
+    }
+  }
+  ACE_CATCHANY
+  {
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+void operator<<= (
+    CORBA::Any &_tao_any,
+    const IR::ComponentDefSeq &_tao_elem
+  ) // copying
+{
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        IR::_tc_ComponentDefSeq,
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin ()
+      );
+  }
+}
+
+void operator<<= (CORBA::Any &_tao_any, IR::ComponentDefSeq *_tao_elem) // non copying
+{
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_ComponentDefSeq,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      IR::ComponentDefSeq::_tao_any_destructor
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::ComponentDefSeq *&_tao_elem)
+{
+  return _tao_any >>= ACE_const_cast(
+      const IR::ComponentDefSeq*&,
+      _tao_elem
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR::ComponentDefSeq *&_tao_elem)
+{
+  _tao_elem = 0;
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (IR::_tc_ComponentDefSeq, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    if (_tao_any.any_owns_data ())
+    {
+      _tao_elem = ACE_static_cast(
+          const IR::ComponentDefSeq*,
+          _tao_any.value ()
+        );
+      return 1;
+    }
+    else
+    {
+      IR::ComponentDefSeq *tmp;
+      ACE_NEW_RETURN (tmp, IR::ComponentDefSeq, 0);
+      TAO_InputCDR stream (
+          _tao_any._tao_get_cdr (),
+          _tao_any._tao_byte_order ()
+        );
+      if (stream >> *tmp)
+      {
+        ((CORBA::Any *)&_tao_any)->_tao_replace (
+            IR::_tc_ComponentDefSeq,
+            1,
+            ACE_static_cast (void *, tmp),
+            IR::ComponentDefSeq::_tao_any_destructor
+          );
+        _tao_elem = tmp;
+        return 1;
+      }
+      else
+      {
+        delete tmp;
+      }
+    }
+  }
+  ACE_CATCHANY
+  {
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+void operator<<= (
+    CORBA::Any &_tao_any,
+    const IR::ProvidesDefSeq &_tao_elem
+  ) // copying
+{
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        IR::_tc_ProvidesDefSeq,
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin ()
+      );
+  }
+}
+
+void operator<<= (CORBA::Any &_tao_any, IR::ProvidesDefSeq *_tao_elem) // non copying
+{
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_ProvidesDefSeq,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      IR::ProvidesDefSeq::_tao_any_destructor
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::ProvidesDefSeq *&_tao_elem)
+{
+  return _tao_any >>= ACE_const_cast(
+      const IR::ProvidesDefSeq*&,
+      _tao_elem
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR::ProvidesDefSeq *&_tao_elem)
+{
+  _tao_elem = 0;
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (IR::_tc_ProvidesDefSeq, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    if (_tao_any.any_owns_data ())
+    {
+      _tao_elem = ACE_static_cast(
+          const IR::ProvidesDefSeq*,
+          _tao_any.value ()
+        );
+      return 1;
+    }
+    else
+    {
+      IR::ProvidesDefSeq *tmp;
+      ACE_NEW_RETURN (tmp, IR::ProvidesDefSeq, 0);
+      TAO_InputCDR stream (
+          _tao_any._tao_get_cdr (),
+          _tao_any._tao_byte_order ()
+        );
+      if (stream >> *tmp)
+      {
+        ((CORBA::Any *)&_tao_any)->_tao_replace (
+            IR::_tc_ProvidesDefSeq,
+            1,
+            ACE_static_cast (void *, tmp),
+            IR::ProvidesDefSeq::_tao_any_destructor
+          );
+        _tao_elem = tmp;
+        return 1;
+      }
+      else
+      {
+        delete tmp;
+      }
+    }
+  }
+  ACE_CATCHANY
+  {
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+void operator<<= (
+    CORBA::Any &_tao_any,
+    const IR::UsesDefSeq &_tao_elem
+  ) // copying
+{
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        IR::_tc_UsesDefSeq,
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin ()
+      );
+  }
+}
+
+void operator<<= (CORBA::Any &_tao_any, IR::UsesDefSeq *_tao_elem) // non copying
+{
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_UsesDefSeq,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      IR::UsesDefSeq::_tao_any_destructor
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::UsesDefSeq *&_tao_elem)
+{
+  return _tao_any >>= ACE_const_cast(
+      const IR::UsesDefSeq*&,
+      _tao_elem
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR::UsesDefSeq *&_tao_elem)
+{
+  _tao_elem = 0;
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (IR::_tc_UsesDefSeq, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    if (_tao_any.any_owns_data ())
+    {
+      _tao_elem = ACE_static_cast(
+          const IR::UsesDefSeq*,
+          _tao_any.value ()
+        );
+      return 1;
+    }
+    else
+    {
+      IR::UsesDefSeq *tmp;
+      ACE_NEW_RETURN (tmp, IR::UsesDefSeq, 0);
+      TAO_InputCDR stream (
+          _tao_any._tao_get_cdr (),
+          _tao_any._tao_byte_order ()
+        );
+      if (stream >> *tmp)
+      {
+        ((CORBA::Any *)&_tao_any)->_tao_replace (
+            IR::_tc_UsesDefSeq,
+            1,
+            ACE_static_cast (void *, tmp),
+            IR::UsesDefSeq::_tao_any_destructor
+          );
+        _tao_elem = tmp;
+        return 1;
+      }
+      else
+      {
+        delete tmp;
+      }
+    }
+  }
+  ACE_CATCHANY
+  {
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+void operator<<= (
+    CORBA::Any &_tao_any,
+    const IR::HomeDefSeq &_tao_elem
+  ) // copying
+{
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        IR::_tc_HomeDefSeq,
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin ()
+      );
+  }
+}
+
+void operator<<= (CORBA::Any &_tao_any, IR::HomeDefSeq *_tao_elem) // non copying
+{
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_HomeDefSeq,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      IR::HomeDefSeq::_tao_any_destructor
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::HomeDefSeq *&_tao_elem)
+{
+  return _tao_any >>= ACE_const_cast(
+      const IR::HomeDefSeq*&,
+      _tao_elem
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR::HomeDefSeq *&_tao_elem)
+{
+  _tao_elem = 0;
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (IR::_tc_HomeDefSeq, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    if (_tao_any.any_owns_data ())
+    {
+      _tao_elem = ACE_static_cast(
+          const IR::HomeDefSeq*,
+          _tao_any.value ()
+        );
+      return 1;
+    }
+    else
+    {
+      IR::HomeDefSeq *tmp;
+      ACE_NEW_RETURN (tmp, IR::HomeDefSeq, 0);
+      TAO_InputCDR stream (
+          _tao_any._tao_get_cdr (),
+          _tao_any._tao_byte_order ()
+        );
+      if (stream >> *tmp)
+      {
+        ((CORBA::Any *)&_tao_any)->_tao_replace (
+            IR::_tc_HomeDefSeq,
+            1,
+            ACE_static_cast (void *, tmp),
+            IR::HomeDefSeq::_tao_any_destructor
+          );
+        _tao_elem = tmp;
+        return 1;
+      }
+      else
+      {
+        delete tmp;
+      }
+    }
+  }
+  ACE_CATCHANY
+  {
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+void operator<<= (
+    CORBA::Any &_tao_any,
+    const IR::EmitsDefSeq &_tao_elem
+  ) // copying
+{
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        IR::_tc_EmitsDefSeq,
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin ()
+      );
+  }
+}
+
+void operator<<= (CORBA::Any &_tao_any, IR::EmitsDefSeq *_tao_elem) // non copying
+{
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_EmitsDefSeq,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      IR::EmitsDefSeq::_tao_any_destructor
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::EmitsDefSeq *&_tao_elem)
+{
+  return _tao_any >>= ACE_const_cast(
+      const IR::EmitsDefSeq*&,
+      _tao_elem
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR::EmitsDefSeq *&_tao_elem)
+{
+  _tao_elem = 0;
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (IR::_tc_EmitsDefSeq, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    if (_tao_any.any_owns_data ())
+    {
+      _tao_elem = ACE_static_cast(
+          const IR::EmitsDefSeq*,
+          _tao_any.value ()
+        );
+      return 1;
+    }
+    else
+    {
+      IR::EmitsDefSeq *tmp;
+      ACE_NEW_RETURN (tmp, IR::EmitsDefSeq, 0);
+      TAO_InputCDR stream (
+          _tao_any._tao_get_cdr (),
+          _tao_any._tao_byte_order ()
+        );
+      if (stream >> *tmp)
+      {
+        ((CORBA::Any *)&_tao_any)->_tao_replace (
+            IR::_tc_EmitsDefSeq,
+            1,
+            ACE_static_cast (void *, tmp),
+            IR::EmitsDefSeq::_tao_any_destructor
+          );
+        _tao_elem = tmp;
+        return 1;
+      }
+      else
+      {
+        delete tmp;
+      }
+    }
+  }
+  ACE_CATCHANY
+  {
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+void operator<<= (
+    CORBA::Any &_tao_any,
+    const IR::PublishesDefSeq &_tao_elem
+  ) // copying
+{
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        IR::_tc_PublishesDefSeq,
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin ()
+      );
+  }
+}
+
+void operator<<= (CORBA::Any &_tao_any, IR::PublishesDefSeq *_tao_elem) // non copying
+{
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_PublishesDefSeq,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      IR::PublishesDefSeq::_tao_any_destructor
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::PublishesDefSeq *&_tao_elem)
+{
+  return _tao_any >>= ACE_const_cast(
+      const IR::PublishesDefSeq*&,
+      _tao_elem
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR::PublishesDefSeq *&_tao_elem)
+{
+  _tao_elem = 0;
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (IR::_tc_PublishesDefSeq, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    if (_tao_any.any_owns_data ())
+    {
+      _tao_elem = ACE_static_cast(
+          const IR::PublishesDefSeq*,
+          _tao_any.value ()
+        );
+      return 1;
+    }
+    else
+    {
+      IR::PublishesDefSeq *tmp;
+      ACE_NEW_RETURN (tmp, IR::PublishesDefSeq, 0);
+      TAO_InputCDR stream (
+          _tao_any._tao_get_cdr (),
+          _tao_any._tao_byte_order ()
+        );
+      if (stream >> *tmp)
+      {
+        ((CORBA::Any *)&_tao_any)->_tao_replace (
+            IR::_tc_PublishesDefSeq,
+            1,
+            ACE_static_cast (void *, tmp),
+            IR::PublishesDefSeq::_tao_any_destructor
+          );
+        _tao_elem = tmp;
+        return 1;
+      }
+      else
+      {
+        delete tmp;
+      }
+    }
+  }
+  ACE_CATCHANY
+  {
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+void operator<<= (
+    CORBA::Any &_tao_any,
+    const IR::ConsumesDefSeq &_tao_elem
+  ) // copying
+{
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        IR::_tc_ConsumesDefSeq,
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin ()
+      );
+  }
+}
+
+void operator<<= (CORBA::Any &_tao_any, IR::ConsumesDefSeq *_tao_elem) // non copying
+{
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_ConsumesDefSeq,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      IR::ConsumesDefSeq::_tao_any_destructor
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::ConsumesDefSeq *&_tao_elem)
+{
+  return _tao_any >>= ACE_const_cast(
+      const IR::ConsumesDefSeq*&,
+      _tao_elem
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR::ConsumesDefSeq *&_tao_elem)
+{
+  _tao_elem = 0;
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (IR::_tc_ConsumesDefSeq, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    if (_tao_any.any_owns_data ())
+    {
+      _tao_elem = ACE_static_cast(
+          const IR::ConsumesDefSeq*,
+          _tao_any.value ()
+        );
+      return 1;
+    }
+    else
+    {
+      IR::ConsumesDefSeq *tmp;
+      ACE_NEW_RETURN (tmp, IR::ConsumesDefSeq, 0);
+      TAO_InputCDR stream (
+          _tao_any._tao_get_cdr (),
+          _tao_any._tao_byte_order ()
+        );
+      if (stream >> *tmp)
+      {
+        ((CORBA::Any *)&_tao_any)->_tao_replace (
+            IR::_tc_ConsumesDefSeq,
+            1,
+            ACE_static_cast (void *, tmp),
+            IR::ConsumesDefSeq::_tao_any_destructor
+          );
+        _tao_elem = tmp;
+        return 1;
+      }
+      else
+      {
+        delete tmp;
+      }
+    }
+  }
+  ACE_CATCHANY
+  {
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+void operator<<= (
+    CORBA::Any &_tao_any,
+    const IR::FactoryDefSeq &_tao_elem
+  ) // copying
+{
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        IR::_tc_FactoryDefSeq,
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin ()
+      );
+  }
+}
+
+void operator<<= (CORBA::Any &_tao_any, IR::FactoryDefSeq *_tao_elem) // non copying
+{
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_FactoryDefSeq,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      IR::FactoryDefSeq::_tao_any_destructor
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::FactoryDefSeq *&_tao_elem)
+{
+  return _tao_any >>= ACE_const_cast(
+      const IR::FactoryDefSeq*&,
+      _tao_elem
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR::FactoryDefSeq *&_tao_elem)
+{
+  _tao_elem = 0;
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (IR::_tc_FactoryDefSeq, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    if (_tao_any.any_owns_data ())
+    {
+      _tao_elem = ACE_static_cast(
+          const IR::FactoryDefSeq*,
+          _tao_any.value ()
+        );
+      return 1;
+    }
+    else
+    {
+      IR::FactoryDefSeq *tmp;
+      ACE_NEW_RETURN (tmp, IR::FactoryDefSeq, 0);
+      TAO_InputCDR stream (
+          _tao_any._tao_get_cdr (),
+          _tao_any._tao_byte_order ()
+        );
+      if (stream >> *tmp)
+      {
+        ((CORBA::Any *)&_tao_any)->_tao_replace (
+            IR::_tc_FactoryDefSeq,
+            1,
+            ACE_static_cast (void *, tmp),
+            IR::FactoryDefSeq::_tao_any_destructor
+          );
+        _tao_elem = tmp;
+        return 1;
+      }
+      else
+      {
+        delete tmp;
+      }
+    }
+  }
+  ACE_CATCHANY
+  {
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+void operator<<= (
+    CORBA::Any &_tao_any,
+    const IR::FinderDefSeq &_tao_elem
+  ) // copying
+{
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        IR::_tc_FinderDefSeq,
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin ()
+      );
+  }
+}
+
+void operator<<= (CORBA::Any &_tao_any, IR::FinderDefSeq *_tao_elem) // non copying
+{
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_FinderDefSeq,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      IR::FinderDefSeq::_tao_any_destructor
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::FinderDefSeq *&_tao_elem)
+{
+  return _tao_any >>= ACE_const_cast(
+      const IR::FinderDefSeq*&,
+      _tao_elem
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR::FinderDefSeq *&_tao_elem)
+{
+  _tao_elem = 0;
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (IR::_tc_FinderDefSeq, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    if (_tao_any.any_owns_data ())
+    {
+      _tao_elem = ACE_static_cast(
+          const IR::FinderDefSeq*,
+          _tao_any.value ()
+        );
+      return 1;
+    }
+    else
+    {
+      IR::FinderDefSeq *tmp;
+      ACE_NEW_RETURN (tmp, IR::FinderDefSeq, 0);
+      TAO_InputCDR stream (
+          _tao_any._tao_get_cdr (),
+          _tao_any._tao_byte_order ()
+        );
+      if (stream >> *tmp)
+      {
+        ((CORBA::Any *)&_tao_any)->_tao_replace (
+            IR::_tc_FinderDefSeq,
+            1,
+            ACE_static_cast (void *, tmp),
+            IR::FinderDefSeq::_tao_any_destructor
+          );
+        _tao_elem = tmp;
+        return 1;
+      }
+      else
+      {
+        delete tmp;
+      }
+    }
+  }
+  ACE_CATCHANY
+  {
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+void operator<<= (CORBA::Any &_tao_any, IR::ComponentRepository_ptr _tao_elem)
+{
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        IR::_tc_ComponentRepository, 
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin (),
+        1,
+        IR::ComponentRepository::_duplicate (_tao_elem),
+        IR::ComponentRepository::_tao_any_destructor
+      );
+  }
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::ComponentRepository_ptr &_tao_elem)
+{
+  ACE_TRY_NEW_ENV
+  {
+    _tao_elem = IR::ComponentRepository::_nil ();
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (IR::_tc_ComponentRepository, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    TAO_InputCDR stream (
+        _tao_any._tao_get_cdr (),
+        _tao_any._tao_byte_order ()
+      );
+    if (stream >> _tao_elem)
+    {
+      ((CORBA::Any *)&_tao_any)->_tao_replace (
+          IR::_tc_ComponentRepository,
+          1,
+          _tao_elem,
+          IR::ComponentRepository::_tao_any_destructor
+        );
+      return 1;
+    }
+  }
+  ACE_CATCHANY
+  {
+    _tao_elem = IR::ComponentRepository::_nil ();
+    return 0;
+  }
+  ACE_ENDTRY;
+  _tao_elem = IR::ComponentRepository::_nil ();
+  return 0;
+}
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
+    defined (ACE_HAS_GNU_REPO)
+    template class TAO_Object_Manager<IR::ComponentRepository,IR::ComponentRepository_var>;
+  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+  #  pragma instantiate TAO_Object_Manager<IR::ComponentRepository,IR::ComponentRepository_var>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+void operator<<= (CORBA::Any &_tao_any, IR::ProvidesDef_ptr _tao_elem)
+{
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        IR::_tc_ProvidesDef, 
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin (),
+        1,
+        IR::ProvidesDef::_duplicate (_tao_elem),
+        IR::ProvidesDef::_tao_any_destructor
+      );
+  }
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::ProvidesDef_ptr &_tao_elem)
+{
+  ACE_TRY_NEW_ENV
+  {
+    _tao_elem = IR::ProvidesDef::_nil ();
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (IR::_tc_ProvidesDef, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    TAO_InputCDR stream (
+        _tao_any._tao_get_cdr (),
+        _tao_any._tao_byte_order ()
+      );
+    if (stream >> _tao_elem)
+    {
+      ((CORBA::Any *)&_tao_any)->_tao_replace (
+          IR::_tc_ProvidesDef,
+          1,
+          _tao_elem,
+          IR::ProvidesDef::_tao_any_destructor
+        );
+      return 1;
+    }
+  }
+  ACE_CATCHANY
+  {
+    _tao_elem = IR::ProvidesDef::_nil ();
+    return 0;
+  }
+  ACE_ENDTRY;
+  _tao_elem = IR::ProvidesDef::_nil ();
+  return 0;
+}
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
+    defined (ACE_HAS_GNU_REPO)
+    template class TAO_Object_Manager<IR::ProvidesDef,IR::ProvidesDef_var>;
+  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+  #  pragma instantiate TAO_Object_Manager<IR::ProvidesDef,IR::ProvidesDef_var>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+void operator<<= (CORBA::Any &_tao_any, const IR::ProvidesDescription &_tao_elem) // copying
+{
+  TAO_OutputCDR stream;
+  stream << _tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_ProvidesDescription,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin ()
+    );
+}
+
+void operator<<= (CORBA::Any &_tao_any, IR::ProvidesDescription *_tao_elem) // non copying
+{
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_ProvidesDescription,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      IR::ProvidesDescription::_tao_any_destructor
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::ProvidesDescription *&_tao_elem)
+{
+  return _tao_any >>= ACE_const_cast(const IR::ProvidesDescription*&,_tao_elem);
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR::ProvidesDescription *&_tao_elem)
+{
+  _tao_elem = 0;
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (IR::_tc_ProvidesDescription, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    if (_tao_any.any_owns_data ())
+    {
+      _tao_elem = ACE_static_cast(
+          const IR::ProvidesDescription*,
+          _tao_any.value ()
+        );
+      return 1;
+    }
+    else
+    {
+      IR::ProvidesDescription *tmp;
+      ACE_NEW_RETURN (tmp, IR::ProvidesDescription, 0);
+      TAO_InputCDR stream (
+          _tao_any._tao_get_cdr (),
+          _tao_any._tao_byte_order ()
+        );
+      if (stream >> *tmp)
+      {
+        ((CORBA::Any *)&_tao_any)->_tao_replace (
+            IR::_tc_ProvidesDescription,
+            1,
+            ACE_static_cast (void *, tmp),
+            IR::ProvidesDescription::_tao_any_destructor
+          );
+        _tao_elem = tmp;
+        return 1;
+      }
+      else
+      {
+        delete tmp;
+      }
+    }
+  }
+  ACE_CATCHANY
+  {
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+void operator<<= (CORBA::Any &_tao_any, IR::UsesDef_ptr _tao_elem)
+{
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        IR::_tc_UsesDef, 
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin (),
+        1,
+        IR::UsesDef::_duplicate (_tao_elem),
+        IR::UsesDef::_tao_any_destructor
+      );
+  }
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::UsesDef_ptr &_tao_elem)
+{
+  ACE_TRY_NEW_ENV
+  {
+    _tao_elem = IR::UsesDef::_nil ();
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (IR::_tc_UsesDef, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    TAO_InputCDR stream (
+        _tao_any._tao_get_cdr (),
+        _tao_any._tao_byte_order ()
+      );
+    if (stream >> _tao_elem)
+    {
+      ((CORBA::Any *)&_tao_any)->_tao_replace (
+          IR::_tc_UsesDef,
+          1,
+          _tao_elem,
+          IR::UsesDef::_tao_any_destructor
+        );
+      return 1;
+    }
+  }
+  ACE_CATCHANY
+  {
+    _tao_elem = IR::UsesDef::_nil ();
+    return 0;
+  }
+  ACE_ENDTRY;
+  _tao_elem = IR::UsesDef::_nil ();
+  return 0;
+}
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
+    defined (ACE_HAS_GNU_REPO)
+    template class TAO_Object_Manager<IR::UsesDef,IR::UsesDef_var>;
+  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+  #  pragma instantiate TAO_Object_Manager<IR::UsesDef,IR::UsesDef_var>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+void operator<<= (CORBA::Any &_tao_any, const IR::UsesDescription &_tao_elem) // copying
+{
+  TAO_OutputCDR stream;
+  stream << _tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_UsesDescription,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin ()
+    );
+}
+
+void operator<<= (CORBA::Any &_tao_any, IR::UsesDescription *_tao_elem) // non copying
+{
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_UsesDescription,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      IR::UsesDescription::_tao_any_destructor
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::UsesDescription *&_tao_elem)
+{
+  return _tao_any >>= ACE_const_cast(const IR::UsesDescription*&,_tao_elem);
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR::UsesDescription *&_tao_elem)
+{
+  _tao_elem = 0;
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (IR::_tc_UsesDescription, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    if (_tao_any.any_owns_data ())
+    {
+      _tao_elem = ACE_static_cast(
+          const IR::UsesDescription*,
+          _tao_any.value ()
+        );
+      return 1;
+    }
+    else
+    {
+      IR::UsesDescription *tmp;
+      ACE_NEW_RETURN (tmp, IR::UsesDescription, 0);
+      TAO_InputCDR stream (
+          _tao_any._tao_get_cdr (),
+          _tao_any._tao_byte_order ()
+        );
+      if (stream >> *tmp)
+      {
+        ((CORBA::Any *)&_tao_any)->_tao_replace (
+            IR::_tc_UsesDescription,
+            1,
+            ACE_static_cast (void *, tmp),
+            IR::UsesDescription::_tao_any_destructor
+          );
+        _tao_elem = tmp;
+        return 1;
+      }
+      else
+      {
+        delete tmp;
+      }
+    }
+  }
+  ACE_CATCHANY
+  {
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+void operator<<= (
+    CORBA::Any &_tao_any,
+    const IR::ProvidesDescSeq &_tao_elem
+  ) // copying
+{
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        IR::_tc_ProvidesDescSeq,
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin ()
+      );
+  }
+}
+
+void operator<<= (CORBA::Any &_tao_any, IR::ProvidesDescSeq *_tao_elem) // non copying
+{
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_ProvidesDescSeq,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      IR::ProvidesDescSeq::_tao_any_destructor
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::ProvidesDescSeq *&_tao_elem)
+{
+  return _tao_any >>= ACE_const_cast(
+      const IR::ProvidesDescSeq*&,
+      _tao_elem
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR::ProvidesDescSeq *&_tao_elem)
+{
+  _tao_elem = 0;
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (IR::_tc_ProvidesDescSeq, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    if (_tao_any.any_owns_data ())
+    {
+      _tao_elem = ACE_static_cast(
+          const IR::ProvidesDescSeq*,
+          _tao_any.value ()
+        );
+      return 1;
+    }
+    else
+    {
+      IR::ProvidesDescSeq *tmp;
+      ACE_NEW_RETURN (tmp, IR::ProvidesDescSeq, 0);
+      TAO_InputCDR stream (
+          _tao_any._tao_get_cdr (),
+          _tao_any._tao_byte_order ()
+        );
+      if (stream >> *tmp)
+      {
+        ((CORBA::Any *)&_tao_any)->_tao_replace (
+            IR::_tc_ProvidesDescSeq,
+            1,
+            ACE_static_cast (void *, tmp),
+            IR::ProvidesDescSeq::_tao_any_destructor
+          );
+        _tao_elem = tmp;
+        return 1;
+      }
+      else
+      {
+        delete tmp;
+      }
+    }
+  }
+  ACE_CATCHANY
+  {
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+void operator<<= (
+    CORBA::Any &_tao_any,
+    const IR::UsesDescSeq &_tao_elem
+  ) // copying
+{
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        IR::_tc_UsesDescSeq,
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin ()
+      );
+  }
+}
+
+void operator<<= (CORBA::Any &_tao_any, IR::UsesDescSeq *_tao_elem) // non copying
+{
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_UsesDescSeq,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      IR::UsesDescSeq::_tao_any_destructor
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::UsesDescSeq *&_tao_elem)
+{
+  return _tao_any >>= ACE_const_cast(
+      const IR::UsesDescSeq*&,
+      _tao_elem
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR::UsesDescSeq *&_tao_elem)
+{
+  _tao_elem = 0;
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (IR::_tc_UsesDescSeq, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    if (_tao_any.any_owns_data ())
+    {
+      _tao_elem = ACE_static_cast(
+          const IR::UsesDescSeq*,
+          _tao_any.value ()
+        );
+      return 1;
+    }
+    else
+    {
+      IR::UsesDescSeq *tmp;
+      ACE_NEW_RETURN (tmp, IR::UsesDescSeq, 0);
+      TAO_InputCDR stream (
+          _tao_any._tao_get_cdr (),
+          _tao_any._tao_byte_order ()
+        );
+      if (stream >> *tmp)
+      {
+        ((CORBA::Any *)&_tao_any)->_tao_replace (
+            IR::_tc_UsesDescSeq,
+            1,
+            ACE_static_cast (void *, tmp),
+            IR::UsesDescSeq::_tao_any_destructor
+          );
+        _tao_elem = tmp;
+        return 1;
+      }
+      else
+      {
+        delete tmp;
+      }
+    }
+  }
+  ACE_CATCHANY
+  {
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+void operator<<= (CORBA::Any &_tao_any, IR::EventDef_ptr _tao_elem)
+{
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        IR::_tc_EventDef, 
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin (),
+        1,
+        IR::EventDef::_duplicate (_tao_elem),
+        IR::EventDef::_tao_any_destructor
+      );
+  }
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::EventDef_ptr &_tao_elem)
+{
+  ACE_TRY_NEW_ENV
+  {
+    _tao_elem = IR::EventDef::_nil ();
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (IR::_tc_EventDef, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    TAO_InputCDR stream (
+        _tao_any._tao_get_cdr (),
+        _tao_any._tao_byte_order ()
+      );
+    if (stream >> _tao_elem)
+    {
+      ((CORBA::Any *)&_tao_any)->_tao_replace (
+          IR::_tc_EventDef,
+          1,
+          _tao_elem,
+          IR::EventDef::_tao_any_destructor
+        );
+      return 1;
+    }
+  }
+  ACE_CATCHANY
+  {
+    _tao_elem = IR::EventDef::_nil ();
+    return 0;
+  }
+  ACE_ENDTRY;
+  _tao_elem = IR::EventDef::_nil ();
+  return 0;
+}
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
+    defined (ACE_HAS_GNU_REPO)
+    template class TAO_Object_Manager<IR::EventDef,IR::EventDef_var>;
+  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+  #  pragma instantiate TAO_Object_Manager<IR::EventDef,IR::EventDef_var>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+void operator<<= (CORBA::Any &_tao_any, const IR::EventDescription &_tao_elem) // copying
+{
+  TAO_OutputCDR stream;
+  stream << _tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_EventDescription,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin ()
+    );
+}
+
+void operator<<= (CORBA::Any &_tao_any, IR::EventDescription *_tao_elem) // non copying
+{
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_EventDescription,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      IR::EventDescription::_tao_any_destructor
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::EventDescription *&_tao_elem)
+{
+  return _tao_any >>= ACE_const_cast(const IR::EventDescription*&,_tao_elem);
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR::EventDescription *&_tao_elem)
+{
+  _tao_elem = 0;
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (IR::_tc_EventDescription, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    if (_tao_any.any_owns_data ())
+    {
+      _tao_elem = ACE_static_cast(
+          const IR::EventDescription*,
+          _tao_any.value ()
+        );
+      return 1;
+    }
+    else
+    {
+      IR::EventDescription *tmp;
+      ACE_NEW_RETURN (tmp, IR::EventDescription, 0);
+      TAO_InputCDR stream (
+          _tao_any._tao_get_cdr (),
+          _tao_any._tao_byte_order ()
+        );
+      if (stream >> *tmp)
+      {
+        ((CORBA::Any *)&_tao_any)->_tao_replace (
+            IR::_tc_EventDescription,
+            1,
+            ACE_static_cast (void *, tmp),
+            IR::EventDescription::_tao_any_destructor
+          );
+        _tao_elem = tmp;
+        return 1;
+      }
+      else
+      {
+        delete tmp;
+      }
+    }
+  }
+  ACE_CATCHANY
+  {
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+void operator<<= (CORBA::Any &_tao_any, IR::EmitsDef_ptr _tao_elem)
+{
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        IR::_tc_EmitsDef, 
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin (),
+        1,
+        IR::EmitsDef::_duplicate (_tao_elem),
+        IR::EmitsDef::_tao_any_destructor
+      );
+  }
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::EmitsDef_ptr &_tao_elem)
+{
+  ACE_TRY_NEW_ENV
+  {
+    _tao_elem = IR::EmitsDef::_nil ();
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (IR::_tc_EmitsDef, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    TAO_InputCDR stream (
+        _tao_any._tao_get_cdr (),
+        _tao_any._tao_byte_order ()
+      );
+    if (stream >> _tao_elem)
+    {
+      ((CORBA::Any *)&_tao_any)->_tao_replace (
+          IR::_tc_EmitsDef,
+          1,
+          _tao_elem,
+          IR::EmitsDef::_tao_any_destructor
+        );
+      return 1;
+    }
+  }
+  ACE_CATCHANY
+  {
+    _tao_elem = IR::EmitsDef::_nil ();
+    return 0;
+  }
+  ACE_ENDTRY;
+  _tao_elem = IR::EmitsDef::_nil ();
+  return 0;
+}
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
+    defined (ACE_HAS_GNU_REPO)
+    template class TAO_Object_Manager<IR::EmitsDef,IR::EmitsDef_var>;
+  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+  #  pragma instantiate TAO_Object_Manager<IR::EmitsDef,IR::EmitsDef_var>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+void operator<<= (CORBA::Any &_tao_any, IR::PublishesDef_ptr _tao_elem)
+{
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        IR::_tc_PublishesDef, 
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin (),
+        1,
+        IR::PublishesDef::_duplicate (_tao_elem),
+        IR::PublishesDef::_tao_any_destructor
+      );
+  }
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::PublishesDef_ptr &_tao_elem)
+{
+  ACE_TRY_NEW_ENV
+  {
+    _tao_elem = IR::PublishesDef::_nil ();
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (IR::_tc_PublishesDef, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    TAO_InputCDR stream (
+        _tao_any._tao_get_cdr (),
+        _tao_any._tao_byte_order ()
+      );
+    if (stream >> _tao_elem)
+    {
+      ((CORBA::Any *)&_tao_any)->_tao_replace (
+          IR::_tc_PublishesDef,
+          1,
+          _tao_elem,
+          IR::PublishesDef::_tao_any_destructor
+        );
+      return 1;
+    }
+  }
+  ACE_CATCHANY
+  {
+    _tao_elem = IR::PublishesDef::_nil ();
+    return 0;
+  }
+  ACE_ENDTRY;
+  _tao_elem = IR::PublishesDef::_nil ();
+  return 0;
+}
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
+    defined (ACE_HAS_GNU_REPO)
+    template class TAO_Object_Manager<IR::PublishesDef,IR::PublishesDef_var>;
+  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+  #  pragma instantiate TAO_Object_Manager<IR::PublishesDef,IR::PublishesDef_var>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+void operator<<= (CORBA::Any &_tao_any, IR::ConsumesDef_ptr _tao_elem)
+{
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        IR::_tc_ConsumesDef, 
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin (),
+        1,
+        IR::ConsumesDef::_duplicate (_tao_elem),
+        IR::ConsumesDef::_tao_any_destructor
+      );
+  }
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::ConsumesDef_ptr &_tao_elem)
+{
+  ACE_TRY_NEW_ENV
+  {
+    _tao_elem = IR::ConsumesDef::_nil ();
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (IR::_tc_ConsumesDef, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    TAO_InputCDR stream (
+        _tao_any._tao_get_cdr (),
+        _tao_any._tao_byte_order ()
+      );
+    if (stream >> _tao_elem)
+    {
+      ((CORBA::Any *)&_tao_any)->_tao_replace (
+          IR::_tc_ConsumesDef,
+          1,
+          _tao_elem,
+          IR::ConsumesDef::_tao_any_destructor
+        );
+      return 1;
+    }
+  }
+  ACE_CATCHANY
+  {
+    _tao_elem = IR::ConsumesDef::_nil ();
+    return 0;
+  }
+  ACE_ENDTRY;
+  _tao_elem = IR::ConsumesDef::_nil ();
+  return 0;
+}
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
+    defined (ACE_HAS_GNU_REPO)
+    template class TAO_Object_Manager<IR::ConsumesDef,IR::ConsumesDef_var>;
+  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+  #  pragma instantiate TAO_Object_Manager<IR::ConsumesDef,IR::ConsumesDef_var>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+void operator<<= (CORBA::Any &_tao_any, IR::ComponentDef_ptr _tao_elem)
+{
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        IR::_tc_ComponentDef, 
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin (),
+        1,
+        IR::ComponentDef::_duplicate (_tao_elem),
+        IR::ComponentDef::_tao_any_destructor
+      );
+  }
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::ComponentDef_ptr &_tao_elem)
+{
+  ACE_TRY_NEW_ENV
+  {
+    _tao_elem = IR::ComponentDef::_nil ();
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (IR::_tc_ComponentDef, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    TAO_InputCDR stream (
+        _tao_any._tao_get_cdr (),
+        _tao_any._tao_byte_order ()
+      );
+    if (stream >> _tao_elem)
+    {
+      ((CORBA::Any *)&_tao_any)->_tao_replace (
+          IR::_tc_ComponentDef,
+          1,
+          _tao_elem,
+          IR::ComponentDef::_tao_any_destructor
+        );
+      return 1;
+    }
+  }
+  ACE_CATCHANY
+  {
+    _tao_elem = IR::ComponentDef::_nil ();
+    return 0;
+  }
+  ACE_ENDTRY;
+  _tao_elem = IR::ComponentDef::_nil ();
+  return 0;
+}
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
+    defined (ACE_HAS_GNU_REPO)
+    template class TAO_Object_Manager<IR::ComponentDef,IR::ComponentDef_var>;
+  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+  #  pragma instantiate TAO_Object_Manager<IR::ComponentDef,IR::ComponentDef_var>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+void operator<<= (CORBA::Any &_tao_any, const IR::ComponentDescription &_tao_elem) // copying
+{
+  TAO_OutputCDR stream;
+  stream << _tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_ComponentDescription,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin ()
+    );
+}
+
+void operator<<= (CORBA::Any &_tao_any, IR::ComponentDescription *_tao_elem) // non copying
+{
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_ComponentDescription,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      IR::ComponentDescription::_tao_any_destructor
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::ComponentDescription *&_tao_elem)
+{
+  return _tao_any >>= ACE_const_cast(const IR::ComponentDescription*&,_tao_elem);
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR::ComponentDescription *&_tao_elem)
+{
+  _tao_elem = 0;
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (IR::_tc_ComponentDescription, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    if (_tao_any.any_owns_data ())
+    {
+      _tao_elem = ACE_static_cast(
+          const IR::ComponentDescription*,
+          _tao_any.value ()
+        );
+      return 1;
+    }
+    else
+    {
+      IR::ComponentDescription *tmp;
+      ACE_NEW_RETURN (tmp, IR::ComponentDescription, 0);
+      TAO_InputCDR stream (
+          _tao_any._tao_get_cdr (),
+          _tao_any._tao_byte_order ()
+        );
+      if (stream >> *tmp)
+      {
+        ((CORBA::Any *)&_tao_any)->_tao_replace (
+            IR::_tc_ComponentDescription,
+            1,
+            ACE_static_cast (void *, tmp),
+            IR::ComponentDescription::_tao_any_destructor
+          );
+        _tao_elem = tmp;
+        return 1;
+      }
+      else
+      {
+        delete tmp;
+      }
+    }
+  }
+  ACE_CATCHANY
+  {
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+void operator<<= (CORBA::Any &_tao_any, IR::PrimaryKeyDef_ptr _tao_elem)
+{
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        IR::_tc_PrimaryKeyDef, 
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin (),
+        1,
+        IR::PrimaryKeyDef::_duplicate (_tao_elem),
+        IR::PrimaryKeyDef::_tao_any_destructor
+      );
+  }
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::PrimaryKeyDef_ptr &_tao_elem)
+{
+  ACE_TRY_NEW_ENV
+  {
+    _tao_elem = IR::PrimaryKeyDef::_nil ();
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (IR::_tc_PrimaryKeyDef, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    TAO_InputCDR stream (
+        _tao_any._tao_get_cdr (),
+        _tao_any._tao_byte_order ()
+      );
+    if (stream >> _tao_elem)
+    {
+      ((CORBA::Any *)&_tao_any)->_tao_replace (
+          IR::_tc_PrimaryKeyDef,
+          1,
+          _tao_elem,
+          IR::PrimaryKeyDef::_tao_any_destructor
+        );
+      return 1;
+    }
+  }
+  ACE_CATCHANY
+  {
+    _tao_elem = IR::PrimaryKeyDef::_nil ();
+    return 0;
+  }
+  ACE_ENDTRY;
+  _tao_elem = IR::PrimaryKeyDef::_nil ();
+  return 0;
+}
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
+    defined (ACE_HAS_GNU_REPO)
+    template class TAO_Object_Manager<IR::PrimaryKeyDef,IR::PrimaryKeyDef_var>;
+  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+  #  pragma instantiate TAO_Object_Manager<IR::PrimaryKeyDef,IR::PrimaryKeyDef_var>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+void operator<<= (CORBA::Any &_tao_any, const IR::PrimaryKeyDescription &_tao_elem) // copying
+{
+  TAO_OutputCDR stream;
+  stream << _tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_PrimaryKeyDescription,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin ()
+    );
+}
+
+void operator<<= (CORBA::Any &_tao_any, IR::PrimaryKeyDescription *_tao_elem) // non copying
+{
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_PrimaryKeyDescription,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      IR::PrimaryKeyDescription::_tao_any_destructor
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::PrimaryKeyDescription *&_tao_elem)
+{
+  return _tao_any >>= ACE_const_cast(const IR::PrimaryKeyDescription*&,_tao_elem);
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR::PrimaryKeyDescription *&_tao_elem)
+{
+  _tao_elem = 0;
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (IR::_tc_PrimaryKeyDescription, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    if (_tao_any.any_owns_data ())
+    {
+      _tao_elem = ACE_static_cast(
+          const IR::PrimaryKeyDescription*,
+          _tao_any.value ()
+        );
+      return 1;
+    }
+    else
+    {
+      IR::PrimaryKeyDescription *tmp;
+      ACE_NEW_RETURN (tmp, IR::PrimaryKeyDescription, 0);
+      TAO_InputCDR stream (
+          _tao_any._tao_get_cdr (),
+          _tao_any._tao_byte_order ()
+        );
+      if (stream >> *tmp)
+      {
+        ((CORBA::Any *)&_tao_any)->_tao_replace (
+            IR::_tc_PrimaryKeyDescription,
+            1,
+            ACE_static_cast (void *, tmp),
+            IR::PrimaryKeyDescription::_tao_any_destructor
+          );
+        _tao_elem = tmp;
+        return 1;
+      }
+      else
+      {
+        delete tmp;
+      }
+    }
+  }
+  ACE_CATCHANY
+  {
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+void operator<<= (CORBA::Any &_tao_any, IR::FactoryDef_ptr _tao_elem)
+{
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        IR::_tc_FactoryDef, 
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin (),
+        1,
+        IR::FactoryDef::_duplicate (_tao_elem),
+        IR::FactoryDef::_tao_any_destructor
+      );
+  }
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::FactoryDef_ptr &_tao_elem)
+{
+  ACE_TRY_NEW_ENV
+  {
+    _tao_elem = IR::FactoryDef::_nil ();
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (IR::_tc_FactoryDef, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    TAO_InputCDR stream (
+        _tao_any._tao_get_cdr (),
+        _tao_any._tao_byte_order ()
+      );
+    if (stream >> _tao_elem)
+    {
+      ((CORBA::Any *)&_tao_any)->_tao_replace (
+          IR::_tc_FactoryDef,
+          1,
+          _tao_elem,
+          IR::FactoryDef::_tao_any_destructor
+        );
+      return 1;
+    }
+  }
+  ACE_CATCHANY
+  {
+    _tao_elem = IR::FactoryDef::_nil ();
+    return 0;
+  }
+  ACE_ENDTRY;
+  _tao_elem = IR::FactoryDef::_nil ();
+  return 0;
+}
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
+    defined (ACE_HAS_GNU_REPO)
+    template class TAO_Object_Manager<IR::FactoryDef,IR::FactoryDef_var>;
+  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+  #  pragma instantiate TAO_Object_Manager<IR::FactoryDef,IR::FactoryDef_var>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+void operator<<= (CORBA::Any &_tao_any, IR::FinderDef_ptr _tao_elem)
+{
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        IR::_tc_FinderDef, 
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin (),
+        1,
+        IR::FinderDef::_duplicate (_tao_elem),
+        IR::FinderDef::_tao_any_destructor
+      );
+  }
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::FinderDef_ptr &_tao_elem)
+{
+  ACE_TRY_NEW_ENV
+  {
+    _tao_elem = IR::FinderDef::_nil ();
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (IR::_tc_FinderDef, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    TAO_InputCDR stream (
+        _tao_any._tao_get_cdr (),
+        _tao_any._tao_byte_order ()
+      );
+    if (stream >> _tao_elem)
+    {
+      ((CORBA::Any *)&_tao_any)->_tao_replace (
+          IR::_tc_FinderDef,
+          1,
+          _tao_elem,
+          IR::FinderDef::_tao_any_destructor
+        );
+      return 1;
+    }
+  }
+  ACE_CATCHANY
+  {
+    _tao_elem = IR::FinderDef::_nil ();
+    return 0;
+  }
+  ACE_ENDTRY;
+  _tao_elem = IR::FinderDef::_nil ();
+  return 0;
+}
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
+    defined (ACE_HAS_GNU_REPO)
+    template class TAO_Object_Manager<IR::FinderDef,IR::FinderDef_var>;
+  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+  #  pragma instantiate TAO_Object_Manager<IR::FinderDef,IR::FinderDef_var>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+void operator<<= (CORBA::Any &_tao_any, IR::HomeDef_ptr _tao_elem)
+{
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        IR::_tc_HomeDef, 
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin (),
+        1,
+        IR::HomeDef::_duplicate (_tao_elem),
+        IR::HomeDef::_tao_any_destructor
+      );
+  }
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::HomeDef_ptr &_tao_elem)
+{
+  ACE_TRY_NEW_ENV
+  {
+    _tao_elem = IR::HomeDef::_nil ();
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (IR::_tc_HomeDef, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    TAO_InputCDR stream (
+        _tao_any._tao_get_cdr (),
+        _tao_any._tao_byte_order ()
+      );
+    if (stream >> _tao_elem)
+    {
+      ((CORBA::Any *)&_tao_any)->_tao_replace (
+          IR::_tc_HomeDef,
+          1,
+          _tao_elem,
+          IR::HomeDef::_tao_any_destructor
+        );
+      return 1;
+    }
+  }
+  ACE_CATCHANY
+  {
+    _tao_elem = IR::HomeDef::_nil ();
+    return 0;
+  }
+  ACE_ENDTRY;
+  _tao_elem = IR::HomeDef::_nil ();
+  return 0;
+}
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
+    defined (ACE_HAS_GNU_REPO)
+    template class TAO_Object_Manager<IR::HomeDef,IR::HomeDef_var>;
+  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+  #  pragma instantiate TAO_Object_Manager<IR::HomeDef,IR::HomeDef_var>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+void operator<<= (CORBA::Any &_tao_any, const IR::HomeDescription &_tao_elem) // copying
+{
+  TAO_OutputCDR stream;
+  stream << _tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_HomeDescription,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin ()
+    );
+}
+
+void operator<<= (CORBA::Any &_tao_any, IR::HomeDescription *_tao_elem) // non copying
+{
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_HomeDescription,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      IR::HomeDescription::_tao_any_destructor
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::HomeDescription *&_tao_elem)
+{
+  return _tao_any >>= ACE_const_cast(const IR::HomeDescription*&,_tao_elem);
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR::HomeDescription *&_tao_elem)
+{
+  _tao_elem = 0;
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (IR::_tc_HomeDescription, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    if (_tao_any.any_owns_data ())
+    {
+      _tao_elem = ACE_static_cast(
+          const IR::HomeDescription*,
+          _tao_any.value ()
+        );
+      return 1;
+    }
+    else
+    {
+      IR::HomeDescription *tmp;
+      ACE_NEW_RETURN (tmp, IR::HomeDescription, 0);
+      TAO_InputCDR stream (
+          _tao_any._tao_get_cdr (),
+          _tao_any._tao_byte_order ()
+        );
+      if (stream >> *tmp)
+      {
+        ((CORBA::Any *)&_tao_any)->_tao_replace (
+            IR::_tc_HomeDescription,
+            1,
+            ACE_static_cast (void *, tmp),
+            IR::HomeDescription::_tao_any_destructor
+          );
+        _tao_elem = tmp;
+        return 1;
+      }
+      else
+      {
+        delete tmp;
+      }
+    }
+  }
+  ACE_CATCHANY
+  {
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+CORBA::Boolean operator<< (
+    TAO_OutputCDR &strm,
+    const IR::RepositoryIdSeq &_tao_sequence
+  )
+{
+  if (strm << _tao_sequence.length ())
+  {
+    // encode all elements
+    CORBA::Boolean _tao_marshal_flag = 1;
+    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
+      _tao_marshal_flag = (strm << _tao_sequence[i].in ());
+    }
+    return _tao_marshal_flag;
+  }
+  return 0; // error
+}
+
+CORBA::Boolean operator>> (
+    TAO_InputCDR &strm,
+    IR::RepositoryIdSeq &_tao_sequence
+  )
+{
+  CORBA::ULong _tao_seq_len;
+  if (strm >> _tao_seq_len)
+  {
+    // set the length of the sequence
+    _tao_sequence.length (_tao_seq_len);
+    // If length is 0 we return true.
+    if (0 >= _tao_seq_len) 
+      return 1;
+    // retrieve all the elements
+    CORBA::Boolean _tao_marshal_flag = 1;
+    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
+      _tao_marshal_flag = (strm >> _tao_sequence[i].out ());
+    }
+    return _tao_marshal_flag;
+  }
+  return 0; // error
+}
+
+CORBA::Boolean operator<< (
+    TAO_OutputCDR &strm,
+    const IR::ComponentDefSeq &_tao_sequence
+  )
+{
+  if (strm << _tao_sequence.length ())
+  {
+    // encode all elements
+    CORBA::Boolean _tao_marshal_flag = 1;
+    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
+      _tao_marshal_flag = (strm << _tao_sequence[i].in ());
+    }
+    return _tao_marshal_flag;
+  }
+  return 0; // error
+}
+
+CORBA::Boolean operator>> (
+    TAO_InputCDR &strm,
+    IR::ComponentDefSeq &_tao_sequence
+  )
+{
+  CORBA::ULong _tao_seq_len;
+  if (strm >> _tao_seq_len)
+  {
+    // set the length of the sequence
+    _tao_sequence.length (_tao_seq_len);
+    // If length is 0 we return true.
+    if (0 >= _tao_seq_len) 
+      return 1;
+    // retrieve all the elements
+    CORBA::Boolean _tao_marshal_flag = 1;
+    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
+      _tao_marshal_flag = (strm >> _tao_sequence[i].out ());
+    }
+    return _tao_marshal_flag;
+  }
+  return 0; // error
+}
+
+CORBA::Boolean operator<< (
+    TAO_OutputCDR &strm,
+    const IR::ProvidesDefSeq &_tao_sequence
+  )
+{
+  if (strm << _tao_sequence.length ())
+  {
+    // encode all elements
+    CORBA::Boolean _tao_marshal_flag = 1;
+    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
+      _tao_marshal_flag = (strm << _tao_sequence[i].in ());
+    }
+    return _tao_marshal_flag;
+  }
+  return 0; // error
+}
+
+CORBA::Boolean operator>> (
+    TAO_InputCDR &strm,
+    IR::ProvidesDefSeq &_tao_sequence
+  )
+{
+  CORBA::ULong _tao_seq_len;
+  if (strm >> _tao_seq_len)
+  {
+    // set the length of the sequence
+    _tao_sequence.length (_tao_seq_len);
+    // If length is 0 we return true.
+    if (0 >= _tao_seq_len) 
+      return 1;
+    // retrieve all the elements
+    CORBA::Boolean _tao_marshal_flag = 1;
+    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
+      _tao_marshal_flag = (strm >> _tao_sequence[i].out ());
+    }
+    return _tao_marshal_flag;
+  }
+  return 0; // error
+}
+
+CORBA::Boolean operator<< (
+    TAO_OutputCDR &strm,
+    const IR::UsesDefSeq &_tao_sequence
+  )
+{
+  if (strm << _tao_sequence.length ())
+  {
+    // encode all elements
+    CORBA::Boolean _tao_marshal_flag = 1;
+    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
+      _tao_marshal_flag = (strm << _tao_sequence[i].in ());
+    }
+    return _tao_marshal_flag;
+  }
+  return 0; // error
+}
+
+CORBA::Boolean operator>> (
+    TAO_InputCDR &strm,
+    IR::UsesDefSeq &_tao_sequence
+  )
+{
+  CORBA::ULong _tao_seq_len;
+  if (strm >> _tao_seq_len)
+  {
+    // set the length of the sequence
+    _tao_sequence.length (_tao_seq_len);
+    // If length is 0 we return true.
+    if (0 >= _tao_seq_len) 
+      return 1;
+    // retrieve all the elements
+    CORBA::Boolean _tao_marshal_flag = 1;
+    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
+      _tao_marshal_flag = (strm >> _tao_sequence[i].out ());
+    }
+    return _tao_marshal_flag;
+  }
+  return 0; // error
+}
+
+CORBA::Boolean operator<< (
+    TAO_OutputCDR &strm,
+    const IR::HomeDefSeq &_tao_sequence
+  )
+{
+  if (strm << _tao_sequence.length ())
+  {
+    // encode all elements
+    CORBA::Boolean _tao_marshal_flag = 1;
+    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
+      _tao_marshal_flag = (strm << _tao_sequence[i].in ());
+    }
+    return _tao_marshal_flag;
+  }
+  return 0; // error
+}
+
+CORBA::Boolean operator>> (
+    TAO_InputCDR &strm,
+    IR::HomeDefSeq &_tao_sequence
+  )
+{
+  CORBA::ULong _tao_seq_len;
+  if (strm >> _tao_seq_len)
+  {
+    // set the length of the sequence
+    _tao_sequence.length (_tao_seq_len);
+    // If length is 0 we return true.
+    if (0 >= _tao_seq_len) 
+      return 1;
+    // retrieve all the elements
+    CORBA::Boolean _tao_marshal_flag = 1;
+    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
+      _tao_marshal_flag = (strm >> _tao_sequence[i].out ());
+    }
+    return _tao_marshal_flag;
+  }
+  return 0; // error
+}
+
+CORBA::Boolean operator<< (
+    TAO_OutputCDR &strm,
+    const IR::EmitsDefSeq &_tao_sequence
+  )
+{
+  if (strm << _tao_sequence.length ())
+  {
+    // encode all elements
+    CORBA::Boolean _tao_marshal_flag = 1;
+    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
+      _tao_marshal_flag = (strm << _tao_sequence[i].in ());
+    }
+    return _tao_marshal_flag;
+  }
+  return 0; // error
+}
+
+CORBA::Boolean operator>> (
+    TAO_InputCDR &strm,
+    IR::EmitsDefSeq &_tao_sequence
+  )
+{
+  CORBA::ULong _tao_seq_len;
+  if (strm >> _tao_seq_len)
+  {
+    // set the length of the sequence
+    _tao_sequence.length (_tao_seq_len);
+    // If length is 0 we return true.
+    if (0 >= _tao_seq_len) 
+      return 1;
+    // retrieve all the elements
+    CORBA::Boolean _tao_marshal_flag = 1;
+    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
+      _tao_marshal_flag = (strm >> _tao_sequence[i].out ());
+    }
+    return _tao_marshal_flag;
+  }
+  return 0; // error
+}
+
+CORBA::Boolean operator<< (
+    TAO_OutputCDR &strm,
+    const IR::PublishesDefSeq &_tao_sequence
+  )
+{
+  if (strm << _tao_sequence.length ())
+  {
+    // encode all elements
+    CORBA::Boolean _tao_marshal_flag = 1;
+    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
+      _tao_marshal_flag = (strm << _tao_sequence[i].in ());
+    }
+    return _tao_marshal_flag;
+  }
+  return 0; // error
+}
+
+CORBA::Boolean operator>> (
+    TAO_InputCDR &strm,
+    IR::PublishesDefSeq &_tao_sequence
+  )
+{
+  CORBA::ULong _tao_seq_len;
+  if (strm >> _tao_seq_len)
+  {
+    // set the length of the sequence
+    _tao_sequence.length (_tao_seq_len);
+    // If length is 0 we return true.
+    if (0 >= _tao_seq_len) 
+      return 1;
+    // retrieve all the elements
+    CORBA::Boolean _tao_marshal_flag = 1;
+    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
+      _tao_marshal_flag = (strm >> _tao_sequence[i].out ());
+    }
+    return _tao_marshal_flag;
+  }
+  return 0; // error
+}
+
+CORBA::Boolean operator<< (
+    TAO_OutputCDR &strm,
+    const IR::ConsumesDefSeq &_tao_sequence
+  )
+{
+  if (strm << _tao_sequence.length ())
+  {
+    // encode all elements
+    CORBA::Boolean _tao_marshal_flag = 1;
+    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
+      _tao_marshal_flag = (strm << _tao_sequence[i].in ());
+    }
+    return _tao_marshal_flag;
+  }
+  return 0; // error
+}
+
+CORBA::Boolean operator>> (
+    TAO_InputCDR &strm,
+    IR::ConsumesDefSeq &_tao_sequence
+  )
+{
+  CORBA::ULong _tao_seq_len;
+  if (strm >> _tao_seq_len)
+  {
+    // set the length of the sequence
+    _tao_sequence.length (_tao_seq_len);
+    // If length is 0 we return true.
+    if (0 >= _tao_seq_len) 
+      return 1;
+    // retrieve all the elements
+    CORBA::Boolean _tao_marshal_flag = 1;
+    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
+      _tao_marshal_flag = (strm >> _tao_sequence[i].out ());
+    }
+    return _tao_marshal_flag;
+  }
+  return 0; // error
+}
+
+CORBA::Boolean operator<< (
+    TAO_OutputCDR &strm,
+    const IR::FactoryDefSeq &_tao_sequence
+  )
+{
+  if (strm << _tao_sequence.length ())
+  {
+    // encode all elements
+    CORBA::Boolean _tao_marshal_flag = 1;
+    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
+      _tao_marshal_flag = (strm << _tao_sequence[i].in ());
+    }
+    return _tao_marshal_flag;
+  }
+  return 0; // error
+}
+
+CORBA::Boolean operator>> (
+    TAO_InputCDR &strm,
+    IR::FactoryDefSeq &_tao_sequence
+  )
+{
+  CORBA::ULong _tao_seq_len;
+  if (strm >> _tao_seq_len)
+  {
+    // set the length of the sequence
+    _tao_sequence.length (_tao_seq_len);
+    // If length is 0 we return true.
+    if (0 >= _tao_seq_len) 
+      return 1;
+    // retrieve all the elements
+    CORBA::Boolean _tao_marshal_flag = 1;
+    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
+      _tao_marshal_flag = (strm >> _tao_sequence[i].out ());
+    }
+    return _tao_marshal_flag;
+  }
+  return 0; // error
+}
+
+CORBA::Boolean operator<< (
+    TAO_OutputCDR &strm,
+    const IR::FinderDefSeq &_tao_sequence
+  )
+{
+  if (strm << _tao_sequence.length ())
+  {
+    // encode all elements
+    CORBA::Boolean _tao_marshal_flag = 1;
+    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
+      _tao_marshal_flag = (strm << _tao_sequence[i].in ());
+    }
+    return _tao_marshal_flag;
+  }
+  return 0; // error
+}
+
+CORBA::Boolean operator>> (
+    TAO_InputCDR &strm,
+    IR::FinderDefSeq &_tao_sequence
+  )
+{
+  CORBA::ULong _tao_seq_len;
+  if (strm >> _tao_seq_len)
+  {
+    // set the length of the sequence
+    _tao_sequence.length (_tao_seq_len);
+    // If length is 0 we return true.
+    if (0 >= _tao_seq_len) 
+      return 1;
+    // retrieve all the elements
+    CORBA::Boolean _tao_marshal_flag = 1;
+    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
+      _tao_marshal_flag = (strm >> _tao_sequence[i].out ());
+    }
+    return _tao_marshal_flag;
+  }
+  return 0; // error
+}
+
+CORBA::Boolean operator<< (
+    TAO_OutputCDR &strm,
+    const IR::ProvidesDescSeq &_tao_sequence
+  )
+{
+  if (strm << _tao_sequence.length ())
+  {
+    // encode all elements
+    CORBA::Boolean _tao_marshal_flag = 1;
+    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
+      _tao_marshal_flag = (strm << _tao_sequence[i]);
+    }
+    return _tao_marshal_flag;
+  }
+  return 0; // error
+}
+
+CORBA::Boolean operator>> (
+    TAO_InputCDR &strm,
+    IR::ProvidesDescSeq &_tao_sequence
+  )
+{
+  CORBA::ULong _tao_seq_len;
+  if (strm >> _tao_seq_len)
+  {
+    // set the length of the sequence
+    _tao_sequence.length (_tao_seq_len);
+    // If length is 0 we return true.
+    if (0 >= _tao_seq_len) 
+      return 1;
+    // retrieve all the elements
+    CORBA::Boolean _tao_marshal_flag = 1;
+    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
+      _tao_marshal_flag = (strm >> _tao_sequence[i]);
+    }
+    return _tao_marshal_flag;
+  }
+  return 0; // error
+}
+
+CORBA::Boolean operator<< (
+    TAO_OutputCDR &strm,
+    const IR::UsesDescSeq &_tao_sequence
+  )
+{
+  if (strm << _tao_sequence.length ())
+  {
+    // encode all elements
+    CORBA::Boolean _tao_marshal_flag = 1;
+    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
+      _tao_marshal_flag = (strm << _tao_sequence[i]);
+    }
+    return _tao_marshal_flag;
+  }
+  return 0; // error
+}
+
+CORBA::Boolean operator>> (
+    TAO_InputCDR &strm,
+    IR::UsesDescSeq &_tao_sequence
+  )
+{
+  CORBA::ULong _tao_seq_len;
+  if (strm >> _tao_seq_len)
+  {
+    // set the length of the sequence
+    _tao_sequence.length (_tao_seq_len);
+    // If length is 0 we return true.
+    if (0 >= _tao_seq_len) 
+      return 1;
+    // retrieve all the elements
+    CORBA::Boolean _tao_marshal_flag = 1;
+    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
+      _tao_marshal_flag = (strm >> _tao_sequence[i]);
+    }
+    return _tao_marshal_flag;
+  }
+  return 0; // error
+}
+
diff --git a/TAO/tao/IFR_Client/IFR_ComponentsC.h b/TAO/tao/IFR_Client/IFR_ComponentsC.h
new file mode 100644
index 00000000000..3c2d09c2c65
--- /dev/null
+++ b/TAO/tao/IFR_Client/IFR_ComponentsC.h
@@ -0,0 +1,8973 @@
+// -*- C++ -*-
+//
+// $Id$
+
+// ****  Code generated by the The ACE ORB (TAO) IDL Compiler ****
+// TAO and the TAO IDL Compiler have been developed by:
+//       Center for Distributed Object Computing
+//       Washington University
+//       St. Louis, MO
+//       USA
+//       http://www.cs.wustl.edu/~schmidt/doc-center.html
+// and
+//       Distributed Object Computing Laboratory
+//       University of California at Irvine
+//       Irvine, CA
+//       USA
+//       http://doc.ece.uci.edu/
+//
+// Information about TAO is available at:
+//     http://www.cs.wustl.edu/~schmidt/TAO.html
+
+#ifndef TAO_IDL_IFR_COMPONENTSC_H
+#define TAO_IDL_IFR_COMPONENTSC_H
+
+#include "ace/pre.h"
+#include "ifr_client_export.h"
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+# pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+#include "IFR_ExtendedC.h"
+
+#if defined (TAO_EXPORT_MACRO)
+#undef TAO_EXPORT_MACRO
+#endif
+#define TAO_EXPORT_MACRO TAO_IFR_Client_Export
+
+#if defined (TAO_EXPORT_NESTED_CLASSES)
+#  if defined (TAO_EXPORT_NESTED_MACRO)
+#    undef TAO_EXPORT_NESTED_MACRO
+#  endif /* defined (TAO_EXPORT_NESTED_MACRO) */
+#  define TAO_EXPORT_NESTED_MACRO TAO_IFR_Client_Export
+#endif /* TAO_EXPORT_NESTED_CLASSES */
+
+#if defined(_MSC_VER)
+#if (_MSC_VER >= 1200)
+#pragma warning(push)
+#endif /* _MSC_VER >= 1200 */
+#pragma warning(disable:4250)
+#endif /* _MSC_VER */
+
+#if defined (__BORLANDC__)
+#pragma option push -w-rvl -w-rch -w-ccc -w-inl
+#endif /* __BORLANDC__ */
+
+TAO_NAMESPACE  IR
+{
+  enum 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    
+  };
+  typedef DefinitionKind &DefinitionKind_out;
+  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_DefinitionKind;
+
+  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;
+
+
+#if !defined (_IR_REPOSITORYIDSEQ_CH_)
+#define _IR_REPOSITORYIDSEQ_CH_
+
+  class RepositoryIdSeq;
+  class RepositoryIdSeq_var;
+  
+  // *************************************************************
+  // RepositoryIdSeq
+  // *************************************************************
+  
+  class TAO_IFR_Client_Export RepositoryIdSeq : public 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+    TAO_Unbounded_String_Sequence
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+    TAO_Unbounded_String_Sequence
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+  {
+  public:
+    RepositoryIdSeq (void); // default ctor
+    RepositoryIdSeq (CORBA::ULong max); // uses max size
+    RepositoryIdSeq (
+      CORBA::ULong max, 
+      CORBA::ULong length, 
+      char * *buffer, 
+      CORBA::Boolean release = 0
+    );
+    RepositoryIdSeq (const RepositoryIdSeq &); // copy ctor
+    ~RepositoryIdSeq (void);
+    static void _tao_any_destructor (void*);
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+    typedef RepositoryIdSeq_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  };
+  
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_REPOSITORYIDSEQ___VAR_CH_)
+#define _IR_REPOSITORYIDSEQ___VAR_CH_
+
+  // *************************************************************
+  // class IR::RepositoryIdSeq_var
+  // *************************************************************
+
+  class TAO_IFR_Client_Export RepositoryIdSeq_var
+  {
+  public:
+    RepositoryIdSeq_var (void); // default constructor
+    RepositoryIdSeq_var (RepositoryIdSeq *);
+    RepositoryIdSeq_var (const RepositoryIdSeq_var &); // copy constructor
+    ~RepositoryIdSeq_var (void); // destructor
+    
+    RepositoryIdSeq_var &operator= (RepositoryIdSeq *);
+    RepositoryIdSeq_var &operator= (const RepositoryIdSeq_var &);
+    RepositoryIdSeq *operator-> (void);
+    const RepositoryIdSeq *operator-> (void) const;
+    
+    operator const RepositoryIdSeq &() const;
+    operator RepositoryIdSeq &();
+    operator RepositoryIdSeq &() const;
+    operator 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;
+
+  private:
+    RepositoryIdSeq *ptr_;
+  };
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_REPOSITORYIDSEQ___OUT_CH_)
+#define _IR_REPOSITORYIDSEQ___OUT_CH_
+
+  class TAO_IFR_Client_Export 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);
+    TAO_SeqElem_String_Manager operator[] (CORBA::ULong index);
+    
+  private:
+    RepositoryIdSeq *&ptr_;
+    // assignment from T_var not allowed
+    void operator= (const RepositoryIdSeq_var &);
+  };
+
+
+#endif /* end #if !defined */
+
+  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_RepositoryIdSeq;
+
+  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 ComponentDef;
+  
+#if !defined (_IR_COMPONENTDEF___PTR_CH_)
+#define _IR_COMPONENTDEF___PTR_CH_
+
+typedef ComponentDef *ComponentDef_ptr;
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_COMPONENTDEF___VAR_CH_)
+#define _IR_COMPONENTDEF___VAR_CH_
+
+  class TAO_IFR_Client_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 (_IR_COMPONENTDEF___OUT_CH_)
+#define _IR_COMPONENTDEF___OUT_CH_
+
+  class TAO_IFR_Client_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_USE_SEQUENCE_TEMPLATES)
+    
+#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_COMPONENTDEFSEQ_CH_)
+#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_COMPONENTDEFSEQ_CH_
+
+    class _TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq : public TAO_Unbounded_Base_Sequence
+    {
+    public:
+      // = Initialization and termination methods.
+      
+      _TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq (void);
+      _TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq (CORBA::ULong maximum);
+      _TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq (CORBA::ULong maximum,
+        CORBA::ULong length,
+        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);
+      // 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;
+      virtual void _shrink_buffer (CORBA::ULong nl, CORBA::ULong ol);
+      virtual void _downcast (
+          void* target,
+          CORBA_Object *src,
+          CORBA_Environment &ACE_TRY_ENV = 
+            TAO_default_environment ()
+        );
+      virtual CORBA_Object* _upcast (void *src) const;
+      
+    };
+
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+  
+#if !defined (_IR_COMPONENTDEFSEQ_CH_)
+#define _IR_COMPONENTDEFSEQ_CH_
+
+  class ComponentDefSeq;
+  class ComponentDefSeq_var;
+  
+  // *************************************************************
+  // ComponentDefSeq
+  // *************************************************************
+  
+  class TAO_IFR_Client_Export 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>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+  {
+  public:
+    ComponentDefSeq (void); // default ctor
+    ComponentDefSeq (CORBA::ULong max); // uses max size
+    ComponentDefSeq (
+      CORBA::ULong max, 
+      CORBA::ULong length, 
+      ComponentDef_ptr *buffer, 
+      CORBA::Boolean release = 0
+    );
+    ComponentDefSeq (const ComponentDefSeq &); // copy ctor
+    ~ComponentDefSeq (void);
+    static void _tao_any_destructor (void*);
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+    typedef ComponentDefSeq_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  };
+  
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_COMPONENTDEFSEQ___VAR_CH_)
+#define _IR_COMPONENTDEFSEQ___VAR_CH_
+
+  // *************************************************************
+  // class IR::ComponentDefSeq_var
+  // *************************************************************
+
+  class TAO_IFR_Client_Export ComponentDefSeq_var
+  {
+  public:
+    ComponentDefSeq_var (void); // default constructor
+    ComponentDefSeq_var (ComponentDefSeq *);
+    ComponentDefSeq_var (const ComponentDefSeq_var &); // copy constructor
+    ~ComponentDefSeq_var (void); // destructor
+    
+    ComponentDefSeq_var &operator= (ComponentDefSeq *);
+    ComponentDefSeq_var &operator= (const ComponentDefSeq_var &);
+    ComponentDefSeq *operator-> (void);
+    const ComponentDefSeq *operator-> (void) const;
+    
+    operator const ComponentDefSeq &() const;
+    operator ComponentDefSeq &();
+    operator ComponentDefSeq &() const;
+    operator ComponentDefSeq *&(); // variable-size base types only
+    
+    TAO_Object_Manager<ComponentDef, 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;
+
+  private:
+    ComponentDefSeq *ptr_;
+  };
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_COMPONENTDEFSEQ___OUT_CH_)
+#define _IR_COMPONENTDEFSEQ___OUT_CH_
+
+  class TAO_IFR_Client_Export 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);
+    
+  private:
+    ComponentDefSeq *&ptr_;
+    // assignment from T_var not allowed
+    void operator= (const ComponentDefSeq_var &);
+  };
+
+
+#endif /* end #if !defined */
+
+  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ComponentDefSeq;
+
+  class ProvidesDef;
+  
+#if !defined (_IR_PROVIDESDEF___PTR_CH_)
+#define _IR_PROVIDESDEF___PTR_CH_
+
+typedef ProvidesDef *ProvidesDef_ptr;
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_PROVIDESDEF___VAR_CH_)
+#define _IR_PROVIDESDEF___VAR_CH_
+
+  class TAO_IFR_Client_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 (_IR_PROVIDESDEF___OUT_CH_)
+#define _IR_PROVIDESDEF___OUT_CH_
+
+  class TAO_IFR_Client_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_USE_SEQUENCE_TEMPLATES)
+    
+#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_PROVIDESDEFSEQ_CH_)
+#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_PROVIDESDEFSEQ_CH_
+
+    class _TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq : public TAO_Unbounded_Base_Sequence
+    {
+    public:
+      // = Initialization and termination methods.
+      
+      _TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq (void);
+      _TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq (CORBA::ULong maximum);
+      _TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq (CORBA::ULong maximum,
+        CORBA::ULong length,
+        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);
+      // 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;
+      virtual void _shrink_buffer (CORBA::ULong nl, CORBA::ULong ol);
+      virtual void _downcast (
+          void* target,
+          CORBA_Object *src,
+          CORBA_Environment &ACE_TRY_ENV = 
+            TAO_default_environment ()
+        );
+      virtual CORBA_Object* _upcast (void *src) const;
+      
+    };
+
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+  
+#if !defined (_IR_PROVIDESDEFSEQ_CH_)
+#define _IR_PROVIDESDEFSEQ_CH_
+
+  class ProvidesDefSeq;
+  class ProvidesDefSeq_var;
+  
+  // *************************************************************
+  // ProvidesDefSeq
+  // *************************************************************
+  
+  class TAO_IFR_Client_Export 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>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+  {
+  public:
+    ProvidesDefSeq (void); // default ctor
+    ProvidesDefSeq (CORBA::ULong max); // uses max size
+    ProvidesDefSeq (
+      CORBA::ULong max, 
+      CORBA::ULong length, 
+      ProvidesDef_ptr *buffer, 
+      CORBA::Boolean release = 0
+    );
+    ProvidesDefSeq (const ProvidesDefSeq &); // copy ctor
+    ~ProvidesDefSeq (void);
+    static void _tao_any_destructor (void*);
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+    typedef ProvidesDefSeq_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  };
+  
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_PROVIDESDEFSEQ___VAR_CH_)
+#define _IR_PROVIDESDEFSEQ___VAR_CH_
+
+  // *************************************************************
+  // class IR::ProvidesDefSeq_var
+  // *************************************************************
+
+  class TAO_IFR_Client_Export ProvidesDefSeq_var
+  {
+  public:
+    ProvidesDefSeq_var (void); // default constructor
+    ProvidesDefSeq_var (ProvidesDefSeq *);
+    ProvidesDefSeq_var (const ProvidesDefSeq_var &); // copy constructor
+    ~ProvidesDefSeq_var (void); // destructor
+    
+    ProvidesDefSeq_var &operator= (ProvidesDefSeq *);
+    ProvidesDefSeq_var &operator= (const ProvidesDefSeq_var &);
+    ProvidesDefSeq *operator-> (void);
+    const ProvidesDefSeq *operator-> (void) const;
+    
+    operator const ProvidesDefSeq &() const;
+    operator ProvidesDefSeq &();
+    operator ProvidesDefSeq &() const;
+    operator ProvidesDefSeq *&(); // variable-size base types only
+    
+    TAO_Object_Manager<ProvidesDef, 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;
+
+  private:
+    ProvidesDefSeq *ptr_;
+  };
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_PROVIDESDEFSEQ___OUT_CH_)
+#define _IR_PROVIDESDEFSEQ___OUT_CH_
+
+  class TAO_IFR_Client_Export 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);
+    
+  private:
+    ProvidesDefSeq *&ptr_;
+    // assignment from T_var not allowed
+    void operator= (const ProvidesDefSeq_var &);
+  };
+
+
+#endif /* end #if !defined */
+
+  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ProvidesDefSeq;
+
+  class UsesDef;
+  
+#if !defined (_IR_USESDEF___PTR_CH_)
+#define _IR_USESDEF___PTR_CH_
+
+typedef UsesDef *UsesDef_ptr;
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_USESDEF___VAR_CH_)
+#define _IR_USESDEF___VAR_CH_
+
+  class TAO_IFR_Client_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 (_IR_USESDEF___OUT_CH_)
+#define _IR_USESDEF___OUT_CH_
+
+  class TAO_IFR_Client_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_;
+  };
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+    
+#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_USESDEFSEQ_CH_)
+#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_USESDEFSEQ_CH_
+
+    class _TAO_Unbounded_Object_Sequence_IR_UsesDefSeq : public TAO_Unbounded_Base_Sequence
+    {
+    public:
+      // = Initialization and termination methods.
+      
+      _TAO_Unbounded_Object_Sequence_IR_UsesDefSeq (void);
+      _TAO_Unbounded_Object_Sequence_IR_UsesDefSeq (CORBA::ULong maximum);
+      _TAO_Unbounded_Object_Sequence_IR_UsesDefSeq (CORBA::ULong maximum,
+        CORBA::ULong length,
+        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);
+      // 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;
+      virtual void _shrink_buffer (CORBA::ULong nl, CORBA::ULong ol);
+      virtual void _downcast (
+          void* target,
+          CORBA_Object *src,
+          CORBA_Environment &ACE_TRY_ENV = 
+            TAO_default_environment ()
+        );
+      virtual CORBA_Object* _upcast (void *src) const;
+      
+    };
+
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+  
+#if !defined (_IR_USESDEFSEQ_CH_)
+#define _IR_USESDEFSEQ_CH_
+
+  class UsesDefSeq;
+  class UsesDefSeq_var;
+  
+  // *************************************************************
+  // UsesDefSeq
+  // *************************************************************
+  
+  class TAO_IFR_Client_Export 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>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+  {
+  public:
+    UsesDefSeq (void); // default ctor
+    UsesDefSeq (CORBA::ULong max); // uses max size
+    UsesDefSeq (
+      CORBA::ULong max, 
+      CORBA::ULong length, 
+      UsesDef_ptr *buffer, 
+      CORBA::Boolean release = 0
+    );
+    UsesDefSeq (const UsesDefSeq &); // copy ctor
+    ~UsesDefSeq (void);
+    static void _tao_any_destructor (void*);
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+    typedef UsesDefSeq_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  };
+  
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_USESDEFSEQ___VAR_CH_)
+#define _IR_USESDEFSEQ___VAR_CH_
+
+  // *************************************************************
+  // class IR::UsesDefSeq_var
+  // *************************************************************
+
+  class TAO_IFR_Client_Export UsesDefSeq_var
+  {
+  public:
+    UsesDefSeq_var (void); // default constructor
+    UsesDefSeq_var (UsesDefSeq *);
+    UsesDefSeq_var (const UsesDefSeq_var &); // copy constructor
+    ~UsesDefSeq_var (void); // destructor
+    
+    UsesDefSeq_var &operator= (UsesDefSeq *);
+    UsesDefSeq_var &operator= (const UsesDefSeq_var &);
+    UsesDefSeq *operator-> (void);
+    const UsesDefSeq *operator-> (void) const;
+    
+    operator const UsesDefSeq &() const;
+    operator UsesDefSeq &();
+    operator UsesDefSeq &() const;
+    operator UsesDefSeq *&(); // variable-size base types only
+    
+    TAO_Object_Manager<UsesDef, 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;
+
+  private:
+    UsesDefSeq *ptr_;
+  };
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_USESDEFSEQ___OUT_CH_)
+#define _IR_USESDEFSEQ___OUT_CH_
+
+  class TAO_IFR_Client_Export 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);
+    
+  private:
+    UsesDefSeq *&ptr_;
+    // assignment from T_var not allowed
+    void operator= (const UsesDefSeq_var &);
+  };
+
+
+#endif /* end #if !defined */
+
+  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_UsesDefSeq;
+
+  class HomeDef;
+  
+#if !defined (_IR_HOMEDEF___PTR_CH_)
+#define _IR_HOMEDEF___PTR_CH_
+
+typedef HomeDef *HomeDef_ptr;
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_HOMEDEF___VAR_CH_)
+#define _IR_HOMEDEF___VAR_CH_
+
+  class TAO_IFR_Client_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);
+  };
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_HOMEDEF___OUT_CH_)
+#define _IR_HOMEDEF___OUT_CH_
+
+  class TAO_IFR_Client_Export 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);
+    
+  private:
+    HomeDef_ptr &ptr_;
+  };
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+    
+#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_HOMEDEFSEQ_CH_)
+#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_HOMEDEFSEQ_CH_
+
+    class _TAO_Unbounded_Object_Sequence_IR_HomeDefSeq : public TAO_Unbounded_Base_Sequence
+    {
+    public:
+      // = Initialization and termination methods.
+      
+      _TAO_Unbounded_Object_Sequence_IR_HomeDefSeq (void);
+      _TAO_Unbounded_Object_Sequence_IR_HomeDefSeq (CORBA::ULong maximum);
+      _TAO_Unbounded_Object_Sequence_IR_HomeDefSeq (CORBA::ULong maximum,
+        CORBA::ULong length,
+        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);
+      // 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;
+      virtual void _shrink_buffer (CORBA::ULong nl, CORBA::ULong ol);
+      virtual void _downcast (
+          void* target,
+          CORBA_Object *src,
+          CORBA_Environment &ACE_TRY_ENV = 
+            TAO_default_environment ()
+        );
+      virtual CORBA_Object* _upcast (void *src) const;
+      
+    };
+
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+  
+#if !defined (_IR_HOMEDEFSEQ_CH_)
+#define _IR_HOMEDEFSEQ_CH_
+
+  class HomeDefSeq;
+  class HomeDefSeq_var;
+  
+  // *************************************************************
+  // HomeDefSeq
+  // *************************************************************
+  
+  class TAO_IFR_Client_Export 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>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+  {
+  public:
+    HomeDefSeq (void); // default ctor
+    HomeDefSeq (CORBA::ULong max); // uses max size
+    HomeDefSeq (
+      CORBA::ULong max, 
+      CORBA::ULong length, 
+      HomeDef_ptr *buffer, 
+      CORBA::Boolean release = 0
+    );
+    HomeDefSeq (const HomeDefSeq &); // copy ctor
+    ~HomeDefSeq (void);
+    static void _tao_any_destructor (void*);
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+    typedef HomeDefSeq_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  };
+  
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_HOMEDEFSEQ___VAR_CH_)
+#define _IR_HOMEDEFSEQ___VAR_CH_
+
+  // *************************************************************
+  // class IR::HomeDefSeq_var
+  // *************************************************************
+
+  class TAO_IFR_Client_Export HomeDefSeq_var
+  {
+  public:
+    HomeDefSeq_var (void); // default constructor
+    HomeDefSeq_var (HomeDefSeq *);
+    HomeDefSeq_var (const HomeDefSeq_var &); // copy constructor
+    ~HomeDefSeq_var (void); // destructor
+    
+    HomeDefSeq_var &operator= (HomeDefSeq *);
+    HomeDefSeq_var &operator= (const HomeDefSeq_var &);
+    HomeDefSeq *operator-> (void);
+    const HomeDefSeq *operator-> (void) const;
+    
+    operator const HomeDefSeq &() const;
+    operator HomeDefSeq &();
+    operator HomeDefSeq &() const;
+    operator HomeDefSeq *&(); // variable-size base types only
+    
+    TAO_Object_Manager<HomeDef, 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;
+
+  private:
+    HomeDefSeq *ptr_;
+  };
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_HOMEDEFSEQ___OUT_CH_)
+#define _IR_HOMEDEFSEQ___OUT_CH_
+
+  class TAO_IFR_Client_Export 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);
+    
+  private:
+    HomeDefSeq *&ptr_;
+    // assignment from T_var not allowed
+    void operator= (const HomeDefSeq_var &);
+  };
+
+
+#endif /* end #if !defined */
+
+  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_HomeDefSeq;
+
+  class EventDef;
+  
+#if !defined (_IR_EVENTDEF___PTR_CH_)
+#define _IR_EVENTDEF___PTR_CH_
+
+typedef EventDef *EventDef_ptr;
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_EVENTDEF___VAR_CH_)
+#define _IR_EVENTDEF___VAR_CH_
+
+  class TAO_IFR_Client_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 (_IR_EVENTDEF___OUT_CH_)
+#define _IR_EVENTDEF___OUT_CH_
+
+  class TAO_IFR_Client_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_;
+  };
+
+
+#endif /* end #if !defined */
+
+  class EmitsDef;
+  
+#if !defined (_IR_EMITSDEF___PTR_CH_)
+#define _IR_EMITSDEF___PTR_CH_
+
+typedef EmitsDef *EmitsDef_ptr;
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_EMITSDEF___VAR_CH_)
+#define _IR_EMITSDEF___VAR_CH_
+
+  class TAO_IFR_Client_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 (_IR_EMITSDEF___OUT_CH_)
+#define _IR_EMITSDEF___OUT_CH_
+
+  class TAO_IFR_Client_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_;
+  };
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+    
+#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_EMITSDEFSEQ_CH_)
+#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_EMITSDEFSEQ_CH_
+
+    class _TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq : public TAO_Unbounded_Base_Sequence
+    {
+    public:
+      // = Initialization and termination methods.
+      
+      _TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq (void);
+      _TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq (CORBA::ULong maximum);
+      _TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq (CORBA::ULong maximum,
+        CORBA::ULong length,
+        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);
+      // 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;
+      virtual void _shrink_buffer (CORBA::ULong nl, CORBA::ULong ol);
+      virtual void _downcast (
+          void* target,
+          CORBA_Object *src,
+          CORBA_Environment &ACE_TRY_ENV = 
+            TAO_default_environment ()
+        );
+      virtual CORBA_Object* _upcast (void *src) const;
+      
+    };
+
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+  
+#if !defined (_IR_EMITSDEFSEQ_CH_)
+#define _IR_EMITSDEFSEQ_CH_
+
+  class EmitsDefSeq;
+  class EmitsDefSeq_var;
+  
+  // *************************************************************
+  // EmitsDefSeq
+  // *************************************************************
+  
+  class TAO_IFR_Client_Export 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>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+  {
+  public:
+    EmitsDefSeq (void); // default ctor
+    EmitsDefSeq (CORBA::ULong max); // uses max size
+    EmitsDefSeq (
+      CORBA::ULong max, 
+      CORBA::ULong length, 
+      EmitsDef_ptr *buffer, 
+      CORBA::Boolean release = 0
+    );
+    EmitsDefSeq (const EmitsDefSeq &); // copy ctor
+    ~EmitsDefSeq (void);
+    static void _tao_any_destructor (void*);
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+    typedef EmitsDefSeq_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  };
+  
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_EMITSDEFSEQ___VAR_CH_)
+#define _IR_EMITSDEFSEQ___VAR_CH_
+
+  // *************************************************************
+  // class IR::EmitsDefSeq_var
+  // *************************************************************
+
+  class TAO_IFR_Client_Export EmitsDefSeq_var
+  {
+  public:
+    EmitsDefSeq_var (void); // default constructor
+    EmitsDefSeq_var (EmitsDefSeq *);
+    EmitsDefSeq_var (const EmitsDefSeq_var &); // copy constructor
+    ~EmitsDefSeq_var (void); // destructor
+    
+    EmitsDefSeq_var &operator= (EmitsDefSeq *);
+    EmitsDefSeq_var &operator= (const EmitsDefSeq_var &);
+    EmitsDefSeq *operator-> (void);
+    const EmitsDefSeq *operator-> (void) const;
+    
+    operator const EmitsDefSeq &() const;
+    operator EmitsDefSeq &();
+    operator EmitsDefSeq &() const;
+    operator EmitsDefSeq *&(); // variable-size base types only
+    
+    TAO_Object_Manager<EmitsDef, 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;
+
+  private:
+    EmitsDefSeq *ptr_;
+  };
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_EMITSDEFSEQ___OUT_CH_)
+#define _IR_EMITSDEFSEQ___OUT_CH_
+
+  class TAO_IFR_Client_Export 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);
+    
+  private:
+    EmitsDefSeq *&ptr_;
+    // assignment from T_var not allowed
+    void operator= (const EmitsDefSeq_var &);
+  };
+
+
+#endif /* end #if !defined */
+
+  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_EmitsDefSeq;
+
+  class PublishesDef;
+  
+#if !defined (_IR_PUBLISHESDEF___PTR_CH_)
+#define _IR_PUBLISHESDEF___PTR_CH_
+
+typedef PublishesDef *PublishesDef_ptr;
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_PUBLISHESDEF___VAR_CH_)
+#define _IR_PUBLISHESDEF___VAR_CH_
+
+  class TAO_IFR_Client_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 (_IR_PUBLISHESDEF___OUT_CH_)
+#define _IR_PUBLISHESDEF___OUT_CH_
+
+  class TAO_IFR_Client_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_USE_SEQUENCE_TEMPLATES)
+    
+#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_PUBLISHESDEFSEQ_CH_)
+#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_PUBLISHESDEFSEQ_CH_
+
+    class _TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq : public TAO_Unbounded_Base_Sequence
+    {
+    public:
+      // = Initialization and termination methods.
+      
+      _TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq (void);
+      _TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq (CORBA::ULong maximum);
+      _TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq (CORBA::ULong maximum,
+        CORBA::ULong length,
+        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);
+      // 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;
+      virtual void _shrink_buffer (CORBA::ULong nl, CORBA::ULong ol);
+      virtual void _downcast (
+          void* target,
+          CORBA_Object *src,
+          CORBA_Environment &ACE_TRY_ENV = 
+            TAO_default_environment ()
+        );
+      virtual CORBA_Object* _upcast (void *src) const;
+      
+    };
+
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+  
+#if !defined (_IR_PUBLISHESDEFSEQ_CH_)
+#define _IR_PUBLISHESDEFSEQ_CH_
+
+  class PublishesDefSeq;
+  class PublishesDefSeq_var;
+  
+  // *************************************************************
+  // PublishesDefSeq
+  // *************************************************************
+  
+  class TAO_IFR_Client_Export 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>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+  {
+  public:
+    PublishesDefSeq (void); // default ctor
+    PublishesDefSeq (CORBA::ULong max); // uses max size
+    PublishesDefSeq (
+      CORBA::ULong max, 
+      CORBA::ULong length, 
+      PublishesDef_ptr *buffer, 
+      CORBA::Boolean release = 0
+    );
+    PublishesDefSeq (const PublishesDefSeq &); // copy ctor
+    ~PublishesDefSeq (void);
+    static void _tao_any_destructor (void*);
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+    typedef PublishesDefSeq_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  };
+  
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_PUBLISHESDEFSEQ___VAR_CH_)
+#define _IR_PUBLISHESDEFSEQ___VAR_CH_
+
+  // *************************************************************
+  // class IR::PublishesDefSeq_var
+  // *************************************************************
+
+  class TAO_IFR_Client_Export PublishesDefSeq_var
+  {
+  public:
+    PublishesDefSeq_var (void); // default constructor
+    PublishesDefSeq_var (PublishesDefSeq *);
+    PublishesDefSeq_var (const PublishesDefSeq_var &); // copy constructor
+    ~PublishesDefSeq_var (void); // destructor
+    
+    PublishesDefSeq_var &operator= (PublishesDefSeq *);
+    PublishesDefSeq_var &operator= (const PublishesDefSeq_var &);
+    PublishesDefSeq *operator-> (void);
+    const PublishesDefSeq *operator-> (void) const;
+    
+    operator const PublishesDefSeq &() const;
+    operator PublishesDefSeq &();
+    operator PublishesDefSeq &() const;
+    operator PublishesDefSeq *&(); // variable-size base types only
+    
+    TAO_Object_Manager<PublishesDef, 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;
+
+  private:
+    PublishesDefSeq *ptr_;
+  };
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_PUBLISHESDEFSEQ___OUT_CH_)
+#define _IR_PUBLISHESDEFSEQ___OUT_CH_
+
+  class TAO_IFR_Client_Export 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);
+    
+  private:
+    PublishesDefSeq *&ptr_;
+    // assignment from T_var not allowed
+    void operator= (const PublishesDefSeq_var &);
+  };
+
+
+#endif /* end #if !defined */
+
+  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_PublishesDefSeq;
+
+  class ConsumesDef;
+  
+#if !defined (_IR_CONSUMESDEF___PTR_CH_)
+#define _IR_CONSUMESDEF___PTR_CH_
+
+typedef ConsumesDef *ConsumesDef_ptr;
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_CONSUMESDEF___VAR_CH_)
+#define _IR_CONSUMESDEF___VAR_CH_
+
+  class TAO_IFR_Client_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 (_IR_CONSUMESDEF___OUT_CH_)
+#define _IR_CONSUMESDEF___OUT_CH_
+
+  class TAO_IFR_Client_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_USE_SEQUENCE_TEMPLATES)
+    
+#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_CONSUMESDEFSEQ_CH_)
+#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_CONSUMESDEFSEQ_CH_
+
+    class _TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq : public TAO_Unbounded_Base_Sequence
+    {
+    public:
+      // = Initialization and termination methods.
+      
+      _TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq (void);
+      _TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq (CORBA::ULong maximum);
+      _TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq (CORBA::ULong maximum,
+        CORBA::ULong length,
+        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);
+      // 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;
+      virtual void _shrink_buffer (CORBA::ULong nl, CORBA::ULong ol);
+      virtual void _downcast (
+          void* target,
+          CORBA_Object *src,
+          CORBA_Environment &ACE_TRY_ENV = 
+            TAO_default_environment ()
+        );
+      virtual CORBA_Object* _upcast (void *src) const;
+      
+    };
+
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+  
+#if !defined (_IR_CONSUMESDEFSEQ_CH_)
+#define _IR_CONSUMESDEFSEQ_CH_
+
+  class ConsumesDefSeq;
+  class ConsumesDefSeq_var;
+  
+  // *************************************************************
+  // ConsumesDefSeq
+  // *************************************************************
+  
+  class TAO_IFR_Client_Export 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>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+  {
+  public:
+    ConsumesDefSeq (void); // default ctor
+    ConsumesDefSeq (CORBA::ULong max); // uses max size
+    ConsumesDefSeq (
+      CORBA::ULong max, 
+      CORBA::ULong length, 
+      ConsumesDef_ptr *buffer, 
+      CORBA::Boolean release = 0
+    );
+    ConsumesDefSeq (const ConsumesDefSeq &); // copy ctor
+    ~ConsumesDefSeq (void);
+    static void _tao_any_destructor (void*);
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+    typedef ConsumesDefSeq_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  };
+  
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_CONSUMESDEFSEQ___VAR_CH_)
+#define _IR_CONSUMESDEFSEQ___VAR_CH_
+
+  // *************************************************************
+  // class IR::ConsumesDefSeq_var
+  // *************************************************************
+
+  class TAO_IFR_Client_Export ConsumesDefSeq_var
+  {
+  public:
+    ConsumesDefSeq_var (void); // default constructor
+    ConsumesDefSeq_var (ConsumesDefSeq *);
+    ConsumesDefSeq_var (const ConsumesDefSeq_var &); // copy constructor
+    ~ConsumesDefSeq_var (void); // destructor
+    
+    ConsumesDefSeq_var &operator= (ConsumesDefSeq *);
+    ConsumesDefSeq_var &operator= (const ConsumesDefSeq_var &);
+    ConsumesDefSeq *operator-> (void);
+    const ConsumesDefSeq *operator-> (void) const;
+    
+    operator const ConsumesDefSeq &() const;
+    operator ConsumesDefSeq &();
+    operator ConsumesDefSeq &() const;
+    operator ConsumesDefSeq *&(); // variable-size base types only
+    
+    TAO_Object_Manager<ConsumesDef, 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;
+
+  private:
+    ConsumesDefSeq *ptr_;
+  };
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_CONSUMESDEFSEQ___OUT_CH_)
+#define _IR_CONSUMESDEFSEQ___OUT_CH_
+
+  class TAO_IFR_Client_Export 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);
+    
+  private:
+    ConsumesDefSeq *&ptr_;
+    // assignment from T_var not allowed
+    void operator= (const ConsumesDefSeq_var &);
+  };
+
+
+#endif /* end #if !defined */
+
+  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ConsumesDefSeq;
+
+  class FactoryDef;
+  
+#if !defined (_IR_FACTORYDEF___PTR_CH_)
+#define _IR_FACTORYDEF___PTR_CH_
+
+typedef FactoryDef *FactoryDef_ptr;
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_FACTORYDEF___VAR_CH_)
+#define _IR_FACTORYDEF___VAR_CH_
+
+  class TAO_IFR_Client_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 (_IR_FACTORYDEF___OUT_CH_)
+#define _IR_FACTORYDEF___OUT_CH_
+
+  class TAO_IFR_Client_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_;
+  };
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+    
+#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_FACTORYDEFSEQ_CH_)
+#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_FACTORYDEFSEQ_CH_
+
+    class _TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq : public TAO_Unbounded_Base_Sequence
+    {
+    public:
+      // = Initialization and termination methods.
+      
+      _TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq (void);
+      _TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq (CORBA::ULong maximum);
+      _TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq (CORBA::ULong maximum,
+        CORBA::ULong length,
+        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);
+      // 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;
+      virtual void _shrink_buffer (CORBA::ULong nl, CORBA::ULong ol);
+      virtual void _downcast (
+          void* target,
+          CORBA_Object *src,
+          CORBA_Environment &ACE_TRY_ENV = 
+            TAO_default_environment ()
+        );
+      virtual CORBA_Object* _upcast (void *src) const;
+      
+    };
+
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+  
+#if !defined (_IR_FACTORYDEFSEQ_CH_)
+#define _IR_FACTORYDEFSEQ_CH_
+
+  class FactoryDefSeq;
+  class FactoryDefSeq_var;
+  
+  // *************************************************************
+  // FactoryDefSeq
+  // *************************************************************
+  
+  class TAO_IFR_Client_Export 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>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+  {
+  public:
+    FactoryDefSeq (void); // default ctor
+    FactoryDefSeq (CORBA::ULong max); // uses max size
+    FactoryDefSeq (
+      CORBA::ULong max, 
+      CORBA::ULong length, 
+      FactoryDef_ptr *buffer, 
+      CORBA::Boolean release = 0
+    );
+    FactoryDefSeq (const FactoryDefSeq &); // copy ctor
+    ~FactoryDefSeq (void);
+    static void _tao_any_destructor (void*);
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+    typedef FactoryDefSeq_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  };
+  
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_FACTORYDEFSEQ___VAR_CH_)
+#define _IR_FACTORYDEFSEQ___VAR_CH_
+
+  // *************************************************************
+  // class IR::FactoryDefSeq_var
+  // *************************************************************
+
+  class TAO_IFR_Client_Export FactoryDefSeq_var
+  {
+  public:
+    FactoryDefSeq_var (void); // default constructor
+    FactoryDefSeq_var (FactoryDefSeq *);
+    FactoryDefSeq_var (const FactoryDefSeq_var &); // copy constructor
+    ~FactoryDefSeq_var (void); // destructor
+    
+    FactoryDefSeq_var &operator= (FactoryDefSeq *);
+    FactoryDefSeq_var &operator= (const FactoryDefSeq_var &);
+    FactoryDefSeq *operator-> (void);
+    const FactoryDefSeq *operator-> (void) const;
+    
+    operator const FactoryDefSeq &() const;
+    operator FactoryDefSeq &();
+    operator FactoryDefSeq &() const;
+    operator FactoryDefSeq *&(); // variable-size base types only
+    
+    TAO_Object_Manager<FactoryDef, 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;
+
+  private:
+    FactoryDefSeq *ptr_;
+  };
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_FACTORYDEFSEQ___OUT_CH_)
+#define _IR_FACTORYDEFSEQ___OUT_CH_
+
+  class TAO_IFR_Client_Export 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);
+    
+  private:
+    FactoryDefSeq *&ptr_;
+    // assignment from T_var not allowed
+    void operator= (const FactoryDefSeq_var &);
+  };
+
+
+#endif /* end #if !defined */
+
+  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_FactoryDefSeq;
+
+  class FinderDef;
+  
+#if !defined (_IR_FINDERDEF___PTR_CH_)
+#define _IR_FINDERDEF___PTR_CH_
+
+typedef FinderDef *FinderDef_ptr;
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_FINDERDEF___VAR_CH_)
+#define _IR_FINDERDEF___VAR_CH_
+
+  class TAO_IFR_Client_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 (_IR_FINDERDEF___OUT_CH_)
+#define _IR_FINDERDEF___OUT_CH_
+
+  class TAO_IFR_Client_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_USE_SEQUENCE_TEMPLATES)
+    
+#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_FINDERDEFSEQ_CH_)
+#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_FINDERDEFSEQ_CH_
+
+    class _TAO_Unbounded_Object_Sequence_IR_FinderDefSeq : public TAO_Unbounded_Base_Sequence
+    {
+    public:
+      // = Initialization and termination methods.
+      
+      _TAO_Unbounded_Object_Sequence_IR_FinderDefSeq (void);
+      _TAO_Unbounded_Object_Sequence_IR_FinderDefSeq (CORBA::ULong maximum);
+      _TAO_Unbounded_Object_Sequence_IR_FinderDefSeq (CORBA::ULong maximum,
+        CORBA::ULong length,
+        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);
+      // 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;
+      virtual void _shrink_buffer (CORBA::ULong nl, CORBA::ULong ol);
+      virtual void _downcast (
+          void* target,
+          CORBA_Object *src,
+          CORBA_Environment &ACE_TRY_ENV = 
+            TAO_default_environment ()
+        );
+      virtual CORBA_Object* _upcast (void *src) const;
+      
+    };
+
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+  
+#if !defined (_IR_FINDERDEFSEQ_CH_)
+#define _IR_FINDERDEFSEQ_CH_
+
+  class FinderDefSeq;
+  class FinderDefSeq_var;
+  
+  // *************************************************************
+  // FinderDefSeq
+  // *************************************************************
+  
+  class TAO_IFR_Client_Export 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>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+  {
+  public:
+    FinderDefSeq (void); // default ctor
+    FinderDefSeq (CORBA::ULong max); // uses max size
+    FinderDefSeq (
+      CORBA::ULong max, 
+      CORBA::ULong length, 
+      FinderDef_ptr *buffer, 
+      CORBA::Boolean release = 0
+    );
+    FinderDefSeq (const FinderDefSeq &); // copy ctor
+    ~FinderDefSeq (void);
+    static void _tao_any_destructor (void*);
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+    typedef FinderDefSeq_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  };
+  
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_FINDERDEFSEQ___VAR_CH_)
+#define _IR_FINDERDEFSEQ___VAR_CH_
+
+  // *************************************************************
+  // class IR::FinderDefSeq_var
+  // *************************************************************
+
+  class TAO_IFR_Client_Export FinderDefSeq_var
+  {
+  public:
+    FinderDefSeq_var (void); // default constructor
+    FinderDefSeq_var (FinderDefSeq *);
+    FinderDefSeq_var (const FinderDefSeq_var &); // copy constructor
+    ~FinderDefSeq_var (void); // destructor
+    
+    FinderDefSeq_var &operator= (FinderDefSeq *);
+    FinderDefSeq_var &operator= (const FinderDefSeq_var &);
+    FinderDefSeq *operator-> (void);
+    const FinderDefSeq *operator-> (void) const;
+    
+    operator const FinderDefSeq &() const;
+    operator FinderDefSeq &();
+    operator FinderDefSeq &() const;
+    operator FinderDefSeq *&(); // variable-size base types only
+    
+    TAO_Object_Manager<FinderDef, 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;
+
+  private:
+    FinderDefSeq *ptr_;
+  };
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_FINDERDEFSEQ___OUT_CH_)
+#define _IR_FINDERDEFSEQ___OUT_CH_
+
+  class TAO_IFR_Client_Export 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);
+    
+  private:
+    FinderDefSeq *&ptr_;
+    // assignment from T_var not allowed
+    void operator= (const FinderDefSeq_var &);
+  };
+
+
+#endif /* end #if !defined */
+
+  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_FinderDefSeq;
+
+  class PrimaryKeyDef;
+  
+#if !defined (_IR_PRIMARYKEYDEF___PTR_CH_)
+#define _IR_PRIMARYKEYDEF___PTR_CH_
+
+typedef PrimaryKeyDef *PrimaryKeyDef_ptr;
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_PRIMARYKEYDEF___VAR_CH_)
+#define _IR_PRIMARYKEYDEF___VAR_CH_
+
+  class TAO_IFR_Client_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
+    
+    PrimaryKeyDef_var &operator= (PrimaryKeyDef_ptr);
+    PrimaryKeyDef_var &operator= (const PrimaryKeyDef_var &);
+    PrimaryKeyDef_ptr operator-> (void) const;
+    
+    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;
+
+  private:
+    PrimaryKeyDef_ptr ptr_;
+    // Unimplemented - prevents widening assignment.
+    PrimaryKeyDef_var (const TAO_Base_var &rhs);
+    PrimaryKeyDef_var &operator= (const TAO_Base_var &rhs);
+  };
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_PRIMARYKEYDEF___OUT_CH_)
+#define _IR_PRIMARYKEYDEF___OUT_CH_
+
+  class TAO_IFR_Client_Export 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);
+    
+  private:
+    PrimaryKeyDef_ptr &ptr_;
+  };
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_COMPONENTREPOSITORY___PTR_CH_)
+#define _IR_COMPONENTREPOSITORY___PTR_CH_
+
+  class ComponentRepository;
+  typedef ComponentRepository *ComponentRepository_ptr;
+  
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_COMPONENTREPOSITORY___VAR_CH_)
+#define _IR_COMPONENTREPOSITORY___VAR_CH_
+
+  class TAO_IFR_Client_Export 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
+    
+    ComponentRepository_var &operator= (ComponentRepository_ptr);
+    ComponentRepository_var &operator= (const ComponentRepository_var &);
+    ComponentRepository_ptr operator-> (void) const;
+    
+    operator const ComponentRepository_ptr &() const;
+    operator 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;
+
+  private:
+    ComponentRepository_ptr ptr_;
+    // Unimplemented - prevents widening assignment.
+    ComponentRepository_var (const TAO_Base_var &rhs);
+    ComponentRepository_var &operator= (const TAO_Base_var &rhs);
+  };
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_COMPONENTREPOSITORY___OUT_CH_)
+#define _IR_COMPONENTREPOSITORY___OUT_CH_
+
+  class TAO_IFR_Client_Export 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);
+    
+  private:
+    ComponentRepository_ptr &ptr_;
+  };
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_COMPONENTREPOSITORY_CH_)
+#define _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_IFR_Client_Export ComponentRepository: public virtual CORBA::Repository
+  {
+  public:
+  #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+    typedef ComponentRepository_ptr _ptr_type;
+    typedef ComponentRepository_var _var_type;
+  #endif /* ! __GNUC__ || g++ >= 2.8 */
+
+    // the static operations
+    static ComponentRepository_ptr _duplicate (ComponentRepository_ptr obj);
+    static ComponentRepository_ptr _narrow (
+        CORBA::Object_ptr obj,
+        CORBA::Environment &ACE_TRY_ENV = 
+          TAO_default_environment ()
+      );
+    static ComponentRepository_ptr _unchecked_narrow (
+        CORBA::Object_ptr obj,
+        CORBA::Environment &ACE_TRY_ENV = 
+          TAO_default_environment ()
+      );
+    static ComponentRepository_ptr _nil (void)
+      {
+        return (ComponentRepository_ptr)0;
+      }
+
+    static void _tao_any_destructor (void*);
+
+    virtual IR::ComponentDef_ptr create_component (
+        const char * id,
+        const char * name,
+        const char * version,
+        IR::ComponentDef_ptr base_component,
+        const CORBA::InterfaceDefSeq & supports_interfaces,
+        CORBA::Environment &ACE_TRY_ENV = 
+          TAO_default_environment ()
+      )
+      ACE_THROW_SPEC ((
+        CORBA::SystemException
+      ));
+
+    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,
+        CORBA::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_ComponentRepository_Proxy_Broker *the_TAO_ComponentRepository_Proxy_Broker_;
+    
+  protected:
+    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 IR_ComponentRepository_setup_collocation (int collocated);
+      
+      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 (
+        TAO_GIOP_Invocation *_tao_invocation,
+        CORBA::Object_ptr _tao_target,
+        const char * id,
+        const char * name,
+        const char * version,
+        IR::ComponentDef_ptr base_component,
+        const CORBA::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 CORBA::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 (
+      TAO_GIOP_Invocation *_tao_invocation,
+      CORBA::Object_ptr _tao_target,
+      const char * id,
+      const char * name,
+      const char * version,
+      IR::HomeDef_ptr base_home,
+      IR::ComponentDef_ptr managed_component,
+      CORBA::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_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_;
+  CORBA::ValueDef_ptr primary_key_;
+  void result (IR::HomeDef_ptr result);
+  // update the result 
+  IR::HomeDef_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_IFR_Client_Export _TAO_ComponentRepository_Proxy_Impl : 
+  public virtual _TAO_Repository_Proxy_Impl
+{
+public:
+  virtual ~_TAO_ComponentRepository_Proxy_Impl (void) { }
+  
+    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 CORBA::InterfaceDefSeq & supports_interfaces,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  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,
+      CORBA::ValueDef_ptr primary_key,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+protected:
+  _TAO_ComponentRepository_Proxy_Impl (void);
+
+};
+//
+//                Base  Proxy Impl. Declaration
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//                    Remote  Impl. Declaration
+//
+
+class TAO_IFR_Client_Export _TAO_ComponentRepository_Remote_Proxy_Impl : 
+  public virtual _TAO_ComponentRepository_Proxy_Impl,
+  public virtual TAO_Remote_Object_Proxy_Impl,
+  public virtual _TAO_Repository_Remote_Proxy_Impl
+  
+{
+public:
+  _TAO_ComponentRepository_Remote_Proxy_Impl (void);
+  
+  virtual ~_TAO_ComponentRepository_Remote_Proxy_Impl (void) { }
+  
+    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 CORBA::InterfaceDefSeq & supports_interfaces,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  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,
+      CORBA::ValueDef_ptr primary_key,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+};
+
+//
+//                Base  Proxy Impl. Declaration
+///////////////////////////////////////////////////////////////////////
+
+
+// The Proxy Brokers are used by each interface to get
+// the right proxy for performing a call. In the new 
+// collocation scheme, the proxy to be used can vary on
+// a call by call basis. 
+
+
+
+///////////////////////////////////////////////////////////////////////
+//                 Base Proxy Broker Declaration 
+//
+
+class TAO_IFR_Client_Export _TAO_ComponentRepository_Proxy_Broker
+{
+public:
+  virtual ~_TAO_ComponentRepository_Proxy_Broker (void);
+  virtual _TAO_ComponentRepository_Proxy_Impl &select_proxy (
+    ComponentRepository *object,
+    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
+  ) = 0;
+
+protected:
+  _TAO_ComponentRepository_Proxy_Broker (void);
+  
+};
+
+//
+//              End Base Proxy Broker Declaration 
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//                 Remote Proxy Broker Declaration 
+//
+
+class TAO_IFR_Client_Export _TAO_ComponentRepository_Remote_Proxy_Broker : public virtual _TAO_ComponentRepository_Proxy_Broker
+{
+public: 
+  _TAO_ComponentRepository_Remote_Proxy_Broker (void);
+  
+  virtual ~_TAO_ComponentRepository_Remote_Proxy_Broker (void);
+  
+  virtual _TAO_ComponentRepository_Proxy_Impl &select_proxy (
+    ComponentRepository *object,
+    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
+  );
+
+private:
+  _TAO_ComponentRepository_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_ComponentRepository_Remote_Proxy_Broker *the_TAO_ComponentRepository_Remote_Proxy_Broker (void);
+};
+
+
+//
+//              End Remote Proxy Broker Declaration 
+///////////////////////////////////////////////////////////////////////
+
+
+#endif /* end #if !defined */
+
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ComponentRepository;
+
+
+#if !defined (_IR_PROVIDESDEF___PTR_CH_)
+#define _IR_PROVIDESDEF___PTR_CH_
+
+class ProvidesDef;
+typedef ProvidesDef *ProvidesDef_ptr;
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_PROVIDESDEF___VAR_CH_)
+#define _IR_PROVIDESDEF___VAR_CH_
+
+class TAO_IFR_Client_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 (_IR_PROVIDESDEF___OUT_CH_)
+#define _IR_PROVIDESDEF___OUT_CH_
+
+class TAO_IFR_Client_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 (_IR_PROVIDESDEF_CH_)
+#define _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_IFR_Client_Export ProvidesDef: public virtual CORBA::Contained
+{
+public:
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef ProvidesDef_ptr _ptr_type;
+  typedef ProvidesDef_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  // the static operations
+  static ProvidesDef_ptr _duplicate (ProvidesDef_ptr obj);
+  static ProvidesDef_ptr _narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    );
+  static ProvidesDef_ptr _unchecked_narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    );
+  static ProvidesDef_ptr _nil (void)
+    {
+      return (ProvidesDef_ptr)0;
+    }
+
+  static void _tao_any_destructor (void*);
+
+  virtual CORBA::InterfaceDef_ptr interface_type (
+      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_ProvidesDef_Proxy_Broker *the_TAO_ProvidesDef_Proxy_Broker_;
+  
+protected:
+  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 IR_ProvidesDef_setup_collocation (int collocated);
+    
+    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 (
+      TAO_GIOP_Invocation *_tao_invocation,
+      CORBA::Object_ptr _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 (CORBA::InterfaceDef_ptr result);
+  // update the result 
+  CORBA::InterfaceDef_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_IFR_Client_Export _TAO_ProvidesDef_Proxy_Impl : 
+  public virtual _TAO_Contained_Proxy_Impl
+{
+public:
+  virtual ~_TAO_ProvidesDef_Proxy_Impl (void) { }
+  
+    virtual CORBA::InterfaceDef_ptr interface_type (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+protected:
+  _TAO_ProvidesDef_Proxy_Impl (void);
+
+};
+//
+//                Base  Proxy Impl. Declaration
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//                    Remote  Impl. Declaration
+//
+
+class TAO_IFR_Client_Export _TAO_ProvidesDef_Remote_Proxy_Impl : 
+  public virtual _TAO_ProvidesDef_Proxy_Impl,
+  public virtual TAO_Remote_Object_Proxy_Impl,
+  public virtual _TAO_Contained_Remote_Proxy_Impl
+  
+{
+public:
+  _TAO_ProvidesDef_Remote_Proxy_Impl (void);
+  
+  virtual ~_TAO_ProvidesDef_Remote_Proxy_Impl (void) { }
+  
+    virtual CORBA::InterfaceDef_ptr interface_type (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+};
+
+//
+//                Base  Proxy Impl. Declaration
+///////////////////////////////////////////////////////////////////////
+
+
+// The Proxy Brokers are used by each interface to get
+// the right proxy for performing a call. In the new 
+// collocation scheme, the proxy to be used can vary on
+// a call by call basis. 
+
+
+
+///////////////////////////////////////////////////////////////////////
+//                 Base Proxy Broker Declaration 
+//
+
+class TAO_IFR_Client_Export _TAO_ProvidesDef_Proxy_Broker
+{
+public:
+  virtual ~_TAO_ProvidesDef_Proxy_Broker (void);
+  virtual _TAO_ProvidesDef_Proxy_Impl &select_proxy (
+    ProvidesDef *object,
+    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
+  ) = 0;
+
+protected:
+  _TAO_ProvidesDef_Proxy_Broker (void);
+  
+};
+
+//
+//              End Base Proxy Broker Declaration 
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//                 Remote Proxy Broker Declaration 
+//
+
+class TAO_IFR_Client_Export _TAO_ProvidesDef_Remote_Proxy_Broker : public virtual _TAO_ProvidesDef_Proxy_Broker
+{
+public: 
+  _TAO_ProvidesDef_Remote_Proxy_Broker (void);
+  
+  virtual ~_TAO_ProvidesDef_Remote_Proxy_Broker (void);
+  
+  virtual _TAO_ProvidesDef_Proxy_Impl &select_proxy (
+    ProvidesDef *object,
+    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
+  );
+
+private:
+  _TAO_ProvidesDef_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_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_IFR_Client_Export ProvidesDescription
+{
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef ProvidesDescription_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  static void _tao_any_destructor (void*);
+
+  TAO_String_Manager name;
+  TAO_String_Manager id;
+  TAO_String_Manager defined_in;
+  TAO_String_Manager version;
+  CORBA::InterfaceDef_var interface_type;
+};
+
+class TAO_IFR_Client_Export ProvidesDescription_var
+{
+public:
+  ProvidesDescription_var (void); // default constructor
+  ProvidesDescription_var (ProvidesDescription *);
+  ProvidesDescription_var (const ProvidesDescription_var &); // copy constructor
+  ~ProvidesDescription_var (void); // destructor
+  
+  ProvidesDescription_var &operator= (ProvidesDescription *);
+  ProvidesDescription_var &operator= (const ProvidesDescription_var &);
+  ProvidesDescription *operator-> (void);
+  const ProvidesDescription *operator-> (void) const;
+  
+  operator const ProvidesDescription &() const;
+  operator ProvidesDescription &();
+  operator ProvidesDescription &() const;
+  operator 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;
+
+private:
+  ProvidesDescription *ptr_;
+};
+
+class TAO_IFR_Client_Export 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);
+  
+private:
+  ProvidesDescription *&ptr_;
+  // assignment from T_var not allowed
+  void operator= (const ProvidesDescription_var &);
+};
+
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ProvidesDescription;
+
+
+#if !defined (_IR_USESDEF___PTR_CH_)
+#define _IR_USESDEF___PTR_CH_
+
+class UsesDef;
+typedef UsesDef *UsesDef_ptr;
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_USESDEF___VAR_CH_)
+#define _IR_USESDEF___VAR_CH_
+
+class TAO_IFR_Client_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 (_IR_USESDEF___OUT_CH_)
+#define _IR_USESDEF___OUT_CH_
+
+class TAO_IFR_Client_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_;
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_USESDEF_CH_)
+#define _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_IFR_Client_Export UsesDef: public virtual CORBA::Contained
+{
+public:
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef UsesDef_ptr _ptr_type;
+  typedef UsesDef_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  // the static operations
+  static UsesDef_ptr _duplicate (UsesDef_ptr obj);
+  static UsesDef_ptr _narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    );
+  static UsesDef_ptr _unchecked_narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    );
+  static UsesDef_ptr _nil (void)
+    {
+      return (UsesDef_ptr)0;
+    }
+
+  static void _tao_any_destructor (void*);
+
+  virtual CORBA::InterfaceDef_ptr interface_type (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::Boolean is_multiple (
+      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_UsesDef_Proxy_Broker *the_TAO_UsesDef_Proxy_Broker_;
+  
+protected:
+  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 IR_UsesDef_setup_collocation (int collocated);
+    
+    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 (
+      TAO_GIOP_Invocation *_tao_invocation,
+      CORBA::Object_ptr _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 (CORBA::InterfaceDef_ptr result);
+  // update the result 
+  CORBA::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 (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _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_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 */
+
+};
+
+
+// The Proxy Implementations are used by each interface to
+// perform a call. Each different implementation encapsulate
+// an invocation logics.
+
+
+///////////////////////////////////////////////////////////////////////
+//                    Base  Impl. Declaration
+//
+
+class TAO_IFR_Client_Export _TAO_UsesDef_Proxy_Impl : 
+  public virtual _TAO_Contained_Proxy_Impl
+{
+public:
+  virtual ~_TAO_UsesDef_Proxy_Impl (void) { }
+  
+    virtual CORBA::InterfaceDef_ptr interface_type (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual CORBA::Boolean is_multiple (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+protected:
+  _TAO_UsesDef_Proxy_Impl (void);
+
+};
+//
+//                Base  Proxy Impl. Declaration
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//                    Remote  Impl. Declaration
+//
+
+class TAO_IFR_Client_Export _TAO_UsesDef_Remote_Proxy_Impl : 
+  public virtual _TAO_UsesDef_Proxy_Impl,
+  public virtual TAO_Remote_Object_Proxy_Impl,
+  public virtual _TAO_Contained_Remote_Proxy_Impl
+  
+{
+public:
+  _TAO_UsesDef_Remote_Proxy_Impl (void);
+  
+  virtual ~_TAO_UsesDef_Remote_Proxy_Impl (void) { }
+  
+    virtual CORBA::InterfaceDef_ptr interface_type (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::Boolean is_multiple (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+};
+
+//
+//                Base  Proxy Impl. Declaration
+///////////////////////////////////////////////////////////////////////
+
+
+// The Proxy Brokers are used by each interface to get
+// the right proxy for performing a call. In the new 
+// collocation scheme, the proxy to be used can vary on
+// a call by call basis. 
+
+
+
+///////////////////////////////////////////////////////////////////////
+//                 Base Proxy Broker Declaration 
+//
+
+class TAO_IFR_Client_Export _TAO_UsesDef_Proxy_Broker
+{
+public:
+  virtual ~_TAO_UsesDef_Proxy_Broker (void);
+  virtual _TAO_UsesDef_Proxy_Impl &select_proxy (
+    UsesDef *object,
+    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
+  ) = 0;
+
+protected:
+  _TAO_UsesDef_Proxy_Broker (void);
+  
+};
+
+//
+//              End Base Proxy Broker Declaration 
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//                 Remote Proxy Broker Declaration 
+//
+
+class TAO_IFR_Client_Export _TAO_UsesDef_Remote_Proxy_Broker : public virtual _TAO_UsesDef_Proxy_Broker
+{
+public: 
+  _TAO_UsesDef_Remote_Proxy_Broker (void);
+  
+  virtual ~_TAO_UsesDef_Remote_Proxy_Broker (void);
+  
+  virtual _TAO_UsesDef_Proxy_Impl &select_proxy (
+    UsesDef *object,
+    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
+  );
+
+private:
+  _TAO_UsesDef_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_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_IFR_Client_Export UsesDescription
+{
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef UsesDescription_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  static void _tao_any_destructor (void*);
+
+  TAO_String_Manager name;
+  TAO_String_Manager id;
+  TAO_String_Manager defined_in;
+  TAO_String_Manager version;
+  CORBA::InterfaceDef_var interface_type;
+  CORBA::Boolean is_multiple;
+};
+
+class TAO_IFR_Client_Export 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
+  
+  // in, inout, out, _retn 
+  const UsesDescription &in (void) const;
+  UsesDescription &inout (void);
+  UsesDescription *&out (void);
+  UsesDescription *_retn (void);
+  UsesDescription *ptr (void) const;
+
+private:
+  UsesDescription *ptr_;
+};
+
+class TAO_IFR_Client_Export 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);
+  
+private:
+  UsesDescription *&ptr_;
+  // assignment from T_var not allowed
+  void operator= (const UsesDescription_var &);
+};
+
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_UsesDescription;
+
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_SEQUENCE_IR_PROVIDESDESCSEQ_CH_)
+#define __TAO_UNBOUNDED_SEQUENCE_IR_PROVIDESDESCSEQ_CH_
+
+  class TAO_EXPORT_NESTED_MACRO _TAO_Unbounded_Sequence_IR_ProvidesDescSeq : public TAO_Unbounded_Base_Sequence
+  {
+  public:
+    // = Initialization and termination methods.
+    
+    _TAO_Unbounded_Sequence_IR_ProvidesDescSeq (void); // Default constructor.
+    _TAO_Unbounded_Sequence_IR_ProvidesDescSeq (CORBA::ULong maximum); 
+    _TAO_Unbounded_Sequence_IR_ProvidesDescSeq (CORBA::ULong maximum,
+      CORBA::ULong length,
+      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;
+    // = Static operations.
+    static ProvidesDescription *allocbuf (CORBA::ULong size);
+    static void freebuf (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;
+    void replace (CORBA::ULong max,
+      CORBA::ULong length,
+      ProvidesDescription *data,
+      CORBA::Boolean release);
+  };
+
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_IR_PROVIDESDESCSEQ_CH_)
+#define _IR_PROVIDESDESCSEQ_CH_
+
+class ProvidesDescSeq;
+class ProvidesDescSeq_var;
+
+// *************************************************************
+// ProvidesDescSeq
+// *************************************************************
+
+class TAO_IFR_Client_Export ProvidesDescSeq : public 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Sequence_IR_ProvidesDescSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<ProvidesDescription>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+{
+public:
+  ProvidesDescSeq (void); // default ctor
+  ProvidesDescSeq (CORBA::ULong max); // uses max size
+  ProvidesDescSeq (
+    CORBA::ULong max, 
+    CORBA::ULong length, 
+    ProvidesDescription *buffer, 
+    CORBA::Boolean release = 0
+  );
+  ProvidesDescSeq (const ProvidesDescSeq &); // copy ctor
+  ~ProvidesDescSeq (void);
+  static void _tao_any_destructor (void*);
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef ProvidesDescSeq_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+};
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_PROVIDESDESCSEQ___VAR_CH_)
+#define _IR_PROVIDESDESCSEQ___VAR_CH_
+
+// *************************************************************
+// class IR::ProvidesDescSeq_var
+// *************************************************************
+
+class TAO_IFR_Client_Export ProvidesDescSeq_var
+{
+public:
+  ProvidesDescSeq_var (void); // default constructor
+  ProvidesDescSeq_var (ProvidesDescSeq *);
+  ProvidesDescSeq_var (const ProvidesDescSeq_var &); // copy constructor
+  ~ProvidesDescSeq_var (void); // destructor
+  
+  ProvidesDescSeq_var &operator= (ProvidesDescSeq *);
+  ProvidesDescSeq_var &operator= (const ProvidesDescSeq_var &);
+  ProvidesDescSeq *operator-> (void);
+  const ProvidesDescSeq *operator-> (void) const;
+  
+  operator const ProvidesDescSeq &() const;
+  operator ProvidesDescSeq &();
+  operator ProvidesDescSeq &() const;
+  operator ProvidesDescSeq *&(); // variable-size base types only
+  
+  ProvidesDescription & operator[] (CORBA::ULong index);
+  const 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;
+
+private:
+  ProvidesDescSeq *ptr_;
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_PROVIDESDESCSEQ___OUT_CH_)
+#define _IR_PROVIDESDESCSEQ___OUT_CH_
+
+class TAO_IFR_Client_Export 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);
+  
+private:
+  ProvidesDescSeq *&ptr_;
+  // assignment from T_var not allowed
+  void operator= (const ProvidesDescSeq_var &);
+};
+
+
+#endif /* end #if !defined */
+
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ProvidesDescSeq;
+
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_SEQUENCE_IR_USESDESCSEQ_CH_)
+#define __TAO_UNBOUNDED_SEQUENCE_IR_USESDESCSEQ_CH_
+
+  class TAO_EXPORT_NESTED_MACRO _TAO_Unbounded_Sequence_IR_UsesDescSeq : public TAO_Unbounded_Base_Sequence
+  {
+  public:
+    // = Initialization and termination methods.
+    
+    _TAO_Unbounded_Sequence_IR_UsesDescSeq (void); // Default constructor.
+    _TAO_Unbounded_Sequence_IR_UsesDescSeq (CORBA::ULong maximum); 
+    _TAO_Unbounded_Sequence_IR_UsesDescSeq (CORBA::ULong maximum,
+      CORBA::ULong length,
+      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;
+    // = Static operations.
+    static UsesDescription *allocbuf (CORBA::ULong size);
+    static void freebuf (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;
+    void replace (CORBA::ULong max,
+      CORBA::ULong length,
+      UsesDescription *data,
+      CORBA::Boolean release);
+  };
+
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_IR_USESDESCSEQ_CH_)
+#define _IR_USESDESCSEQ_CH_
+
+class UsesDescSeq;
+class UsesDescSeq_var;
+
+// *************************************************************
+// UsesDescSeq
+// *************************************************************
+
+class TAO_IFR_Client_Export UsesDescSeq : public 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Sequence_IR_UsesDescSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<UsesDescription>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+{
+public:
+  UsesDescSeq (void); // default ctor
+  UsesDescSeq (CORBA::ULong max); // uses max size
+  UsesDescSeq (
+    CORBA::ULong max, 
+    CORBA::ULong length, 
+    UsesDescription *buffer, 
+    CORBA::Boolean release = 0
+  );
+  UsesDescSeq (const UsesDescSeq &); // copy ctor
+  ~UsesDescSeq (void);
+  static void _tao_any_destructor (void*);
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef UsesDescSeq_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+};
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_USESDESCSEQ___VAR_CH_)
+#define _IR_USESDESCSEQ___VAR_CH_
+
+// *************************************************************
+// class IR::UsesDescSeq_var
+// *************************************************************
+
+class TAO_IFR_Client_Export UsesDescSeq_var
+{
+public:
+  UsesDescSeq_var (void); // default constructor
+  UsesDescSeq_var (UsesDescSeq *);
+  UsesDescSeq_var (const UsesDescSeq_var &); // copy constructor
+  ~UsesDescSeq_var (void); // destructor
+  
+  UsesDescSeq_var &operator= (UsesDescSeq *);
+  UsesDescSeq_var &operator= (const UsesDescSeq_var &);
+  UsesDescSeq *operator-> (void);
+  const UsesDescSeq *operator-> (void) const;
+  
+  operator const UsesDescSeq &() const;
+  operator UsesDescSeq &();
+  operator UsesDescSeq &() const;
+  operator UsesDescSeq *&(); // variable-size base types only
+  
+  UsesDescription & operator[] (CORBA::ULong index);
+  const 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;
+
+private:
+  UsesDescSeq *ptr_;
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_USESDESCSEQ___OUT_CH_)
+#define _IR_USESDESCSEQ___OUT_CH_
+
+class TAO_IFR_Client_Export 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);
+  
+private:
+  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 (_IR_EVENTDEF___PTR_CH_)
+#define _IR_EVENTDEF___PTR_CH_
+
+class EventDef;
+typedef EventDef *EventDef_ptr;
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_EVENTDEF___VAR_CH_)
+#define _IR_EVENTDEF___VAR_CH_
+
+class TAO_IFR_Client_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 (_IR_EVENTDEF___OUT_CH_)
+#define _IR_EVENTDEF___OUT_CH_
+
+class TAO_IFR_Client_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_;
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_EVENTDEF_CH_)
+#define _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_IFR_Client_Export EventDef: public virtual CORBA::Contained
+{
+public:
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef EventDef_ptr _ptr_type;
+  typedef EventDef_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  // the static operations
+  static EventDef_ptr _duplicate (EventDef_ptr obj);
+  static EventDef_ptr _narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    );
+  static EventDef_ptr _unchecked_narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    );
+  static EventDef_ptr _nil (void)
+    {
+      return (EventDef_ptr)0;
+    }
+
+  static void _tao_any_destructor (void*);
+
+  virtual CORBA::Boolean is_a (
+      const char * event_id,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::ValueDef_ptr event (
+      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_EventDef_Proxy_Broker *the_TAO_EventDef_Proxy_Broker_;
+  
+protected:
+  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 IR_EventDef_setup_collocation (int collocated);
+    
+    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 (
+      TAO_GIOP_Invocation *_tao_invocation,
+      CORBA::Object_ptr _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 (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _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_EventDef_event_get (const TAO_ClientRequestInfo_IR_EventDef_event_get &);
+  void operator= (const TAO_ClientRequestInfo_IR_EventDef_event_get &);
+  void result (CORBA::ValueDef_ptr result);
+  // update the result 
+  CORBA::ValueDef_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_IFR_Client_Export _TAO_EventDef_Proxy_Impl : 
+  public virtual _TAO_Contained_Proxy_Impl
+{
+public:
+  virtual ~_TAO_EventDef_Proxy_Impl (void) { }
+  
+    virtual CORBA::Boolean is_a (
+      CORBA_Object *_collocated_tao_target_,
+      const char * event_id,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual CORBA::ValueDef_ptr event (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+protected:
+  _TAO_EventDef_Proxy_Impl (void);
+
+};
+//
+//                Base  Proxy Impl. Declaration
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//                    Remote  Impl. Declaration
+//
+
+class TAO_IFR_Client_Export _TAO_EventDef_Remote_Proxy_Impl : 
+  public virtual _TAO_EventDef_Proxy_Impl,
+  public virtual TAO_Remote_Object_Proxy_Impl,
+  public virtual _TAO_Contained_Remote_Proxy_Impl
+  
+{
+public:
+  _TAO_EventDef_Remote_Proxy_Impl (void);
+  
+  virtual ~_TAO_EventDef_Remote_Proxy_Impl (void) { }
+  
+    virtual CORBA::Boolean is_a (
+      CORBA_Object *_collocated_tao_target_,
+      const char * event_id,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::ValueDef_ptr event (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+};
+
+//
+//                Base  Proxy Impl. Declaration
+///////////////////////////////////////////////////////////////////////
+
+
+// The Proxy Brokers are used by each interface to get
+// the right proxy for performing a call. In the new 
+// collocation scheme, the proxy to be used can vary on
+// a call by call basis. 
+
+
+
+///////////////////////////////////////////////////////////////////////
+//                 Base Proxy Broker Declaration 
+//
+
+class TAO_IFR_Client_Export _TAO_EventDef_Proxy_Broker
+{
+public:
+  virtual ~_TAO_EventDef_Proxy_Broker (void);
+  virtual _TAO_EventDef_Proxy_Impl &select_proxy (
+    EventDef *object,
+    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
+  ) = 0;
+
+protected:
+  _TAO_EventDef_Proxy_Broker (void);
+  
+};
+
+//
+//              End Base Proxy Broker Declaration 
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//                 Remote Proxy Broker Declaration 
+//
+
+class TAO_IFR_Client_Export _TAO_EventDef_Remote_Proxy_Broker : public virtual _TAO_EventDef_Proxy_Broker
+{
+public: 
+  _TAO_EventDef_Remote_Proxy_Broker (void);
+  
+  virtual ~_TAO_EventDef_Remote_Proxy_Broker (void);
+  
+  virtual _TAO_EventDef_Proxy_Impl &select_proxy (
+    EventDef *object,
+    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
+  );
+
+private:
+  _TAO_EventDef_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_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_IFR_Client_Export EventDescription
+{
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef EventDescription_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  static void _tao_any_destructor (void*);
+
+  TAO_String_Manager name;
+  TAO_String_Manager id;
+  TAO_String_Manager defined_in;
+  TAO_String_Manager version;
+  CORBA::ValueDef_var value;
+};
+
+class TAO_IFR_Client_Export EventDescription_var
+{
+public:
+  EventDescription_var (void); // default constructor
+  EventDescription_var (EventDescription *);
+  EventDescription_var (const EventDescription_var &); // copy constructor
+  ~EventDescription_var (void); // destructor
+  
+  EventDescription_var &operator= (EventDescription *);
+  EventDescription_var &operator= (const EventDescription_var &);
+  EventDescription *operator-> (void);
+  const EventDescription *operator-> (void) const;
+  
+  operator const EventDescription &() const;
+  operator EventDescription &();
+  operator EventDescription &() const;
+  operator 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;
+
+private:
+  EventDescription *ptr_;
+};
+
+class TAO_IFR_Client_Export 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);
+  
+private:
+  EventDescription *&ptr_;
+  // assignment from T_var not allowed
+  void operator= (const EventDescription_var &);
+};
+
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_EventDescription;
+
+
+#if !defined (_IR_EMITSDEF___PTR_CH_)
+#define _IR_EMITSDEF___PTR_CH_
+
+class EmitsDef;
+typedef EmitsDef *EmitsDef_ptr;
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_EMITSDEF___VAR_CH_)
+#define _IR_EMITSDEF___VAR_CH_
+
+class TAO_IFR_Client_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 (_IR_EMITSDEF___OUT_CH_)
+#define _IR_EMITSDEF___OUT_CH_
+
+class TAO_IFR_Client_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_;
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_EMITSDEF_CH_)
+#define _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_IFR_Client_Export EmitsDef: public virtual EventDef
+{
+public:
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef EmitsDef_ptr _ptr_type;
+  typedef EmitsDef_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  // the static operations
+  static EmitsDef_ptr _duplicate (EmitsDef_ptr obj);
+  static EmitsDef_ptr _narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    );
+  static EmitsDef_ptr _unchecked_narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    );
+  static EmitsDef_ptr _nil (void)
+    {
+      return (EmitsDef_ptr)0;
+    }
+
+  static void _tao_any_destructor (void*);
+
+  virtual CORBA::Boolean _is_a (
+      const CORBA::Char *type_id, 
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    );
+  virtual void *_tao_QueryInterface (ptr_arith_t type);
+  
+  virtual const char* _interface_repository_id (void) const;
+
+private:
+  _TAO_EmitsDef_Proxy_Broker *the_TAO_EmitsDef_Proxy_Broker_;
+  
+protected:
+  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 IR_EmitsDef_setup_collocation (int collocated);
+    
+    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;
+  
+  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 */
+
+};
+
+
+// The Proxy Implementations are used by each interface to
+// perform a call. Each different implementation encapsulate
+// an invocation logics.
+
+
+///////////////////////////////////////////////////////////////////////
+//                    Base  Impl. Declaration
+//
+
+class TAO_IFR_Client_Export _TAO_EmitsDef_Proxy_Impl : 
+  public virtual IR::_TAO_EventDef_Proxy_Impl
+{
+public:
+  virtual ~_TAO_EmitsDef_Proxy_Impl (void) { }
+  
+  protected:
+  _TAO_EmitsDef_Proxy_Impl (void);
+
+};
+//
+//                Base  Proxy Impl. Declaration
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//                    Remote  Impl. Declaration
+//
+
+class TAO_IFR_Client_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:
+  _TAO_EmitsDef_Remote_Proxy_Impl (void);
+  
+  virtual ~_TAO_EmitsDef_Remote_Proxy_Impl (void) { }
+  
+  };
+
+//
+//                Base  Proxy Impl. Declaration
+///////////////////////////////////////////////////////////////////////
+
+
+// The Proxy Brokers are used by each interface to get
+// the right proxy for performing a call. In the new 
+// collocation scheme, the proxy to be used can vary on
+// a call by call basis. 
+
+
+
+///////////////////////////////////////////////////////////////////////
+//                 Base Proxy Broker Declaration 
+//
+
+class TAO_IFR_Client_Export _TAO_EmitsDef_Proxy_Broker
+{
+public:
+  virtual ~_TAO_EmitsDef_Proxy_Broker (void);
+  virtual _TAO_EmitsDef_Proxy_Impl &select_proxy (
+    EmitsDef *object,
+    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
+  ) = 0;
+
+protected:
+  _TAO_EmitsDef_Proxy_Broker (void);
+  
+};
+
+//
+//              End Base Proxy Broker Declaration 
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//                 Remote Proxy Broker Declaration 
+//
+
+class TAO_IFR_Client_Export _TAO_EmitsDef_Remote_Proxy_Broker : public virtual _TAO_EmitsDef_Proxy_Broker
+{
+public: 
+  _TAO_EmitsDef_Remote_Proxy_Broker (void);
+  
+  virtual ~_TAO_EmitsDef_Remote_Proxy_Broker (void);
+  
+  virtual _TAO_EmitsDef_Proxy_Impl &select_proxy (
+    EmitsDef *object,
+    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
+  );
+
+private:
+  _TAO_EmitsDef_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_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 (_IR_PUBLISHESDEF___PTR_CH_)
+#define _IR_PUBLISHESDEF___PTR_CH_
+
+class PublishesDef;
+typedef PublishesDef *PublishesDef_ptr;
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_PUBLISHESDEF___VAR_CH_)
+#define _IR_PUBLISHESDEF___VAR_CH_
+
+class TAO_IFR_Client_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 (_IR_PUBLISHESDEF___OUT_CH_)
+#define _IR_PUBLISHESDEF___OUT_CH_
+
+class TAO_IFR_Client_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 (_IR_PUBLISHESDEF_CH_)
+#define _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_IFR_Client_Export PublishesDef: public virtual EventDef
+{
+public:
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef PublishesDef_ptr _ptr_type;
+  typedef PublishesDef_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  // the static operations
+  static PublishesDef_ptr _duplicate (PublishesDef_ptr obj);
+  static PublishesDef_ptr _narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    );
+  static PublishesDef_ptr _unchecked_narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    );
+  static PublishesDef_ptr _nil (void)
+    {
+      return (PublishesDef_ptr)0;
+    }
+
+  static void _tao_any_destructor (void*);
+
+  virtual CORBA::Boolean _is_a (
+      const CORBA::Char *type_id, 
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    );
+  virtual void *_tao_QueryInterface (ptr_arith_t type);
+  
+  virtual const char* _interface_repository_id (void) const;
+
+private:
+  _TAO_PublishesDef_Proxy_Broker *the_TAO_PublishesDef_Proxy_Broker_;
+  
+protected:
+  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 IR_PublishesDef_setup_collocation (int collocated);
+    
+    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;
+  
+  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 */
+
+};
+
+
+// The Proxy Implementations are used by each interface to
+// perform a call. Each different implementation encapsulate
+// an invocation logics.
+
+
+///////////////////////////////////////////////////////////////////////
+//                    Base  Impl. Declaration
+//
+
+class TAO_IFR_Client_Export _TAO_PublishesDef_Proxy_Impl : 
+  public virtual IR::_TAO_EventDef_Proxy_Impl
+{
+public:
+  virtual ~_TAO_PublishesDef_Proxy_Impl (void) { }
+  
+  protected:
+  _TAO_PublishesDef_Proxy_Impl (void);
+
+};
+//
+//                Base  Proxy Impl. Declaration
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//                    Remote  Impl. Declaration
+//
+
+class TAO_IFR_Client_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:
+  _TAO_PublishesDef_Remote_Proxy_Impl (void);
+  
+  virtual ~_TAO_PublishesDef_Remote_Proxy_Impl (void) { }
+  
+  };
+
+//
+//                Base  Proxy Impl. Declaration
+///////////////////////////////////////////////////////////////////////
+
+
+// The Proxy Brokers are used by each interface to get
+// the right proxy for performing a call. In the new 
+// collocation scheme, the proxy to be used can vary on
+// a call by call basis. 
+
+
+
+///////////////////////////////////////////////////////////////////////
+//                 Base Proxy Broker Declaration 
+//
+
+class TAO_IFR_Client_Export _TAO_PublishesDef_Proxy_Broker
+{
+public:
+  virtual ~_TAO_PublishesDef_Proxy_Broker (void);
+  virtual _TAO_PublishesDef_Proxy_Impl &select_proxy (
+    PublishesDef *object,
+    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
+  ) = 0;
+
+protected:
+  _TAO_PublishesDef_Proxy_Broker (void);
+  
+};
+
+//
+//              End Base Proxy Broker Declaration 
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//                 Remote Proxy Broker Declaration 
+//
+
+class TAO_IFR_Client_Export _TAO_PublishesDef_Remote_Proxy_Broker : public virtual _TAO_PublishesDef_Proxy_Broker
+{
+public: 
+  _TAO_PublishesDef_Remote_Proxy_Broker (void);
+  
+  virtual ~_TAO_PublishesDef_Remote_Proxy_Broker (void);
+  
+  virtual _TAO_PublishesDef_Proxy_Impl &select_proxy (
+    PublishesDef *object,
+    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
+  );
+
+private:
+  _TAO_PublishesDef_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_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 (_IR_CONSUMESDEF___PTR_CH_)
+#define _IR_CONSUMESDEF___PTR_CH_
+
+class ConsumesDef;
+typedef ConsumesDef *ConsumesDef_ptr;
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_CONSUMESDEF___VAR_CH_)
+#define _IR_CONSUMESDEF___VAR_CH_
+
+class TAO_IFR_Client_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 (_IR_CONSUMESDEF___OUT_CH_)
+#define _IR_CONSUMESDEF___OUT_CH_
+
+class TAO_IFR_Client_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 (_IR_CONSUMESDEF_CH_)
+#define _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_IFR_Client_Export ConsumesDef: public virtual EventDef
+{
+public:
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef ConsumesDef_ptr _ptr_type;
+  typedef ConsumesDef_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  // the static operations
+  static ConsumesDef_ptr _duplicate (ConsumesDef_ptr obj);
+  static ConsumesDef_ptr _narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    );
+  static ConsumesDef_ptr _unchecked_narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    );
+  static ConsumesDef_ptr _nil (void)
+    {
+      return (ConsumesDef_ptr)0;
+    }
+
+  static void _tao_any_destructor (void*);
+
+  virtual CORBA::Boolean _is_a (
+      const CORBA::Char *type_id, 
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    );
+  virtual void *_tao_QueryInterface (ptr_arith_t type);
+  
+  virtual const char* _interface_repository_id (void) const;
+
+private:
+  _TAO_ConsumesDef_Proxy_Broker *the_TAO_ConsumesDef_Proxy_Broker_;
+  
+protected:
+  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 IR_ConsumesDef_setup_collocation (int collocated);
+    
+    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;
+  
+  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 */
+
+};
+
+
+// The Proxy Implementations are used by each interface to
+// perform a call. Each different implementation encapsulate
+// an invocation logics.
+
+
+///////////////////////////////////////////////////////////////////////
+//                    Base  Impl. Declaration
+//
+
+class TAO_IFR_Client_Export _TAO_ConsumesDef_Proxy_Impl : 
+  public virtual IR::_TAO_EventDef_Proxy_Impl
+{
+public:
+  virtual ~_TAO_ConsumesDef_Proxy_Impl (void) { }
+  
+  protected:
+  _TAO_ConsumesDef_Proxy_Impl (void);
+
+};
+//
+//                Base  Proxy Impl. Declaration
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//                    Remote  Impl. Declaration
+//
+
+class TAO_IFR_Client_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:
+  _TAO_ConsumesDef_Remote_Proxy_Impl (void);
+  
+  virtual ~_TAO_ConsumesDef_Remote_Proxy_Impl (void) { }
+  
+  };
+
+//
+//                Base  Proxy Impl. Declaration
+///////////////////////////////////////////////////////////////////////
+
+
+// The Proxy Brokers are used by each interface to get
+// the right proxy for performing a call. In the new 
+// collocation scheme, the proxy to be used can vary on
+// a call by call basis. 
+
+
+
+///////////////////////////////////////////////////////////////////////
+//                 Base Proxy Broker Declaration 
+//
+
+class TAO_IFR_Client_Export _TAO_ConsumesDef_Proxy_Broker
+{
+public:
+  virtual ~_TAO_ConsumesDef_Proxy_Broker (void);
+  virtual _TAO_ConsumesDef_Proxy_Impl &select_proxy (
+    ConsumesDef *object,
+    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
+  ) = 0;
+
+protected:
+  _TAO_ConsumesDef_Proxy_Broker (void);
+  
+};
+
+//
+//              End Base Proxy Broker Declaration 
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//                 Remote Proxy Broker Declaration 
+//
+
+class TAO_IFR_Client_Export _TAO_ConsumesDef_Remote_Proxy_Broker : public virtual _TAO_ConsumesDef_Proxy_Broker
+{
+public: 
+  _TAO_ConsumesDef_Remote_Proxy_Broker (void);
+  
+  virtual ~_TAO_ConsumesDef_Remote_Proxy_Broker (void);
+  
+  virtual _TAO_ConsumesDef_Proxy_Impl &select_proxy (
+    ConsumesDef *object,
+    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
+  );
+
+private:
+  _TAO_ConsumesDef_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_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 (_IR_COMPONENTDEF___PTR_CH_)
+#define _IR_COMPONENTDEF___PTR_CH_
+
+class ComponentDef;
+typedef ComponentDef *ComponentDef_ptr;
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_COMPONENTDEF___VAR_CH_)
+#define _IR_COMPONENTDEF___VAR_CH_
+
+class TAO_IFR_Client_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 (_IR_COMPONENTDEF___OUT_CH_)
+#define _IR_COMPONENTDEF___OUT_CH_
+
+class TAO_IFR_Client_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 (_IR_COMPONENTDEF_CH_)
+#define _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_IFR_Client_Export ComponentDef: public virtual CORBA::InterfaceDef
+{
+public:
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef ComponentDef_ptr _ptr_type;
+  typedef ComponentDef_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  // the static operations
+  static ComponentDef_ptr _duplicate (ComponentDef_ptr obj);
+  static ComponentDef_ptr _narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    );
+  static ComponentDef_ptr _unchecked_narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    );
+  static ComponentDef_ptr _nil (void)
+    {
+      return (ComponentDef_ptr)0;
+    }
+
+  static void _tao_any_destructor (void*);
+
+  virtual CORBA::InterfaceDefSeq * supported_interfaces (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void supported_interfaces (
+      const CORBA::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 (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::PublishesDefSeq * publishes_events (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::ConsumesDefSeq * consumes_events (
+      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 IR::ProvidesDef_ptr create_provides (
+      const char * id,
+      const char * name,
+      const char * version,
+      CORBA::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,
+      CORBA::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,
+      CORBA::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,
+      CORBA::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,
+      CORBA::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 IR_ComponentDef_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 (
+      TAO_GIOP_Invocation *_tao_invocation,
+      CORBA::Object_ptr _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 (CORBA::InterfaceDefSeq * result);
+  // update the result 
+  CORBA::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 (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const CORBA::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 CORBA::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 (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _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 (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _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 (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _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 (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _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 (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _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 (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _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;
+};
+
+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;
+
+TAO_ClientRequestInfo_IR_ComponentDef_is_basic_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _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_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;
+};
+
+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;
+
+TAO_ClientRequestInfo_IR_ComponentDef_create_provides (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const char * id,
+    const char * name,
+    const char * version,
+    CORBA::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_;
+  CORBA::InterfaceDef_ptr interface_type_;
+  void result (IR::ProvidesDef_ptr result);
+  // update the result 
+  IR::ProvidesDef_ptr _result;
+};
+
+class TAO_ClientRequestInfo_IR_ComponentDef_create_uses : 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_uses (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const char * id,
+    const char * name,
+    const char * version,
+    CORBA::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_;
+  CORBA::InterfaceDef_ptr interface_type_;
+  const CORBA::Boolean & is_multiple_;
+  void result (IR::UsesDef_ptr result);
+  // update the result 
+  IR::UsesDef_ptr _result;
+};
+
+class TAO_ClientRequestInfo_IR_ComponentDef_create_emits : 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_emits (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const char * id,
+    const char * name,
+    const char * version,
+    CORBA::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_;
+  CORBA::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;
+  
+  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 (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const char * id,
+    const char * name,
+    const char * version,
+    CORBA::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_;
+  CORBA::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 (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const char * id,
+    const char * name,
+    const char * version,
+    CORBA::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_;
+  CORBA::ValueDef_ptr value_;
+  void result (IR::ConsumesDef_ptr result);
+  // update the result 
+  IR::ConsumesDef_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_IFR_Client_Export _TAO_ComponentDef_Proxy_Impl : 
+  public virtual _TAO_InterfaceDef_Proxy_Impl
+{
+public:
+  virtual ~_TAO_ComponentDef_Proxy_Impl (void) { }
+  
+    virtual CORBA::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 CORBA::InterfaceDefSeq & supported_interfaces,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual IR::ComponentDef_ptr base_component (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual IR::ProvidesDefSeq * provides_interfaces (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual IR::UsesDefSeq * uses_interfaces (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual IR::EmitsDefSeq * emits_events (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual IR::PublishesDefSeq * publishes_events (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual IR::ConsumesDefSeq * consumes_events (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual CORBA::Boolean is_basic (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual IR::ProvidesDef_ptr create_provides (
+      CORBA_Object *_collocated_tao_target_,
+      const char * id,
+      const char * name,
+      const char * version,
+      CORBA::InterfaceDef_ptr interface_type,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual IR::UsesDef_ptr create_uses (
+      CORBA_Object *_collocated_tao_target_,
+      const char * id,
+      const char * name,
+      const char * version,
+      CORBA::InterfaceDef_ptr interface_type,
+      CORBA::Boolean is_multiple,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual IR::EmitsDef_ptr create_emits (
+      CORBA_Object *_collocated_tao_target_,
+      const char * id,
+      const char * name,
+      const char * version,
+      CORBA::ValueDef_ptr value,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual IR::PublishesDef_ptr create_publishes (
+      CORBA_Object *_collocated_tao_target_,
+      const char * id,
+      const char * name,
+      const char * version,
+      CORBA::ValueDef_ptr value,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual IR::ConsumesDef_ptr create_consumes (
+      CORBA_Object *_collocated_tao_target_,
+      const char * id,
+      const char * name,
+      const char * version,
+      CORBA::ValueDef_ptr value,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+protected:
+  _TAO_ComponentDef_Proxy_Impl (void);
+
+};
+//
+//                Base  Proxy Impl. Declaration
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//                    Remote  Impl. Declaration
+//
+
+class TAO_IFR_Client_Export _TAO_ComponentDef_Remote_Proxy_Impl : 
+  public virtual _TAO_ComponentDef_Proxy_Impl,
+  public virtual TAO_Remote_Object_Proxy_Impl,
+  public virtual _TAO_InterfaceDef_Remote_Proxy_Impl
+  
+{
+public:
+  _TAO_ComponentDef_Remote_Proxy_Impl (void);
+  
+  virtual ~_TAO_ComponentDef_Remote_Proxy_Impl (void) { }
+  
+    virtual CORBA::InterfaceDefSeq * supported_interfaces (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void supported_interfaces (
+      CORBA_Object *_collocated_tao_target_,
+      const CORBA::InterfaceDefSeq & supported_interfaces,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::ComponentDef_ptr base_component (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::ProvidesDefSeq * provides_interfaces (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::UsesDefSeq * uses_interfaces (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::EmitsDefSeq * emits_events (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::PublishesDefSeq * publishes_events (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::ConsumesDefSeq * consumes_events (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::Boolean is_basic (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::ProvidesDef_ptr create_provides (
+      CORBA_Object *_collocated_tao_target_,
+      const char * id,
+      const char * name,
+      const char * version,
+      CORBA::InterfaceDef_ptr interface_type,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::UsesDef_ptr create_uses (
+      CORBA_Object *_collocated_tao_target_,
+      const char * id,
+      const char * name,
+      const char * version,
+      CORBA::InterfaceDef_ptr interface_type,
+      CORBA::Boolean is_multiple,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::EmitsDef_ptr create_emits (
+      CORBA_Object *_collocated_tao_target_,
+      const char * id,
+      const char * name,
+      const char * version,
+      CORBA::ValueDef_ptr value,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::PublishesDef_ptr create_publishes (
+      CORBA_Object *_collocated_tao_target_,
+      const char * id,
+      const char * name,
+      const char * version,
+      CORBA::ValueDef_ptr value,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::ConsumesDef_ptr create_consumes (
+      CORBA_Object *_collocated_tao_target_,
+      const char * id,
+      const char * name,
+      const char * version,
+      CORBA::ValueDef_ptr value,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+};
+
+//
+//                Base  Proxy Impl. Declaration
+///////////////////////////////////////////////////////////////////////
+
+
+// The Proxy Brokers are used by each interface to get
+// the right proxy for performing a call. In the new 
+// collocation scheme, the proxy to be used can vary on
+// a call by call basis. 
+
+
+
+///////////////////////////////////////////////////////////////////////
+//                 Base Proxy Broker Declaration 
+//
+
+class TAO_IFR_Client_Export _TAO_ComponentDef_Proxy_Broker
+{
+public:
+  virtual ~_TAO_ComponentDef_Proxy_Broker (void);
+  virtual _TAO_ComponentDef_Proxy_Impl &select_proxy (
+    ComponentDef *object,
+    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
+  ) = 0;
+
+protected:
+  _TAO_ComponentDef_Proxy_Broker (void);
+  
+};
+
+//
+//              End Base Proxy Broker Declaration 
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//                 Remote Proxy Broker Declaration 
+//
+
+class TAO_IFR_Client_Export _TAO_ComponentDef_Remote_Proxy_Broker : public virtual _TAO_ComponentDef_Proxy_Broker
+{
+public: 
+  _TAO_ComponentDef_Remote_Proxy_Broker (void);
+  
+  virtual ~_TAO_ComponentDef_Remote_Proxy_Broker (void);
+  
+  virtual _TAO_ComponentDef_Proxy_Impl &select_proxy (
+    ComponentDef *object,
+    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
+  );
+
+private:
+  _TAO_ComponentDef_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_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_IFR_Client_Export ComponentDescription
+{
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef ComponentDescription_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  static void _tao_any_destructor (void*);
+
+  TAO_String_Manager name;
+  TAO_String_Manager id;
+  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;
+  CORBA::AttrDescriptionSeq attributes;
+  ACE_NESTED_CLASS (IR, EmitsDefSeq) emits_events;
+  ACE_NESTED_CLASS (IR, PublishesDefSeq) publishes_events;
+  ACE_NESTED_CLASS (IR, ConsumesDefSeq) consumes_events;
+  CORBA::Boolean is_basic;
+};
+
+class TAO_IFR_Client_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_IFR_Client_Export ComponentDescription_out
+{
+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);
+  
+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 (_IR_PRIMARYKEYDEF___PTR_CH_)
+#define _IR_PRIMARYKEYDEF___PTR_CH_
+
+class PrimaryKeyDef;
+typedef PrimaryKeyDef *PrimaryKeyDef_ptr;
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_PRIMARYKEYDEF___VAR_CH_)
+#define _IR_PRIMARYKEYDEF___VAR_CH_
+
+class TAO_IFR_Client_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
+  
+  PrimaryKeyDef_var &operator= (PrimaryKeyDef_ptr);
+  PrimaryKeyDef_var &operator= (const PrimaryKeyDef_var &);
+  PrimaryKeyDef_ptr operator-> (void) const;
+  
+  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;
+
+private:
+  PrimaryKeyDef_ptr ptr_;
+  // Unimplemented - prevents widening assignment.
+  PrimaryKeyDef_var (const TAO_Base_var &rhs);
+  PrimaryKeyDef_var &operator= (const TAO_Base_var &rhs);
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_PRIMARYKEYDEF___OUT_CH_)
+#define _IR_PRIMARYKEYDEF___OUT_CH_
+
+class TAO_IFR_Client_Export 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);
+  
+private:
+  PrimaryKeyDef_ptr &ptr_;
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_PRIMARYKEYDEF_CH_)
+#define _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_IFR_Client_Export PrimaryKeyDef: public virtual CORBA::Contained
+{
+public:
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef PrimaryKeyDef_ptr _ptr_type;
+  typedef 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 (
+      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 CORBA::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 IR_PrimaryKeyDef_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 (
+      TAO_GIOP_Invocation *_tao_invocation,
+      CORBA::Object_ptr _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 (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _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_PrimaryKeyDef_primary_key_get (const TAO_ClientRequestInfo_IR_PrimaryKeyDef_primary_key_get &);
+  void operator= (const TAO_ClientRequestInfo_IR_PrimaryKeyDef_primary_key_get &);
+  void result (CORBA::ValueDef_ptr result);
+  // update the result 
+  CORBA::ValueDef_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_IFR_Client_Export _TAO_PrimaryKeyDef_Proxy_Impl : 
+  public virtual _TAO_Contained_Proxy_Impl
+{
+public:
+  virtual ~_TAO_PrimaryKeyDef_Proxy_Impl (void) { }
+  
+    virtual CORBA::Boolean is_a (
+      CORBA_Object *_collocated_tao_target_,
+      const char * primary_key_id,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual CORBA::ValueDef_ptr primary_key (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+protected:
+  _TAO_PrimaryKeyDef_Proxy_Impl (void);
+
+};
+//
+//                Base  Proxy Impl. Declaration
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//                    Remote  Impl. Declaration
+//
+
+class TAO_IFR_Client_Export _TAO_PrimaryKeyDef_Remote_Proxy_Impl : 
+  public virtual _TAO_PrimaryKeyDef_Proxy_Impl,
+  public virtual TAO_Remote_Object_Proxy_Impl,
+  public virtual _TAO_Contained_Remote_Proxy_Impl
+  
+{
+public:
+  _TAO_PrimaryKeyDef_Remote_Proxy_Impl (void);
+  
+  virtual ~_TAO_PrimaryKeyDef_Remote_Proxy_Impl (void) { }
+  
+    virtual CORBA::Boolean is_a (
+      CORBA_Object *_collocated_tao_target_,
+      const char * primary_key_id,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::ValueDef_ptr primary_key (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+};
+
+//
+//                Base  Proxy Impl. Declaration
+///////////////////////////////////////////////////////////////////////
+
+
+// The Proxy Brokers are used by each interface to get
+// the right proxy for performing a call. In the new 
+// collocation scheme, the proxy to be used can vary on
+// a call by call basis. 
+
+
+
+///////////////////////////////////////////////////////////////////////
+//                 Base Proxy Broker Declaration 
+//
+
+class TAO_IFR_Client_Export _TAO_PrimaryKeyDef_Proxy_Broker
+{
+public:
+  virtual ~_TAO_PrimaryKeyDef_Proxy_Broker (void);
+  virtual _TAO_PrimaryKeyDef_Proxy_Impl &select_proxy (
+    PrimaryKeyDef *object,
+    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
+  ) = 0;
+
+protected:
+  _TAO_PrimaryKeyDef_Proxy_Broker (void);
+  
+};
+
+//
+//              End Base Proxy Broker Declaration 
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//                 Remote Proxy Broker Declaration 
+//
+
+class TAO_IFR_Client_Export _TAO_PrimaryKeyDef_Remote_Proxy_Broker : public virtual _TAO_PrimaryKeyDef_Proxy_Broker
+{
+public: 
+  _TAO_PrimaryKeyDef_Remote_Proxy_Broker (void);
+  
+  virtual ~_TAO_PrimaryKeyDef_Remote_Proxy_Broker (void);
+  
+  virtual _TAO_PrimaryKeyDef_Proxy_Impl &select_proxy (
+    PrimaryKeyDef *object,
+    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
+  );
+
+private:
+  _TAO_PrimaryKeyDef_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_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_IFR_Client_Export PrimaryKeyDescription
+{
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef PrimaryKeyDescription_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  static void _tao_any_destructor (void*);
+
+  TAO_String_Manager name;
+  TAO_String_Manager id;
+  TAO_String_Manager defined_in;
+  TAO_String_Manager version;
+  CORBA::ValueDef_var primary_key;
+};
+
+class TAO_IFR_Client_Export PrimaryKeyDescription_var
+{
+public:
+  PrimaryKeyDescription_var (void); // default constructor
+  PrimaryKeyDescription_var (PrimaryKeyDescription *);
+  PrimaryKeyDescription_var (const PrimaryKeyDescription_var &); // copy constructor
+  ~PrimaryKeyDescription_var (void); // destructor
+  
+  PrimaryKeyDescription_var &operator= (PrimaryKeyDescription *);
+  PrimaryKeyDescription_var &operator= (const PrimaryKeyDescription_var &);
+  PrimaryKeyDescription *operator-> (void);
+  const PrimaryKeyDescription *operator-> (void) const;
+  
+  operator const PrimaryKeyDescription &() const;
+  operator PrimaryKeyDescription &();
+  operator PrimaryKeyDescription &() const;
+  operator 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;
+
+private:
+  PrimaryKeyDescription *ptr_;
+};
+
+class TAO_IFR_Client_Export 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);
+  
+private:
+  PrimaryKeyDescription *&ptr_;
+  // assignment from T_var not allowed
+  void operator= (const PrimaryKeyDescription_var &);
+};
+
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_PrimaryKeyDescription;
+
+
+#if !defined (_IR_FACTORYDEF___PTR_CH_)
+#define _IR_FACTORYDEF___PTR_CH_
+
+class FactoryDef;
+typedef FactoryDef *FactoryDef_ptr;
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_FACTORYDEF___VAR_CH_)
+#define _IR_FACTORYDEF___VAR_CH_
+
+class TAO_IFR_Client_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 (_IR_FACTORYDEF___OUT_CH_)
+#define _IR_FACTORYDEF___OUT_CH_
+
+class TAO_IFR_Client_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_;
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_FACTORYDEF_CH_)
+#define _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_IFR_Client_Export FactoryDef: public virtual CORBA::OperationDef
+{
+public:
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef FactoryDef_ptr _ptr_type;
+  typedef FactoryDef_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  // the static operations
+  static FactoryDef_ptr _duplicate (FactoryDef_ptr obj);
+  static FactoryDef_ptr _narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    );
+  static FactoryDef_ptr _unchecked_narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    );
+  static FactoryDef_ptr _nil (void)
+    {
+      return (FactoryDef_ptr)0;
+    }
+
+  static void _tao_any_destructor (void*);
+
+  virtual CORBA::Boolean _is_a (
+      const CORBA::Char *type_id, 
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    );
+  virtual void *_tao_QueryInterface (ptr_arith_t type);
+  
+  virtual const char* _interface_repository_id (void) const;
+
+private:
+  _TAO_FactoryDef_Proxy_Broker *the_TAO_FactoryDef_Proxy_Broker_;
+  
+protected:
+  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 IR_FactoryDef_setup_collocation (int collocated);
+    
+    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;
+  
+  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 */
+
+};
+
+
+// The Proxy Implementations are used by each interface to
+// perform a call. Each different implementation encapsulate
+// an invocation logics.
+
+
+///////////////////////////////////////////////////////////////////////
+//                    Base  Impl. Declaration
+//
+
+class TAO_IFR_Client_Export _TAO_FactoryDef_Proxy_Impl : 
+  public virtual _TAO_OperationDef_Proxy_Impl
+{
+public:
+  virtual ~_TAO_FactoryDef_Proxy_Impl (void) { }
+  
+  protected:
+  _TAO_FactoryDef_Proxy_Impl (void);
+
+};
+//
+//                Base  Proxy Impl. Declaration
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//                    Remote  Impl. Declaration
+//
+
+class TAO_IFR_Client_Export _TAO_FactoryDef_Remote_Proxy_Impl : 
+  public virtual _TAO_FactoryDef_Proxy_Impl,
+  public virtual TAO_Remote_Object_Proxy_Impl,
+  public virtual _TAO_OperationDef_Remote_Proxy_Impl
+  
+{
+public:
+  _TAO_FactoryDef_Remote_Proxy_Impl (void);
+  
+  virtual ~_TAO_FactoryDef_Remote_Proxy_Impl (void) { }
+  
+  };
+
+//
+//                Base  Proxy Impl. Declaration
+///////////////////////////////////////////////////////////////////////
+
+
+// The Proxy Brokers are used by each interface to get
+// the right proxy for performing a call. In the new 
+// collocation scheme, the proxy to be used can vary on
+// a call by call basis. 
+
+
+
+///////////////////////////////////////////////////////////////////////
+//                 Base Proxy Broker Declaration 
+//
+
+class TAO_IFR_Client_Export _TAO_FactoryDef_Proxy_Broker
+{
+public:
+  virtual ~_TAO_FactoryDef_Proxy_Broker (void);
+  virtual _TAO_FactoryDef_Proxy_Impl &select_proxy (
+    FactoryDef *object,
+    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
+  ) = 0;
+
+protected:
+  _TAO_FactoryDef_Proxy_Broker (void);
+  
+};
+
+//
+//              End Base Proxy Broker Declaration 
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//                 Remote Proxy Broker Declaration 
+//
+
+class TAO_IFR_Client_Export _TAO_FactoryDef_Remote_Proxy_Broker : public virtual _TAO_FactoryDef_Proxy_Broker
+{
+public: 
+  _TAO_FactoryDef_Remote_Proxy_Broker (void);
+  
+  virtual ~_TAO_FactoryDef_Remote_Proxy_Broker (void);
+  
+  virtual _TAO_FactoryDef_Proxy_Impl &select_proxy (
+    FactoryDef *object,
+    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
+  );
+
+private:
+  _TAO_FactoryDef_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_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 (_IR_FINDERDEF___PTR_CH_)
+#define _IR_FINDERDEF___PTR_CH_
+
+class FinderDef;
+typedef FinderDef *FinderDef_ptr;
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_FINDERDEF___VAR_CH_)
+#define _IR_FINDERDEF___VAR_CH_
+
+class TAO_IFR_Client_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 (_IR_FINDERDEF___OUT_CH_)
+#define _IR_FINDERDEF___OUT_CH_
+
+class TAO_IFR_Client_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 (_IR_FINDERDEF_CH_)
+#define _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_IFR_Client_Export FinderDef: public virtual CORBA::OperationDef
+{
+public:
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef FinderDef_ptr _ptr_type;
+  typedef FinderDef_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  // the static operations
+  static FinderDef_ptr _duplicate (FinderDef_ptr obj);
+  static FinderDef_ptr _narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    );
+  static FinderDef_ptr _unchecked_narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    );
+  static FinderDef_ptr _nil (void)
+    {
+      return (FinderDef_ptr)0;
+    }
+
+  static void _tao_any_destructor (void*);
+
+  virtual CORBA::Boolean _is_a (
+      const CORBA::Char *type_id, 
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    );
+  virtual void *_tao_QueryInterface (ptr_arith_t type);
+  
+  virtual const char* _interface_repository_id (void) const;
+
+private:
+  _TAO_FinderDef_Proxy_Broker *the_TAO_FinderDef_Proxy_Broker_;
+  
+protected:
+  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 IR_FinderDef_setup_collocation (int collocated);
+    
+    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;
+  
+  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 */
+
+};
+
+
+// The Proxy Implementations are used by each interface to
+// perform a call. Each different implementation encapsulate
+// an invocation logics.
+
+
+///////////////////////////////////////////////////////////////////////
+//                    Base  Impl. Declaration
+//
+
+class TAO_IFR_Client_Export _TAO_FinderDef_Proxy_Impl : 
+  public virtual _TAO_OperationDef_Proxy_Impl
+{
+public:
+  virtual ~_TAO_FinderDef_Proxy_Impl (void) { }
+  
+  protected:
+  _TAO_FinderDef_Proxy_Impl (void);
+
+};
+//
+//                Base  Proxy Impl. Declaration
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//                    Remote  Impl. Declaration
+//
+
+class TAO_IFR_Client_Export _TAO_FinderDef_Remote_Proxy_Impl : 
+  public virtual _TAO_FinderDef_Proxy_Impl,
+  public virtual TAO_Remote_Object_Proxy_Impl,
+  public virtual _TAO_OperationDef_Remote_Proxy_Impl
+  
+{
+public:
+  _TAO_FinderDef_Remote_Proxy_Impl (void);
+  
+  virtual ~_TAO_FinderDef_Remote_Proxy_Impl (void) { }
+  
+  };
+
+//
+//                Base  Proxy Impl. Declaration
+///////////////////////////////////////////////////////////////////////
+
+
+// The Proxy Brokers are used by each interface to get
+// the right proxy for performing a call. In the new 
+// collocation scheme, the proxy to be used can vary on
+// a call by call basis. 
+
+
+
+///////////////////////////////////////////////////////////////////////
+//                 Base Proxy Broker Declaration 
+//
+
+class TAO_IFR_Client_Export _TAO_FinderDef_Proxy_Broker
+{
+public:
+  virtual ~_TAO_FinderDef_Proxy_Broker (void);
+  virtual _TAO_FinderDef_Proxy_Impl &select_proxy (
+    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_IFR_Client_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 (_IR_HOMEDEF___PTR_CH_)
+#define _IR_HOMEDEF___PTR_CH_
+
+class HomeDef;
+typedef HomeDef *HomeDef_ptr;
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_HOMEDEF___VAR_CH_)
+#define _IR_HOMEDEF___VAR_CH_
+
+class TAO_IFR_Client_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);
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_HOMEDEF___OUT_CH_)
+#define _IR_HOMEDEF___OUT_CH_
+
+class TAO_IFR_Client_Export 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);
+  
+private:
+  HomeDef_ptr &ptr_;
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_HOMEDEF_CH_)
+#define _IR_HOMEDEF_CH_
+
+// Forward Classes Declaration
+class _TAO_HomeDef_Proxy_Impl;
+class _TAO_HomeDef_Remote_Proxy_Impl;
+class _TAO_HomeDef_Proxy_Broker;
+class _TAO_HomeDef_Remote_Proxy_Broker;
+
+class TAO_IFR_Client_Export HomeDef: public virtual CORBA::InterfaceDef
+{
+public:
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef HomeDef_ptr _ptr_type;
+  typedef HomeDef_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  // the static operations
+  static HomeDef_ptr _duplicate (HomeDef_ptr obj);
+  static HomeDef_ptr _narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    );
+  static HomeDef_ptr _unchecked_narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    );
+  static HomeDef_ptr _nil (void)
+    {
+      return (HomeDef_ptr)0;
+    }
+
+  static void _tao_any_destructor (void*);
+
+  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 (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::PrimaryKeyDef_ptr primary_key (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::FactoryDefSeq * factories (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::FinderDefSeq * finders (
+      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 IR::PrimaryKeyDef_ptr create_primary_key (
+      const char * id,
+      const char * name,
+      const char * version,
+      CORBA::ValueDef_ptr primary_key,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::FactoryDef_ptr create_factory (
+      const char * id,
+      const char * name,
+      const char * version,
+      const CORBA::ParDescriptionSeq & params,
+      const CORBA::ExceptionDefSeq & exceptions,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::FinderDef_ptr create_finder (
+      const char * id,
+      const char * name,
+      const char * version,
+      const CORBA::ParDescriptionSeq & params,
+      const CORBA::ExceptionDefSeq & exceptions,
+      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_HomeDef_Proxy_Broker *the_TAO_HomeDef_Proxy_Broker_;
+  
+protected:
+  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 IR_HomeDef_setup_collocation (int collocated);
+    
+    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 (
+      TAO_GIOP_Invocation *_tao_invocation,
+      CORBA::Object_ptr _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 (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _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 (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _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 (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _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 (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _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 (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _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_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 (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const char * id,
+    const char * name,
+    const char * version,
+    CORBA::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_;
+  CORBA::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 (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const char * id,
+    const char * name,
+    const char * version,
+    const CORBA::ParDescriptionSeq & params,
+    const CORBA::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 CORBA::ParDescriptionSeq & params_;
+  const CORBA::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 (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const char * id,
+    const char * name,
+    const char * version,
+    const CORBA::ParDescriptionSeq & params,
+    const CORBA::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 CORBA::ParDescriptionSeq & params_;
+  const CORBA::ExceptionDefSeq & exceptions_;
+  void result (IR::FinderDef_ptr result);
+  // update the result 
+  IR::FinderDef_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_IFR_Client_Export _TAO_HomeDef_Proxy_Impl : 
+  public virtual _TAO_InterfaceDef_Proxy_Impl
+{
+public:
+  virtual ~_TAO_HomeDef_Proxy_Impl (void) { }
+  
+    virtual IR::HomeDef_ptr base_home (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual IR::ComponentDef_ptr managed_component (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual IR::PrimaryKeyDef_ptr primary_key (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual IR::FactoryDefSeq * factories (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual IR::FinderDefSeq * finders (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual CORBA::Boolean is_basic (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual IR::PrimaryKeyDef_ptr create_primary_key (
+      CORBA_Object *_collocated_tao_target_,
+      const char * id,
+      const char * name,
+      const char * version,
+      CORBA::ValueDef_ptr primary_key,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual IR::FactoryDef_ptr create_factory (
+      CORBA_Object *_collocated_tao_target_,
+      const char * id,
+      const char * name,
+      const char * version,
+      const CORBA::ParDescriptionSeq & params,
+      const CORBA::ExceptionDefSeq & exceptions,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual IR::FinderDef_ptr create_finder (
+      CORBA_Object *_collocated_tao_target_,
+      const char * id,
+      const char * name,
+      const char * version,
+      const CORBA::ParDescriptionSeq & params,
+      const CORBA::ExceptionDefSeq & exceptions,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+protected:
+  _TAO_HomeDef_Proxy_Impl (void);
+
+};
+//
+//                Base  Proxy Impl. Declaration
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//                    Remote  Impl. Declaration
+//
+
+class TAO_IFR_Client_Export _TAO_HomeDef_Remote_Proxy_Impl : 
+  public virtual _TAO_HomeDef_Proxy_Impl,
+  public virtual TAO_Remote_Object_Proxy_Impl,
+  public virtual _TAO_InterfaceDef_Remote_Proxy_Impl
+  
+{
+public:
+  _TAO_HomeDef_Remote_Proxy_Impl (void);
+  
+  virtual ~_TAO_HomeDef_Remote_Proxy_Impl (void) { }
+  
+    virtual IR::HomeDef_ptr base_home (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::ComponentDef_ptr managed_component (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::PrimaryKeyDef_ptr primary_key (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::FactoryDefSeq * factories (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::FinderDefSeq * finders (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::Boolean is_basic (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::PrimaryKeyDef_ptr create_primary_key (
+      CORBA_Object *_collocated_tao_target_,
+      const char * id,
+      const char * name,
+      const char * version,
+      CORBA::ValueDef_ptr primary_key,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::FactoryDef_ptr create_factory (
+      CORBA_Object *_collocated_tao_target_,
+      const char * id,
+      const char * name,
+      const char * version,
+      const CORBA::ParDescriptionSeq & params,
+      const CORBA::ExceptionDefSeq & exceptions,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::FinderDef_ptr create_finder (
+      CORBA_Object *_collocated_tao_target_,
+      const char * id,
+      const char * name,
+      const char * version,
+      const CORBA::ParDescriptionSeq & params,
+      const CORBA::ExceptionDefSeq & exceptions,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+};
+
+//
+//                Base  Proxy Impl. Declaration
+///////////////////////////////////////////////////////////////////////
+
+
+// The Proxy Brokers are used by each interface to get
+// the right proxy for performing a call. In the new 
+// collocation scheme, the proxy to be used can vary on
+// a call by call basis. 
+
+
+
+///////////////////////////////////////////////////////////////////////
+//                 Base Proxy Broker Declaration 
+//
+
+class TAO_IFR_Client_Export _TAO_HomeDef_Proxy_Broker
+{
+public:
+  virtual ~_TAO_HomeDef_Proxy_Broker (void);
+  virtual _TAO_HomeDef_Proxy_Impl &select_proxy (
+    HomeDef *object,
+    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
+  ) = 0;
+
+protected:
+  _TAO_HomeDef_Proxy_Broker (void);
+  
+};
+
+//
+//              End Base Proxy Broker Declaration 
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//                 Remote Proxy Broker Declaration 
+//
+
+class TAO_IFR_Client_Export _TAO_HomeDef_Remote_Proxy_Broker : public virtual _TAO_HomeDef_Proxy_Broker
+{
+public: 
+  _TAO_HomeDef_Remote_Proxy_Broker (void);
+  
+  virtual ~_TAO_HomeDef_Remote_Proxy_Broker (void);
+  
+  virtual _TAO_HomeDef_Proxy_Impl &select_proxy (
+    HomeDef *object,
+    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
+  );
+
+private:
+  _TAO_HomeDef_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_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_IFR_Client_Export HomeDescription
+{
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef HomeDescription_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  static void _tao_any_destructor (void*);
+
+  TAO_String_Manager name;
+  TAO_String_Manager id;
+  TAO_String_Manager defined_in;
+  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;
+  CORBA::OpDescriptionSeq operations;
+  CORBA::AttrDescriptionSeq attributes;
+  CORBA::Boolean is_basic;
+};
+
+class TAO_IFR_Client_Export 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
+  
+  // in, inout, out, _retn 
+  const HomeDescription &in (void) const;
+  HomeDescription &inout (void);
+  HomeDescription *&out (void);
+  HomeDescription *_retn (void);
+  HomeDescription *ptr (void) const;
+
+private:
+  HomeDescription *ptr_;
+};
+
+class TAO_IFR_Client_Export 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);
+  
+private:
+  HomeDescription *&ptr_;
+  // assignment from T_var not allowed
+  void operator= (const HomeDescription_var &);
+};
+
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_HomeDescription;
+
+
+}
+TAO_NAMESPACE_CLOSE // module IR
+
+// Proxy Broker Factory function pointer declarations.
+
+extern TAO_IFR_Client_Export IR::_TAO_ComponentRepository_Proxy_Broker * (*IR__TAO_ComponentRepository_Proxy_Broker_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  );
+
+extern TAO_IFR_Client_Export IR::_TAO_ProvidesDef_Proxy_Broker * (*IR__TAO_ProvidesDef_Proxy_Broker_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  );
+
+extern TAO_IFR_Client_Export IR::_TAO_UsesDef_Proxy_Broker * (*IR__TAO_UsesDef_Proxy_Broker_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  );
+
+extern TAO_IFR_Client_Export IR::_TAO_EventDef_Proxy_Broker * (*IR__TAO_EventDef_Proxy_Broker_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  );
+
+extern TAO_IFR_Client_Export IR::_TAO_EmitsDef_Proxy_Broker * (*IR__TAO_EmitsDef_Proxy_Broker_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  );
+
+extern TAO_IFR_Client_Export IR::_TAO_PublishesDef_Proxy_Broker * (*IR__TAO_PublishesDef_Proxy_Broker_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  );
+
+extern TAO_IFR_Client_Export IR::_TAO_ConsumesDef_Proxy_Broker * (*IR__TAO_ConsumesDef_Proxy_Broker_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  );
+
+extern TAO_IFR_Client_Export IR::_TAO_ComponentDef_Proxy_Broker * (*IR__TAO_ComponentDef_Proxy_Broker_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  );
+
+extern TAO_IFR_Client_Export IR::_TAO_PrimaryKeyDef_Proxy_Broker * (*IR__TAO_PrimaryKeyDef_Proxy_Broker_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  );
+
+extern TAO_IFR_Client_Export IR::_TAO_FactoryDef_Proxy_Broker * (*IR__TAO_FactoryDef_Proxy_Broker_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  );
+
+extern TAO_IFR_Client_Export IR::_TAO_FinderDef_Proxy_Broker * (*IR__TAO_FinderDef_Proxy_Broker_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  );
+
+extern TAO_IFR_Client_Export IR::_TAO_HomeDef_Proxy_Broker * (*IR__TAO_HomeDef_Proxy_Broker_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  );
+
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR::DefinitionKind);
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::DefinitionKind &);
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const IR::RepositoryIdSeq &); // copying version
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR::RepositoryIdSeq*); // noncopying version
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::RepositoryIdSeq *&); // deprecated
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::RepositoryIdSeq *&);
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const IR::ComponentDefSeq &); // copying version
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR::ComponentDefSeq*); // noncopying version
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::ComponentDefSeq *&); // deprecated
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::ComponentDefSeq *&);
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const IR::ProvidesDefSeq &); // copying version
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR::ProvidesDefSeq*); // noncopying version
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::ProvidesDefSeq *&); // deprecated
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::ProvidesDefSeq *&);
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const IR::UsesDefSeq &); // copying version
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR::UsesDefSeq*); // noncopying version
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::UsesDefSeq *&); // deprecated
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::UsesDefSeq *&);
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const IR::HomeDefSeq &); // copying version
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR::HomeDefSeq*); // noncopying version
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::HomeDefSeq *&); // deprecated
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::HomeDefSeq *&);
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const IR::EmitsDefSeq &); // copying version
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR::EmitsDefSeq*); // noncopying version
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::EmitsDefSeq *&); // deprecated
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::EmitsDefSeq *&);
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const IR::PublishesDefSeq &); // copying version
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR::PublishesDefSeq*); // noncopying version
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::PublishesDefSeq *&); // deprecated
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::PublishesDefSeq *&);
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const IR::ConsumesDefSeq &); // copying version
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR::ConsumesDefSeq*); // noncopying version
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::ConsumesDefSeq *&); // deprecated
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::ConsumesDefSeq *&);
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const IR::FactoryDefSeq &); // copying version
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR::FactoryDefSeq*); // noncopying version
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::FactoryDefSeq *&); // deprecated
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::FactoryDefSeq *&);
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const IR::FinderDefSeq &); // copying version
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR::FinderDefSeq*); // noncopying version
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::FinderDefSeq *&); // deprecated
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::FinderDefSeq *&);
+// Any operators for interface IR::ComponentRepository
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR::ComponentRepository_ptr);
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::ComponentRepository *&);
+// Any operators for interface IR::ProvidesDef
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR::ProvidesDef_ptr);
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::ProvidesDef *&);
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const IR::ProvidesDescription &); // copying version
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR::ProvidesDescription*); // noncopying version
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::ProvidesDescription *&); // deprecated
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::ProvidesDescription *&);
+// Any operators for interface IR::UsesDef
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR::UsesDef_ptr);
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::UsesDef *&);
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const IR::UsesDescription &); // copying version
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR::UsesDescription*); // noncopying version
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::UsesDescription *&); // deprecated
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::UsesDescription *&);
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const IR::ProvidesDescSeq &); // copying version
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR::ProvidesDescSeq*); // noncopying version
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::ProvidesDescSeq *&); // deprecated
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::ProvidesDescSeq *&);
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const IR::UsesDescSeq &); // copying version
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR::UsesDescSeq*); // noncopying version
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::UsesDescSeq *&); // deprecated
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::UsesDescSeq *&);
+// Any operators for interface IR::EventDef
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR::EventDef_ptr);
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::EventDef *&);
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const IR::EventDescription &); // copying version
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR::EventDescription*); // noncopying version
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::EventDescription *&); // deprecated
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::EventDescription *&);
+// Any operators for interface IR::EmitsDef
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR::EmitsDef_ptr);
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::EmitsDef *&);
+// Any operators for interface IR::PublishesDef
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR::PublishesDef_ptr);
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::PublishesDef *&);
+// Any operators for interface IR::ConsumesDef
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR::ConsumesDef_ptr);
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::ConsumesDef *&);
+// Any operators for interface IR::ComponentDef
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR::ComponentDef_ptr);
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::ComponentDef *&);
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const IR::ComponentDescription &); // copying version
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR::ComponentDescription*); // noncopying version
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::ComponentDescription *&); // deprecated
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::ComponentDescription *&);
+// Any operators for interface IR::PrimaryKeyDef
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR::PrimaryKeyDef_ptr);
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::PrimaryKeyDef *&);
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const IR::PrimaryKeyDescription &); // copying version
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR::PrimaryKeyDescription*); // noncopying version
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::PrimaryKeyDescription *&); // deprecated
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::PrimaryKeyDescription *&);
+// Any operators for interface IR::FactoryDef
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR::FactoryDef_ptr);
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::FactoryDef *&);
+// Any operators for interface IR::FinderDef
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR::FinderDef_ptr);
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::FinderDef *&);
+// Any operators for interface IR::HomeDef
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR::HomeDef_ptr);
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::HomeDef *&);
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const IR::HomeDescription &); // copying version
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR::HomeDescription*); // noncopying version
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::HomeDescription *&); // deprecated
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::HomeDescription *&);
+
+#ifndef __ACE_INLINE__
+
+TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::DefinitionKind &); // 
+TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::DefinitionKind &);
+
+#if !defined _TAO_CDR_OP_IR_RepositoryIdSeq_H_
+#define _TAO_CDR_OP_IR_RepositoryIdSeq_H_
+
+TAO_IFR_Client_Export CORBA::Boolean operator<< (
+    TAO_OutputCDR &,
+    const IR::RepositoryIdSeq &
+  );
+TAO_IFR_Client_Export CORBA::Boolean operator>> (
+    TAO_InputCDR &,
+    IR::RepositoryIdSeq &
+  );
+
+#endif /* _TAO_CDR_OP_IR_RepositoryIdSeq_H_ */
+
+
+#if !defined _TAO_CDR_OP_IR_ComponentDefSeq_H_
+#define _TAO_CDR_OP_IR_ComponentDefSeq_H_
+
+TAO_IFR_Client_Export CORBA::Boolean operator<< (
+    TAO_OutputCDR &,
+    const IR::ComponentDefSeq &
+  );
+TAO_IFR_Client_Export CORBA::Boolean operator>> (
+    TAO_InputCDR &,
+    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_IFR_Client_Export CORBA::Boolean operator<< (
+    TAO_OutputCDR &,
+    const IR::ProvidesDefSeq &
+  );
+TAO_IFR_Client_Export CORBA::Boolean operator>> (
+    TAO_InputCDR &,
+    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_IFR_Client_Export CORBA::Boolean operator<< (
+    TAO_OutputCDR &,
+    const IR::UsesDefSeq &
+  );
+TAO_IFR_Client_Export CORBA::Boolean operator>> (
+    TAO_InputCDR &,
+    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_IFR_Client_Export CORBA::Boolean operator<< (
+    TAO_OutputCDR &,
+    const IR::HomeDefSeq &
+  );
+TAO_IFR_Client_Export CORBA::Boolean operator>> (
+    TAO_InputCDR &,
+    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_IFR_Client_Export CORBA::Boolean operator<< (
+    TAO_OutputCDR &,
+    const IR::EmitsDefSeq &
+  );
+TAO_IFR_Client_Export CORBA::Boolean operator>> (
+    TAO_InputCDR &,
+    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_IFR_Client_Export CORBA::Boolean operator<< (
+    TAO_OutputCDR &,
+    const IR::PublishesDefSeq &
+  );
+TAO_IFR_Client_Export CORBA::Boolean operator>> (
+    TAO_InputCDR &,
+    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_IFR_Client_Export CORBA::Boolean operator<< (
+    TAO_OutputCDR &,
+    const IR::ConsumesDefSeq &
+  );
+TAO_IFR_Client_Export CORBA::Boolean operator>> (
+    TAO_InputCDR &,
+    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_IFR_Client_Export CORBA::Boolean operator<< (
+    TAO_OutputCDR &,
+    const IR::FactoryDefSeq &
+  );
+TAO_IFR_Client_Export CORBA::Boolean operator>> (
+    TAO_InputCDR &,
+    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_IFR_Client_Export CORBA::Boolean operator<< (
+    TAO_OutputCDR &,
+    const IR::FinderDefSeq &
+  );
+TAO_IFR_Client_Export CORBA::Boolean operator>> (
+    TAO_InputCDR &,
+    IR::FinderDefSeq &
+  );
+
+#endif /* _TAO_CDR_OP_IR_FinderDefSeq_H_ */
+
+TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::ComponentRepository_ptr );
+TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::ComponentRepository_ptr &);
+TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::ProvidesDef_ptr );
+TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::ProvidesDef_ptr &);
+TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::ProvidesDescription &);
+TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::ProvidesDescription &);
+TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::UsesDef_ptr );
+TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::UsesDef_ptr &);
+TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::UsesDescription &);
+TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::UsesDescription &);
+
+#if !defined _TAO_CDR_OP_IR_ProvidesDescSeq_H_
+#define _TAO_CDR_OP_IR_ProvidesDescSeq_H_
+
+TAO_IFR_Client_Export CORBA::Boolean operator<< (
+    TAO_OutputCDR &,
+    const IR::ProvidesDescSeq &
+  );
+TAO_IFR_Client_Export CORBA::Boolean operator>> (
+    TAO_InputCDR &,
+    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_IFR_Client_Export CORBA::Boolean operator<< (
+    TAO_OutputCDR &,
+    const IR::UsesDescSeq &
+  );
+TAO_IFR_Client_Export CORBA::Boolean operator>> (
+    TAO_InputCDR &,
+    IR::UsesDescSeq &
+  );
+
+#endif /* _TAO_CDR_OP_IR_UsesDescSeq_H_ */
+
+TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::EventDef_ptr );
+TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::EventDef_ptr &);
+TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::EventDescription &);
+TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::EventDescription &);
+TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::EmitsDef_ptr );
+TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::EmitsDef_ptr &);
+TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::PublishesDef_ptr );
+TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::PublishesDef_ptr &);
+TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::ConsumesDef_ptr );
+TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::ConsumesDef_ptr &);
+TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::ComponentDef_ptr );
+TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::ComponentDef_ptr &);
+TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::ComponentDescription &);
+TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::ComponentDescription &);
+TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::PrimaryKeyDef_ptr );
+TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::PrimaryKeyDef_ptr &);
+TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::PrimaryKeyDescription &);
+TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::PrimaryKeyDescription &);
+TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::FactoryDef_ptr );
+TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::FactoryDef_ptr &);
+TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::FinderDef_ptr );
+TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::FinderDef_ptr &);
+TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::HomeDef_ptr );
+TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::HomeDef_ptr &);
+TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::HomeDescription &);
+TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::HomeDescription &);
+
+#endif /* __ACE_INLINE__ */
+
+
+#if defined (__ACE_INLINE__)
+#include "IFR_ComponentsC.i"
+#endif /* defined INLINE */
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+#pragma warning(pop)
+#endif /* _MSC_VER */
+
+#if defined (__BORLANDC__)
+#pragma option pop
+#endif /* __BORLANDC__ */
+
+#include "ace/post.h"
+#endif /* ifndef */
diff --git a/TAO/tao/IFR_Client/IFR_ComponentsC.i b/TAO/tao/IFR_Client/IFR_ComponentsC.i
new file mode 100644
index 00000000000..ef243412bc6
--- /dev/null
+++ b/TAO/tao/IFR_Client/IFR_ComponentsC.i
@@ -0,0 +1,8855 @@
+// -*- C++ -*-
+//
+// $Id$
+
+// ****  Code generated by the The ACE ORB (TAO) IDL Compiler ****
+// TAO and the TAO IDL Compiler have been developed by:
+//       Center for Distributed Object Computing
+//       Washington University
+//       St. Louis, MO
+//       USA
+//       http://www.cs.wustl.edu/~schmidt/doc-center.html
+// and
+//       Distributed Object Computing Laboratory
+//       University of California at Irvine
+//       Irvine, CA
+//       USA
+//       http://doc.ece.uci.edu/
+//
+// Information about TAO is available at:
+//     http://www.cs.wustl.edu/~schmidt/TAO.html
+
+
+#if !defined (_IR_REPOSITORYIDSEQ_CI_)
+#define _IR_REPOSITORYIDSEQ_CI_
+
+// *************************************************************
+// Inline operations for class IR::RepositoryIdSeq_var
+// *************************************************************
+
+ACE_INLINE
+IR::RepositoryIdSeq_var::RepositoryIdSeq_var (void) // default constructor
+  : ptr_ (0)
+{}
+
+ACE_INLINE
+IR::RepositoryIdSeq_var::RepositoryIdSeq_var (RepositoryIdSeq *p)
+  : ptr_ (p)
+{}
+
+ACE_INLINE
+IR::RepositoryIdSeq_var::RepositoryIdSeq_var (const ::IR::RepositoryIdSeq_var &p) // copy constructor
+{
+  if (p.ptr_)
+    ACE_NEW (this->ptr_, ::IR::RepositoryIdSeq (*p.ptr_));
+  else
+    this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::RepositoryIdSeq_var::~RepositoryIdSeq_var (void) // destructor
+{
+  delete this->ptr_;
+}
+
+ACE_INLINE IR::RepositoryIdSeq_var &
+IR::RepositoryIdSeq_var::operator= (RepositoryIdSeq *p)
+{
+  delete this->ptr_;
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE ::IR::RepositoryIdSeq_var &
+IR::RepositoryIdSeq_var::operator= (const ::IR::RepositoryIdSeq_var &p)
+{
+  if (this != &p)
+    {
+      if (p.ptr_ == 0)
+        {
+          delete this->ptr_;
+          this->ptr_ = 0;
+        }
+      else
+        {
+          RepositoryIdSeq *deep_copy =
+            new RepositoryIdSeq (*p.ptr_);
+          
+          if (deep_copy != 0)
+            {
+              RepositoryIdSeq *tmp = deep_copy;
+              deep_copy = this->ptr_;
+              this->ptr_ = tmp;
+              delete deep_copy;
+            }
+        }
+    }
+  
+  return *this;
+}
+
+ACE_INLINE const ::IR::RepositoryIdSeq *
+IR::RepositoryIdSeq_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::RepositoryIdSeq *
+IR::RepositoryIdSeq_var::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+IR::RepositoryIdSeq_var::operator const ::IR::RepositoryIdSeq &() const // cast
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE 
+IR::RepositoryIdSeq_var::operator ::IR::RepositoryIdSeq &() // cast 
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE 
+IR::RepositoryIdSeq_var::operator ::IR::RepositoryIdSeq &() const // cast 
+{
+  return *this->ptr_;
+}
+
+// variable-size types only
+ACE_INLINE
+IR::RepositoryIdSeq_var::operator ::IR::RepositoryIdSeq *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE TAO_SeqElem_String_Manager
+IR::RepositoryIdSeq_var::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+ACE_INLINE const ::IR::RepositoryIdSeq &
+IR::RepositoryIdSeq_var::in (void) const
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE ::IR::RepositoryIdSeq &
+IR::RepositoryIdSeq_var::inout (void)
+{
+  return *this->ptr_;
+}
+
+// mapping for variable size 
+ACE_INLINE ::IR::RepositoryIdSeq *&
+IR::RepositoryIdSeq_var::out (void)
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::RepositoryIdSeq *
+IR::RepositoryIdSeq_var::_retn (void)
+{
+  ::IR::RepositoryIdSeq *tmp = this->ptr_;
+  this->ptr_ = 0;
+  return tmp;
+}
+
+ACE_INLINE ::IR::RepositoryIdSeq *
+IR::RepositoryIdSeq_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+// *************************************************************
+// Inline operations for class IR::RepositoryIdSeq_out
+// *************************************************************
+
+ACE_INLINE
+IR::RepositoryIdSeq_out::RepositoryIdSeq_out (RepositoryIdSeq *&p)
+  : ptr_ (p)
+{
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::RepositoryIdSeq_out::RepositoryIdSeq_out (RepositoryIdSeq_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::RepositoryIdSeq_out::RepositoryIdSeq_out (const ::IR::RepositoryIdSeq_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (RepositoryIdSeq_out&, p).ptr_)
+{}
+
+ACE_INLINE ::IR::RepositoryIdSeq_out &
+IR::RepositoryIdSeq_out::operator= (const ::IR::RepositoryIdSeq_out &p)
+{
+  this->ptr_ = ACE_const_cast (RepositoryIdSeq_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE ::IR::RepositoryIdSeq_out &
+IR::RepositoryIdSeq_out::operator= (RepositoryIdSeq *p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+IR::RepositoryIdSeq_out::operator ::IR::RepositoryIdSeq *&() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::RepositoryIdSeq *&
+IR::RepositoryIdSeq_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::RepositoryIdSeq *
+IR::RepositoryIdSeq_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE TAO_SeqElem_String_Manager
+IR::RepositoryIdSeq_out::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_COMPONENTDEF___CI_)
+#define _IR_COMPONENTDEF___CI_
+
+ACE_INLINE
+IR::ComponentDef::ComponentDef (
+    TAO_Stub *objref,
+    CORBA::Boolean _tao_collocated,
+    TAO_Abstract_ServantBase *servant
+  )
+  : CORBA_Object (objref, _tao_collocated, servant)
+{
+  this->IR_ComponentDef_setup_collocation (_tao_collocated);
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_COMPONENTDEF___VAR_CI_)
+#define _IR_COMPONENTDEF___VAR_CI_
+
+// *************************************************************
+// Inline operations for class IR::ComponentDef_var
+// *************************************************************
+
+ACE_INLINE
+IR::ComponentDef_var::ComponentDef_var (void) // default constructor
+  : ptr_ (IR::ComponentDef::_nil ())
+{}
+
+ACE_INLINE IR::ComponentDef_ptr 
+IR::ComponentDef_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+IR::ComponentDef_var::ComponentDef_var (const IR::ComponentDef_var &p) // copy constructor
+  : TAO_Base_var (),
+    ptr_ (ComponentDef::_duplicate (p.ptr ()))
+{}
+
+ACE_INLINE
+IR::ComponentDef_var::~ComponentDef_var (void) // destructor
+{
+  CORBA::release (this->ptr_);
+}
+
+ACE_INLINE IR::ComponentDef_var &
+IR::ComponentDef_var::operator= (IR::ComponentDef_ptr p)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE IR::ComponentDef_var &
+IR::ComponentDef_var::operator= (const IR::ComponentDef_var &p)
+{
+  if (this != &p)
+  {
+    CORBA::release (this->ptr_);
+    this->ptr_ = IR::ComponentDef::_duplicate (p.ptr ());
+  }
+  return *this;
+}
+
+ACE_INLINE 
+IR::ComponentDef_var::operator const IR::ComponentDef_ptr &() const // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+IR::ComponentDef_var::operator IR::ComponentDef_ptr &() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE IR::ComponentDef_ptr 
+IR::ComponentDef_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE IR::ComponentDef_ptr
+IR::ComponentDef_var::in (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE IR::ComponentDef_ptr &
+IR::ComponentDef_var::inout (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE IR::ComponentDef_ptr &
+IR::ComponentDef_var::out (void)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = IR::ComponentDef::_nil ();
+  return this->ptr_;
+}
+
+ACE_INLINE IR::ComponentDef_ptr 
+IR::ComponentDef_var::_retn (void)
+{
+  // yield ownership of managed obj reference
+  IR::ComponentDef_ptr val = this->ptr_;
+  this->ptr_ = IR::ComponentDef::_nil ();
+  return val;
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_COMPONENTDEF___OUT_CI_)
+#define _IR_COMPONENTDEF___OUT_CI_
+
+// *************************************************************
+// Inline operations for class IR::ComponentDef_out
+// *************************************************************
+
+ACE_INLINE
+IR::ComponentDef_out::ComponentDef_out (IR::ComponentDef_ptr &p)
+  : ptr_ (p)
+{
+  this->ptr_ = IR::ComponentDef::_nil ();
+}
+
+ACE_INLINE
+IR::ComponentDef_out::ComponentDef_out (IR::ComponentDef_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = IR::ComponentDef::_nil ();
+}
+
+ACE_INLINE
+IR::ComponentDef_out::ComponentDef_out (const IR::ComponentDef_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (IR::ComponentDef_out&,p).ptr_)
+{}
+
+ACE_INLINE IR::ComponentDef_out &
+IR::ComponentDef_out::operator= (const IR::ComponentDef_out &p)
+{
+  this->ptr_ = ACE_const_cast (IR::ComponentDef_out&,p).ptr_;
+  return *this;
+}
+
+ACE_INLINE IR::ComponentDef_out &
+IR::ComponentDef_out::operator= (const IR::ComponentDef_var &p)
+{
+  this->ptr_ = IR::ComponentDef::_duplicate (p.ptr ());
+  return *this;
+}
+
+ACE_INLINE IR::ComponentDef_out &
+IR::ComponentDef_out::operator= (IR::ComponentDef_ptr p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+IR::ComponentDef_out::operator IR::ComponentDef_ptr &() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE IR::ComponentDef_ptr &
+IR::ComponentDef_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE IR::ComponentDef_ptr 
+IR::ComponentDef_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_COMPONENTDEFSEQ_CI_)
+#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_COMPONENTDEFSEQ_CI_
+
+  ACE_INLINE IR::ComponentDef **
+  IR::_TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq::allocbuf (CORBA::ULong nelems)
+  {
+    IR::ComponentDef **buf = 0;
+    
+    ACE_NEW_RETURN (buf, IR::ComponentDef*[nelems], 0);
+    
+    for (CORBA::ULong i = 0; i < nelems; i++)
+      buf[i] = IR::ComponentDef::_nil ();
+    
+    return buf;
+  }
+  
+  ACE_INLINE void 
+  IR::_TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq::freebuf (IR::ComponentDef **buffer)
+  {
+    if (buffer == 0)
+      return;
+    delete[] buffer;
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq::_TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq (void)
+  {
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq::_TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq (CORBA::ULong maximum)
+    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq::allocbuf (maximum))
+  {
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq::_TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq (CORBA::ULong maximum,
+    CORBA::ULong length,
+    IR::ComponentDef* *value,
+    CORBA::Boolean release)
+  : TAO_Unbounded_Base_Sequence (maximum, length, value, release)
+  {
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq::_TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq(const _TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq &rhs)
+    : TAO_Unbounded_Base_Sequence (rhs)
+  {
+    if (rhs.buffer_ != 0)
+    {
+      IR::ComponentDef **tmp1 = _TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq::allocbuf (this->maximum_);
+      IR::ComponentDef ** const tmp2 = ACE_reinterpret_cast (IR::ComponentDef ** ACE_CAST_CONST, rhs.buffer_);
+      
+      for (CORBA::ULong i = 0; i < rhs.length_; ++i)
+        tmp1[i] = IR::ComponentDef::_duplicate (tmp2[i]);
+      
+      this->buffer_ = tmp1;
+    }
+    else
+    {
+      this->buffer_ = 0;
+    }
+  }
+  
+  ACE_INLINE IR::_TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq &
+  IR::_TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq::operator= (const _TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq &rhs)
+  {
+    if (this == &rhs)
+      return *this;
+    
+    if (this->release_)
+    {
+      IR::ComponentDef **tmp = ACE_reinterpret_cast (IR::ComponentDef **, this->buffer_);
+      
+      for (CORBA::ULong i = 0; i < this->length_; ++i)
+      {
+        CORBA::release (tmp[i]);
+        tmp[i] = IR::ComponentDef::_nil ();
+      }
+      if (this->maximum_ < rhs.maximum_)
+      {
+        _TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq::freebuf (tmp);
+        this->buffer_ = _TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq::allocbuf (rhs.maximum_);
+      }
+    }
+    else
+      this->buffer_ = _TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq::allocbuf (rhs.maximum_);
+    
+    TAO_Unbounded_Base_Sequence::operator= (rhs);
+    
+    IR::ComponentDef **tmp1 = ACE_reinterpret_cast (IR::ComponentDef **, this->buffer_);
+    IR::ComponentDef ** const tmp2 = ACE_reinterpret_cast (IR::ComponentDef ** ACE_CAST_CONST, rhs.buffer_);
+    
+    for (CORBA::ULong i = 0; i < rhs.length_; ++i)
+      tmp1[i] = IR::ComponentDef::_duplicate (tmp2[i]);
+    
+    return *this;
+  }
+  
+  ACE_INLINE TAO_Object_Manager<IR::ComponentDef,IR::ComponentDef_var>
+  IR::_TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq::operator[] (CORBA::ULong index) const
+  // read-write accessor
+  {
+    ACE_ASSERT (index < this->maximum_);
+    IR::ComponentDef ** const tmp = ACE_reinterpret_cast (IR::ComponentDef ** ACE_CAST_CONST, this->buffer_);
+    return TAO_Object_Manager<IR::ComponentDef,IR::ComponentDef_var> (tmp + index, this->release_);
+  }
+  
+  ACE_INLINE IR::ComponentDef* *
+  IR::_TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq::get_buffer (CORBA::Boolean orphan)
+  {
+    IR::ComponentDef **result = 0;
+    if (orphan == 0)
+    {
+      // We retain ownership.
+      if (this->buffer_ == 0)
+      {
+        result = _TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq::allocbuf (this->maximum_);
+        this->buffer_ = result;
+        this->release_ = 1;
+      }
+      else
+      {
+        result = ACE_reinterpret_cast (IR::ComponentDef**, this->buffer_);
+      }
+    }
+    else // if (orphan == 1)
+    {
+      if (this->release_ != 0)
+      {
+        // We set the state back to default and relinquish
+        // ownership.
+        result = ACE_reinterpret_cast(IR::ComponentDef**,this->buffer_);
+        this->maximum_ = 0;
+        this->length_ = 0;
+        this->buffer_ = 0;
+        this->release_ = 0;
+      }
+    }
+    return result;
+  }
+  
+  ACE_INLINE const IR::ComponentDef* *
+  IR::_TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq::get_buffer (void) const
+  {
+    return ACE_reinterpret_cast(const IR::ComponentDef ** ACE_CAST_CONST, this->buffer_);
+  }
+  
+  
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_IR_COMPONENTDEFSEQ_CI_)
+#define _IR_COMPONENTDEFSEQ_CI_
+
+// *************************************************************
+// Inline operations for class IR::ComponentDefSeq_var
+// *************************************************************
+
+ACE_INLINE
+IR::ComponentDefSeq_var::ComponentDefSeq_var (void) // default constructor
+  : ptr_ (0)
+{}
+
+ACE_INLINE
+IR::ComponentDefSeq_var::ComponentDefSeq_var (ComponentDefSeq *p)
+  : ptr_ (p)
+{}
+
+ACE_INLINE
+IR::ComponentDefSeq_var::ComponentDefSeq_var (const ::IR::ComponentDefSeq_var &p) // copy constructor
+{
+  if (p.ptr_)
+    ACE_NEW (this->ptr_, ::IR::ComponentDefSeq (*p.ptr_));
+  else
+    this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::ComponentDefSeq_var::~ComponentDefSeq_var (void) // destructor
+{
+  delete this->ptr_;
+}
+
+ACE_INLINE IR::ComponentDefSeq_var &
+IR::ComponentDefSeq_var::operator= (ComponentDefSeq *p)
+{
+  delete this->ptr_;
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE ::IR::ComponentDefSeq_var &
+IR::ComponentDefSeq_var::operator= (const ::IR::ComponentDefSeq_var &p)
+{
+  if (this != &p)
+    {
+      if (p.ptr_ == 0)
+        {
+          delete this->ptr_;
+          this->ptr_ = 0;
+        }
+      else
+        {
+          ComponentDefSeq *deep_copy =
+            new ComponentDefSeq (*p.ptr_);
+          
+          if (deep_copy != 0)
+            {
+              ComponentDefSeq *tmp = deep_copy;
+              deep_copy = this->ptr_;
+              this->ptr_ = tmp;
+              delete deep_copy;
+            }
+        }
+    }
+  
+  return *this;
+}
+
+ACE_INLINE const ::IR::ComponentDefSeq *
+IR::ComponentDefSeq_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ComponentDefSeq *
+IR::ComponentDefSeq_var::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+IR::ComponentDefSeq_var::operator const ::IR::ComponentDefSeq &() const // cast
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE 
+IR::ComponentDefSeq_var::operator ::IR::ComponentDefSeq &() // cast 
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE 
+IR::ComponentDefSeq_var::operator ::IR::ComponentDefSeq &() const // cast 
+{
+  return *this->ptr_;
+}
+
+// variable-size types only
+ACE_INLINE
+IR::ComponentDefSeq_var::operator ::IR::ComponentDefSeq *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE TAO_Object_Manager<IR::ComponentDef, IR::ComponentDef_var>
+IR::ComponentDefSeq_var::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+ACE_INLINE const ::IR::ComponentDefSeq &
+IR::ComponentDefSeq_var::in (void) const
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE ::IR::ComponentDefSeq &
+IR::ComponentDefSeq_var::inout (void)
+{
+  return *this->ptr_;
+}
+
+// mapping for variable size 
+ACE_INLINE ::IR::ComponentDefSeq *&
+IR::ComponentDefSeq_var::out (void)
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ComponentDefSeq *
+IR::ComponentDefSeq_var::_retn (void)
+{
+  ::IR::ComponentDefSeq *tmp = this->ptr_;
+  this->ptr_ = 0;
+  return tmp;
+}
+
+ACE_INLINE ::IR::ComponentDefSeq *
+IR::ComponentDefSeq_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+// *************************************************************
+// Inline operations for class IR::ComponentDefSeq_out
+// *************************************************************
+
+ACE_INLINE
+IR::ComponentDefSeq_out::ComponentDefSeq_out (ComponentDefSeq *&p)
+  : ptr_ (p)
+{
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::ComponentDefSeq_out::ComponentDefSeq_out (ComponentDefSeq_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::ComponentDefSeq_out::ComponentDefSeq_out (const ::IR::ComponentDefSeq_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (ComponentDefSeq_out&, p).ptr_)
+{}
+
+ACE_INLINE ::IR::ComponentDefSeq_out &
+IR::ComponentDefSeq_out::operator= (const ::IR::ComponentDefSeq_out &p)
+{
+  this->ptr_ = ACE_const_cast (ComponentDefSeq_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE ::IR::ComponentDefSeq_out &
+IR::ComponentDefSeq_out::operator= (ComponentDefSeq *p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+IR::ComponentDefSeq_out::operator ::IR::ComponentDefSeq *&() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ComponentDefSeq *&
+IR::ComponentDefSeq_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ComponentDefSeq *
+IR::ComponentDefSeq_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE TAO_Object_Manager<IR::ComponentDef, IR::ComponentDef_var>
+IR::ComponentDefSeq_out::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_PROVIDESDEF___CI_)
+#define _IR_PROVIDESDEF___CI_
+
+ACE_INLINE
+IR::ProvidesDef::ProvidesDef (
+    TAO_Stub *objref,
+    CORBA::Boolean _tao_collocated,
+    TAO_Abstract_ServantBase *servant
+  )
+  : CORBA_Object (objref, _tao_collocated, servant)
+{
+  this->IR_ProvidesDef_setup_collocation (_tao_collocated);
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_PROVIDESDEF___VAR_CI_)
+#define _IR_PROVIDESDEF___VAR_CI_
+
+// *************************************************************
+// Inline operations for class IR::ProvidesDef_var
+// *************************************************************
+
+ACE_INLINE
+IR::ProvidesDef_var::ProvidesDef_var (void) // default constructor
+  : ptr_ (IR::ProvidesDef::_nil ())
+{}
+
+ACE_INLINE IR::ProvidesDef_ptr 
+IR::ProvidesDef_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+IR::ProvidesDef_var::ProvidesDef_var (const IR::ProvidesDef_var &p) // copy constructor
+  : TAO_Base_var (),
+    ptr_ (ProvidesDef::_duplicate (p.ptr ()))
+{}
+
+ACE_INLINE
+IR::ProvidesDef_var::~ProvidesDef_var (void) // destructor
+{
+  CORBA::release (this->ptr_);
+}
+
+ACE_INLINE IR::ProvidesDef_var &
+IR::ProvidesDef_var::operator= (IR::ProvidesDef_ptr p)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE IR::ProvidesDef_var &
+IR::ProvidesDef_var::operator= (const IR::ProvidesDef_var &p)
+{
+  if (this != &p)
+  {
+    CORBA::release (this->ptr_);
+    this->ptr_ = IR::ProvidesDef::_duplicate (p.ptr ());
+  }
+  return *this;
+}
+
+ACE_INLINE 
+IR::ProvidesDef_var::operator const IR::ProvidesDef_ptr &() const // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+IR::ProvidesDef_var::operator IR::ProvidesDef_ptr &() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE IR::ProvidesDef_ptr 
+IR::ProvidesDef_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE IR::ProvidesDef_ptr
+IR::ProvidesDef_var::in (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE IR::ProvidesDef_ptr &
+IR::ProvidesDef_var::inout (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE IR::ProvidesDef_ptr &
+IR::ProvidesDef_var::out (void)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = IR::ProvidesDef::_nil ();
+  return this->ptr_;
+}
+
+ACE_INLINE IR::ProvidesDef_ptr 
+IR::ProvidesDef_var::_retn (void)
+{
+  // yield ownership of managed obj reference
+  IR::ProvidesDef_ptr val = this->ptr_;
+  this->ptr_ = IR::ProvidesDef::_nil ();
+  return val;
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_PROVIDESDEF___OUT_CI_)
+#define _IR_PROVIDESDEF___OUT_CI_
+
+// *************************************************************
+// Inline operations for class IR::ProvidesDef_out
+// *************************************************************
+
+ACE_INLINE
+IR::ProvidesDef_out::ProvidesDef_out (IR::ProvidesDef_ptr &p)
+  : ptr_ (p)
+{
+  this->ptr_ = IR::ProvidesDef::_nil ();
+}
+
+ACE_INLINE
+IR::ProvidesDef_out::ProvidesDef_out (IR::ProvidesDef_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = IR::ProvidesDef::_nil ();
+}
+
+ACE_INLINE
+IR::ProvidesDef_out::ProvidesDef_out (const IR::ProvidesDef_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (IR::ProvidesDef_out&,p).ptr_)
+{}
+
+ACE_INLINE IR::ProvidesDef_out &
+IR::ProvidesDef_out::operator= (const IR::ProvidesDef_out &p)
+{
+  this->ptr_ = ACE_const_cast (IR::ProvidesDef_out&,p).ptr_;
+  return *this;
+}
+
+ACE_INLINE IR::ProvidesDef_out &
+IR::ProvidesDef_out::operator= (const IR::ProvidesDef_var &p)
+{
+  this->ptr_ = IR::ProvidesDef::_duplicate (p.ptr ());
+  return *this;
+}
+
+ACE_INLINE IR::ProvidesDef_out &
+IR::ProvidesDef_out::operator= (IR::ProvidesDef_ptr p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+IR::ProvidesDef_out::operator IR::ProvidesDef_ptr &() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE IR::ProvidesDef_ptr &
+IR::ProvidesDef_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE IR::ProvidesDef_ptr 
+IR::ProvidesDef_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_PROVIDESDEFSEQ_CI_)
+#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_PROVIDESDEFSEQ_CI_
+
+  ACE_INLINE IR::ProvidesDef **
+  IR::_TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq::allocbuf (CORBA::ULong nelems)
+  {
+    IR::ProvidesDef **buf = 0;
+    
+    ACE_NEW_RETURN (buf, IR::ProvidesDef*[nelems], 0);
+    
+    for (CORBA::ULong i = 0; i < nelems; i++)
+      buf[i] = IR::ProvidesDef::_nil ();
+    
+    return buf;
+  }
+  
+  ACE_INLINE void 
+  IR::_TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq::freebuf (IR::ProvidesDef **buffer)
+  {
+    if (buffer == 0)
+      return;
+    delete[] buffer;
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq::_TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq (void)
+  {
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq::_TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq (CORBA::ULong maximum)
+    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq::allocbuf (maximum))
+  {
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq::_TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq (CORBA::ULong maximum,
+    CORBA::ULong length,
+    IR::ProvidesDef* *value,
+    CORBA::Boolean release)
+  : TAO_Unbounded_Base_Sequence (maximum, length, value, release)
+  {
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq::_TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq(const _TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq &rhs)
+    : TAO_Unbounded_Base_Sequence (rhs)
+  {
+    if (rhs.buffer_ != 0)
+    {
+      IR::ProvidesDef **tmp1 = _TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq::allocbuf (this->maximum_);
+      IR::ProvidesDef ** const tmp2 = ACE_reinterpret_cast (IR::ProvidesDef ** ACE_CAST_CONST, rhs.buffer_);
+      
+      for (CORBA::ULong i = 0; i < rhs.length_; ++i)
+        tmp1[i] = IR::ProvidesDef::_duplicate (tmp2[i]);
+      
+      this->buffer_ = tmp1;
+    }
+    else
+    {
+      this->buffer_ = 0;
+    }
+  }
+  
+  ACE_INLINE IR::_TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq &
+  IR::_TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq::operator= (const _TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq &rhs)
+  {
+    if (this == &rhs)
+      return *this;
+    
+    if (this->release_)
+    {
+      IR::ProvidesDef **tmp = ACE_reinterpret_cast (IR::ProvidesDef **, this->buffer_);
+      
+      for (CORBA::ULong i = 0; i < this->length_; ++i)
+      {
+        CORBA::release (tmp[i]);
+        tmp[i] = IR::ProvidesDef::_nil ();
+      }
+      if (this->maximum_ < rhs.maximum_)
+      {
+        _TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq::freebuf (tmp);
+        this->buffer_ = _TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq::allocbuf (rhs.maximum_);
+      }
+    }
+    else
+      this->buffer_ = _TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq::allocbuf (rhs.maximum_);
+    
+    TAO_Unbounded_Base_Sequence::operator= (rhs);
+    
+    IR::ProvidesDef **tmp1 = ACE_reinterpret_cast (IR::ProvidesDef **, this->buffer_);
+    IR::ProvidesDef ** const tmp2 = ACE_reinterpret_cast (IR::ProvidesDef ** ACE_CAST_CONST, rhs.buffer_);
+    
+    for (CORBA::ULong i = 0; i < rhs.length_; ++i)
+      tmp1[i] = IR::ProvidesDef::_duplicate (tmp2[i]);
+    
+    return *this;
+  }
+  
+  ACE_INLINE TAO_Object_Manager<IR::ProvidesDef,IR::ProvidesDef_var>
+  IR::_TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq::operator[] (CORBA::ULong index) const
+  // read-write accessor
+  {
+    ACE_ASSERT (index < this->maximum_);
+    IR::ProvidesDef ** const tmp = ACE_reinterpret_cast (IR::ProvidesDef ** ACE_CAST_CONST, this->buffer_);
+    return TAO_Object_Manager<IR::ProvidesDef,IR::ProvidesDef_var> (tmp + index, this->release_);
+  }
+  
+  ACE_INLINE IR::ProvidesDef* *
+  IR::_TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq::get_buffer (CORBA::Boolean orphan)
+  {
+    IR::ProvidesDef **result = 0;
+    if (orphan == 0)
+    {
+      // We retain ownership.
+      if (this->buffer_ == 0)
+      {
+        result = _TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq::allocbuf (this->maximum_);
+        this->buffer_ = result;
+        this->release_ = 1;
+      }
+      else
+      {
+        result = ACE_reinterpret_cast (IR::ProvidesDef**, this->buffer_);
+      }
+    }
+    else // if (orphan == 1)
+    {
+      if (this->release_ != 0)
+      {
+        // We set the state back to default and relinquish
+        // ownership.
+        result = ACE_reinterpret_cast(IR::ProvidesDef**,this->buffer_);
+        this->maximum_ = 0;
+        this->length_ = 0;
+        this->buffer_ = 0;
+        this->release_ = 0;
+      }
+    }
+    return result;
+  }
+  
+  ACE_INLINE const IR::ProvidesDef* *
+  IR::_TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq::get_buffer (void) const
+  {
+    return ACE_reinterpret_cast(const IR::ProvidesDef ** ACE_CAST_CONST, this->buffer_);
+  }
+  
+  
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_IR_PROVIDESDEFSEQ_CI_)
+#define _IR_PROVIDESDEFSEQ_CI_
+
+// *************************************************************
+// Inline operations for class IR::ProvidesDefSeq_var
+// *************************************************************
+
+ACE_INLINE
+IR::ProvidesDefSeq_var::ProvidesDefSeq_var (void) // default constructor
+  : ptr_ (0)
+{}
+
+ACE_INLINE
+IR::ProvidesDefSeq_var::ProvidesDefSeq_var (ProvidesDefSeq *p)
+  : ptr_ (p)
+{}
+
+ACE_INLINE
+IR::ProvidesDefSeq_var::ProvidesDefSeq_var (const ::IR::ProvidesDefSeq_var &p) // copy constructor
+{
+  if (p.ptr_)
+    ACE_NEW (this->ptr_, ::IR::ProvidesDefSeq (*p.ptr_));
+  else
+    this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::ProvidesDefSeq_var::~ProvidesDefSeq_var (void) // destructor
+{
+  delete this->ptr_;
+}
+
+ACE_INLINE IR::ProvidesDefSeq_var &
+IR::ProvidesDefSeq_var::operator= (ProvidesDefSeq *p)
+{
+  delete this->ptr_;
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE ::IR::ProvidesDefSeq_var &
+IR::ProvidesDefSeq_var::operator= (const ::IR::ProvidesDefSeq_var &p)
+{
+  if (this != &p)
+    {
+      if (p.ptr_ == 0)
+        {
+          delete this->ptr_;
+          this->ptr_ = 0;
+        }
+      else
+        {
+          ProvidesDefSeq *deep_copy =
+            new ProvidesDefSeq (*p.ptr_);
+          
+          if (deep_copy != 0)
+            {
+              ProvidesDefSeq *tmp = deep_copy;
+              deep_copy = this->ptr_;
+              this->ptr_ = tmp;
+              delete deep_copy;
+            }
+        }
+    }
+  
+  return *this;
+}
+
+ACE_INLINE const ::IR::ProvidesDefSeq *
+IR::ProvidesDefSeq_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ProvidesDefSeq *
+IR::ProvidesDefSeq_var::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+IR::ProvidesDefSeq_var::operator const ::IR::ProvidesDefSeq &() const // cast
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE 
+IR::ProvidesDefSeq_var::operator ::IR::ProvidesDefSeq &() // cast 
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE 
+IR::ProvidesDefSeq_var::operator ::IR::ProvidesDefSeq &() const // cast 
+{
+  return *this->ptr_;
+}
+
+// variable-size types only
+ACE_INLINE
+IR::ProvidesDefSeq_var::operator ::IR::ProvidesDefSeq *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE TAO_Object_Manager<IR::ProvidesDef, IR::ProvidesDef_var>
+IR::ProvidesDefSeq_var::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+ACE_INLINE const ::IR::ProvidesDefSeq &
+IR::ProvidesDefSeq_var::in (void) const
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE ::IR::ProvidesDefSeq &
+IR::ProvidesDefSeq_var::inout (void)
+{
+  return *this->ptr_;
+}
+
+// mapping for variable size 
+ACE_INLINE ::IR::ProvidesDefSeq *&
+IR::ProvidesDefSeq_var::out (void)
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ProvidesDefSeq *
+IR::ProvidesDefSeq_var::_retn (void)
+{
+  ::IR::ProvidesDefSeq *tmp = this->ptr_;
+  this->ptr_ = 0;
+  return tmp;
+}
+
+ACE_INLINE ::IR::ProvidesDefSeq *
+IR::ProvidesDefSeq_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+// *************************************************************
+// Inline operations for class IR::ProvidesDefSeq_out
+// *************************************************************
+
+ACE_INLINE
+IR::ProvidesDefSeq_out::ProvidesDefSeq_out (ProvidesDefSeq *&p)
+  : ptr_ (p)
+{
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::ProvidesDefSeq_out::ProvidesDefSeq_out (ProvidesDefSeq_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::ProvidesDefSeq_out::ProvidesDefSeq_out (const ::IR::ProvidesDefSeq_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (ProvidesDefSeq_out&, p).ptr_)
+{}
+
+ACE_INLINE ::IR::ProvidesDefSeq_out &
+IR::ProvidesDefSeq_out::operator= (const ::IR::ProvidesDefSeq_out &p)
+{
+  this->ptr_ = ACE_const_cast (ProvidesDefSeq_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE ::IR::ProvidesDefSeq_out &
+IR::ProvidesDefSeq_out::operator= (ProvidesDefSeq *p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+IR::ProvidesDefSeq_out::operator ::IR::ProvidesDefSeq *&() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ProvidesDefSeq *&
+IR::ProvidesDefSeq_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ProvidesDefSeq *
+IR::ProvidesDefSeq_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE TAO_Object_Manager<IR::ProvidesDef, IR::ProvidesDef_var>
+IR::ProvidesDefSeq_out::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_USESDEF___CI_)
+#define _IR_USESDEF___CI_
+
+ACE_INLINE
+IR::UsesDef::UsesDef (
+    TAO_Stub *objref,
+    CORBA::Boolean _tao_collocated,
+    TAO_Abstract_ServantBase *servant
+  )
+  : CORBA_Object (objref, _tao_collocated, servant)
+{
+  this->IR_UsesDef_setup_collocation (_tao_collocated);
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_USESDEF___VAR_CI_)
+#define _IR_USESDEF___VAR_CI_
+
+// *************************************************************
+// Inline operations for class IR::UsesDef_var
+// *************************************************************
+
+ACE_INLINE
+IR::UsesDef_var::UsesDef_var (void) // default constructor
+  : ptr_ (IR::UsesDef::_nil ())
+{}
+
+ACE_INLINE IR::UsesDef_ptr 
+IR::UsesDef_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+IR::UsesDef_var::UsesDef_var (const IR::UsesDef_var &p) // copy constructor
+  : TAO_Base_var (),
+    ptr_ (UsesDef::_duplicate (p.ptr ()))
+{}
+
+ACE_INLINE
+IR::UsesDef_var::~UsesDef_var (void) // destructor
+{
+  CORBA::release (this->ptr_);
+}
+
+ACE_INLINE IR::UsesDef_var &
+IR::UsesDef_var::operator= (IR::UsesDef_ptr p)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE IR::UsesDef_var &
+IR::UsesDef_var::operator= (const IR::UsesDef_var &p)
+{
+  if (this != &p)
+  {
+    CORBA::release (this->ptr_);
+    this->ptr_ = IR::UsesDef::_duplicate (p.ptr ());
+  }
+  return *this;
+}
+
+ACE_INLINE 
+IR::UsesDef_var::operator const IR::UsesDef_ptr &() const // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+IR::UsesDef_var::operator IR::UsesDef_ptr &() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE IR::UsesDef_ptr 
+IR::UsesDef_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE IR::UsesDef_ptr
+IR::UsesDef_var::in (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE IR::UsesDef_ptr &
+IR::UsesDef_var::inout (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE IR::UsesDef_ptr &
+IR::UsesDef_var::out (void)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = IR::UsesDef::_nil ();
+  return this->ptr_;
+}
+
+ACE_INLINE IR::UsesDef_ptr 
+IR::UsesDef_var::_retn (void)
+{
+  // yield ownership of managed obj reference
+  IR::UsesDef_ptr val = this->ptr_;
+  this->ptr_ = IR::UsesDef::_nil ();
+  return val;
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_USESDEF___OUT_CI_)
+#define _IR_USESDEF___OUT_CI_
+
+// *************************************************************
+// Inline operations for class IR::UsesDef_out
+// *************************************************************
+
+ACE_INLINE
+IR::UsesDef_out::UsesDef_out (IR::UsesDef_ptr &p)
+  : ptr_ (p)
+{
+  this->ptr_ = IR::UsesDef::_nil ();
+}
+
+ACE_INLINE
+IR::UsesDef_out::UsesDef_out (IR::UsesDef_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = IR::UsesDef::_nil ();
+}
+
+ACE_INLINE
+IR::UsesDef_out::UsesDef_out (const IR::UsesDef_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (IR::UsesDef_out&,p).ptr_)
+{}
+
+ACE_INLINE IR::UsesDef_out &
+IR::UsesDef_out::operator= (const IR::UsesDef_out &p)
+{
+  this->ptr_ = ACE_const_cast (IR::UsesDef_out&,p).ptr_;
+  return *this;
+}
+
+ACE_INLINE IR::UsesDef_out &
+IR::UsesDef_out::operator= (const IR::UsesDef_var &p)
+{
+  this->ptr_ = IR::UsesDef::_duplicate (p.ptr ());
+  return *this;
+}
+
+ACE_INLINE IR::UsesDef_out &
+IR::UsesDef_out::operator= (IR::UsesDef_ptr p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+IR::UsesDef_out::operator IR::UsesDef_ptr &() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE IR::UsesDef_ptr &
+IR::UsesDef_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE IR::UsesDef_ptr 
+IR::UsesDef_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_USESDEFSEQ_CI_)
+#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_USESDEFSEQ_CI_
+
+  ACE_INLINE IR::UsesDef **
+  IR::_TAO_Unbounded_Object_Sequence_IR_UsesDefSeq::allocbuf (CORBA::ULong nelems)
+  {
+    IR::UsesDef **buf = 0;
+    
+    ACE_NEW_RETURN (buf, IR::UsesDef*[nelems], 0);
+    
+    for (CORBA::ULong i = 0; i < nelems; i++)
+      buf[i] = IR::UsesDef::_nil ();
+    
+    return buf;
+  }
+  
+  ACE_INLINE void 
+  IR::_TAO_Unbounded_Object_Sequence_IR_UsesDefSeq::freebuf (IR::UsesDef **buffer)
+  {
+    if (buffer == 0)
+      return;
+    delete[] buffer;
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Object_Sequence_IR_UsesDefSeq::_TAO_Unbounded_Object_Sequence_IR_UsesDefSeq (void)
+  {
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Object_Sequence_IR_UsesDefSeq::_TAO_Unbounded_Object_Sequence_IR_UsesDefSeq (CORBA::ULong maximum)
+    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Object_Sequence_IR_UsesDefSeq::allocbuf (maximum))
+  {
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Object_Sequence_IR_UsesDefSeq::_TAO_Unbounded_Object_Sequence_IR_UsesDefSeq (CORBA::ULong maximum,
+    CORBA::ULong length,
+    IR::UsesDef* *value,
+    CORBA::Boolean release)
+  : TAO_Unbounded_Base_Sequence (maximum, length, value, release)
+  {
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Object_Sequence_IR_UsesDefSeq::_TAO_Unbounded_Object_Sequence_IR_UsesDefSeq(const _TAO_Unbounded_Object_Sequence_IR_UsesDefSeq &rhs)
+    : TAO_Unbounded_Base_Sequence (rhs)
+  {
+    if (rhs.buffer_ != 0)
+    {
+      IR::UsesDef **tmp1 = _TAO_Unbounded_Object_Sequence_IR_UsesDefSeq::allocbuf (this->maximum_);
+      IR::UsesDef ** const tmp2 = ACE_reinterpret_cast (IR::UsesDef ** ACE_CAST_CONST, rhs.buffer_);
+      
+      for (CORBA::ULong i = 0; i < rhs.length_; ++i)
+        tmp1[i] = IR::UsesDef::_duplicate (tmp2[i]);
+      
+      this->buffer_ = tmp1;
+    }
+    else
+    {
+      this->buffer_ = 0;
+    }
+  }
+  
+  ACE_INLINE IR::_TAO_Unbounded_Object_Sequence_IR_UsesDefSeq &
+  IR::_TAO_Unbounded_Object_Sequence_IR_UsesDefSeq::operator= (const _TAO_Unbounded_Object_Sequence_IR_UsesDefSeq &rhs)
+  {
+    if (this == &rhs)
+      return *this;
+    
+    if (this->release_)
+    {
+      IR::UsesDef **tmp = ACE_reinterpret_cast (IR::UsesDef **, this->buffer_);
+      
+      for (CORBA::ULong i = 0; i < this->length_; ++i)
+      {
+        CORBA::release (tmp[i]);
+        tmp[i] = IR::UsesDef::_nil ();
+      }
+      if (this->maximum_ < rhs.maximum_)
+      {
+        _TAO_Unbounded_Object_Sequence_IR_UsesDefSeq::freebuf (tmp);
+        this->buffer_ = _TAO_Unbounded_Object_Sequence_IR_UsesDefSeq::allocbuf (rhs.maximum_);
+      }
+    }
+    else
+      this->buffer_ = _TAO_Unbounded_Object_Sequence_IR_UsesDefSeq::allocbuf (rhs.maximum_);
+    
+    TAO_Unbounded_Base_Sequence::operator= (rhs);
+    
+    IR::UsesDef **tmp1 = ACE_reinterpret_cast (IR::UsesDef **, this->buffer_);
+    IR::UsesDef ** const tmp2 = ACE_reinterpret_cast (IR::UsesDef ** ACE_CAST_CONST, rhs.buffer_);
+    
+    for (CORBA::ULong i = 0; i < rhs.length_; ++i)
+      tmp1[i] = IR::UsesDef::_duplicate (tmp2[i]);
+    
+    return *this;
+  }
+  
+  ACE_INLINE TAO_Object_Manager<IR::UsesDef,IR::UsesDef_var>
+  IR::_TAO_Unbounded_Object_Sequence_IR_UsesDefSeq::operator[] (CORBA::ULong index) const
+  // read-write accessor
+  {
+    ACE_ASSERT (index < this->maximum_);
+    IR::UsesDef ** const tmp = ACE_reinterpret_cast (IR::UsesDef ** ACE_CAST_CONST, this->buffer_);
+    return TAO_Object_Manager<IR::UsesDef,IR::UsesDef_var> (tmp + index, this->release_);
+  }
+  
+  ACE_INLINE IR::UsesDef* *
+  IR::_TAO_Unbounded_Object_Sequence_IR_UsesDefSeq::get_buffer (CORBA::Boolean orphan)
+  {
+    IR::UsesDef **result = 0;
+    if (orphan == 0)
+    {
+      // We retain ownership.
+      if (this->buffer_ == 0)
+      {
+        result = _TAO_Unbounded_Object_Sequence_IR_UsesDefSeq::allocbuf (this->maximum_);
+        this->buffer_ = result;
+        this->release_ = 1;
+      }
+      else
+      {
+        result = ACE_reinterpret_cast (IR::UsesDef**, this->buffer_);
+      }
+    }
+    else // if (orphan == 1)
+    {
+      if (this->release_ != 0)
+      {
+        // We set the state back to default and relinquish
+        // ownership.
+        result = ACE_reinterpret_cast(IR::UsesDef**,this->buffer_);
+        this->maximum_ = 0;
+        this->length_ = 0;
+        this->buffer_ = 0;
+        this->release_ = 0;
+      }
+    }
+    return result;
+  }
+  
+  ACE_INLINE const IR::UsesDef* *
+  IR::_TAO_Unbounded_Object_Sequence_IR_UsesDefSeq::get_buffer (void) const
+  {
+    return ACE_reinterpret_cast(const IR::UsesDef ** ACE_CAST_CONST, this->buffer_);
+  }
+  
+  
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_IR_USESDEFSEQ_CI_)
+#define _IR_USESDEFSEQ_CI_
+
+// *************************************************************
+// Inline operations for class IR::UsesDefSeq_var
+// *************************************************************
+
+ACE_INLINE
+IR::UsesDefSeq_var::UsesDefSeq_var (void) // default constructor
+  : ptr_ (0)
+{}
+
+ACE_INLINE
+IR::UsesDefSeq_var::UsesDefSeq_var (UsesDefSeq *p)
+  : ptr_ (p)
+{}
+
+ACE_INLINE
+IR::UsesDefSeq_var::UsesDefSeq_var (const ::IR::UsesDefSeq_var &p) // copy constructor
+{
+  if (p.ptr_)
+    ACE_NEW (this->ptr_, ::IR::UsesDefSeq (*p.ptr_));
+  else
+    this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::UsesDefSeq_var::~UsesDefSeq_var (void) // destructor
+{
+  delete this->ptr_;
+}
+
+ACE_INLINE IR::UsesDefSeq_var &
+IR::UsesDefSeq_var::operator= (UsesDefSeq *p)
+{
+  delete this->ptr_;
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE ::IR::UsesDefSeq_var &
+IR::UsesDefSeq_var::operator= (const ::IR::UsesDefSeq_var &p)
+{
+  if (this != &p)
+    {
+      if (p.ptr_ == 0)
+        {
+          delete this->ptr_;
+          this->ptr_ = 0;
+        }
+      else
+        {
+          UsesDefSeq *deep_copy =
+            new UsesDefSeq (*p.ptr_);
+          
+          if (deep_copy != 0)
+            {
+              UsesDefSeq *tmp = deep_copy;
+              deep_copy = this->ptr_;
+              this->ptr_ = tmp;
+              delete deep_copy;
+            }
+        }
+    }
+  
+  return *this;
+}
+
+ACE_INLINE const ::IR::UsesDefSeq *
+IR::UsesDefSeq_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::UsesDefSeq *
+IR::UsesDefSeq_var::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+IR::UsesDefSeq_var::operator const ::IR::UsesDefSeq &() const // cast
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE 
+IR::UsesDefSeq_var::operator ::IR::UsesDefSeq &() // cast 
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE 
+IR::UsesDefSeq_var::operator ::IR::UsesDefSeq &() const // cast 
+{
+  return *this->ptr_;
+}
+
+// variable-size types only
+ACE_INLINE
+IR::UsesDefSeq_var::operator ::IR::UsesDefSeq *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE TAO_Object_Manager<IR::UsesDef, IR::UsesDef_var>
+IR::UsesDefSeq_var::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+ACE_INLINE const ::IR::UsesDefSeq &
+IR::UsesDefSeq_var::in (void) const
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE ::IR::UsesDefSeq &
+IR::UsesDefSeq_var::inout (void)
+{
+  return *this->ptr_;
+}
+
+// mapping for variable size 
+ACE_INLINE ::IR::UsesDefSeq *&
+IR::UsesDefSeq_var::out (void)
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::UsesDefSeq *
+IR::UsesDefSeq_var::_retn (void)
+{
+  ::IR::UsesDefSeq *tmp = this->ptr_;
+  this->ptr_ = 0;
+  return tmp;
+}
+
+ACE_INLINE ::IR::UsesDefSeq *
+IR::UsesDefSeq_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+// *************************************************************
+// Inline operations for class IR::UsesDefSeq_out
+// *************************************************************
+
+ACE_INLINE
+IR::UsesDefSeq_out::UsesDefSeq_out (UsesDefSeq *&p)
+  : ptr_ (p)
+{
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::UsesDefSeq_out::UsesDefSeq_out (UsesDefSeq_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::UsesDefSeq_out::UsesDefSeq_out (const ::IR::UsesDefSeq_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (UsesDefSeq_out&, p).ptr_)
+{}
+
+ACE_INLINE ::IR::UsesDefSeq_out &
+IR::UsesDefSeq_out::operator= (const ::IR::UsesDefSeq_out &p)
+{
+  this->ptr_ = ACE_const_cast (UsesDefSeq_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE ::IR::UsesDefSeq_out &
+IR::UsesDefSeq_out::operator= (UsesDefSeq *p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+IR::UsesDefSeq_out::operator ::IR::UsesDefSeq *&() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::UsesDefSeq *&
+IR::UsesDefSeq_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::UsesDefSeq *
+IR::UsesDefSeq_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE TAO_Object_Manager<IR::UsesDef, IR::UsesDef_var>
+IR::UsesDefSeq_out::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_HOMEDEF___CI_)
+#define _IR_HOMEDEF___CI_
+
+ACE_INLINE
+IR::HomeDef::HomeDef (
+    TAO_Stub *objref,
+    CORBA::Boolean _tao_collocated,
+    TAO_Abstract_ServantBase *servant
+  )
+  : CORBA_Object (objref, _tao_collocated, servant)
+{
+  this->IR_HomeDef_setup_collocation (_tao_collocated);
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_HOMEDEF___VAR_CI_)
+#define _IR_HOMEDEF___VAR_CI_
+
+// *************************************************************
+// Inline operations for class IR::HomeDef_var
+// *************************************************************
+
+ACE_INLINE
+IR::HomeDef_var::HomeDef_var (void) // default constructor
+  : ptr_ (IR::HomeDef::_nil ())
+{}
+
+ACE_INLINE IR::HomeDef_ptr 
+IR::HomeDef_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+IR::HomeDef_var::HomeDef_var (const IR::HomeDef_var &p) // copy constructor
+  : TAO_Base_var (),
+    ptr_ (HomeDef::_duplicate (p.ptr ()))
+{}
+
+ACE_INLINE
+IR::HomeDef_var::~HomeDef_var (void) // destructor
+{
+  CORBA::release (this->ptr_);
+}
+
+ACE_INLINE IR::HomeDef_var &
+IR::HomeDef_var::operator= (IR::HomeDef_ptr p)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE IR::HomeDef_var &
+IR::HomeDef_var::operator= (const IR::HomeDef_var &p)
+{
+  if (this != &p)
+  {
+    CORBA::release (this->ptr_);
+    this->ptr_ = IR::HomeDef::_duplicate (p.ptr ());
+  }
+  return *this;
+}
+
+ACE_INLINE 
+IR::HomeDef_var::operator const IR::HomeDef_ptr &() const // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+IR::HomeDef_var::operator IR::HomeDef_ptr &() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE IR::HomeDef_ptr 
+IR::HomeDef_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE IR::HomeDef_ptr
+IR::HomeDef_var::in (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE IR::HomeDef_ptr &
+IR::HomeDef_var::inout (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE IR::HomeDef_ptr &
+IR::HomeDef_var::out (void)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = IR::HomeDef::_nil ();
+  return this->ptr_;
+}
+
+ACE_INLINE IR::HomeDef_ptr 
+IR::HomeDef_var::_retn (void)
+{
+  // yield ownership of managed obj reference
+  IR::HomeDef_ptr val = this->ptr_;
+  this->ptr_ = IR::HomeDef::_nil ();
+  return val;
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_HOMEDEF___OUT_CI_)
+#define _IR_HOMEDEF___OUT_CI_
+
+// *************************************************************
+// Inline operations for class IR::HomeDef_out
+// *************************************************************
+
+ACE_INLINE
+IR::HomeDef_out::HomeDef_out (IR::HomeDef_ptr &p)
+  : ptr_ (p)
+{
+  this->ptr_ = IR::HomeDef::_nil ();
+}
+
+ACE_INLINE
+IR::HomeDef_out::HomeDef_out (IR::HomeDef_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = IR::HomeDef::_nil ();
+}
+
+ACE_INLINE
+IR::HomeDef_out::HomeDef_out (const IR::HomeDef_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (IR::HomeDef_out&,p).ptr_)
+{}
+
+ACE_INLINE IR::HomeDef_out &
+IR::HomeDef_out::operator= (const IR::HomeDef_out &p)
+{
+  this->ptr_ = ACE_const_cast (IR::HomeDef_out&,p).ptr_;
+  return *this;
+}
+
+ACE_INLINE IR::HomeDef_out &
+IR::HomeDef_out::operator= (const IR::HomeDef_var &p)
+{
+  this->ptr_ = IR::HomeDef::_duplicate (p.ptr ());
+  return *this;
+}
+
+ACE_INLINE IR::HomeDef_out &
+IR::HomeDef_out::operator= (IR::HomeDef_ptr p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+IR::HomeDef_out::operator IR::HomeDef_ptr &() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE IR::HomeDef_ptr &
+IR::HomeDef_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE IR::HomeDef_ptr 
+IR::HomeDef_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_HOMEDEFSEQ_CI_)
+#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_HOMEDEFSEQ_CI_
+
+  ACE_INLINE IR::HomeDef **
+  IR::_TAO_Unbounded_Object_Sequence_IR_HomeDefSeq::allocbuf (CORBA::ULong nelems)
+  {
+    IR::HomeDef **buf = 0;
+    
+    ACE_NEW_RETURN (buf, IR::HomeDef*[nelems], 0);
+    
+    for (CORBA::ULong i = 0; i < nelems; i++)
+      buf[i] = IR::HomeDef::_nil ();
+    
+    return buf;
+  }
+  
+  ACE_INLINE void 
+  IR::_TAO_Unbounded_Object_Sequence_IR_HomeDefSeq::freebuf (IR::HomeDef **buffer)
+  {
+    if (buffer == 0)
+      return;
+    delete[] buffer;
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Object_Sequence_IR_HomeDefSeq::_TAO_Unbounded_Object_Sequence_IR_HomeDefSeq (void)
+  {
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Object_Sequence_IR_HomeDefSeq::_TAO_Unbounded_Object_Sequence_IR_HomeDefSeq (CORBA::ULong maximum)
+    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Object_Sequence_IR_HomeDefSeq::allocbuf (maximum))
+  {
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Object_Sequence_IR_HomeDefSeq::_TAO_Unbounded_Object_Sequence_IR_HomeDefSeq (CORBA::ULong maximum,
+    CORBA::ULong length,
+    IR::HomeDef* *value,
+    CORBA::Boolean release)
+  : TAO_Unbounded_Base_Sequence (maximum, length, value, release)
+  {
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Object_Sequence_IR_HomeDefSeq::_TAO_Unbounded_Object_Sequence_IR_HomeDefSeq(const _TAO_Unbounded_Object_Sequence_IR_HomeDefSeq &rhs)
+    : TAO_Unbounded_Base_Sequence (rhs)
+  {
+    if (rhs.buffer_ != 0)
+    {
+      IR::HomeDef **tmp1 = _TAO_Unbounded_Object_Sequence_IR_HomeDefSeq::allocbuf (this->maximum_);
+      IR::HomeDef ** const tmp2 = ACE_reinterpret_cast (IR::HomeDef ** ACE_CAST_CONST, rhs.buffer_);
+      
+      for (CORBA::ULong i = 0; i < rhs.length_; ++i)
+        tmp1[i] = IR::HomeDef::_duplicate (tmp2[i]);
+      
+      this->buffer_ = tmp1;
+    }
+    else
+    {
+      this->buffer_ = 0;
+    }
+  }
+  
+  ACE_INLINE IR::_TAO_Unbounded_Object_Sequence_IR_HomeDefSeq &
+  IR::_TAO_Unbounded_Object_Sequence_IR_HomeDefSeq::operator= (const _TAO_Unbounded_Object_Sequence_IR_HomeDefSeq &rhs)
+  {
+    if (this == &rhs)
+      return *this;
+    
+    if (this->release_)
+    {
+      IR::HomeDef **tmp = ACE_reinterpret_cast (IR::HomeDef **, this->buffer_);
+      
+      for (CORBA::ULong i = 0; i < this->length_; ++i)
+      {
+        CORBA::release (tmp[i]);
+        tmp[i] = IR::HomeDef::_nil ();
+      }
+      if (this->maximum_ < rhs.maximum_)
+      {
+        _TAO_Unbounded_Object_Sequence_IR_HomeDefSeq::freebuf (tmp);
+        this->buffer_ = _TAO_Unbounded_Object_Sequence_IR_HomeDefSeq::allocbuf (rhs.maximum_);
+      }
+    }
+    else
+      this->buffer_ = _TAO_Unbounded_Object_Sequence_IR_HomeDefSeq::allocbuf (rhs.maximum_);
+    
+    TAO_Unbounded_Base_Sequence::operator= (rhs);
+    
+    IR::HomeDef **tmp1 = ACE_reinterpret_cast (IR::HomeDef **, this->buffer_);
+    IR::HomeDef ** const tmp2 = ACE_reinterpret_cast (IR::HomeDef ** ACE_CAST_CONST, rhs.buffer_);
+    
+    for (CORBA::ULong i = 0; i < rhs.length_; ++i)
+      tmp1[i] = IR::HomeDef::_duplicate (tmp2[i]);
+    
+    return *this;
+  }
+  
+  ACE_INLINE TAO_Object_Manager<IR::HomeDef,IR::HomeDef_var>
+  IR::_TAO_Unbounded_Object_Sequence_IR_HomeDefSeq::operator[] (CORBA::ULong index) const
+  // read-write accessor
+  {
+    ACE_ASSERT (index < this->maximum_);
+    IR::HomeDef ** const tmp = ACE_reinterpret_cast (IR::HomeDef ** ACE_CAST_CONST, this->buffer_);
+    return TAO_Object_Manager<IR::HomeDef,IR::HomeDef_var> (tmp + index, this->release_);
+  }
+  
+  ACE_INLINE IR::HomeDef* *
+  IR::_TAO_Unbounded_Object_Sequence_IR_HomeDefSeq::get_buffer (CORBA::Boolean orphan)
+  {
+    IR::HomeDef **result = 0;
+    if (orphan == 0)
+    {
+      // We retain ownership.
+      if (this->buffer_ == 0)
+      {
+        result = _TAO_Unbounded_Object_Sequence_IR_HomeDefSeq::allocbuf (this->maximum_);
+        this->buffer_ = result;
+        this->release_ = 1;
+      }
+      else
+      {
+        result = ACE_reinterpret_cast (IR::HomeDef**, this->buffer_);
+      }
+    }
+    else // if (orphan == 1)
+    {
+      if (this->release_ != 0)
+      {
+        // We set the state back to default and relinquish
+        // ownership.
+        result = ACE_reinterpret_cast(IR::HomeDef**,this->buffer_);
+        this->maximum_ = 0;
+        this->length_ = 0;
+        this->buffer_ = 0;
+        this->release_ = 0;
+      }
+    }
+    return result;
+  }
+  
+  ACE_INLINE const IR::HomeDef* *
+  IR::_TAO_Unbounded_Object_Sequence_IR_HomeDefSeq::get_buffer (void) const
+  {
+    return ACE_reinterpret_cast(const IR::HomeDef ** ACE_CAST_CONST, this->buffer_);
+  }
+  
+  
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_IR_HOMEDEFSEQ_CI_)
+#define _IR_HOMEDEFSEQ_CI_
+
+// *************************************************************
+// Inline operations for class IR::HomeDefSeq_var
+// *************************************************************
+
+ACE_INLINE
+IR::HomeDefSeq_var::HomeDefSeq_var (void) // default constructor
+  : ptr_ (0)
+{}
+
+ACE_INLINE
+IR::HomeDefSeq_var::HomeDefSeq_var (HomeDefSeq *p)
+  : ptr_ (p)
+{}
+
+ACE_INLINE
+IR::HomeDefSeq_var::HomeDefSeq_var (const ::IR::HomeDefSeq_var &p) // copy constructor
+{
+  if (p.ptr_)
+    ACE_NEW (this->ptr_, ::IR::HomeDefSeq (*p.ptr_));
+  else
+    this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::HomeDefSeq_var::~HomeDefSeq_var (void) // destructor
+{
+  delete this->ptr_;
+}
+
+ACE_INLINE IR::HomeDefSeq_var &
+IR::HomeDefSeq_var::operator= (HomeDefSeq *p)
+{
+  delete this->ptr_;
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE ::IR::HomeDefSeq_var &
+IR::HomeDefSeq_var::operator= (const ::IR::HomeDefSeq_var &p)
+{
+  if (this != &p)
+    {
+      if (p.ptr_ == 0)
+        {
+          delete this->ptr_;
+          this->ptr_ = 0;
+        }
+      else
+        {
+          HomeDefSeq *deep_copy =
+            new HomeDefSeq (*p.ptr_);
+          
+          if (deep_copy != 0)
+            {
+              HomeDefSeq *tmp = deep_copy;
+              deep_copy = this->ptr_;
+              this->ptr_ = tmp;
+              delete deep_copy;
+            }
+        }
+    }
+  
+  return *this;
+}
+
+ACE_INLINE const ::IR::HomeDefSeq *
+IR::HomeDefSeq_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::HomeDefSeq *
+IR::HomeDefSeq_var::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+IR::HomeDefSeq_var::operator const ::IR::HomeDefSeq &() const // cast
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE 
+IR::HomeDefSeq_var::operator ::IR::HomeDefSeq &() // cast 
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE 
+IR::HomeDefSeq_var::operator ::IR::HomeDefSeq &() const // cast 
+{
+  return *this->ptr_;
+}
+
+// variable-size types only
+ACE_INLINE
+IR::HomeDefSeq_var::operator ::IR::HomeDefSeq *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE TAO_Object_Manager<IR::HomeDef, IR::HomeDef_var>
+IR::HomeDefSeq_var::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+ACE_INLINE const ::IR::HomeDefSeq &
+IR::HomeDefSeq_var::in (void) const
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE ::IR::HomeDefSeq &
+IR::HomeDefSeq_var::inout (void)
+{
+  return *this->ptr_;
+}
+
+// mapping for variable size 
+ACE_INLINE ::IR::HomeDefSeq *&
+IR::HomeDefSeq_var::out (void)
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::HomeDefSeq *
+IR::HomeDefSeq_var::_retn (void)
+{
+  ::IR::HomeDefSeq *tmp = this->ptr_;
+  this->ptr_ = 0;
+  return tmp;
+}
+
+ACE_INLINE ::IR::HomeDefSeq *
+IR::HomeDefSeq_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+// *************************************************************
+// Inline operations for class IR::HomeDefSeq_out
+// *************************************************************
+
+ACE_INLINE
+IR::HomeDefSeq_out::HomeDefSeq_out (HomeDefSeq *&p)
+  : ptr_ (p)
+{
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::HomeDefSeq_out::HomeDefSeq_out (HomeDefSeq_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::HomeDefSeq_out::HomeDefSeq_out (const ::IR::HomeDefSeq_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (HomeDefSeq_out&, p).ptr_)
+{}
+
+ACE_INLINE ::IR::HomeDefSeq_out &
+IR::HomeDefSeq_out::operator= (const ::IR::HomeDefSeq_out &p)
+{
+  this->ptr_ = ACE_const_cast (HomeDefSeq_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE ::IR::HomeDefSeq_out &
+IR::HomeDefSeq_out::operator= (HomeDefSeq *p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+IR::HomeDefSeq_out::operator ::IR::HomeDefSeq *&() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::HomeDefSeq *&
+IR::HomeDefSeq_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::HomeDefSeq *
+IR::HomeDefSeq_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE TAO_Object_Manager<IR::HomeDef, IR::HomeDef_var>
+IR::HomeDefSeq_out::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_EVENTDEF___CI_)
+#define _IR_EVENTDEF___CI_
+
+ACE_INLINE
+IR::EventDef::EventDef (
+    TAO_Stub *objref,
+    CORBA::Boolean _tao_collocated,
+    TAO_Abstract_ServantBase *servant
+  )
+  : CORBA_Object (objref, _tao_collocated, servant)
+{
+  this->IR_EventDef_setup_collocation (_tao_collocated);
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_EVENTDEF___VAR_CI_)
+#define _IR_EVENTDEF___VAR_CI_
+
+// *************************************************************
+// Inline operations for class IR::EventDef_var
+// *************************************************************
+
+ACE_INLINE
+IR::EventDef_var::EventDef_var (void) // default constructor
+  : ptr_ (IR::EventDef::_nil ())
+{}
+
+ACE_INLINE IR::EventDef_ptr 
+IR::EventDef_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+IR::EventDef_var::EventDef_var (const IR::EventDef_var &p) // copy constructor
+  : TAO_Base_var (),
+    ptr_ (EventDef::_duplicate (p.ptr ()))
+{}
+
+ACE_INLINE
+IR::EventDef_var::~EventDef_var (void) // destructor
+{
+  CORBA::release (this->ptr_);
+}
+
+ACE_INLINE IR::EventDef_var &
+IR::EventDef_var::operator= (IR::EventDef_ptr p)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE IR::EventDef_var &
+IR::EventDef_var::operator= (const IR::EventDef_var &p)
+{
+  if (this != &p)
+  {
+    CORBA::release (this->ptr_);
+    this->ptr_ = IR::EventDef::_duplicate (p.ptr ());
+  }
+  return *this;
+}
+
+ACE_INLINE 
+IR::EventDef_var::operator const IR::EventDef_ptr &() const // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+IR::EventDef_var::operator IR::EventDef_ptr &() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE IR::EventDef_ptr 
+IR::EventDef_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE IR::EventDef_ptr
+IR::EventDef_var::in (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE IR::EventDef_ptr &
+IR::EventDef_var::inout (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE IR::EventDef_ptr &
+IR::EventDef_var::out (void)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = IR::EventDef::_nil ();
+  return this->ptr_;
+}
+
+ACE_INLINE IR::EventDef_ptr 
+IR::EventDef_var::_retn (void)
+{
+  // yield ownership of managed obj reference
+  IR::EventDef_ptr val = this->ptr_;
+  this->ptr_ = IR::EventDef::_nil ();
+  return val;
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_EVENTDEF___OUT_CI_)
+#define _IR_EVENTDEF___OUT_CI_
+
+// *************************************************************
+// Inline operations for class IR::EventDef_out
+// *************************************************************
+
+ACE_INLINE
+IR::EventDef_out::EventDef_out (IR::EventDef_ptr &p)
+  : ptr_ (p)
+{
+  this->ptr_ = IR::EventDef::_nil ();
+}
+
+ACE_INLINE
+IR::EventDef_out::EventDef_out (IR::EventDef_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = IR::EventDef::_nil ();
+}
+
+ACE_INLINE
+IR::EventDef_out::EventDef_out (const IR::EventDef_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (IR::EventDef_out&,p).ptr_)
+{}
+
+ACE_INLINE IR::EventDef_out &
+IR::EventDef_out::operator= (const IR::EventDef_out &p)
+{
+  this->ptr_ = ACE_const_cast (IR::EventDef_out&,p).ptr_;
+  return *this;
+}
+
+ACE_INLINE IR::EventDef_out &
+IR::EventDef_out::operator= (const IR::EventDef_var &p)
+{
+  this->ptr_ = IR::EventDef::_duplicate (p.ptr ());
+  return *this;
+}
+
+ACE_INLINE IR::EventDef_out &
+IR::EventDef_out::operator= (IR::EventDef_ptr p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+IR::EventDef_out::operator IR::EventDef_ptr &() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE IR::EventDef_ptr &
+IR::EventDef_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE IR::EventDef_ptr 
+IR::EventDef_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_EMITSDEF___CI_)
+#define _IR_EMITSDEF___CI_
+
+ACE_INLINE
+IR::EmitsDef::EmitsDef (
+    TAO_Stub *objref,
+    CORBA::Boolean _tao_collocated,
+    TAO_Abstract_ServantBase *servant
+  )
+  : CORBA_Object (objref, _tao_collocated, servant)
+{
+  this->IR_EmitsDef_setup_collocation (_tao_collocated);
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_EMITSDEF___VAR_CI_)
+#define _IR_EMITSDEF___VAR_CI_
+
+// *************************************************************
+// Inline operations for class IR::EmitsDef_var
+// *************************************************************
+
+ACE_INLINE
+IR::EmitsDef_var::EmitsDef_var (void) // default constructor
+  : ptr_ (IR::EmitsDef::_nil ())
+{}
+
+ACE_INLINE IR::EmitsDef_ptr 
+IR::EmitsDef_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+IR::EmitsDef_var::EmitsDef_var (const IR::EmitsDef_var &p) // copy constructor
+  : TAO_Base_var (),
+    ptr_ (EmitsDef::_duplicate (p.ptr ()))
+{}
+
+ACE_INLINE
+IR::EmitsDef_var::~EmitsDef_var (void) // destructor
+{
+  CORBA::release (this->ptr_);
+}
+
+ACE_INLINE IR::EmitsDef_var &
+IR::EmitsDef_var::operator= (IR::EmitsDef_ptr p)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE IR::EmitsDef_var &
+IR::EmitsDef_var::operator= (const IR::EmitsDef_var &p)
+{
+  if (this != &p)
+  {
+    CORBA::release (this->ptr_);
+    this->ptr_ = IR::EmitsDef::_duplicate (p.ptr ());
+  }
+  return *this;
+}
+
+ACE_INLINE 
+IR::EmitsDef_var::operator const IR::EmitsDef_ptr &() const // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+IR::EmitsDef_var::operator IR::EmitsDef_ptr &() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE IR::EmitsDef_ptr 
+IR::EmitsDef_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE IR::EmitsDef_ptr
+IR::EmitsDef_var::in (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE IR::EmitsDef_ptr &
+IR::EmitsDef_var::inout (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE IR::EmitsDef_ptr &
+IR::EmitsDef_var::out (void)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = IR::EmitsDef::_nil ();
+  return this->ptr_;
+}
+
+ACE_INLINE IR::EmitsDef_ptr 
+IR::EmitsDef_var::_retn (void)
+{
+  // yield ownership of managed obj reference
+  IR::EmitsDef_ptr val = this->ptr_;
+  this->ptr_ = IR::EmitsDef::_nil ();
+  return val;
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_EMITSDEF___OUT_CI_)
+#define _IR_EMITSDEF___OUT_CI_
+
+// *************************************************************
+// Inline operations for class IR::EmitsDef_out
+// *************************************************************
+
+ACE_INLINE
+IR::EmitsDef_out::EmitsDef_out (IR::EmitsDef_ptr &p)
+  : ptr_ (p)
+{
+  this->ptr_ = IR::EmitsDef::_nil ();
+}
+
+ACE_INLINE
+IR::EmitsDef_out::EmitsDef_out (IR::EmitsDef_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = IR::EmitsDef::_nil ();
+}
+
+ACE_INLINE
+IR::EmitsDef_out::EmitsDef_out (const IR::EmitsDef_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (IR::EmitsDef_out&,p).ptr_)
+{}
+
+ACE_INLINE IR::EmitsDef_out &
+IR::EmitsDef_out::operator= (const IR::EmitsDef_out &p)
+{
+  this->ptr_ = ACE_const_cast (IR::EmitsDef_out&,p).ptr_;
+  return *this;
+}
+
+ACE_INLINE IR::EmitsDef_out &
+IR::EmitsDef_out::operator= (const IR::EmitsDef_var &p)
+{
+  this->ptr_ = IR::EmitsDef::_duplicate (p.ptr ());
+  return *this;
+}
+
+ACE_INLINE IR::EmitsDef_out &
+IR::EmitsDef_out::operator= (IR::EmitsDef_ptr p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+IR::EmitsDef_out::operator IR::EmitsDef_ptr &() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE IR::EmitsDef_ptr &
+IR::EmitsDef_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE IR::EmitsDef_ptr 
+IR::EmitsDef_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_EMITSDEFSEQ_CI_)
+#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_EMITSDEFSEQ_CI_
+
+  ACE_INLINE IR::EmitsDef **
+  IR::_TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq::allocbuf (CORBA::ULong nelems)
+  {
+    IR::EmitsDef **buf = 0;
+    
+    ACE_NEW_RETURN (buf, IR::EmitsDef*[nelems], 0);
+    
+    for (CORBA::ULong i = 0; i < nelems; i++)
+      buf[i] = IR::EmitsDef::_nil ();
+    
+    return buf;
+  }
+  
+  ACE_INLINE void 
+  IR::_TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq::freebuf (IR::EmitsDef **buffer)
+  {
+    if (buffer == 0)
+      return;
+    delete[] buffer;
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq::_TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq (void)
+  {
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq::_TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq (CORBA::ULong maximum)
+    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq::allocbuf (maximum))
+  {
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq::_TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq (CORBA::ULong maximum,
+    CORBA::ULong length,
+    IR::EmitsDef* *value,
+    CORBA::Boolean release)
+  : TAO_Unbounded_Base_Sequence (maximum, length, value, release)
+  {
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq::_TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq(const _TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq &rhs)
+    : TAO_Unbounded_Base_Sequence (rhs)
+  {
+    if (rhs.buffer_ != 0)
+    {
+      IR::EmitsDef **tmp1 = _TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq::allocbuf (this->maximum_);
+      IR::EmitsDef ** const tmp2 = ACE_reinterpret_cast (IR::EmitsDef ** ACE_CAST_CONST, rhs.buffer_);
+      
+      for (CORBA::ULong i = 0; i < rhs.length_; ++i)
+        tmp1[i] = IR::EmitsDef::_duplicate (tmp2[i]);
+      
+      this->buffer_ = tmp1;
+    }
+    else
+    {
+      this->buffer_ = 0;
+    }
+  }
+  
+  ACE_INLINE IR::_TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq &
+  IR::_TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq::operator= (const _TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq &rhs)
+  {
+    if (this == &rhs)
+      return *this;
+    
+    if (this->release_)
+    {
+      IR::EmitsDef **tmp = ACE_reinterpret_cast (IR::EmitsDef **, this->buffer_);
+      
+      for (CORBA::ULong i = 0; i < this->length_; ++i)
+      {
+        CORBA::release (tmp[i]);
+        tmp[i] = IR::EmitsDef::_nil ();
+      }
+      if (this->maximum_ < rhs.maximum_)
+      {
+        _TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq::freebuf (tmp);
+        this->buffer_ = _TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq::allocbuf (rhs.maximum_);
+      }
+    }
+    else
+      this->buffer_ = _TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq::allocbuf (rhs.maximum_);
+    
+    TAO_Unbounded_Base_Sequence::operator= (rhs);
+    
+    IR::EmitsDef **tmp1 = ACE_reinterpret_cast (IR::EmitsDef **, this->buffer_);
+    IR::EmitsDef ** const tmp2 = ACE_reinterpret_cast (IR::EmitsDef ** ACE_CAST_CONST, rhs.buffer_);
+    
+    for (CORBA::ULong i = 0; i < rhs.length_; ++i)
+      tmp1[i] = IR::EmitsDef::_duplicate (tmp2[i]);
+    
+    return *this;
+  }
+  
+  ACE_INLINE TAO_Object_Manager<IR::EmitsDef,IR::EmitsDef_var>
+  IR::_TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq::operator[] (CORBA::ULong index) const
+  // read-write accessor
+  {
+    ACE_ASSERT (index < this->maximum_);
+    IR::EmitsDef ** const tmp = ACE_reinterpret_cast (IR::EmitsDef ** ACE_CAST_CONST, this->buffer_);
+    return TAO_Object_Manager<IR::EmitsDef,IR::EmitsDef_var> (tmp + index, this->release_);
+  }
+  
+  ACE_INLINE IR::EmitsDef* *
+  IR::_TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq::get_buffer (CORBA::Boolean orphan)
+  {
+    IR::EmitsDef **result = 0;
+    if (orphan == 0)
+    {
+      // We retain ownership.
+      if (this->buffer_ == 0)
+      {
+        result = _TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq::allocbuf (this->maximum_);
+        this->buffer_ = result;
+        this->release_ = 1;
+      }
+      else
+      {
+        result = ACE_reinterpret_cast (IR::EmitsDef**, this->buffer_);
+      }
+    }
+    else // if (orphan == 1)
+    {
+      if (this->release_ != 0)
+      {
+        // We set the state back to default and relinquish
+        // ownership.
+        result = ACE_reinterpret_cast(IR::EmitsDef**,this->buffer_);
+        this->maximum_ = 0;
+        this->length_ = 0;
+        this->buffer_ = 0;
+        this->release_ = 0;
+      }
+    }
+    return result;
+  }
+  
+  ACE_INLINE const IR::EmitsDef* *
+  IR::_TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq::get_buffer (void) const
+  {
+    return ACE_reinterpret_cast(const IR::EmitsDef ** ACE_CAST_CONST, this->buffer_);
+  }
+  
+  
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_IR_EMITSDEFSEQ_CI_)
+#define _IR_EMITSDEFSEQ_CI_
+
+// *************************************************************
+// Inline operations for class IR::EmitsDefSeq_var
+// *************************************************************
+
+ACE_INLINE
+IR::EmitsDefSeq_var::EmitsDefSeq_var (void) // default constructor
+  : ptr_ (0)
+{}
+
+ACE_INLINE
+IR::EmitsDefSeq_var::EmitsDefSeq_var (EmitsDefSeq *p)
+  : ptr_ (p)
+{}
+
+ACE_INLINE
+IR::EmitsDefSeq_var::EmitsDefSeq_var (const ::IR::EmitsDefSeq_var &p) // copy constructor
+{
+  if (p.ptr_)
+    ACE_NEW (this->ptr_, ::IR::EmitsDefSeq (*p.ptr_));
+  else
+    this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::EmitsDefSeq_var::~EmitsDefSeq_var (void) // destructor
+{
+  delete this->ptr_;
+}
+
+ACE_INLINE IR::EmitsDefSeq_var &
+IR::EmitsDefSeq_var::operator= (EmitsDefSeq *p)
+{
+  delete this->ptr_;
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE ::IR::EmitsDefSeq_var &
+IR::EmitsDefSeq_var::operator= (const ::IR::EmitsDefSeq_var &p)
+{
+  if (this != &p)
+    {
+      if (p.ptr_ == 0)
+        {
+          delete this->ptr_;
+          this->ptr_ = 0;
+        }
+      else
+        {
+          EmitsDefSeq *deep_copy =
+            new EmitsDefSeq (*p.ptr_);
+          
+          if (deep_copy != 0)
+            {
+              EmitsDefSeq *tmp = deep_copy;
+              deep_copy = this->ptr_;
+              this->ptr_ = tmp;
+              delete deep_copy;
+            }
+        }
+    }
+  
+  return *this;
+}
+
+ACE_INLINE const ::IR::EmitsDefSeq *
+IR::EmitsDefSeq_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::EmitsDefSeq *
+IR::EmitsDefSeq_var::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+IR::EmitsDefSeq_var::operator const ::IR::EmitsDefSeq &() const // cast
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE 
+IR::EmitsDefSeq_var::operator ::IR::EmitsDefSeq &() // cast 
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE 
+IR::EmitsDefSeq_var::operator ::IR::EmitsDefSeq &() const // cast 
+{
+  return *this->ptr_;
+}
+
+// variable-size types only
+ACE_INLINE
+IR::EmitsDefSeq_var::operator ::IR::EmitsDefSeq *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE TAO_Object_Manager<IR::EmitsDef, IR::EmitsDef_var>
+IR::EmitsDefSeq_var::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+ACE_INLINE const ::IR::EmitsDefSeq &
+IR::EmitsDefSeq_var::in (void) const
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE ::IR::EmitsDefSeq &
+IR::EmitsDefSeq_var::inout (void)
+{
+  return *this->ptr_;
+}
+
+// mapping for variable size 
+ACE_INLINE ::IR::EmitsDefSeq *&
+IR::EmitsDefSeq_var::out (void)
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::EmitsDefSeq *
+IR::EmitsDefSeq_var::_retn (void)
+{
+  ::IR::EmitsDefSeq *tmp = this->ptr_;
+  this->ptr_ = 0;
+  return tmp;
+}
+
+ACE_INLINE ::IR::EmitsDefSeq *
+IR::EmitsDefSeq_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+// *************************************************************
+// Inline operations for class IR::EmitsDefSeq_out
+// *************************************************************
+
+ACE_INLINE
+IR::EmitsDefSeq_out::EmitsDefSeq_out (EmitsDefSeq *&p)
+  : ptr_ (p)
+{
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::EmitsDefSeq_out::EmitsDefSeq_out (EmitsDefSeq_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::EmitsDefSeq_out::EmitsDefSeq_out (const ::IR::EmitsDefSeq_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (EmitsDefSeq_out&, p).ptr_)
+{}
+
+ACE_INLINE ::IR::EmitsDefSeq_out &
+IR::EmitsDefSeq_out::operator= (const ::IR::EmitsDefSeq_out &p)
+{
+  this->ptr_ = ACE_const_cast (EmitsDefSeq_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE ::IR::EmitsDefSeq_out &
+IR::EmitsDefSeq_out::operator= (EmitsDefSeq *p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+IR::EmitsDefSeq_out::operator ::IR::EmitsDefSeq *&() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::EmitsDefSeq *&
+IR::EmitsDefSeq_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::EmitsDefSeq *
+IR::EmitsDefSeq_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE TAO_Object_Manager<IR::EmitsDef, IR::EmitsDef_var>
+IR::EmitsDefSeq_out::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_PUBLISHESDEF___CI_)
+#define _IR_PUBLISHESDEF___CI_
+
+ACE_INLINE
+IR::PublishesDef::PublishesDef (
+    TAO_Stub *objref,
+    CORBA::Boolean _tao_collocated,
+    TAO_Abstract_ServantBase *servant
+  )
+  : CORBA_Object (objref, _tao_collocated, servant)
+{
+  this->IR_PublishesDef_setup_collocation (_tao_collocated);
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_PUBLISHESDEF___VAR_CI_)
+#define _IR_PUBLISHESDEF___VAR_CI_
+
+// *************************************************************
+// Inline operations for class IR::PublishesDef_var
+// *************************************************************
+
+ACE_INLINE
+IR::PublishesDef_var::PublishesDef_var (void) // default constructor
+  : ptr_ (IR::PublishesDef::_nil ())
+{}
+
+ACE_INLINE IR::PublishesDef_ptr 
+IR::PublishesDef_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+IR::PublishesDef_var::PublishesDef_var (const IR::PublishesDef_var &p) // copy constructor
+  : TAO_Base_var (),
+    ptr_ (PublishesDef::_duplicate (p.ptr ()))
+{}
+
+ACE_INLINE
+IR::PublishesDef_var::~PublishesDef_var (void) // destructor
+{
+  CORBA::release (this->ptr_);
+}
+
+ACE_INLINE IR::PublishesDef_var &
+IR::PublishesDef_var::operator= (IR::PublishesDef_ptr p)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE IR::PublishesDef_var &
+IR::PublishesDef_var::operator= (const IR::PublishesDef_var &p)
+{
+  if (this != &p)
+  {
+    CORBA::release (this->ptr_);
+    this->ptr_ = IR::PublishesDef::_duplicate (p.ptr ());
+  }
+  return *this;
+}
+
+ACE_INLINE 
+IR::PublishesDef_var::operator const IR::PublishesDef_ptr &() const // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+IR::PublishesDef_var::operator IR::PublishesDef_ptr &() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE IR::PublishesDef_ptr 
+IR::PublishesDef_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE IR::PublishesDef_ptr
+IR::PublishesDef_var::in (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE IR::PublishesDef_ptr &
+IR::PublishesDef_var::inout (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE IR::PublishesDef_ptr &
+IR::PublishesDef_var::out (void)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = IR::PublishesDef::_nil ();
+  return this->ptr_;
+}
+
+ACE_INLINE IR::PublishesDef_ptr 
+IR::PublishesDef_var::_retn (void)
+{
+  // yield ownership of managed obj reference
+  IR::PublishesDef_ptr val = this->ptr_;
+  this->ptr_ = IR::PublishesDef::_nil ();
+  return val;
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_PUBLISHESDEF___OUT_CI_)
+#define _IR_PUBLISHESDEF___OUT_CI_
+
+// *************************************************************
+// Inline operations for class IR::PublishesDef_out
+// *************************************************************
+
+ACE_INLINE
+IR::PublishesDef_out::PublishesDef_out (IR::PublishesDef_ptr &p)
+  : ptr_ (p)
+{
+  this->ptr_ = IR::PublishesDef::_nil ();
+}
+
+ACE_INLINE
+IR::PublishesDef_out::PublishesDef_out (IR::PublishesDef_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = IR::PublishesDef::_nil ();
+}
+
+ACE_INLINE
+IR::PublishesDef_out::PublishesDef_out (const IR::PublishesDef_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (IR::PublishesDef_out&,p).ptr_)
+{}
+
+ACE_INLINE IR::PublishesDef_out &
+IR::PublishesDef_out::operator= (const IR::PublishesDef_out &p)
+{
+  this->ptr_ = ACE_const_cast (IR::PublishesDef_out&,p).ptr_;
+  return *this;
+}
+
+ACE_INLINE IR::PublishesDef_out &
+IR::PublishesDef_out::operator= (const IR::PublishesDef_var &p)
+{
+  this->ptr_ = IR::PublishesDef::_duplicate (p.ptr ());
+  return *this;
+}
+
+ACE_INLINE IR::PublishesDef_out &
+IR::PublishesDef_out::operator= (IR::PublishesDef_ptr p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+IR::PublishesDef_out::operator IR::PublishesDef_ptr &() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE IR::PublishesDef_ptr &
+IR::PublishesDef_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE IR::PublishesDef_ptr 
+IR::PublishesDef_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_PUBLISHESDEFSEQ_CI_)
+#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_PUBLISHESDEFSEQ_CI_
+
+  ACE_INLINE IR::PublishesDef **
+  IR::_TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq::allocbuf (CORBA::ULong nelems)
+  {
+    IR::PublishesDef **buf = 0;
+    
+    ACE_NEW_RETURN (buf, IR::PublishesDef*[nelems], 0);
+    
+    for (CORBA::ULong i = 0; i < nelems; i++)
+      buf[i] = IR::PublishesDef::_nil ();
+    
+    return buf;
+  }
+  
+  ACE_INLINE void 
+  IR::_TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq::freebuf (IR::PublishesDef **buffer)
+  {
+    if (buffer == 0)
+      return;
+    delete[] buffer;
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq::_TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq (void)
+  {
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq::_TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq (CORBA::ULong maximum)
+    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq::allocbuf (maximum))
+  {
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq::_TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq (CORBA::ULong maximum,
+    CORBA::ULong length,
+    IR::PublishesDef* *value,
+    CORBA::Boolean release)
+  : TAO_Unbounded_Base_Sequence (maximum, length, value, release)
+  {
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq::_TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq(const _TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq &rhs)
+    : TAO_Unbounded_Base_Sequence (rhs)
+  {
+    if (rhs.buffer_ != 0)
+    {
+      IR::PublishesDef **tmp1 = _TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq::allocbuf (this->maximum_);
+      IR::PublishesDef ** const tmp2 = ACE_reinterpret_cast (IR::PublishesDef ** ACE_CAST_CONST, rhs.buffer_);
+      
+      for (CORBA::ULong i = 0; i < rhs.length_; ++i)
+        tmp1[i] = IR::PublishesDef::_duplicate (tmp2[i]);
+      
+      this->buffer_ = tmp1;
+    }
+    else
+    {
+      this->buffer_ = 0;
+    }
+  }
+  
+  ACE_INLINE IR::_TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq &
+  IR::_TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq::operator= (const _TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq &rhs)
+  {
+    if (this == &rhs)
+      return *this;
+    
+    if (this->release_)
+    {
+      IR::PublishesDef **tmp = ACE_reinterpret_cast (IR::PublishesDef **, this->buffer_);
+      
+      for (CORBA::ULong i = 0; i < this->length_; ++i)
+      {
+        CORBA::release (tmp[i]);
+        tmp[i] = IR::PublishesDef::_nil ();
+      }
+      if (this->maximum_ < rhs.maximum_)
+      {
+        _TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq::freebuf (tmp);
+        this->buffer_ = _TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq::allocbuf (rhs.maximum_);
+      }
+    }
+    else
+      this->buffer_ = _TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq::allocbuf (rhs.maximum_);
+    
+    TAO_Unbounded_Base_Sequence::operator= (rhs);
+    
+    IR::PublishesDef **tmp1 = ACE_reinterpret_cast (IR::PublishesDef **, this->buffer_);
+    IR::PublishesDef ** const tmp2 = ACE_reinterpret_cast (IR::PublishesDef ** ACE_CAST_CONST, rhs.buffer_);
+    
+    for (CORBA::ULong i = 0; i < rhs.length_; ++i)
+      tmp1[i] = IR::PublishesDef::_duplicate (tmp2[i]);
+    
+    return *this;
+  }
+  
+  ACE_INLINE TAO_Object_Manager<IR::PublishesDef,IR::PublishesDef_var>
+  IR::_TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq::operator[] (CORBA::ULong index) const
+  // read-write accessor
+  {
+    ACE_ASSERT (index < this->maximum_);
+    IR::PublishesDef ** const tmp = ACE_reinterpret_cast (IR::PublishesDef ** ACE_CAST_CONST, this->buffer_);
+    return TAO_Object_Manager<IR::PublishesDef,IR::PublishesDef_var> (tmp + index, this->release_);
+  }
+  
+  ACE_INLINE IR::PublishesDef* *
+  IR::_TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq::get_buffer (CORBA::Boolean orphan)
+  {
+    IR::PublishesDef **result = 0;
+    if (orphan == 0)
+    {
+      // We retain ownership.
+      if (this->buffer_ == 0)
+      {
+        result = _TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq::allocbuf (this->maximum_);
+        this->buffer_ = result;
+        this->release_ = 1;
+      }
+      else
+      {
+        result = ACE_reinterpret_cast (IR::PublishesDef**, this->buffer_);
+      }
+    }
+    else // if (orphan == 1)
+    {
+      if (this->release_ != 0)
+      {
+        // We set the state back to default and relinquish
+        // ownership.
+        result = ACE_reinterpret_cast(IR::PublishesDef**,this->buffer_);
+        this->maximum_ = 0;
+        this->length_ = 0;
+        this->buffer_ = 0;
+        this->release_ = 0;
+      }
+    }
+    return result;
+  }
+  
+  ACE_INLINE const IR::PublishesDef* *
+  IR::_TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq::get_buffer (void) const
+  {
+    return ACE_reinterpret_cast(const IR::PublishesDef ** ACE_CAST_CONST, this->buffer_);
+  }
+  
+  
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_IR_PUBLISHESDEFSEQ_CI_)
+#define _IR_PUBLISHESDEFSEQ_CI_
+
+// *************************************************************
+// Inline operations for class IR::PublishesDefSeq_var
+// *************************************************************
+
+ACE_INLINE
+IR::PublishesDefSeq_var::PublishesDefSeq_var (void) // default constructor
+  : ptr_ (0)
+{}
+
+ACE_INLINE
+IR::PublishesDefSeq_var::PublishesDefSeq_var (PublishesDefSeq *p)
+  : ptr_ (p)
+{}
+
+ACE_INLINE
+IR::PublishesDefSeq_var::PublishesDefSeq_var (const ::IR::PublishesDefSeq_var &p) // copy constructor
+{
+  if (p.ptr_)
+    ACE_NEW (this->ptr_, ::IR::PublishesDefSeq (*p.ptr_));
+  else
+    this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::PublishesDefSeq_var::~PublishesDefSeq_var (void) // destructor
+{
+  delete this->ptr_;
+}
+
+ACE_INLINE IR::PublishesDefSeq_var &
+IR::PublishesDefSeq_var::operator= (PublishesDefSeq *p)
+{
+  delete this->ptr_;
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE ::IR::PublishesDefSeq_var &
+IR::PublishesDefSeq_var::operator= (const ::IR::PublishesDefSeq_var &p)
+{
+  if (this != &p)
+    {
+      if (p.ptr_ == 0)
+        {
+          delete this->ptr_;
+          this->ptr_ = 0;
+        }
+      else
+        {
+          PublishesDefSeq *deep_copy =
+            new PublishesDefSeq (*p.ptr_);
+          
+          if (deep_copy != 0)
+            {
+              PublishesDefSeq *tmp = deep_copy;
+              deep_copy = this->ptr_;
+              this->ptr_ = tmp;
+              delete deep_copy;
+            }
+        }
+    }
+  
+  return *this;
+}
+
+ACE_INLINE const ::IR::PublishesDefSeq *
+IR::PublishesDefSeq_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::PublishesDefSeq *
+IR::PublishesDefSeq_var::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+IR::PublishesDefSeq_var::operator const ::IR::PublishesDefSeq &() const // cast
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE 
+IR::PublishesDefSeq_var::operator ::IR::PublishesDefSeq &() // cast 
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE 
+IR::PublishesDefSeq_var::operator ::IR::PublishesDefSeq &() const // cast 
+{
+  return *this->ptr_;
+}
+
+// variable-size types only
+ACE_INLINE
+IR::PublishesDefSeq_var::operator ::IR::PublishesDefSeq *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE TAO_Object_Manager<IR::PublishesDef, IR::PublishesDef_var>
+IR::PublishesDefSeq_var::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+ACE_INLINE const ::IR::PublishesDefSeq &
+IR::PublishesDefSeq_var::in (void) const
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE ::IR::PublishesDefSeq &
+IR::PublishesDefSeq_var::inout (void)
+{
+  return *this->ptr_;
+}
+
+// mapping for variable size 
+ACE_INLINE ::IR::PublishesDefSeq *&
+IR::PublishesDefSeq_var::out (void)
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::PublishesDefSeq *
+IR::PublishesDefSeq_var::_retn (void)
+{
+  ::IR::PublishesDefSeq *tmp = this->ptr_;
+  this->ptr_ = 0;
+  return tmp;
+}
+
+ACE_INLINE ::IR::PublishesDefSeq *
+IR::PublishesDefSeq_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+// *************************************************************
+// Inline operations for class IR::PublishesDefSeq_out
+// *************************************************************
+
+ACE_INLINE
+IR::PublishesDefSeq_out::PublishesDefSeq_out (PublishesDefSeq *&p)
+  : ptr_ (p)
+{
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::PublishesDefSeq_out::PublishesDefSeq_out (PublishesDefSeq_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::PublishesDefSeq_out::PublishesDefSeq_out (const ::IR::PublishesDefSeq_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (PublishesDefSeq_out&, p).ptr_)
+{}
+
+ACE_INLINE ::IR::PublishesDefSeq_out &
+IR::PublishesDefSeq_out::operator= (const ::IR::PublishesDefSeq_out &p)
+{
+  this->ptr_ = ACE_const_cast (PublishesDefSeq_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE ::IR::PublishesDefSeq_out &
+IR::PublishesDefSeq_out::operator= (PublishesDefSeq *p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+IR::PublishesDefSeq_out::operator ::IR::PublishesDefSeq *&() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::PublishesDefSeq *&
+IR::PublishesDefSeq_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::PublishesDefSeq *
+IR::PublishesDefSeq_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE TAO_Object_Manager<IR::PublishesDef, IR::PublishesDef_var>
+IR::PublishesDefSeq_out::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_CONSUMESDEF___CI_)
+#define _IR_CONSUMESDEF___CI_
+
+ACE_INLINE
+IR::ConsumesDef::ConsumesDef (
+    TAO_Stub *objref,
+    CORBA::Boolean _tao_collocated,
+    TAO_Abstract_ServantBase *servant
+  )
+  : CORBA_Object (objref, _tao_collocated, servant)
+{
+  this->IR_ConsumesDef_setup_collocation (_tao_collocated);
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_CONSUMESDEF___VAR_CI_)
+#define _IR_CONSUMESDEF___VAR_CI_
+
+// *************************************************************
+// Inline operations for class IR::ConsumesDef_var
+// *************************************************************
+
+ACE_INLINE
+IR::ConsumesDef_var::ConsumesDef_var (void) // default constructor
+  : ptr_ (IR::ConsumesDef::_nil ())
+{}
+
+ACE_INLINE IR::ConsumesDef_ptr 
+IR::ConsumesDef_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+IR::ConsumesDef_var::ConsumesDef_var (const IR::ConsumesDef_var &p) // copy constructor
+  : TAO_Base_var (),
+    ptr_ (ConsumesDef::_duplicate (p.ptr ()))
+{}
+
+ACE_INLINE
+IR::ConsumesDef_var::~ConsumesDef_var (void) // destructor
+{
+  CORBA::release (this->ptr_);
+}
+
+ACE_INLINE IR::ConsumesDef_var &
+IR::ConsumesDef_var::operator= (IR::ConsumesDef_ptr p)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE IR::ConsumesDef_var &
+IR::ConsumesDef_var::operator= (const IR::ConsumesDef_var &p)
+{
+  if (this != &p)
+  {
+    CORBA::release (this->ptr_);
+    this->ptr_ = IR::ConsumesDef::_duplicate (p.ptr ());
+  }
+  return *this;
+}
+
+ACE_INLINE 
+IR::ConsumesDef_var::operator const IR::ConsumesDef_ptr &() const // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+IR::ConsumesDef_var::operator IR::ConsumesDef_ptr &() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE IR::ConsumesDef_ptr 
+IR::ConsumesDef_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE IR::ConsumesDef_ptr
+IR::ConsumesDef_var::in (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE IR::ConsumesDef_ptr &
+IR::ConsumesDef_var::inout (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE IR::ConsumesDef_ptr &
+IR::ConsumesDef_var::out (void)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = IR::ConsumesDef::_nil ();
+  return this->ptr_;
+}
+
+ACE_INLINE IR::ConsumesDef_ptr 
+IR::ConsumesDef_var::_retn (void)
+{
+  // yield ownership of managed obj reference
+  IR::ConsumesDef_ptr val = this->ptr_;
+  this->ptr_ = IR::ConsumesDef::_nil ();
+  return val;
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_CONSUMESDEF___OUT_CI_)
+#define _IR_CONSUMESDEF___OUT_CI_
+
+// *************************************************************
+// Inline operations for class IR::ConsumesDef_out
+// *************************************************************
+
+ACE_INLINE
+IR::ConsumesDef_out::ConsumesDef_out (IR::ConsumesDef_ptr &p)
+  : ptr_ (p)
+{
+  this->ptr_ = IR::ConsumesDef::_nil ();
+}
+
+ACE_INLINE
+IR::ConsumesDef_out::ConsumesDef_out (IR::ConsumesDef_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = IR::ConsumesDef::_nil ();
+}
+
+ACE_INLINE
+IR::ConsumesDef_out::ConsumesDef_out (const IR::ConsumesDef_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (IR::ConsumesDef_out&,p).ptr_)
+{}
+
+ACE_INLINE IR::ConsumesDef_out &
+IR::ConsumesDef_out::operator= (const IR::ConsumesDef_out &p)
+{
+  this->ptr_ = ACE_const_cast (IR::ConsumesDef_out&,p).ptr_;
+  return *this;
+}
+
+ACE_INLINE IR::ConsumesDef_out &
+IR::ConsumesDef_out::operator= (const IR::ConsumesDef_var &p)
+{
+  this->ptr_ = IR::ConsumesDef::_duplicate (p.ptr ());
+  return *this;
+}
+
+ACE_INLINE IR::ConsumesDef_out &
+IR::ConsumesDef_out::operator= (IR::ConsumesDef_ptr p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+IR::ConsumesDef_out::operator IR::ConsumesDef_ptr &() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE IR::ConsumesDef_ptr &
+IR::ConsumesDef_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE IR::ConsumesDef_ptr 
+IR::ConsumesDef_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_CONSUMESDEFSEQ_CI_)
+#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_CONSUMESDEFSEQ_CI_
+
+  ACE_INLINE IR::ConsumesDef **
+  IR::_TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq::allocbuf (CORBA::ULong nelems)
+  {
+    IR::ConsumesDef **buf = 0;
+    
+    ACE_NEW_RETURN (buf, IR::ConsumesDef*[nelems], 0);
+    
+    for (CORBA::ULong i = 0; i < nelems; i++)
+      buf[i] = IR::ConsumesDef::_nil ();
+    
+    return buf;
+  }
+  
+  ACE_INLINE void 
+  IR::_TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq::freebuf (IR::ConsumesDef **buffer)
+  {
+    if (buffer == 0)
+      return;
+    delete[] buffer;
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq::_TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq (void)
+  {
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq::_TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq (CORBA::ULong maximum)
+    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq::allocbuf (maximum))
+  {
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq::_TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq (CORBA::ULong maximum,
+    CORBA::ULong length,
+    IR::ConsumesDef* *value,
+    CORBA::Boolean release)
+  : TAO_Unbounded_Base_Sequence (maximum, length, value, release)
+  {
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq::_TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq(const _TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq &rhs)
+    : TAO_Unbounded_Base_Sequence (rhs)
+  {
+    if (rhs.buffer_ != 0)
+    {
+      IR::ConsumesDef **tmp1 = _TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq::allocbuf (this->maximum_);
+      IR::ConsumesDef ** const tmp2 = ACE_reinterpret_cast (IR::ConsumesDef ** ACE_CAST_CONST, rhs.buffer_);
+      
+      for (CORBA::ULong i = 0; i < rhs.length_; ++i)
+        tmp1[i] = IR::ConsumesDef::_duplicate (tmp2[i]);
+      
+      this->buffer_ = tmp1;
+    }
+    else
+    {
+      this->buffer_ = 0;
+    }
+  }
+  
+  ACE_INLINE IR::_TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq &
+  IR::_TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq::operator= (const _TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq &rhs)
+  {
+    if (this == &rhs)
+      return *this;
+    
+    if (this->release_)
+    {
+      IR::ConsumesDef **tmp = ACE_reinterpret_cast (IR::ConsumesDef **, this->buffer_);
+      
+      for (CORBA::ULong i = 0; i < this->length_; ++i)
+      {
+        CORBA::release (tmp[i]);
+        tmp[i] = IR::ConsumesDef::_nil ();
+      }
+      if (this->maximum_ < rhs.maximum_)
+      {
+        _TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq::freebuf (tmp);
+        this->buffer_ = _TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq::allocbuf (rhs.maximum_);
+      }
+    }
+    else
+      this->buffer_ = _TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq::allocbuf (rhs.maximum_);
+    
+    TAO_Unbounded_Base_Sequence::operator= (rhs);
+    
+    IR::ConsumesDef **tmp1 = ACE_reinterpret_cast (IR::ConsumesDef **, this->buffer_);
+    IR::ConsumesDef ** const tmp2 = ACE_reinterpret_cast (IR::ConsumesDef ** ACE_CAST_CONST, rhs.buffer_);
+    
+    for (CORBA::ULong i = 0; i < rhs.length_; ++i)
+      tmp1[i] = IR::ConsumesDef::_duplicate (tmp2[i]);
+    
+    return *this;
+  }
+  
+  ACE_INLINE TAO_Object_Manager<IR::ConsumesDef,IR::ConsumesDef_var>
+  IR::_TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq::operator[] (CORBA::ULong index) const
+  // read-write accessor
+  {
+    ACE_ASSERT (index < this->maximum_);
+    IR::ConsumesDef ** const tmp = ACE_reinterpret_cast (IR::ConsumesDef ** ACE_CAST_CONST, this->buffer_);
+    return TAO_Object_Manager<IR::ConsumesDef,IR::ConsumesDef_var> (tmp + index, this->release_);
+  }
+  
+  ACE_INLINE IR::ConsumesDef* *
+  IR::_TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq::get_buffer (CORBA::Boolean orphan)
+  {
+    IR::ConsumesDef **result = 0;
+    if (orphan == 0)
+    {
+      // We retain ownership.
+      if (this->buffer_ == 0)
+      {
+        result = _TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq::allocbuf (this->maximum_);
+        this->buffer_ = result;
+        this->release_ = 1;
+      }
+      else
+      {
+        result = ACE_reinterpret_cast (IR::ConsumesDef**, this->buffer_);
+      }
+    }
+    else // if (orphan == 1)
+    {
+      if (this->release_ != 0)
+      {
+        // We set the state back to default and relinquish
+        // ownership.
+        result = ACE_reinterpret_cast(IR::ConsumesDef**,this->buffer_);
+        this->maximum_ = 0;
+        this->length_ = 0;
+        this->buffer_ = 0;
+        this->release_ = 0;
+      }
+    }
+    return result;
+  }
+  
+  ACE_INLINE const IR::ConsumesDef* *
+  IR::_TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq::get_buffer (void) const
+  {
+    return ACE_reinterpret_cast(const IR::ConsumesDef ** ACE_CAST_CONST, this->buffer_);
+  }
+  
+  
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_IR_CONSUMESDEFSEQ_CI_)
+#define _IR_CONSUMESDEFSEQ_CI_
+
+// *************************************************************
+// Inline operations for class IR::ConsumesDefSeq_var
+// *************************************************************
+
+ACE_INLINE
+IR::ConsumesDefSeq_var::ConsumesDefSeq_var (void) // default constructor
+  : ptr_ (0)
+{}
+
+ACE_INLINE
+IR::ConsumesDefSeq_var::ConsumesDefSeq_var (ConsumesDefSeq *p)
+  : ptr_ (p)
+{}
+
+ACE_INLINE
+IR::ConsumesDefSeq_var::ConsumesDefSeq_var (const ::IR::ConsumesDefSeq_var &p) // copy constructor
+{
+  if (p.ptr_)
+    ACE_NEW (this->ptr_, ::IR::ConsumesDefSeq (*p.ptr_));
+  else
+    this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::ConsumesDefSeq_var::~ConsumesDefSeq_var (void) // destructor
+{
+  delete this->ptr_;
+}
+
+ACE_INLINE IR::ConsumesDefSeq_var &
+IR::ConsumesDefSeq_var::operator= (ConsumesDefSeq *p)
+{
+  delete this->ptr_;
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE ::IR::ConsumesDefSeq_var &
+IR::ConsumesDefSeq_var::operator= (const ::IR::ConsumesDefSeq_var &p)
+{
+  if (this != &p)
+    {
+      if (p.ptr_ == 0)
+        {
+          delete this->ptr_;
+          this->ptr_ = 0;
+        }
+      else
+        {
+          ConsumesDefSeq *deep_copy =
+            new ConsumesDefSeq (*p.ptr_);
+          
+          if (deep_copy != 0)
+            {
+              ConsumesDefSeq *tmp = deep_copy;
+              deep_copy = this->ptr_;
+              this->ptr_ = tmp;
+              delete deep_copy;
+            }
+        }
+    }
+  
+  return *this;
+}
+
+ACE_INLINE const ::IR::ConsumesDefSeq *
+IR::ConsumesDefSeq_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ConsumesDefSeq *
+IR::ConsumesDefSeq_var::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+IR::ConsumesDefSeq_var::operator const ::IR::ConsumesDefSeq &() const // cast
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE 
+IR::ConsumesDefSeq_var::operator ::IR::ConsumesDefSeq &() // cast 
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE 
+IR::ConsumesDefSeq_var::operator ::IR::ConsumesDefSeq &() const // cast 
+{
+  return *this->ptr_;
+}
+
+// variable-size types only
+ACE_INLINE
+IR::ConsumesDefSeq_var::operator ::IR::ConsumesDefSeq *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE TAO_Object_Manager<IR::ConsumesDef, IR::ConsumesDef_var>
+IR::ConsumesDefSeq_var::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+ACE_INLINE const ::IR::ConsumesDefSeq &
+IR::ConsumesDefSeq_var::in (void) const
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE ::IR::ConsumesDefSeq &
+IR::ConsumesDefSeq_var::inout (void)
+{
+  return *this->ptr_;
+}
+
+// mapping for variable size 
+ACE_INLINE ::IR::ConsumesDefSeq *&
+IR::ConsumesDefSeq_var::out (void)
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ConsumesDefSeq *
+IR::ConsumesDefSeq_var::_retn (void)
+{
+  ::IR::ConsumesDefSeq *tmp = this->ptr_;
+  this->ptr_ = 0;
+  return tmp;
+}
+
+ACE_INLINE ::IR::ConsumesDefSeq *
+IR::ConsumesDefSeq_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+// *************************************************************
+// Inline operations for class IR::ConsumesDefSeq_out
+// *************************************************************
+
+ACE_INLINE
+IR::ConsumesDefSeq_out::ConsumesDefSeq_out (ConsumesDefSeq *&p)
+  : ptr_ (p)
+{
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::ConsumesDefSeq_out::ConsumesDefSeq_out (ConsumesDefSeq_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::ConsumesDefSeq_out::ConsumesDefSeq_out (const ::IR::ConsumesDefSeq_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (ConsumesDefSeq_out&, p).ptr_)
+{}
+
+ACE_INLINE ::IR::ConsumesDefSeq_out &
+IR::ConsumesDefSeq_out::operator= (const ::IR::ConsumesDefSeq_out &p)
+{
+  this->ptr_ = ACE_const_cast (ConsumesDefSeq_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE ::IR::ConsumesDefSeq_out &
+IR::ConsumesDefSeq_out::operator= (ConsumesDefSeq *p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+IR::ConsumesDefSeq_out::operator ::IR::ConsumesDefSeq *&() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ConsumesDefSeq *&
+IR::ConsumesDefSeq_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ConsumesDefSeq *
+IR::ConsumesDefSeq_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE TAO_Object_Manager<IR::ConsumesDef, IR::ConsumesDef_var>
+IR::ConsumesDefSeq_out::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_FACTORYDEF___CI_)
+#define _IR_FACTORYDEF___CI_
+
+ACE_INLINE
+IR::FactoryDef::FactoryDef (
+    TAO_Stub *objref,
+    CORBA::Boolean _tao_collocated,
+    TAO_Abstract_ServantBase *servant
+  )
+  : CORBA_Object (objref, _tao_collocated, servant)
+{
+  this->IR_FactoryDef_setup_collocation (_tao_collocated);
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_FACTORYDEF___VAR_CI_)
+#define _IR_FACTORYDEF___VAR_CI_
+
+// *************************************************************
+// Inline operations for class IR::FactoryDef_var
+// *************************************************************
+
+ACE_INLINE
+IR::FactoryDef_var::FactoryDef_var (void) // default constructor
+  : ptr_ (IR::FactoryDef::_nil ())
+{}
+
+ACE_INLINE IR::FactoryDef_ptr 
+IR::FactoryDef_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+IR::FactoryDef_var::FactoryDef_var (const IR::FactoryDef_var &p) // copy constructor
+  : TAO_Base_var (),
+    ptr_ (FactoryDef::_duplicate (p.ptr ()))
+{}
+
+ACE_INLINE
+IR::FactoryDef_var::~FactoryDef_var (void) // destructor
+{
+  CORBA::release (this->ptr_);
+}
+
+ACE_INLINE IR::FactoryDef_var &
+IR::FactoryDef_var::operator= (IR::FactoryDef_ptr p)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE IR::FactoryDef_var &
+IR::FactoryDef_var::operator= (const IR::FactoryDef_var &p)
+{
+  if (this != &p)
+  {
+    CORBA::release (this->ptr_);
+    this->ptr_ = IR::FactoryDef::_duplicate (p.ptr ());
+  }
+  return *this;
+}
+
+ACE_INLINE 
+IR::FactoryDef_var::operator const IR::FactoryDef_ptr &() const // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+IR::FactoryDef_var::operator IR::FactoryDef_ptr &() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE IR::FactoryDef_ptr 
+IR::FactoryDef_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE IR::FactoryDef_ptr
+IR::FactoryDef_var::in (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE IR::FactoryDef_ptr &
+IR::FactoryDef_var::inout (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE IR::FactoryDef_ptr &
+IR::FactoryDef_var::out (void)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = IR::FactoryDef::_nil ();
+  return this->ptr_;
+}
+
+ACE_INLINE IR::FactoryDef_ptr 
+IR::FactoryDef_var::_retn (void)
+{
+  // yield ownership of managed obj reference
+  IR::FactoryDef_ptr val = this->ptr_;
+  this->ptr_ = IR::FactoryDef::_nil ();
+  return val;
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_FACTORYDEF___OUT_CI_)
+#define _IR_FACTORYDEF___OUT_CI_
+
+// *************************************************************
+// Inline operations for class IR::FactoryDef_out
+// *************************************************************
+
+ACE_INLINE
+IR::FactoryDef_out::FactoryDef_out (IR::FactoryDef_ptr &p)
+  : ptr_ (p)
+{
+  this->ptr_ = IR::FactoryDef::_nil ();
+}
+
+ACE_INLINE
+IR::FactoryDef_out::FactoryDef_out (IR::FactoryDef_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = IR::FactoryDef::_nil ();
+}
+
+ACE_INLINE
+IR::FactoryDef_out::FactoryDef_out (const IR::FactoryDef_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (IR::FactoryDef_out&,p).ptr_)
+{}
+
+ACE_INLINE IR::FactoryDef_out &
+IR::FactoryDef_out::operator= (const IR::FactoryDef_out &p)
+{
+  this->ptr_ = ACE_const_cast (IR::FactoryDef_out&,p).ptr_;
+  return *this;
+}
+
+ACE_INLINE IR::FactoryDef_out &
+IR::FactoryDef_out::operator= (const IR::FactoryDef_var &p)
+{
+  this->ptr_ = IR::FactoryDef::_duplicate (p.ptr ());
+  return *this;
+}
+
+ACE_INLINE IR::FactoryDef_out &
+IR::FactoryDef_out::operator= (IR::FactoryDef_ptr p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+IR::FactoryDef_out::operator IR::FactoryDef_ptr &() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE IR::FactoryDef_ptr &
+IR::FactoryDef_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE IR::FactoryDef_ptr 
+IR::FactoryDef_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_FACTORYDEFSEQ_CI_)
+#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_FACTORYDEFSEQ_CI_
+
+  ACE_INLINE IR::FactoryDef **
+  IR::_TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq::allocbuf (CORBA::ULong nelems)
+  {
+    IR::FactoryDef **buf = 0;
+    
+    ACE_NEW_RETURN (buf, IR::FactoryDef*[nelems], 0);
+    
+    for (CORBA::ULong i = 0; i < nelems; i++)
+      buf[i] = IR::FactoryDef::_nil ();
+    
+    return buf;
+  }
+  
+  ACE_INLINE void 
+  IR::_TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq::freebuf (IR::FactoryDef **buffer)
+  {
+    if (buffer == 0)
+      return;
+    delete[] buffer;
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq::_TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq (void)
+  {
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq::_TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq (CORBA::ULong maximum)
+    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq::allocbuf (maximum))
+  {
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq::_TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq (CORBA::ULong maximum,
+    CORBA::ULong length,
+    IR::FactoryDef* *value,
+    CORBA::Boolean release)
+  : TAO_Unbounded_Base_Sequence (maximum, length, value, release)
+  {
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq::_TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq(const _TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq &rhs)
+    : TAO_Unbounded_Base_Sequence (rhs)
+  {
+    if (rhs.buffer_ != 0)
+    {
+      IR::FactoryDef **tmp1 = _TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq::allocbuf (this->maximum_);
+      IR::FactoryDef ** const tmp2 = ACE_reinterpret_cast (IR::FactoryDef ** ACE_CAST_CONST, rhs.buffer_);
+      
+      for (CORBA::ULong i = 0; i < rhs.length_; ++i)
+        tmp1[i] = IR::FactoryDef::_duplicate (tmp2[i]);
+      
+      this->buffer_ = tmp1;
+    }
+    else
+    {
+      this->buffer_ = 0;
+    }
+  }
+  
+  ACE_INLINE IR::_TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq &
+  IR::_TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq::operator= (const _TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq &rhs)
+  {
+    if (this == &rhs)
+      return *this;
+    
+    if (this->release_)
+    {
+      IR::FactoryDef **tmp = ACE_reinterpret_cast (IR::FactoryDef **, this->buffer_);
+      
+      for (CORBA::ULong i = 0; i < this->length_; ++i)
+      {
+        CORBA::release (tmp[i]);
+        tmp[i] = IR::FactoryDef::_nil ();
+      }
+      if (this->maximum_ < rhs.maximum_)
+      {
+        _TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq::freebuf (tmp);
+        this->buffer_ = _TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq::allocbuf (rhs.maximum_);
+      }
+    }
+    else
+      this->buffer_ = _TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq::allocbuf (rhs.maximum_);
+    
+    TAO_Unbounded_Base_Sequence::operator= (rhs);
+    
+    IR::FactoryDef **tmp1 = ACE_reinterpret_cast (IR::FactoryDef **, this->buffer_);
+    IR::FactoryDef ** const tmp2 = ACE_reinterpret_cast (IR::FactoryDef ** ACE_CAST_CONST, rhs.buffer_);
+    
+    for (CORBA::ULong i = 0; i < rhs.length_; ++i)
+      tmp1[i] = IR::FactoryDef::_duplicate (tmp2[i]);
+    
+    return *this;
+  }
+  
+  ACE_INLINE TAO_Object_Manager<IR::FactoryDef,IR::FactoryDef_var>
+  IR::_TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq::operator[] (CORBA::ULong index) const
+  // read-write accessor
+  {
+    ACE_ASSERT (index < this->maximum_);
+    IR::FactoryDef ** const tmp = ACE_reinterpret_cast (IR::FactoryDef ** ACE_CAST_CONST, this->buffer_);
+    return TAO_Object_Manager<IR::FactoryDef,IR::FactoryDef_var> (tmp + index, this->release_);
+  }
+  
+  ACE_INLINE IR::FactoryDef* *
+  IR::_TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq::get_buffer (CORBA::Boolean orphan)
+  {
+    IR::FactoryDef **result = 0;
+    if (orphan == 0)
+    {
+      // We retain ownership.
+      if (this->buffer_ == 0)
+      {
+        result = _TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq::allocbuf (this->maximum_);
+        this->buffer_ = result;
+        this->release_ = 1;
+      }
+      else
+      {
+        result = ACE_reinterpret_cast (IR::FactoryDef**, this->buffer_);
+      }
+    }
+    else // if (orphan == 1)
+    {
+      if (this->release_ != 0)
+      {
+        // We set the state back to default and relinquish
+        // ownership.
+        result = ACE_reinterpret_cast(IR::FactoryDef**,this->buffer_);
+        this->maximum_ = 0;
+        this->length_ = 0;
+        this->buffer_ = 0;
+        this->release_ = 0;
+      }
+    }
+    return result;
+  }
+  
+  ACE_INLINE const IR::FactoryDef* *
+  IR::_TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq::get_buffer (void) const
+  {
+    return ACE_reinterpret_cast(const IR::FactoryDef ** ACE_CAST_CONST, this->buffer_);
+  }
+  
+  
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_IR_FACTORYDEFSEQ_CI_)
+#define _IR_FACTORYDEFSEQ_CI_
+
+// *************************************************************
+// Inline operations for class IR::FactoryDefSeq_var
+// *************************************************************
+
+ACE_INLINE
+IR::FactoryDefSeq_var::FactoryDefSeq_var (void) // default constructor
+  : ptr_ (0)
+{}
+
+ACE_INLINE
+IR::FactoryDefSeq_var::FactoryDefSeq_var (FactoryDefSeq *p)
+  : ptr_ (p)
+{}
+
+ACE_INLINE
+IR::FactoryDefSeq_var::FactoryDefSeq_var (const ::IR::FactoryDefSeq_var &p) // copy constructor
+{
+  if (p.ptr_)
+    ACE_NEW (this->ptr_, ::IR::FactoryDefSeq (*p.ptr_));
+  else
+    this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::FactoryDefSeq_var::~FactoryDefSeq_var (void) // destructor
+{
+  delete this->ptr_;
+}
+
+ACE_INLINE IR::FactoryDefSeq_var &
+IR::FactoryDefSeq_var::operator= (FactoryDefSeq *p)
+{
+  delete this->ptr_;
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE ::IR::FactoryDefSeq_var &
+IR::FactoryDefSeq_var::operator= (const ::IR::FactoryDefSeq_var &p)
+{
+  if (this != &p)
+    {
+      if (p.ptr_ == 0)
+        {
+          delete this->ptr_;
+          this->ptr_ = 0;
+        }
+      else
+        {
+          FactoryDefSeq *deep_copy =
+            new FactoryDefSeq (*p.ptr_);
+          
+          if (deep_copy != 0)
+            {
+              FactoryDefSeq *tmp = deep_copy;
+              deep_copy = this->ptr_;
+              this->ptr_ = tmp;
+              delete deep_copy;
+            }
+        }
+    }
+  
+  return *this;
+}
+
+ACE_INLINE const ::IR::FactoryDefSeq *
+IR::FactoryDefSeq_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::FactoryDefSeq *
+IR::FactoryDefSeq_var::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+IR::FactoryDefSeq_var::operator const ::IR::FactoryDefSeq &() const // cast
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE 
+IR::FactoryDefSeq_var::operator ::IR::FactoryDefSeq &() // cast 
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE 
+IR::FactoryDefSeq_var::operator ::IR::FactoryDefSeq &() const // cast 
+{
+  return *this->ptr_;
+}
+
+// variable-size types only
+ACE_INLINE
+IR::FactoryDefSeq_var::operator ::IR::FactoryDefSeq *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE TAO_Object_Manager<IR::FactoryDef, IR::FactoryDef_var>
+IR::FactoryDefSeq_var::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+ACE_INLINE const ::IR::FactoryDefSeq &
+IR::FactoryDefSeq_var::in (void) const
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE ::IR::FactoryDefSeq &
+IR::FactoryDefSeq_var::inout (void)
+{
+  return *this->ptr_;
+}
+
+// mapping for variable size 
+ACE_INLINE ::IR::FactoryDefSeq *&
+IR::FactoryDefSeq_var::out (void)
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::FactoryDefSeq *
+IR::FactoryDefSeq_var::_retn (void)
+{
+  ::IR::FactoryDefSeq *tmp = this->ptr_;
+  this->ptr_ = 0;
+  return tmp;
+}
+
+ACE_INLINE ::IR::FactoryDefSeq *
+IR::FactoryDefSeq_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+// *************************************************************
+// Inline operations for class IR::FactoryDefSeq_out
+// *************************************************************
+
+ACE_INLINE
+IR::FactoryDefSeq_out::FactoryDefSeq_out (FactoryDefSeq *&p)
+  : ptr_ (p)
+{
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::FactoryDefSeq_out::FactoryDefSeq_out (FactoryDefSeq_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::FactoryDefSeq_out::FactoryDefSeq_out (const ::IR::FactoryDefSeq_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (FactoryDefSeq_out&, p).ptr_)
+{}
+
+ACE_INLINE ::IR::FactoryDefSeq_out &
+IR::FactoryDefSeq_out::operator= (const ::IR::FactoryDefSeq_out &p)
+{
+  this->ptr_ = ACE_const_cast (FactoryDefSeq_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE ::IR::FactoryDefSeq_out &
+IR::FactoryDefSeq_out::operator= (FactoryDefSeq *p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+IR::FactoryDefSeq_out::operator ::IR::FactoryDefSeq *&() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::FactoryDefSeq *&
+IR::FactoryDefSeq_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::FactoryDefSeq *
+IR::FactoryDefSeq_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE TAO_Object_Manager<IR::FactoryDef, IR::FactoryDef_var>
+IR::FactoryDefSeq_out::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_FINDERDEF___CI_)
+#define _IR_FINDERDEF___CI_
+
+ACE_INLINE
+IR::FinderDef::FinderDef (
+    TAO_Stub *objref,
+    CORBA::Boolean _tao_collocated,
+    TAO_Abstract_ServantBase *servant
+  )
+  : CORBA_Object (objref, _tao_collocated, servant)
+{
+  this->IR_FinderDef_setup_collocation (_tao_collocated);
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_FINDERDEF___VAR_CI_)
+#define _IR_FINDERDEF___VAR_CI_
+
+// *************************************************************
+// Inline operations for class IR::FinderDef_var
+// *************************************************************
+
+ACE_INLINE
+IR::FinderDef_var::FinderDef_var (void) // default constructor
+  : ptr_ (IR::FinderDef::_nil ())
+{}
+
+ACE_INLINE IR::FinderDef_ptr 
+IR::FinderDef_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+IR::FinderDef_var::FinderDef_var (const IR::FinderDef_var &p) // copy constructor
+  : TAO_Base_var (),
+    ptr_ (FinderDef::_duplicate (p.ptr ()))
+{}
+
+ACE_INLINE
+IR::FinderDef_var::~FinderDef_var (void) // destructor
+{
+  CORBA::release (this->ptr_);
+}
+
+ACE_INLINE IR::FinderDef_var &
+IR::FinderDef_var::operator= (IR::FinderDef_ptr p)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE IR::FinderDef_var &
+IR::FinderDef_var::operator= (const IR::FinderDef_var &p)
+{
+  if (this != &p)
+  {
+    CORBA::release (this->ptr_);
+    this->ptr_ = IR::FinderDef::_duplicate (p.ptr ());
+  }
+  return *this;
+}
+
+ACE_INLINE 
+IR::FinderDef_var::operator const IR::FinderDef_ptr &() const // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+IR::FinderDef_var::operator IR::FinderDef_ptr &() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE IR::FinderDef_ptr 
+IR::FinderDef_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE IR::FinderDef_ptr
+IR::FinderDef_var::in (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE IR::FinderDef_ptr &
+IR::FinderDef_var::inout (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE IR::FinderDef_ptr &
+IR::FinderDef_var::out (void)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = IR::FinderDef::_nil ();
+  return this->ptr_;
+}
+
+ACE_INLINE IR::FinderDef_ptr 
+IR::FinderDef_var::_retn (void)
+{
+  // yield ownership of managed obj reference
+  IR::FinderDef_ptr val = this->ptr_;
+  this->ptr_ = IR::FinderDef::_nil ();
+  return val;
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_FINDERDEF___OUT_CI_)
+#define _IR_FINDERDEF___OUT_CI_
+
+// *************************************************************
+// Inline operations for class IR::FinderDef_out
+// *************************************************************
+
+ACE_INLINE
+IR::FinderDef_out::FinderDef_out (IR::FinderDef_ptr &p)
+  : ptr_ (p)
+{
+  this->ptr_ = IR::FinderDef::_nil ();
+}
+
+ACE_INLINE
+IR::FinderDef_out::FinderDef_out (IR::FinderDef_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = IR::FinderDef::_nil ();
+}
+
+ACE_INLINE
+IR::FinderDef_out::FinderDef_out (const IR::FinderDef_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (IR::FinderDef_out&,p).ptr_)
+{}
+
+ACE_INLINE IR::FinderDef_out &
+IR::FinderDef_out::operator= (const IR::FinderDef_out &p)
+{
+  this->ptr_ = ACE_const_cast (IR::FinderDef_out&,p).ptr_;
+  return *this;
+}
+
+ACE_INLINE IR::FinderDef_out &
+IR::FinderDef_out::operator= (const IR::FinderDef_var &p)
+{
+  this->ptr_ = IR::FinderDef::_duplicate (p.ptr ());
+  return *this;
+}
+
+ACE_INLINE IR::FinderDef_out &
+IR::FinderDef_out::operator= (IR::FinderDef_ptr p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+IR::FinderDef_out::operator IR::FinderDef_ptr &() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE IR::FinderDef_ptr &
+IR::FinderDef_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE IR::FinderDef_ptr 
+IR::FinderDef_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_FINDERDEFSEQ_CI_)
+#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_FINDERDEFSEQ_CI_
+
+  ACE_INLINE IR::FinderDef **
+  IR::_TAO_Unbounded_Object_Sequence_IR_FinderDefSeq::allocbuf (CORBA::ULong nelems)
+  {
+    IR::FinderDef **buf = 0;
+    
+    ACE_NEW_RETURN (buf, IR::FinderDef*[nelems], 0);
+    
+    for (CORBA::ULong i = 0; i < nelems; i++)
+      buf[i] = IR::FinderDef::_nil ();
+    
+    return buf;
+  }
+  
+  ACE_INLINE void 
+  IR::_TAO_Unbounded_Object_Sequence_IR_FinderDefSeq::freebuf (IR::FinderDef **buffer)
+  {
+    if (buffer == 0)
+      return;
+    delete[] buffer;
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Object_Sequence_IR_FinderDefSeq::_TAO_Unbounded_Object_Sequence_IR_FinderDefSeq (void)
+  {
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Object_Sequence_IR_FinderDefSeq::_TAO_Unbounded_Object_Sequence_IR_FinderDefSeq (CORBA::ULong maximum)
+    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Object_Sequence_IR_FinderDefSeq::allocbuf (maximum))
+  {
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Object_Sequence_IR_FinderDefSeq::_TAO_Unbounded_Object_Sequence_IR_FinderDefSeq (CORBA::ULong maximum,
+    CORBA::ULong length,
+    IR::FinderDef* *value,
+    CORBA::Boolean release)
+  : TAO_Unbounded_Base_Sequence (maximum, length, value, release)
+  {
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Object_Sequence_IR_FinderDefSeq::_TAO_Unbounded_Object_Sequence_IR_FinderDefSeq(const _TAO_Unbounded_Object_Sequence_IR_FinderDefSeq &rhs)
+    : TAO_Unbounded_Base_Sequence (rhs)
+  {
+    if (rhs.buffer_ != 0)
+    {
+      IR::FinderDef **tmp1 = _TAO_Unbounded_Object_Sequence_IR_FinderDefSeq::allocbuf (this->maximum_);
+      IR::FinderDef ** const tmp2 = ACE_reinterpret_cast (IR::FinderDef ** ACE_CAST_CONST, rhs.buffer_);
+      
+      for (CORBA::ULong i = 0; i < rhs.length_; ++i)
+        tmp1[i] = IR::FinderDef::_duplicate (tmp2[i]);
+      
+      this->buffer_ = tmp1;
+    }
+    else
+    {
+      this->buffer_ = 0;
+    }
+  }
+  
+  ACE_INLINE IR::_TAO_Unbounded_Object_Sequence_IR_FinderDefSeq &
+  IR::_TAO_Unbounded_Object_Sequence_IR_FinderDefSeq::operator= (const _TAO_Unbounded_Object_Sequence_IR_FinderDefSeq &rhs)
+  {
+    if (this == &rhs)
+      return *this;
+    
+    if (this->release_)
+    {
+      IR::FinderDef **tmp = ACE_reinterpret_cast (IR::FinderDef **, this->buffer_);
+      
+      for (CORBA::ULong i = 0; i < this->length_; ++i)
+      {
+        CORBA::release (tmp[i]);
+        tmp[i] = IR::FinderDef::_nil ();
+      }
+      if (this->maximum_ < rhs.maximum_)
+      {
+        _TAO_Unbounded_Object_Sequence_IR_FinderDefSeq::freebuf (tmp);
+        this->buffer_ = _TAO_Unbounded_Object_Sequence_IR_FinderDefSeq::allocbuf (rhs.maximum_);
+      }
+    }
+    else
+      this->buffer_ = _TAO_Unbounded_Object_Sequence_IR_FinderDefSeq::allocbuf (rhs.maximum_);
+    
+    TAO_Unbounded_Base_Sequence::operator= (rhs);
+    
+    IR::FinderDef **tmp1 = ACE_reinterpret_cast (IR::FinderDef **, this->buffer_);
+    IR::FinderDef ** const tmp2 = ACE_reinterpret_cast (IR::FinderDef ** ACE_CAST_CONST, rhs.buffer_);
+    
+    for (CORBA::ULong i = 0; i < rhs.length_; ++i)
+      tmp1[i] = IR::FinderDef::_duplicate (tmp2[i]);
+    
+    return *this;
+  }
+  
+  ACE_INLINE TAO_Object_Manager<IR::FinderDef,IR::FinderDef_var>
+  IR::_TAO_Unbounded_Object_Sequence_IR_FinderDefSeq::operator[] (CORBA::ULong index) const
+  // read-write accessor
+  {
+    ACE_ASSERT (index < this->maximum_);
+    IR::FinderDef ** const tmp = ACE_reinterpret_cast (IR::FinderDef ** ACE_CAST_CONST, this->buffer_);
+    return TAO_Object_Manager<IR::FinderDef,IR::FinderDef_var> (tmp + index, this->release_);
+  }
+  
+  ACE_INLINE IR::FinderDef* *
+  IR::_TAO_Unbounded_Object_Sequence_IR_FinderDefSeq::get_buffer (CORBA::Boolean orphan)
+  {
+    IR::FinderDef **result = 0;
+    if (orphan == 0)
+    {
+      // We retain ownership.
+      if (this->buffer_ == 0)
+      {
+        result = _TAO_Unbounded_Object_Sequence_IR_FinderDefSeq::allocbuf (this->maximum_);
+        this->buffer_ = result;
+        this->release_ = 1;
+      }
+      else
+      {
+        result = ACE_reinterpret_cast (IR::FinderDef**, this->buffer_);
+      }
+    }
+    else // if (orphan == 1)
+    {
+      if (this->release_ != 0)
+      {
+        // We set the state back to default and relinquish
+        // ownership.
+        result = ACE_reinterpret_cast(IR::FinderDef**,this->buffer_);
+        this->maximum_ = 0;
+        this->length_ = 0;
+        this->buffer_ = 0;
+        this->release_ = 0;
+      }
+    }
+    return result;
+  }
+  
+  ACE_INLINE const IR::FinderDef* *
+  IR::_TAO_Unbounded_Object_Sequence_IR_FinderDefSeq::get_buffer (void) const
+  {
+    return ACE_reinterpret_cast(const IR::FinderDef ** ACE_CAST_CONST, this->buffer_);
+  }
+  
+  
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_IR_FINDERDEFSEQ_CI_)
+#define _IR_FINDERDEFSEQ_CI_
+
+// *************************************************************
+// Inline operations for class IR::FinderDefSeq_var
+// *************************************************************
+
+ACE_INLINE
+IR::FinderDefSeq_var::FinderDefSeq_var (void) // default constructor
+  : ptr_ (0)
+{}
+
+ACE_INLINE
+IR::FinderDefSeq_var::FinderDefSeq_var (FinderDefSeq *p)
+  : ptr_ (p)
+{}
+
+ACE_INLINE
+IR::FinderDefSeq_var::FinderDefSeq_var (const ::IR::FinderDefSeq_var &p) // copy constructor
+{
+  if (p.ptr_)
+    ACE_NEW (this->ptr_, ::IR::FinderDefSeq (*p.ptr_));
+  else
+    this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::FinderDefSeq_var::~FinderDefSeq_var (void) // destructor
+{
+  delete this->ptr_;
+}
+
+ACE_INLINE IR::FinderDefSeq_var &
+IR::FinderDefSeq_var::operator= (FinderDefSeq *p)
+{
+  delete this->ptr_;
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE ::IR::FinderDefSeq_var &
+IR::FinderDefSeq_var::operator= (const ::IR::FinderDefSeq_var &p)
+{
+  if (this != &p)
+    {
+      if (p.ptr_ == 0)
+        {
+          delete this->ptr_;
+          this->ptr_ = 0;
+        }
+      else
+        {
+          FinderDefSeq *deep_copy =
+            new FinderDefSeq (*p.ptr_);
+          
+          if (deep_copy != 0)
+            {
+              FinderDefSeq *tmp = deep_copy;
+              deep_copy = this->ptr_;
+              this->ptr_ = tmp;
+              delete deep_copy;
+            }
+        }
+    }
+  
+  return *this;
+}
+
+ACE_INLINE const ::IR::FinderDefSeq *
+IR::FinderDefSeq_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::FinderDefSeq *
+IR::FinderDefSeq_var::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+IR::FinderDefSeq_var::operator const ::IR::FinderDefSeq &() const // cast
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE 
+IR::FinderDefSeq_var::operator ::IR::FinderDefSeq &() // cast 
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE 
+IR::FinderDefSeq_var::operator ::IR::FinderDefSeq &() const // cast 
+{
+  return *this->ptr_;
+}
+
+// variable-size types only
+ACE_INLINE
+IR::FinderDefSeq_var::operator ::IR::FinderDefSeq *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE TAO_Object_Manager<IR::FinderDef, IR::FinderDef_var>
+IR::FinderDefSeq_var::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+ACE_INLINE const ::IR::FinderDefSeq &
+IR::FinderDefSeq_var::in (void) const
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE ::IR::FinderDefSeq &
+IR::FinderDefSeq_var::inout (void)
+{
+  return *this->ptr_;
+}
+
+// mapping for variable size 
+ACE_INLINE ::IR::FinderDefSeq *&
+IR::FinderDefSeq_var::out (void)
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::FinderDefSeq *
+IR::FinderDefSeq_var::_retn (void)
+{
+  ::IR::FinderDefSeq *tmp = this->ptr_;
+  this->ptr_ = 0;
+  return tmp;
+}
+
+ACE_INLINE ::IR::FinderDefSeq *
+IR::FinderDefSeq_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+// *************************************************************
+// Inline operations for class IR::FinderDefSeq_out
+// *************************************************************
+
+ACE_INLINE
+IR::FinderDefSeq_out::FinderDefSeq_out (FinderDefSeq *&p)
+  : ptr_ (p)
+{
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::FinderDefSeq_out::FinderDefSeq_out (FinderDefSeq_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::FinderDefSeq_out::FinderDefSeq_out (const ::IR::FinderDefSeq_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (FinderDefSeq_out&, p).ptr_)
+{}
+
+ACE_INLINE ::IR::FinderDefSeq_out &
+IR::FinderDefSeq_out::operator= (const ::IR::FinderDefSeq_out &p)
+{
+  this->ptr_ = ACE_const_cast (FinderDefSeq_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE ::IR::FinderDefSeq_out &
+IR::FinderDefSeq_out::operator= (FinderDefSeq *p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+IR::FinderDefSeq_out::operator ::IR::FinderDefSeq *&() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::FinderDefSeq *&
+IR::FinderDefSeq_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::FinderDefSeq *
+IR::FinderDefSeq_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE TAO_Object_Manager<IR::FinderDef, IR::FinderDef_var>
+IR::FinderDefSeq_out::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_PRIMARYKEYDEF___CI_)
+#define _IR_PRIMARYKEYDEF___CI_
+
+ACE_INLINE
+IR::PrimaryKeyDef::PrimaryKeyDef (
+    TAO_Stub *objref,
+    CORBA::Boolean _tao_collocated,
+    TAO_Abstract_ServantBase *servant
+  )
+  : CORBA_Object (objref, _tao_collocated, servant)
+{
+  this->IR_PrimaryKeyDef_setup_collocation (_tao_collocated);
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_PRIMARYKEYDEF___VAR_CI_)
+#define _IR_PRIMARYKEYDEF___VAR_CI_
+
+// *************************************************************
+// Inline operations for class IR::PrimaryKeyDef_var
+// *************************************************************
+
+ACE_INLINE
+IR::PrimaryKeyDef_var::PrimaryKeyDef_var (void) // default constructor
+  : ptr_ (IR::PrimaryKeyDef::_nil ())
+{}
+
+ACE_INLINE IR::PrimaryKeyDef_ptr 
+IR::PrimaryKeyDef_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+IR::PrimaryKeyDef_var::PrimaryKeyDef_var (const IR::PrimaryKeyDef_var &p) // copy constructor
+  : TAO_Base_var (),
+    ptr_ (PrimaryKeyDef::_duplicate (p.ptr ()))
+{}
+
+ACE_INLINE
+IR::PrimaryKeyDef_var::~PrimaryKeyDef_var (void) // destructor
+{
+  CORBA::release (this->ptr_);
+}
+
+ACE_INLINE IR::PrimaryKeyDef_var &
+IR::PrimaryKeyDef_var::operator= (IR::PrimaryKeyDef_ptr p)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE IR::PrimaryKeyDef_var &
+IR::PrimaryKeyDef_var::operator= (const IR::PrimaryKeyDef_var &p)
+{
+  if (this != &p)
+  {
+    CORBA::release (this->ptr_);
+    this->ptr_ = IR::PrimaryKeyDef::_duplicate (p.ptr ());
+  }
+  return *this;
+}
+
+ACE_INLINE 
+IR::PrimaryKeyDef_var::operator const IR::PrimaryKeyDef_ptr &() const // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+IR::PrimaryKeyDef_var::operator IR::PrimaryKeyDef_ptr &() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE IR::PrimaryKeyDef_ptr 
+IR::PrimaryKeyDef_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE IR::PrimaryKeyDef_ptr
+IR::PrimaryKeyDef_var::in (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE IR::PrimaryKeyDef_ptr &
+IR::PrimaryKeyDef_var::inout (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE IR::PrimaryKeyDef_ptr &
+IR::PrimaryKeyDef_var::out (void)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = IR::PrimaryKeyDef::_nil ();
+  return this->ptr_;
+}
+
+ACE_INLINE IR::PrimaryKeyDef_ptr 
+IR::PrimaryKeyDef_var::_retn (void)
+{
+  // yield ownership of managed obj reference
+  IR::PrimaryKeyDef_ptr val = this->ptr_;
+  this->ptr_ = IR::PrimaryKeyDef::_nil ();
+  return val;
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_PRIMARYKEYDEF___OUT_CI_)
+#define _IR_PRIMARYKEYDEF___OUT_CI_
+
+// *************************************************************
+// Inline operations for class IR::PrimaryKeyDef_out
+// *************************************************************
+
+ACE_INLINE
+IR::PrimaryKeyDef_out::PrimaryKeyDef_out (IR::PrimaryKeyDef_ptr &p)
+  : ptr_ (p)
+{
+  this->ptr_ = IR::PrimaryKeyDef::_nil ();
+}
+
+ACE_INLINE
+IR::PrimaryKeyDef_out::PrimaryKeyDef_out (IR::PrimaryKeyDef_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = IR::PrimaryKeyDef::_nil ();
+}
+
+ACE_INLINE
+IR::PrimaryKeyDef_out::PrimaryKeyDef_out (const IR::PrimaryKeyDef_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (IR::PrimaryKeyDef_out&,p).ptr_)
+{}
+
+ACE_INLINE IR::PrimaryKeyDef_out &
+IR::PrimaryKeyDef_out::operator= (const IR::PrimaryKeyDef_out &p)
+{
+  this->ptr_ = ACE_const_cast (IR::PrimaryKeyDef_out&,p).ptr_;
+  return *this;
+}
+
+ACE_INLINE IR::PrimaryKeyDef_out &
+IR::PrimaryKeyDef_out::operator= (const IR::PrimaryKeyDef_var &p)
+{
+  this->ptr_ = IR::PrimaryKeyDef::_duplicate (p.ptr ());
+  return *this;
+}
+
+ACE_INLINE IR::PrimaryKeyDef_out &
+IR::PrimaryKeyDef_out::operator= (IR::PrimaryKeyDef_ptr p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+IR::PrimaryKeyDef_out::operator IR::PrimaryKeyDef_ptr &() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE IR::PrimaryKeyDef_ptr &
+IR::PrimaryKeyDef_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE IR::PrimaryKeyDef_ptr 
+IR::PrimaryKeyDef_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_COMPONENTREPOSITORY___CI_)
+#define _IR_COMPONENTREPOSITORY___CI_
+
+ACE_INLINE
+IR::ComponentRepository::ComponentRepository (
+    TAO_Stub *objref,
+    CORBA::Boolean _tao_collocated,
+    TAO_Abstract_ServantBase *servant
+  )
+  : CORBA_Object (objref, _tao_collocated, servant)
+{
+  this->IR_ComponentRepository_setup_collocation (_tao_collocated);
+}
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_COMPONENTREPOSITORY___VAR_CI_)
+#define _IR_COMPONENTREPOSITORY___VAR_CI_
+
+// *************************************************************
+// Inline operations for class IR::ComponentRepository_var
+// *************************************************************
+
+ACE_INLINE
+IR::ComponentRepository_var::ComponentRepository_var (void) // default constructor
+  : ptr_ (ComponentRepository::_nil ())
+{}
+
+ACE_INLINE ::IR::ComponentRepository_ptr
+IR::ComponentRepository_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+IR::ComponentRepository_var::ComponentRepository_var (const ::IR::ComponentRepository_var &p) // copy constructor
+  : TAO_Base_var (),
+    ptr_ (ComponentRepository::_duplicate (p.ptr ()))
+{}
+
+ACE_INLINE
+IR::ComponentRepository_var::~ComponentRepository_var (void) // destructor
+{
+  CORBA::release (this->ptr_);
+}
+
+ACE_INLINE IR::ComponentRepository_var &
+IR::ComponentRepository_var::operator= (ComponentRepository_ptr p)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE IR::ComponentRepository_var &
+IR::ComponentRepository_var::operator= (const ::IR::ComponentRepository_var &p)
+{
+  if (this != &p)
+  {
+    CORBA::release (this->ptr_);
+    this->ptr_ = ::IR::ComponentRepository::_duplicate (p.ptr ());
+  }
+  return *this;
+}
+
+ACE_INLINE 
+IR::ComponentRepository_var::operator const ::IR::ComponentRepository_ptr &() const // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+IR::ComponentRepository_var::operator ::IR::ComponentRepository_ptr &() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ComponentRepository_ptr
+IR::ComponentRepository_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ComponentRepository_ptr
+IR::ComponentRepository_var::in (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ComponentRepository_ptr &
+IR::ComponentRepository_var::inout (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ComponentRepository_ptr &
+IR::ComponentRepository_var::out (void)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = ::IR::ComponentRepository::_nil ();
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ComponentRepository_ptr
+IR::ComponentRepository_var::_retn (void)
+{
+  // yield ownership of managed obj reference
+  ::IR::ComponentRepository_ptr val = this->ptr_;
+  this->ptr_ = ::IR::ComponentRepository::_nil ();
+  return val;
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_COMPONENTREPOSITORY___OUT_CI_)
+#define _IR_COMPONENTREPOSITORY___OUT_CI_
+
+// *************************************************************
+// Inline operations for class IR::ComponentRepository_out
+// *************************************************************
+
+ACE_INLINE
+IR::ComponentRepository_out::ComponentRepository_out (ComponentRepository_ptr &p)
+  : ptr_ (p)
+{
+  this->ptr_ = ::IR::ComponentRepository::_nil ();
+}
+
+ACE_INLINE
+IR::ComponentRepository_out::ComponentRepository_out (ComponentRepository_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = ::IR::ComponentRepository::_nil ();
+}
+
+ACE_INLINE
+IR::ComponentRepository_out::ComponentRepository_out (const ::IR::ComponentRepository_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (ComponentRepository_out &, p).ptr_)
+{}
+
+ACE_INLINE ::IR::ComponentRepository_out &
+IR::ComponentRepository_out::operator= (const ::IR::ComponentRepository_out &p)
+{
+  this->ptr_ = ACE_const_cast (ComponentRepository_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE IR::ComponentRepository_out &
+IR::ComponentRepository_out::operator= (const ::IR::ComponentRepository_var &p)
+{
+  this->ptr_ = ::IR::ComponentRepository::_duplicate (p.ptr ());
+  return *this;
+}
+
+ACE_INLINE IR::ComponentRepository_out &
+IR::ComponentRepository_out::operator= (ComponentRepository_ptr p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+IR::ComponentRepository_out::operator ::IR::ComponentRepository_ptr &() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ComponentRepository_ptr &
+IR::ComponentRepository_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ComponentRepository_ptr
+IR::ComponentRepository_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+
+#endif /* end #if !defined */
+
+// *************************************************************
+// Inline operations for class IR::ProvidesDescription_var
+// *************************************************************
+
+ACE_INLINE
+IR::ProvidesDescription_var::ProvidesDescription_var (void) // default constructor
+  : ptr_ (0)
+{}
+
+ACE_INLINE
+IR::ProvidesDescription_var::ProvidesDescription_var (ProvidesDescription *p)
+  : ptr_ (p)
+{}
+
+ACE_INLINE
+IR::ProvidesDescription_var::ProvidesDescription_var (const ::IR::ProvidesDescription_var &p) // copy constructor
+{
+  if (p.ptr_)
+    ACE_NEW (this->ptr_, ::IR::ProvidesDescription (*p.ptr_));
+  else
+    this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::ProvidesDescription_var::~ProvidesDescription_var (void) // destructor
+{
+  delete this->ptr_;
+}
+
+ACE_INLINE IR::ProvidesDescription_var &
+IR::ProvidesDescription_var::operator= (ProvidesDescription *p)
+{
+  delete this->ptr_;
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE ::IR::ProvidesDescription_var &
+IR::ProvidesDescription_var::operator= (const ::IR::ProvidesDescription_var &p)
+{
+  if (this != &p)
+    {
+      if (p.ptr_ == 0)
+        {
+          delete this->ptr_;
+          this->ptr_ = 0;
+        }
+      else
+        {
+          ProvidesDescription *deep_copy =
+            new ProvidesDescription (*p.ptr_);
+          
+          if (deep_copy != 0)
+            {
+              ProvidesDescription *tmp = deep_copy;
+              deep_copy = this->ptr_;
+              this->ptr_ = tmp;
+              delete deep_copy;
+            }
+        }
+    }
+  
+  return *this;
+}
+
+ACE_INLINE const ::IR::ProvidesDescription *
+IR::ProvidesDescription_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ProvidesDescription *
+IR::ProvidesDescription_var::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+IR::ProvidesDescription_var::operator const ::IR::ProvidesDescription &() const // cast
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE
+IR::ProvidesDescription_var::operator ::IR::ProvidesDescription &() // cast 
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE
+IR::ProvidesDescription_var::operator ::IR::ProvidesDescription &() const // cast 
+{
+  return *this->ptr_;
+}
+
+// variable-size types only
+ACE_INLINE
+IR::ProvidesDescription_var::operator ::IR::ProvidesDescription *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE const ::IR::ProvidesDescription &
+IR::ProvidesDescription_var::in (void) const
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE ::IR::ProvidesDescription &
+IR::ProvidesDescription_var::inout (void)
+{
+  return *this->ptr_;
+}
+
+// mapping for variable size 
+ACE_INLINE ::IR::ProvidesDescription *&
+IR::ProvidesDescription_var::out (void)
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ProvidesDescription *
+IR::ProvidesDescription_var::_retn (void)
+{
+  ::IR::ProvidesDescription *tmp = this->ptr_;
+  this->ptr_ = 0;
+  return tmp;
+}
+
+ACE_INLINE ::IR::ProvidesDescription *
+IR::ProvidesDescription_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+// *************************************************************
+// Inline operations for class IR::ProvidesDescription_out
+// *************************************************************
+
+ACE_INLINE
+IR::ProvidesDescription_out::ProvidesDescription_out (::IR::ProvidesDescription *&p)
+  : ptr_ (p)
+{
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::ProvidesDescription_out::ProvidesDescription_out (ProvidesDescription_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::ProvidesDescription_out::ProvidesDescription_out (const ::IR::ProvidesDescription_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (ProvidesDescription_out&, p).ptr_)
+{}
+
+ACE_INLINE IR::ProvidesDescription_out &
+IR::ProvidesDescription_out::operator= (const ::IR::ProvidesDescription_out &p)
+{
+  this->ptr_ = ACE_const_cast (ProvidesDescription_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE IR::ProvidesDescription_out &
+IR::ProvidesDescription_out::operator= (ProvidesDescription *p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+IR::ProvidesDescription_out::operator ::IR::ProvidesDescription *&() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ProvidesDescription *&
+IR::ProvidesDescription_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ProvidesDescription *
+IR::ProvidesDescription_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+// *************************************************************
+// Inline operations for class IR::UsesDescription_var
+// *************************************************************
+
+ACE_INLINE
+IR::UsesDescription_var::UsesDescription_var (void) // default constructor
+  : ptr_ (0)
+{}
+
+ACE_INLINE
+IR::UsesDescription_var::UsesDescription_var (UsesDescription *p)
+  : ptr_ (p)
+{}
+
+ACE_INLINE
+IR::UsesDescription_var::UsesDescription_var (const ::IR::UsesDescription_var &p) // copy constructor
+{
+  if (p.ptr_)
+    ACE_NEW (this->ptr_, ::IR::UsesDescription (*p.ptr_));
+  else
+    this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::UsesDescription_var::~UsesDescription_var (void) // destructor
+{
+  delete this->ptr_;
+}
+
+ACE_INLINE IR::UsesDescription_var &
+IR::UsesDescription_var::operator= (UsesDescription *p)
+{
+  delete this->ptr_;
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE ::IR::UsesDescription_var &
+IR::UsesDescription_var::operator= (const ::IR::UsesDescription_var &p)
+{
+  if (this != &p)
+    {
+      if (p.ptr_ == 0)
+        {
+          delete this->ptr_;
+          this->ptr_ = 0;
+        }
+      else
+        {
+          UsesDescription *deep_copy =
+            new UsesDescription (*p.ptr_);
+          
+          if (deep_copy != 0)
+            {
+              UsesDescription *tmp = deep_copy;
+              deep_copy = this->ptr_;
+              this->ptr_ = tmp;
+              delete deep_copy;
+            }
+        }
+    }
+  
+  return *this;
+}
+
+ACE_INLINE const ::IR::UsesDescription *
+IR::UsesDescription_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::UsesDescription *
+IR::UsesDescription_var::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+IR::UsesDescription_var::operator const ::IR::UsesDescription &() const // cast
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE
+IR::UsesDescription_var::operator ::IR::UsesDescription &() // cast 
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE
+IR::UsesDescription_var::operator ::IR::UsesDescription &() const // cast 
+{
+  return *this->ptr_;
+}
+
+// variable-size types only
+ACE_INLINE
+IR::UsesDescription_var::operator ::IR::UsesDescription *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE const ::IR::UsesDescription &
+IR::UsesDescription_var::in (void) const
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE ::IR::UsesDescription &
+IR::UsesDescription_var::inout (void)
+{
+  return *this->ptr_;
+}
+
+// mapping for variable size 
+ACE_INLINE ::IR::UsesDescription *&
+IR::UsesDescription_var::out (void)
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::UsesDescription *
+IR::UsesDescription_var::_retn (void)
+{
+  ::IR::UsesDescription *tmp = this->ptr_;
+  this->ptr_ = 0;
+  return tmp;
+}
+
+ACE_INLINE ::IR::UsesDescription *
+IR::UsesDescription_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+// *************************************************************
+// Inline operations for class IR::UsesDescription_out
+// *************************************************************
+
+ACE_INLINE
+IR::UsesDescription_out::UsesDescription_out (::IR::UsesDescription *&p)
+  : ptr_ (p)
+{
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::UsesDescription_out::UsesDescription_out (UsesDescription_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::UsesDescription_out::UsesDescription_out (const ::IR::UsesDescription_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (UsesDescription_out&, p).ptr_)
+{}
+
+ACE_INLINE IR::UsesDescription_out &
+IR::UsesDescription_out::operator= (const ::IR::UsesDescription_out &p)
+{
+  this->ptr_ = ACE_const_cast (UsesDescription_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE IR::UsesDescription_out &
+IR::UsesDescription_out::operator= (UsesDescription *p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+IR::UsesDescription_out::operator ::IR::UsesDescription *&() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::UsesDescription *&
+IR::UsesDescription_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::UsesDescription *
+IR::UsesDescription_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_SEQUENCE_IR_PROVIDESDESCSEQ_CI_)
+#define __TAO_UNBOUNDED_SEQUENCE_IR_PROVIDESDESCSEQ_CI_
+
+  // = Static operations.
+  ACE_INLINE IR::ProvidesDescription *
+  IR::_TAO_Unbounded_Sequence_IR_ProvidesDescSeq::allocbuf (CORBA::ULong size)
+  // Allocate storage for the sequence.
+  {
+    IR::ProvidesDescription *retval = 0;
+    ACE_NEW_RETURN (retval, IR::ProvidesDescription[size], 0);
+    return retval;
+  }
+  
+  ACE_INLINE void IR::_TAO_Unbounded_Sequence_IR_ProvidesDescSeq::freebuf (IR::ProvidesDescription *buffer)
+  // Free the sequence.
+  {
+    delete [] buffer;
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Sequence_IR_ProvidesDescSeq::_TAO_Unbounded_Sequence_IR_ProvidesDescSeq (void) // Default constructor.
+  {
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Sequence_IR_ProvidesDescSeq::_TAO_Unbounded_Sequence_IR_ProvidesDescSeq (CORBA::ULong maximum) // Constructor using a maximum length value.
+    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Sequence_IR_ProvidesDescSeq::allocbuf (maximum))
+  {
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Sequence_IR_ProvidesDescSeq::_TAO_Unbounded_Sequence_IR_ProvidesDescSeq (CORBA::ULong maximum,
+    CORBA::ULong length,
+    IR::ProvidesDescription *data,
+    CORBA::Boolean release)
+  : TAO_Unbounded_Base_Sequence (maximum, length, data, release)
+  {
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Sequence_IR_ProvidesDescSeq::_TAO_Unbounded_Sequence_IR_ProvidesDescSeq (const _TAO_Unbounded_Sequence_IR_ProvidesDescSeq &rhs)
+  // Copy constructor.
+    : TAO_Unbounded_Base_Sequence (rhs)
+  {
+    if (rhs.buffer_ != 0)
+    {
+      IR::ProvidesDescription *tmp1 = _TAO_Unbounded_Sequence_IR_ProvidesDescSeq::allocbuf (this->maximum_);
+      IR::ProvidesDescription * const tmp2 = ACE_reinterpret_cast (IR::ProvidesDescription * ACE_CAST_CONST, rhs.buffer_);
+      
+      for (CORBA::ULong i = 0; i < this->length_; ++i)
+        tmp1[i] = tmp2[i];
+      
+      this->buffer_ = tmp1;
+    }
+    else
+    {
+      this->buffer_ = 0;
+    }
+  }
+  
+  ACE_INLINE IR::_TAO_Unbounded_Sequence_IR_ProvidesDescSeq &
+  IR::_TAO_Unbounded_Sequence_IR_ProvidesDescSeq::operator= (const _TAO_Unbounded_Sequence_IR_ProvidesDescSeq &rhs)
+  // Assignment operator.
+  {
+    if (this == &rhs)
+      return *this;
+    
+    if (this->release_)
+    {
+      if (this->maximum_ < rhs.maximum_)
+      {
+        // free the old buffer
+        IR::ProvidesDescription *tmp = ACE_reinterpret_cast (IR::ProvidesDescription *, this->buffer_);
+        _TAO_Unbounded_Sequence_IR_ProvidesDescSeq::freebuf (tmp);
+        this->buffer_ = _TAO_Unbounded_Sequence_IR_ProvidesDescSeq::allocbuf (rhs.maximum_);
+      }
+    }
+    else
+      this->buffer_ = _TAO_Unbounded_Sequence_IR_ProvidesDescSeq::allocbuf (rhs.maximum_);
+    
+    TAO_Unbounded_Base_Sequence::operator= (rhs);
+    
+    IR::ProvidesDescription *tmp1 = ACE_reinterpret_cast (IR::ProvidesDescription *, this->buffer_);
+    IR::ProvidesDescription * const tmp2 = ACE_reinterpret_cast (IR::ProvidesDescription * ACE_CAST_CONST, rhs.buffer_);
+    
+    for (CORBA::ULong i = 0; i < this->length_; ++i)
+      tmp1[i] = tmp2[i];
+    
+    return *this;
+  }
+  
+  // = Accessors.
+  ACE_INLINE IR::ProvidesDescription &
+  IR::_TAO_Unbounded_Sequence_IR_ProvidesDescSeq::operator[] (CORBA::ULong i)
+  // operator []
+  {
+    ACE_ASSERT (i < this->maximum_);
+    IR::ProvidesDescription* tmp = ACE_reinterpret_cast(IR::ProvidesDescription*,this->buffer_);
+    return tmp[i];
+  }
+  
+  ACE_INLINE const IR::ProvidesDescription &
+  IR::_TAO_Unbounded_Sequence_IR_ProvidesDescSeq::operator[] (CORBA::ULong i) const
+  // operator []
+  {
+    ACE_ASSERT (i < this->maximum_);
+    IR::ProvidesDescription * const tmp = ACE_reinterpret_cast (IR::ProvidesDescription* ACE_CAST_CONST, this->buffer_);
+    return tmp[i];
+  }
+  
+  // Implement the TAO_Base_Sequence methods (see Sequence.h)
+  
+  ACE_INLINE IR::ProvidesDescription *
+  IR::_TAO_Unbounded_Sequence_IR_ProvidesDescSeq::get_buffer (CORBA::Boolean orphan)
+  {
+    IR::ProvidesDescription *result = 0;
+    if (orphan == 0)
+    {
+      // We retain ownership.
+      if (this->buffer_ == 0)
+      {
+        result = _TAO_Unbounded_Sequence_IR_ProvidesDescSeq::allocbuf (this->length_);
+        this->buffer_ = result;
+        this->release_ = 1;
+      }
+      else
+      {
+        result = ACE_reinterpret_cast (IR::ProvidesDescription*, this->buffer_);
+      }
+    }
+    else // if (orphan == 1)
+    {
+      if (this->release_ != 0)
+      {
+        // We set the state back to default and relinquish
+        // ownership.
+        result = ACE_reinterpret_cast(IR::ProvidesDescription*,this->buffer_);
+        this->maximum_ = 0;
+        this->length_ = 0;
+        this->buffer_ = 0;
+        this->release_ = 0;
+      }
+    }
+    return result;
+  }
+  
+  ACE_INLINE const IR::ProvidesDescription *
+  IR::_TAO_Unbounded_Sequence_IR_ProvidesDescSeq::get_buffer (void) const
+  {
+    return ACE_reinterpret_cast(const IR::ProvidesDescription * ACE_CAST_CONST, this->buffer_);
+  }
+  
+  ACE_INLINE void
+  IR::_TAO_Unbounded_Sequence_IR_ProvidesDescSeq::replace (CORBA::ULong max,
+  CORBA::ULong length,
+  IR::ProvidesDescription *data,
+  CORBA::Boolean release)
+  {
+    this->maximum_ = max;
+    this->length_ = length;
+    if (this->buffer_ && this->release_ == 1)
+    {
+      IR::ProvidesDescription *tmp = ACE_reinterpret_cast(IR::ProvidesDescription*,this->buffer_);
+      _TAO_Unbounded_Sequence_IR_ProvidesDescSeq::freebuf (tmp);
+    }
+    this->buffer_ = data;
+    this->release_ = release;
+  }
+  
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_IR_PROVIDESDESCSEQ_CI_)
+#define _IR_PROVIDESDESCSEQ_CI_
+
+// *************************************************************
+// Inline operations for class IR::ProvidesDescSeq_var
+// *************************************************************
+
+ACE_INLINE
+IR::ProvidesDescSeq_var::ProvidesDescSeq_var (void) // default constructor
+  : ptr_ (0)
+{}
+
+ACE_INLINE
+IR::ProvidesDescSeq_var::ProvidesDescSeq_var (ProvidesDescSeq *p)
+  : ptr_ (p)
+{}
+
+ACE_INLINE
+IR::ProvidesDescSeq_var::ProvidesDescSeq_var (const ::IR::ProvidesDescSeq_var &p) // copy constructor
+{
+  if (p.ptr_)
+    ACE_NEW (this->ptr_, ::IR::ProvidesDescSeq (*p.ptr_));
+  else
+    this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::ProvidesDescSeq_var::~ProvidesDescSeq_var (void) // destructor
+{
+  delete this->ptr_;
+}
+
+ACE_INLINE IR::ProvidesDescSeq_var &
+IR::ProvidesDescSeq_var::operator= (ProvidesDescSeq *p)
+{
+  delete this->ptr_;
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE ::IR::ProvidesDescSeq_var &
+IR::ProvidesDescSeq_var::operator= (const ::IR::ProvidesDescSeq_var &p)
+{
+  if (this != &p)
+    {
+      if (p.ptr_ == 0)
+        {
+          delete this->ptr_;
+          this->ptr_ = 0;
+        }
+      else
+        {
+          ProvidesDescSeq *deep_copy =
+            new ProvidesDescSeq (*p.ptr_);
+          
+          if (deep_copy != 0)
+            {
+              ProvidesDescSeq *tmp = deep_copy;
+              deep_copy = this->ptr_;
+              this->ptr_ = tmp;
+              delete deep_copy;
+            }
+        }
+    }
+  
+  return *this;
+}
+
+ACE_INLINE const ::IR::ProvidesDescSeq *
+IR::ProvidesDescSeq_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ProvidesDescSeq *
+IR::ProvidesDescSeq_var::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+IR::ProvidesDescSeq_var::operator const ::IR::ProvidesDescSeq &() const // cast
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE 
+IR::ProvidesDescSeq_var::operator ::IR::ProvidesDescSeq &() // cast 
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE 
+IR::ProvidesDescSeq_var::operator ::IR::ProvidesDescSeq &() const // cast 
+{
+  return *this->ptr_;
+}
+
+// variable-size types only
+ACE_INLINE
+IR::ProvidesDescSeq_var::operator ::IR::ProvidesDescSeq *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE IR::ProvidesDescription &
+IR::ProvidesDescSeq_var::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+ACE_INLINE const IR::ProvidesDescription &
+IR::ProvidesDescSeq_var::operator[] (CORBA::ULong index) const
+{
+  return ACE_const_cast (const IR::ProvidesDescription &, this->ptr_->operator[] (index));
+}
+
+ACE_INLINE const ::IR::ProvidesDescSeq &
+IR::ProvidesDescSeq_var::in (void) const
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE ::IR::ProvidesDescSeq &
+IR::ProvidesDescSeq_var::inout (void)
+{
+  return *this->ptr_;
+}
+
+// mapping for variable size 
+ACE_INLINE ::IR::ProvidesDescSeq *&
+IR::ProvidesDescSeq_var::out (void)
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ProvidesDescSeq *
+IR::ProvidesDescSeq_var::_retn (void)
+{
+  ::IR::ProvidesDescSeq *tmp = this->ptr_;
+  this->ptr_ = 0;
+  return tmp;
+}
+
+ACE_INLINE ::IR::ProvidesDescSeq *
+IR::ProvidesDescSeq_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+// *************************************************************
+// Inline operations for class IR::ProvidesDescSeq_out
+// *************************************************************
+
+ACE_INLINE
+IR::ProvidesDescSeq_out::ProvidesDescSeq_out (ProvidesDescSeq *&p)
+  : ptr_ (p)
+{
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::ProvidesDescSeq_out::ProvidesDescSeq_out (ProvidesDescSeq_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::ProvidesDescSeq_out::ProvidesDescSeq_out (const ::IR::ProvidesDescSeq_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (ProvidesDescSeq_out&, p).ptr_)
+{}
+
+ACE_INLINE ::IR::ProvidesDescSeq_out &
+IR::ProvidesDescSeq_out::operator= (const ::IR::ProvidesDescSeq_out &p)
+{
+  this->ptr_ = ACE_const_cast (ProvidesDescSeq_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE ::IR::ProvidesDescSeq_out &
+IR::ProvidesDescSeq_out::operator= (ProvidesDescSeq *p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+IR::ProvidesDescSeq_out::operator ::IR::ProvidesDescSeq *&() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ProvidesDescSeq *&
+IR::ProvidesDescSeq_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ProvidesDescSeq *
+IR::ProvidesDescSeq_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE IR::ProvidesDescription &
+IR::ProvidesDescSeq_out::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_SEQUENCE_IR_USESDESCSEQ_CI_)
+#define __TAO_UNBOUNDED_SEQUENCE_IR_USESDESCSEQ_CI_
+
+  // = Static operations.
+  ACE_INLINE IR::UsesDescription *
+  IR::_TAO_Unbounded_Sequence_IR_UsesDescSeq::allocbuf (CORBA::ULong size)
+  // Allocate storage for the sequence.
+  {
+    IR::UsesDescription *retval = 0;
+    ACE_NEW_RETURN (retval, IR::UsesDescription[size], 0);
+    return retval;
+  }
+  
+  ACE_INLINE void IR::_TAO_Unbounded_Sequence_IR_UsesDescSeq::freebuf (IR::UsesDescription *buffer)
+  // Free the sequence.
+  {
+    delete [] buffer;
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Sequence_IR_UsesDescSeq::_TAO_Unbounded_Sequence_IR_UsesDescSeq (void) // Default constructor.
+  {
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Sequence_IR_UsesDescSeq::_TAO_Unbounded_Sequence_IR_UsesDescSeq (CORBA::ULong maximum) // Constructor using a maximum length value.
+    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Sequence_IR_UsesDescSeq::allocbuf (maximum))
+  {
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Sequence_IR_UsesDescSeq::_TAO_Unbounded_Sequence_IR_UsesDescSeq (CORBA::ULong maximum,
+    CORBA::ULong length,
+    IR::UsesDescription *data,
+    CORBA::Boolean release)
+  : TAO_Unbounded_Base_Sequence (maximum, length, data, release)
+  {
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Sequence_IR_UsesDescSeq::_TAO_Unbounded_Sequence_IR_UsesDescSeq (const _TAO_Unbounded_Sequence_IR_UsesDescSeq &rhs)
+  // Copy constructor.
+    : TAO_Unbounded_Base_Sequence (rhs)
+  {
+    if (rhs.buffer_ != 0)
+    {
+      IR::UsesDescription *tmp1 = _TAO_Unbounded_Sequence_IR_UsesDescSeq::allocbuf (this->maximum_);
+      IR::UsesDescription * const tmp2 = ACE_reinterpret_cast (IR::UsesDescription * ACE_CAST_CONST, rhs.buffer_);
+      
+      for (CORBA::ULong i = 0; i < this->length_; ++i)
+        tmp1[i] = tmp2[i];
+      
+      this->buffer_ = tmp1;
+    }
+    else
+    {
+      this->buffer_ = 0;
+    }
+  }
+  
+  ACE_INLINE IR::_TAO_Unbounded_Sequence_IR_UsesDescSeq &
+  IR::_TAO_Unbounded_Sequence_IR_UsesDescSeq::operator= (const _TAO_Unbounded_Sequence_IR_UsesDescSeq &rhs)
+  // Assignment operator.
+  {
+    if (this == &rhs)
+      return *this;
+    
+    if (this->release_)
+    {
+      if (this->maximum_ < rhs.maximum_)
+      {
+        // free the old buffer
+        IR::UsesDescription *tmp = ACE_reinterpret_cast (IR::UsesDescription *, this->buffer_);
+        _TAO_Unbounded_Sequence_IR_UsesDescSeq::freebuf (tmp);
+        this->buffer_ = _TAO_Unbounded_Sequence_IR_UsesDescSeq::allocbuf (rhs.maximum_);
+      }
+    }
+    else
+      this->buffer_ = _TAO_Unbounded_Sequence_IR_UsesDescSeq::allocbuf (rhs.maximum_);
+    
+    TAO_Unbounded_Base_Sequence::operator= (rhs);
+    
+    IR::UsesDescription *tmp1 = ACE_reinterpret_cast (IR::UsesDescription *, this->buffer_);
+    IR::UsesDescription * const tmp2 = ACE_reinterpret_cast (IR::UsesDescription * ACE_CAST_CONST, rhs.buffer_);
+    
+    for (CORBA::ULong i = 0; i < this->length_; ++i)
+      tmp1[i] = tmp2[i];
+    
+    return *this;
+  }
+  
+  // = Accessors.
+  ACE_INLINE IR::UsesDescription &
+  IR::_TAO_Unbounded_Sequence_IR_UsesDescSeq::operator[] (CORBA::ULong i)
+  // operator []
+  {
+    ACE_ASSERT (i < this->maximum_);
+    IR::UsesDescription* tmp = ACE_reinterpret_cast(IR::UsesDescription*,this->buffer_);
+    return tmp[i];
+  }
+  
+  ACE_INLINE const IR::UsesDescription &
+  IR::_TAO_Unbounded_Sequence_IR_UsesDescSeq::operator[] (CORBA::ULong i) const
+  // operator []
+  {
+    ACE_ASSERT (i < this->maximum_);
+    IR::UsesDescription * const tmp = ACE_reinterpret_cast (IR::UsesDescription* ACE_CAST_CONST, this->buffer_);
+    return tmp[i];
+  }
+  
+  // Implement the TAO_Base_Sequence methods (see Sequence.h)
+  
+  ACE_INLINE IR::UsesDescription *
+  IR::_TAO_Unbounded_Sequence_IR_UsesDescSeq::get_buffer (CORBA::Boolean orphan)
+  {
+    IR::UsesDescription *result = 0;
+    if (orphan == 0)
+    {
+      // We retain ownership.
+      if (this->buffer_ == 0)
+      {
+        result = _TAO_Unbounded_Sequence_IR_UsesDescSeq::allocbuf (this->length_);
+        this->buffer_ = result;
+        this->release_ = 1;
+      }
+      else
+      {
+        result = ACE_reinterpret_cast (IR::UsesDescription*, this->buffer_);
+      }
+    }
+    else // if (orphan == 1)
+    {
+      if (this->release_ != 0)
+      {
+        // We set the state back to default and relinquish
+        // ownership.
+        result = ACE_reinterpret_cast(IR::UsesDescription*,this->buffer_);
+        this->maximum_ = 0;
+        this->length_ = 0;
+        this->buffer_ = 0;
+        this->release_ = 0;
+      }
+    }
+    return result;
+  }
+  
+  ACE_INLINE const IR::UsesDescription *
+  IR::_TAO_Unbounded_Sequence_IR_UsesDescSeq::get_buffer (void) const
+  {
+    return ACE_reinterpret_cast(const IR::UsesDescription * ACE_CAST_CONST, this->buffer_);
+  }
+  
+  ACE_INLINE void
+  IR::_TAO_Unbounded_Sequence_IR_UsesDescSeq::replace (CORBA::ULong max,
+  CORBA::ULong length,
+  IR::UsesDescription *data,
+  CORBA::Boolean release)
+  {
+    this->maximum_ = max;
+    this->length_ = length;
+    if (this->buffer_ && this->release_ == 1)
+    {
+      IR::UsesDescription *tmp = ACE_reinterpret_cast(IR::UsesDescription*,this->buffer_);
+      _TAO_Unbounded_Sequence_IR_UsesDescSeq::freebuf (tmp);
+    }
+    this->buffer_ = data;
+    this->release_ = release;
+  }
+  
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_IR_USESDESCSEQ_CI_)
+#define _IR_USESDESCSEQ_CI_
+
+// *************************************************************
+// Inline operations for class IR::UsesDescSeq_var
+// *************************************************************
+
+ACE_INLINE
+IR::UsesDescSeq_var::UsesDescSeq_var (void) // default constructor
+  : ptr_ (0)
+{}
+
+ACE_INLINE
+IR::UsesDescSeq_var::UsesDescSeq_var (UsesDescSeq *p)
+  : ptr_ (p)
+{}
+
+ACE_INLINE
+IR::UsesDescSeq_var::UsesDescSeq_var (const ::IR::UsesDescSeq_var &p) // copy constructor
+{
+  if (p.ptr_)
+    ACE_NEW (this->ptr_, ::IR::UsesDescSeq (*p.ptr_));
+  else
+    this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::UsesDescSeq_var::~UsesDescSeq_var (void) // destructor
+{
+  delete this->ptr_;
+}
+
+ACE_INLINE IR::UsesDescSeq_var &
+IR::UsesDescSeq_var::operator= (UsesDescSeq *p)
+{
+  delete this->ptr_;
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE ::IR::UsesDescSeq_var &
+IR::UsesDescSeq_var::operator= (const ::IR::UsesDescSeq_var &p)
+{
+  if (this != &p)
+    {
+      if (p.ptr_ == 0)
+        {
+          delete this->ptr_;
+          this->ptr_ = 0;
+        }
+      else
+        {
+          UsesDescSeq *deep_copy =
+            new UsesDescSeq (*p.ptr_);
+          
+          if (deep_copy != 0)
+            {
+              UsesDescSeq *tmp = deep_copy;
+              deep_copy = this->ptr_;
+              this->ptr_ = tmp;
+              delete deep_copy;
+            }
+        }
+    }
+  
+  return *this;
+}
+
+ACE_INLINE const ::IR::UsesDescSeq *
+IR::UsesDescSeq_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::UsesDescSeq *
+IR::UsesDescSeq_var::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+IR::UsesDescSeq_var::operator const ::IR::UsesDescSeq &() const // cast
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE 
+IR::UsesDescSeq_var::operator ::IR::UsesDescSeq &() // cast 
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE 
+IR::UsesDescSeq_var::operator ::IR::UsesDescSeq &() const // cast 
+{
+  return *this->ptr_;
+}
+
+// variable-size types only
+ACE_INLINE
+IR::UsesDescSeq_var::operator ::IR::UsesDescSeq *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE IR::UsesDescription &
+IR::UsesDescSeq_var::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+ACE_INLINE const IR::UsesDescription &
+IR::UsesDescSeq_var::operator[] (CORBA::ULong index) const
+{
+  return ACE_const_cast (const IR::UsesDescription &, this->ptr_->operator[] (index));
+}
+
+ACE_INLINE const ::IR::UsesDescSeq &
+IR::UsesDescSeq_var::in (void) const
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE ::IR::UsesDescSeq &
+IR::UsesDescSeq_var::inout (void)
+{
+  return *this->ptr_;
+}
+
+// mapping for variable size 
+ACE_INLINE ::IR::UsesDescSeq *&
+IR::UsesDescSeq_var::out (void)
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::UsesDescSeq *
+IR::UsesDescSeq_var::_retn (void)
+{
+  ::IR::UsesDescSeq *tmp = this->ptr_;
+  this->ptr_ = 0;
+  return tmp;
+}
+
+ACE_INLINE ::IR::UsesDescSeq *
+IR::UsesDescSeq_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+// *************************************************************
+// Inline operations for class IR::UsesDescSeq_out
+// *************************************************************
+
+ACE_INLINE
+IR::UsesDescSeq_out::UsesDescSeq_out (UsesDescSeq *&p)
+  : ptr_ (p)
+{
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::UsesDescSeq_out::UsesDescSeq_out (UsesDescSeq_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::UsesDescSeq_out::UsesDescSeq_out (const ::IR::UsesDescSeq_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (UsesDescSeq_out&, p).ptr_)
+{}
+
+ACE_INLINE ::IR::UsesDescSeq_out &
+IR::UsesDescSeq_out::operator= (const ::IR::UsesDescSeq_out &p)
+{
+  this->ptr_ = ACE_const_cast (UsesDescSeq_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE ::IR::UsesDescSeq_out &
+IR::UsesDescSeq_out::operator= (UsesDescSeq *p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+IR::UsesDescSeq_out::operator ::IR::UsesDescSeq *&() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::UsesDescSeq *&
+IR::UsesDescSeq_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::UsesDescSeq *
+IR::UsesDescSeq_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE IR::UsesDescription &
+IR::UsesDescSeq_out::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+
+#endif /* end #if !defined */
+
+// *************************************************************
+// Inline operations for class IR::EventDescription_var
+// *************************************************************
+
+ACE_INLINE
+IR::EventDescription_var::EventDescription_var (void) // default constructor
+  : ptr_ (0)
+{}
+
+ACE_INLINE
+IR::EventDescription_var::EventDescription_var (EventDescription *p)
+  : ptr_ (p)
+{}
+
+ACE_INLINE
+IR::EventDescription_var::EventDescription_var (const ::IR::EventDescription_var &p) // copy constructor
+{
+  if (p.ptr_)
+    ACE_NEW (this->ptr_, ::IR::EventDescription (*p.ptr_));
+  else
+    this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::EventDescription_var::~EventDescription_var (void) // destructor
+{
+  delete this->ptr_;
+}
+
+ACE_INLINE IR::EventDescription_var &
+IR::EventDescription_var::operator= (EventDescription *p)
+{
+  delete this->ptr_;
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE ::IR::EventDescription_var &
+IR::EventDescription_var::operator= (const ::IR::EventDescription_var &p)
+{
+  if (this != &p)
+    {
+      if (p.ptr_ == 0)
+        {
+          delete this->ptr_;
+          this->ptr_ = 0;
+        }
+      else
+        {
+          EventDescription *deep_copy =
+            new EventDescription (*p.ptr_);
+          
+          if (deep_copy != 0)
+            {
+              EventDescription *tmp = deep_copy;
+              deep_copy = this->ptr_;
+              this->ptr_ = tmp;
+              delete deep_copy;
+            }
+        }
+    }
+  
+  return *this;
+}
+
+ACE_INLINE const ::IR::EventDescription *
+IR::EventDescription_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::EventDescription *
+IR::EventDescription_var::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+IR::EventDescription_var::operator const ::IR::EventDescription &() const // cast
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE
+IR::EventDescription_var::operator ::IR::EventDescription &() // cast 
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE
+IR::EventDescription_var::operator ::IR::EventDescription &() const // cast 
+{
+  return *this->ptr_;
+}
+
+// variable-size types only
+ACE_INLINE
+IR::EventDescription_var::operator ::IR::EventDescription *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE const ::IR::EventDescription &
+IR::EventDescription_var::in (void) const
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE ::IR::EventDescription &
+IR::EventDescription_var::inout (void)
+{
+  return *this->ptr_;
+}
+
+// mapping for variable size 
+ACE_INLINE ::IR::EventDescription *&
+IR::EventDescription_var::out (void)
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::EventDescription *
+IR::EventDescription_var::_retn (void)
+{
+  ::IR::EventDescription *tmp = this->ptr_;
+  this->ptr_ = 0;
+  return tmp;
+}
+
+ACE_INLINE ::IR::EventDescription *
+IR::EventDescription_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+// *************************************************************
+// Inline operations for class IR::EventDescription_out
+// *************************************************************
+
+ACE_INLINE
+IR::EventDescription_out::EventDescription_out (::IR::EventDescription *&p)
+  : ptr_ (p)
+{
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::EventDescription_out::EventDescription_out (EventDescription_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::EventDescription_out::EventDescription_out (const ::IR::EventDescription_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (EventDescription_out&, p).ptr_)
+{}
+
+ACE_INLINE IR::EventDescription_out &
+IR::EventDescription_out::operator= (const ::IR::EventDescription_out &p)
+{
+  this->ptr_ = ACE_const_cast (EventDescription_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE IR::EventDescription_out &
+IR::EventDescription_out::operator= (EventDescription *p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+IR::EventDescription_out::operator ::IR::EventDescription *&() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::EventDescription *&
+IR::EventDescription_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::EventDescription *
+IR::EventDescription_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+// *************************************************************
+// Inline operations for class IR::ComponentDescription_var
+// *************************************************************
+
+ACE_INLINE
+IR::ComponentDescription_var::ComponentDescription_var (void) // default constructor
+  : ptr_ (0)
+{}
+
+ACE_INLINE
+IR::ComponentDescription_var::ComponentDescription_var (ComponentDescription *p)
+  : ptr_ (p)
+{}
+
+ACE_INLINE
+IR::ComponentDescription_var::ComponentDescription_var (const ::IR::ComponentDescription_var &p) // copy constructor
+{
+  if (p.ptr_)
+    ACE_NEW (this->ptr_, ::IR::ComponentDescription (*p.ptr_));
+  else
+    this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::ComponentDescription_var::~ComponentDescription_var (void) // destructor
+{
+  delete this->ptr_;
+}
+
+ACE_INLINE IR::ComponentDescription_var &
+IR::ComponentDescription_var::operator= (ComponentDescription *p)
+{
+  delete this->ptr_;
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE ::IR::ComponentDescription_var &
+IR::ComponentDescription_var::operator= (const ::IR::ComponentDescription_var &p)
+{
+  if (this != &p)
+    {
+      if (p.ptr_ == 0)
+        {
+          delete this->ptr_;
+          this->ptr_ = 0;
+        }
+      else
+        {
+          ComponentDescription *deep_copy =
+            new ComponentDescription (*p.ptr_);
+          
+          if (deep_copy != 0)
+            {
+              ComponentDescription *tmp = deep_copy;
+              deep_copy = this->ptr_;
+              this->ptr_ = tmp;
+              delete deep_copy;
+            }
+        }
+    }
+  
+  return *this;
+}
+
+ACE_INLINE const ::IR::ComponentDescription *
+IR::ComponentDescription_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ComponentDescription *
+IR::ComponentDescription_var::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+IR::ComponentDescription_var::operator const ::IR::ComponentDescription &() const // cast
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE
+IR::ComponentDescription_var::operator ::IR::ComponentDescription &() // cast 
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE
+IR::ComponentDescription_var::operator ::IR::ComponentDescription &() const // cast 
+{
+  return *this->ptr_;
+}
+
+// variable-size types only
+ACE_INLINE
+IR::ComponentDescription_var::operator ::IR::ComponentDescription *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE const ::IR::ComponentDescription &
+IR::ComponentDescription_var::in (void) const
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE ::IR::ComponentDescription &
+IR::ComponentDescription_var::inout (void)
+{
+  return *this->ptr_;
+}
+
+// mapping for variable size 
+ACE_INLINE ::IR::ComponentDescription *&
+IR::ComponentDescription_var::out (void)
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ComponentDescription *
+IR::ComponentDescription_var::_retn (void)
+{
+  ::IR::ComponentDescription *tmp = this->ptr_;
+  this->ptr_ = 0;
+  return tmp;
+}
+
+ACE_INLINE ::IR::ComponentDescription *
+IR::ComponentDescription_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+// *************************************************************
+// Inline operations for class IR::ComponentDescription_out
+// *************************************************************
+
+ACE_INLINE
+IR::ComponentDescription_out::ComponentDescription_out (::IR::ComponentDescription *&p)
+  : ptr_ (p)
+{
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::ComponentDescription_out::ComponentDescription_out (ComponentDescription_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::ComponentDescription_out::ComponentDescription_out (const ::IR::ComponentDescription_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (ComponentDescription_out&, p).ptr_)
+{}
+
+ACE_INLINE IR::ComponentDescription_out &
+IR::ComponentDescription_out::operator= (const ::IR::ComponentDescription_out &p)
+{
+  this->ptr_ = ACE_const_cast (ComponentDescription_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE IR::ComponentDescription_out &
+IR::ComponentDescription_out::operator= (ComponentDescription *p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+IR::ComponentDescription_out::operator ::IR::ComponentDescription *&() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ComponentDescription *&
+IR::ComponentDescription_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ComponentDescription *
+IR::ComponentDescription_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+// *************************************************************
+// Inline operations for class IR::PrimaryKeyDescription_var
+// *************************************************************
+
+ACE_INLINE
+IR::PrimaryKeyDescription_var::PrimaryKeyDescription_var (void) // default constructor
+  : ptr_ (0)
+{}
+
+ACE_INLINE
+IR::PrimaryKeyDescription_var::PrimaryKeyDescription_var (PrimaryKeyDescription *p)
+  : ptr_ (p)
+{}
+
+ACE_INLINE
+IR::PrimaryKeyDescription_var::PrimaryKeyDescription_var (const ::IR::PrimaryKeyDescription_var &p) // copy constructor
+{
+  if (p.ptr_)
+    ACE_NEW (this->ptr_, ::IR::PrimaryKeyDescription (*p.ptr_));
+  else
+    this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::PrimaryKeyDescription_var::~PrimaryKeyDescription_var (void) // destructor
+{
+  delete this->ptr_;
+}
+
+ACE_INLINE IR::PrimaryKeyDescription_var &
+IR::PrimaryKeyDescription_var::operator= (PrimaryKeyDescription *p)
+{
+  delete this->ptr_;
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE ::IR::PrimaryKeyDescription_var &
+IR::PrimaryKeyDescription_var::operator= (const ::IR::PrimaryKeyDescription_var &p)
+{
+  if (this != &p)
+    {
+      if (p.ptr_ == 0)
+        {
+          delete this->ptr_;
+          this->ptr_ = 0;
+        }
+      else
+        {
+          PrimaryKeyDescription *deep_copy =
+            new PrimaryKeyDescription (*p.ptr_);
+          
+          if (deep_copy != 0)
+            {
+              PrimaryKeyDescription *tmp = deep_copy;
+              deep_copy = this->ptr_;
+              this->ptr_ = tmp;
+              delete deep_copy;
+            }
+        }
+    }
+  
+  return *this;
+}
+
+ACE_INLINE const ::IR::PrimaryKeyDescription *
+IR::PrimaryKeyDescription_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::PrimaryKeyDescription *
+IR::PrimaryKeyDescription_var::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+IR::PrimaryKeyDescription_var::operator const ::IR::PrimaryKeyDescription &() const // cast
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE
+IR::PrimaryKeyDescription_var::operator ::IR::PrimaryKeyDescription &() // cast 
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE
+IR::PrimaryKeyDescription_var::operator ::IR::PrimaryKeyDescription &() const // cast 
+{
+  return *this->ptr_;
+}
+
+// variable-size types only
+ACE_INLINE
+IR::PrimaryKeyDescription_var::operator ::IR::PrimaryKeyDescription *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE const ::IR::PrimaryKeyDescription &
+IR::PrimaryKeyDescription_var::in (void) const
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE ::IR::PrimaryKeyDescription &
+IR::PrimaryKeyDescription_var::inout (void)
+{
+  return *this->ptr_;
+}
+
+// mapping for variable size 
+ACE_INLINE ::IR::PrimaryKeyDescription *&
+IR::PrimaryKeyDescription_var::out (void)
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::PrimaryKeyDescription *
+IR::PrimaryKeyDescription_var::_retn (void)
+{
+  ::IR::PrimaryKeyDescription *tmp = this->ptr_;
+  this->ptr_ = 0;
+  return tmp;
+}
+
+ACE_INLINE ::IR::PrimaryKeyDescription *
+IR::PrimaryKeyDescription_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+// *************************************************************
+// Inline operations for class IR::PrimaryKeyDescription_out
+// *************************************************************
+
+ACE_INLINE
+IR::PrimaryKeyDescription_out::PrimaryKeyDescription_out (::IR::PrimaryKeyDescription *&p)
+  : ptr_ (p)
+{
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::PrimaryKeyDescription_out::PrimaryKeyDescription_out (PrimaryKeyDescription_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::PrimaryKeyDescription_out::PrimaryKeyDescription_out (const ::IR::PrimaryKeyDescription_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (PrimaryKeyDescription_out&, p).ptr_)
+{}
+
+ACE_INLINE IR::PrimaryKeyDescription_out &
+IR::PrimaryKeyDescription_out::operator= (const ::IR::PrimaryKeyDescription_out &p)
+{
+  this->ptr_ = ACE_const_cast (PrimaryKeyDescription_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE IR::PrimaryKeyDescription_out &
+IR::PrimaryKeyDescription_out::operator= (PrimaryKeyDescription *p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+IR::PrimaryKeyDescription_out::operator ::IR::PrimaryKeyDescription *&() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::PrimaryKeyDescription *&
+IR::PrimaryKeyDescription_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::PrimaryKeyDescription *
+IR::PrimaryKeyDescription_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+// *************************************************************
+// Inline operations for class IR::HomeDescription_var
+// *************************************************************
+
+ACE_INLINE
+IR::HomeDescription_var::HomeDescription_var (void) // default constructor
+  : ptr_ (0)
+{}
+
+ACE_INLINE
+IR::HomeDescription_var::HomeDescription_var (HomeDescription *p)
+  : ptr_ (p)
+{}
+
+ACE_INLINE
+IR::HomeDescription_var::HomeDescription_var (const ::IR::HomeDescription_var &p) // copy constructor
+{
+  if (p.ptr_)
+    ACE_NEW (this->ptr_, ::IR::HomeDescription (*p.ptr_));
+  else
+    this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::HomeDescription_var::~HomeDescription_var (void) // destructor
+{
+  delete this->ptr_;
+}
+
+ACE_INLINE IR::HomeDescription_var &
+IR::HomeDescription_var::operator= (HomeDescription *p)
+{
+  delete this->ptr_;
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE ::IR::HomeDescription_var &
+IR::HomeDescription_var::operator= (const ::IR::HomeDescription_var &p)
+{
+  if (this != &p)
+    {
+      if (p.ptr_ == 0)
+        {
+          delete this->ptr_;
+          this->ptr_ = 0;
+        }
+      else
+        {
+          HomeDescription *deep_copy =
+            new HomeDescription (*p.ptr_);
+          
+          if (deep_copy != 0)
+            {
+              HomeDescription *tmp = deep_copy;
+              deep_copy = this->ptr_;
+              this->ptr_ = tmp;
+              delete deep_copy;
+            }
+        }
+    }
+  
+  return *this;
+}
+
+ACE_INLINE const ::IR::HomeDescription *
+IR::HomeDescription_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::HomeDescription *
+IR::HomeDescription_var::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+IR::HomeDescription_var::operator const ::IR::HomeDescription &() const // cast
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE
+IR::HomeDescription_var::operator ::IR::HomeDescription &() // cast 
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE
+IR::HomeDescription_var::operator ::IR::HomeDescription &() const // cast 
+{
+  return *this->ptr_;
+}
+
+// variable-size types only
+ACE_INLINE
+IR::HomeDescription_var::operator ::IR::HomeDescription *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE const ::IR::HomeDescription &
+IR::HomeDescription_var::in (void) const
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE ::IR::HomeDescription &
+IR::HomeDescription_var::inout (void)
+{
+  return *this->ptr_;
+}
+
+// mapping for variable size 
+ACE_INLINE ::IR::HomeDescription *&
+IR::HomeDescription_var::out (void)
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::HomeDescription *
+IR::HomeDescription_var::_retn (void)
+{
+  ::IR::HomeDescription *tmp = this->ptr_;
+  this->ptr_ = 0;
+  return tmp;
+}
+
+ACE_INLINE ::IR::HomeDescription *
+IR::HomeDescription_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+// *************************************************************
+// Inline operations for class IR::HomeDescription_out
+// *************************************************************
+
+ACE_INLINE
+IR::HomeDescription_out::HomeDescription_out (::IR::HomeDescription *&p)
+  : ptr_ (p)
+{
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::HomeDescription_out::HomeDescription_out (HomeDescription_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::HomeDescription_out::HomeDescription_out (const ::IR::HomeDescription_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (HomeDescription_out&, p).ptr_)
+{}
+
+ACE_INLINE IR::HomeDescription_out &
+IR::HomeDescription_out::operator= (const ::IR::HomeDescription_out &p)
+{
+  this->ptr_ = ACE_const_cast (HomeDescription_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE IR::HomeDescription_out &
+IR::HomeDescription_out::operator= (HomeDescription *p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+IR::HomeDescription_out::operator ::IR::HomeDescription *&() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::HomeDescription *&
+IR::HomeDescription_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::HomeDescription *
+IR::HomeDescription_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const IR::DefinitionKind &_tao_enumval)
+{
+  CORBA::ULong _tao_temp = _tao_enumval;
+  return strm << _tao_temp;
+}
+
+ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, IR::DefinitionKind &_tao_enumval)
+{
+  CORBA::ULong _tao_temp = 0;
+  CORBA::Boolean _tao_result = strm >> _tao_temp;
+  
+  if (_tao_result == 1)
+    {
+      _tao_enumval = ACE_static_cast (IR::DefinitionKind, _tao_temp);
+    }
+  
+  return _tao_result;
+}
+
+
+#if !defined _TAO_CDR_OP_IR_RepositoryIdSeq_I_
+#define _TAO_CDR_OP_IR_RepositoryIdSeq_I_
+
+CORBA::Boolean TAO_IFR_Client_Export operator<< (
+    TAO_OutputCDR &,
+    const IR::RepositoryIdSeq &
+  );
+CORBA::Boolean TAO_IFR_Client_Export operator>> (
+    TAO_InputCDR &,
+    IR::RepositoryIdSeq &
+  );
+
+#endif /* _TAO_CDR_OP_IR_RepositoryIdSeq_I_ */
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &,
+    const IR::ComponentDef_ptr
+  );
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &,
+    IR::ComponentDef_ptr &
+  );
+
+#if !defined _TAO_CDR_OP_IR_ComponentDefSeq_I_
+#define _TAO_CDR_OP_IR_ComponentDefSeq_I_
+
+CORBA::Boolean TAO_IFR_Client_Export operator<< (
+    TAO_OutputCDR &,
+    const IR::ComponentDefSeq &
+  );
+CORBA::Boolean TAO_IFR_Client_Export operator>> (
+    TAO_InputCDR &,
+    IR::ComponentDefSeq &
+  );
+
+#endif /* _TAO_CDR_OP_IR_ComponentDefSeq_I_ */
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &,
+    const IR::ProvidesDef_ptr
+  );
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &,
+    IR::ProvidesDef_ptr &
+  );
+
+#if !defined _TAO_CDR_OP_IR_ProvidesDefSeq_I_
+#define _TAO_CDR_OP_IR_ProvidesDefSeq_I_
+
+CORBA::Boolean TAO_IFR_Client_Export operator<< (
+    TAO_OutputCDR &,
+    const IR::ProvidesDefSeq &
+  );
+CORBA::Boolean TAO_IFR_Client_Export operator>> (
+    TAO_InputCDR &,
+    IR::ProvidesDefSeq &
+  );
+
+#endif /* _TAO_CDR_OP_IR_ProvidesDefSeq_I_ */
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &,
+    const IR::UsesDef_ptr
+  );
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &,
+    IR::UsesDef_ptr &
+  );
+
+#if !defined _TAO_CDR_OP_IR_UsesDefSeq_I_
+#define _TAO_CDR_OP_IR_UsesDefSeq_I_
+
+CORBA::Boolean TAO_IFR_Client_Export operator<< (
+    TAO_OutputCDR &,
+    const IR::UsesDefSeq &
+  );
+CORBA::Boolean TAO_IFR_Client_Export operator>> (
+    TAO_InputCDR &,
+    IR::UsesDefSeq &
+  );
+
+#endif /* _TAO_CDR_OP_IR_UsesDefSeq_I_ */
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &,
+    const IR::HomeDef_ptr
+  );
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &,
+    IR::HomeDef_ptr &
+  );
+
+#if !defined _TAO_CDR_OP_IR_HomeDefSeq_I_
+#define _TAO_CDR_OP_IR_HomeDefSeq_I_
+
+CORBA::Boolean TAO_IFR_Client_Export operator<< (
+    TAO_OutputCDR &,
+    const IR::HomeDefSeq &
+  );
+CORBA::Boolean TAO_IFR_Client_Export operator>> (
+    TAO_InputCDR &,
+    IR::HomeDefSeq &
+  );
+
+#endif /* _TAO_CDR_OP_IR_HomeDefSeq_I_ */
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &,
+    const IR::EventDef_ptr
+  );
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &,
+    IR::EventDef_ptr &
+  );
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &,
+    const IR::EmitsDef_ptr
+  );
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &,
+    IR::EmitsDef_ptr &
+  );
+
+#if !defined _TAO_CDR_OP_IR_EmitsDefSeq_I_
+#define _TAO_CDR_OP_IR_EmitsDefSeq_I_
+
+CORBA::Boolean TAO_IFR_Client_Export operator<< (
+    TAO_OutputCDR &,
+    const IR::EmitsDefSeq &
+  );
+CORBA::Boolean TAO_IFR_Client_Export operator>> (
+    TAO_InputCDR &,
+    IR::EmitsDefSeq &
+  );
+
+#endif /* _TAO_CDR_OP_IR_EmitsDefSeq_I_ */
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &,
+    const IR::PublishesDef_ptr
+  );
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &,
+    IR::PublishesDef_ptr &
+  );
+
+#if !defined _TAO_CDR_OP_IR_PublishesDefSeq_I_
+#define _TAO_CDR_OP_IR_PublishesDefSeq_I_
+
+CORBA::Boolean TAO_IFR_Client_Export operator<< (
+    TAO_OutputCDR &,
+    const IR::PublishesDefSeq &
+  );
+CORBA::Boolean TAO_IFR_Client_Export operator>> (
+    TAO_InputCDR &,
+    IR::PublishesDefSeq &
+  );
+
+#endif /* _TAO_CDR_OP_IR_PublishesDefSeq_I_ */
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &,
+    const IR::ConsumesDef_ptr
+  );
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &,
+    IR::ConsumesDef_ptr &
+  );
+
+#if !defined _TAO_CDR_OP_IR_ConsumesDefSeq_I_
+#define _TAO_CDR_OP_IR_ConsumesDefSeq_I_
+
+CORBA::Boolean TAO_IFR_Client_Export operator<< (
+    TAO_OutputCDR &,
+    const IR::ConsumesDefSeq &
+  );
+CORBA::Boolean TAO_IFR_Client_Export operator>> (
+    TAO_InputCDR &,
+    IR::ConsumesDefSeq &
+  );
+
+#endif /* _TAO_CDR_OP_IR_ConsumesDefSeq_I_ */
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &,
+    const IR::FactoryDef_ptr
+  );
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &,
+    IR::FactoryDef_ptr &
+  );
+
+#if !defined _TAO_CDR_OP_IR_FactoryDefSeq_I_
+#define _TAO_CDR_OP_IR_FactoryDefSeq_I_
+
+CORBA::Boolean TAO_IFR_Client_Export operator<< (
+    TAO_OutputCDR &,
+    const IR::FactoryDefSeq &
+  );
+CORBA::Boolean TAO_IFR_Client_Export operator>> (
+    TAO_InputCDR &,
+    IR::FactoryDefSeq &
+  );
+
+#endif /* _TAO_CDR_OP_IR_FactoryDefSeq_I_ */
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &,
+    const IR::FinderDef_ptr
+  );
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &,
+    IR::FinderDef_ptr &
+  );
+
+#if !defined _TAO_CDR_OP_IR_FinderDefSeq_I_
+#define _TAO_CDR_OP_IR_FinderDefSeq_I_
+
+CORBA::Boolean TAO_IFR_Client_Export operator<< (
+    TAO_OutputCDR &,
+    const IR::FinderDefSeq &
+  );
+CORBA::Boolean TAO_IFR_Client_Export operator>> (
+    TAO_InputCDR &,
+    IR::FinderDefSeq &
+  );
+
+#endif /* _TAO_CDR_OP_IR_FinderDefSeq_I_ */
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &,
+    const IR::PrimaryKeyDef_ptr
+  );
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &,
+    IR::PrimaryKeyDef_ptr &
+  );
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &,
+    const IR::ComponentRepository_ptr
+  );
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &,
+    IR::ComponentRepository_ptr &
+  );
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &strm,
+    const IR::ComponentRepository_ptr _tao_objref
+  )
+{
+  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
+  return (strm << _tao_corba_obj);
+}
+
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &strm,
+    IR::ComponentRepository_ptr &_tao_objref
+  )
+{
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::Object_var obj;
+    if ((strm >> obj.inout ()) == 0)
+      return 0;
+    // narrow to the right type
+    _tao_objref =
+      IR::ComponentRepository::_unchecked_narrow (
+          obj.in (),
+          ACE_TRY_ENV
+        );
+    ACE_TRY_CHECK;
+    return 1;
+  }
+  ACE_CATCHANY
+  {
+    // do nothing
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &,
+    const IR::ProvidesDef_ptr
+  );
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &,
+    IR::ProvidesDef_ptr &
+  );
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &strm,
+    const IR::ProvidesDef_ptr _tao_objref
+  )
+{
+  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
+  return (strm << _tao_corba_obj);
+}
+
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &strm,
+    IR::ProvidesDef_ptr &_tao_objref
+  )
+{
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::Object_var obj;
+    if ((strm >> obj.inout ()) == 0)
+      return 0;
+    // narrow to the right type
+    _tao_objref =
+      IR::ProvidesDef::_unchecked_narrow (
+          obj.in (),
+          ACE_TRY_ENV
+        );
+    ACE_TRY_CHECK;
+    return 1;
+  }
+  ACE_CATCHANY
+  {
+    // do nothing
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const IR::ProvidesDescription &_tao_aggregate)
+{
+  if (
+    (strm << _tao_aggregate.name.in ()) &&
+    (strm << _tao_aggregate.id.in ()) &&
+    (strm << _tao_aggregate.defined_in.in ()) &&
+    (strm << _tao_aggregate.version.in ()) &&
+    (strm << _tao_aggregate.interface_type.in ())
+  )
+    return 1;
+  else
+    return 0;
+  
+}
+
+ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, IR::ProvidesDescription &_tao_aggregate)
+{
+  if (
+    (strm >> _tao_aggregate.name.out ()) &&
+    (strm >> _tao_aggregate.id.out ()) &&
+    (strm >> _tao_aggregate.defined_in.out ()) &&
+    (strm >> _tao_aggregate.version.out ()) &&
+    (strm >> _tao_aggregate.interface_type.out ())
+  )
+    return 1;
+  else
+    return 0;
+  
+}
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &,
+    const IR::UsesDef_ptr
+  );
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &,
+    IR::UsesDef_ptr &
+  );
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &strm,
+    const IR::UsesDef_ptr _tao_objref
+  )
+{
+  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
+  return (strm << _tao_corba_obj);
+}
+
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &strm,
+    IR::UsesDef_ptr &_tao_objref
+  )
+{
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::Object_var obj;
+    if ((strm >> obj.inout ()) == 0)
+      return 0;
+    // narrow to the right type
+    _tao_objref =
+      IR::UsesDef::_unchecked_narrow (
+          obj.in (),
+          ACE_TRY_ENV
+        );
+    ACE_TRY_CHECK;
+    return 1;
+  }
+  ACE_CATCHANY
+  {
+    // do nothing
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const IR::UsesDescription &_tao_aggregate)
+{
+  if (
+    (strm << _tao_aggregate.name.in ()) &&
+    (strm << _tao_aggregate.id.in ()) &&
+    (strm << _tao_aggregate.defined_in.in ()) &&
+    (strm << _tao_aggregate.version.in ()) &&
+    (strm << _tao_aggregate.interface_type.in ()) &&
+    (strm << CORBA::Any::from_boolean (_tao_aggregate.is_multiple))
+  )
+    return 1;
+  else
+    return 0;
+  
+}
+
+ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, IR::UsesDescription &_tao_aggregate)
+{
+  if (
+    (strm >> _tao_aggregate.name.out ()) &&
+    (strm >> _tao_aggregate.id.out ()) &&
+    (strm >> _tao_aggregate.defined_in.out ()) &&
+    (strm >> _tao_aggregate.version.out ()) &&
+    (strm >> _tao_aggregate.interface_type.out ()) &&
+    (strm >> CORBA::Any::to_boolean (_tao_aggregate.is_multiple))
+  )
+    return 1;
+  else
+    return 0;
+  
+}
+
+
+#if !defined _TAO_CDR_OP_IR_ProvidesDescSeq_I_
+#define _TAO_CDR_OP_IR_ProvidesDescSeq_I_
+
+CORBA::Boolean TAO_IFR_Client_Export operator<< (
+    TAO_OutputCDR &,
+    const IR::ProvidesDescSeq &
+  );
+CORBA::Boolean TAO_IFR_Client_Export operator>> (
+    TAO_InputCDR &,
+    IR::ProvidesDescSeq &
+  );
+
+#endif /* _TAO_CDR_OP_IR_ProvidesDescSeq_I_ */
+
+
+#if !defined _TAO_CDR_OP_IR_UsesDescSeq_I_
+#define _TAO_CDR_OP_IR_UsesDescSeq_I_
+
+CORBA::Boolean TAO_IFR_Client_Export operator<< (
+    TAO_OutputCDR &,
+    const IR::UsesDescSeq &
+  );
+CORBA::Boolean TAO_IFR_Client_Export operator>> (
+    TAO_InputCDR &,
+    IR::UsesDescSeq &
+  );
+
+#endif /* _TAO_CDR_OP_IR_UsesDescSeq_I_ */
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &,
+    const IR::EventDef_ptr
+  );
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &,
+    IR::EventDef_ptr &
+  );
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &strm,
+    const IR::EventDef_ptr _tao_objref
+  )
+{
+  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
+  return (strm << _tao_corba_obj);
+}
+
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &strm,
+    IR::EventDef_ptr &_tao_objref
+  )
+{
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::Object_var obj;
+    if ((strm >> obj.inout ()) == 0)
+      return 0;
+    // narrow to the right type
+    _tao_objref =
+      IR::EventDef::_unchecked_narrow (
+          obj.in (),
+          ACE_TRY_ENV
+        );
+    ACE_TRY_CHECK;
+    return 1;
+  }
+  ACE_CATCHANY
+  {
+    // do nothing
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const IR::EventDescription &_tao_aggregate)
+{
+  if (
+    (strm << _tao_aggregate.name.in ()) &&
+    (strm << _tao_aggregate.id.in ()) &&
+    (strm << _tao_aggregate.defined_in.in ()) &&
+    (strm << _tao_aggregate.version.in ()) &&
+    (strm << _tao_aggregate.value.in ())
+  )
+    return 1;
+  else
+    return 0;
+  
+}
+
+ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, IR::EventDescription &_tao_aggregate)
+{
+  if (
+    (strm >> _tao_aggregate.name.out ()) &&
+    (strm >> _tao_aggregate.id.out ()) &&
+    (strm >> _tao_aggregate.defined_in.out ()) &&
+    (strm >> _tao_aggregate.version.out ()) &&
+    (strm >> _tao_aggregate.value.out ())
+  )
+    return 1;
+  else
+    return 0;
+  
+}
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &,
+    const IR::EmitsDef_ptr
+  );
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &,
+    IR::EmitsDef_ptr &
+  );
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &strm,
+    const IR::EmitsDef_ptr _tao_objref
+  )
+{
+  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
+  return (strm << _tao_corba_obj);
+}
+
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &strm,
+    IR::EmitsDef_ptr &_tao_objref
+  )
+{
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::Object_var obj;
+    if ((strm >> obj.inout ()) == 0)
+      return 0;
+    // narrow to the right type
+    _tao_objref =
+      IR::EmitsDef::_unchecked_narrow (
+          obj.in (),
+          ACE_TRY_ENV
+        );
+    ACE_TRY_CHECK;
+    return 1;
+  }
+  ACE_CATCHANY
+  {
+    // do nothing
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &,
+    const IR::PublishesDef_ptr
+  );
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &,
+    IR::PublishesDef_ptr &
+  );
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &strm,
+    const IR::PublishesDef_ptr _tao_objref
+  )
+{
+  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
+  return (strm << _tao_corba_obj);
+}
+
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &strm,
+    IR::PublishesDef_ptr &_tao_objref
+  )
+{
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::Object_var obj;
+    if ((strm >> obj.inout ()) == 0)
+      return 0;
+    // narrow to the right type
+    _tao_objref =
+      IR::PublishesDef::_unchecked_narrow (
+          obj.in (),
+          ACE_TRY_ENV
+        );
+    ACE_TRY_CHECK;
+    return 1;
+  }
+  ACE_CATCHANY
+  {
+    // do nothing
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &,
+    const IR::ConsumesDef_ptr
+  );
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &,
+    IR::ConsumesDef_ptr &
+  );
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &strm,
+    const IR::ConsumesDef_ptr _tao_objref
+  )
+{
+  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
+  return (strm << _tao_corba_obj);
+}
+
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &strm,
+    IR::ConsumesDef_ptr &_tao_objref
+  )
+{
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::Object_var obj;
+    if ((strm >> obj.inout ()) == 0)
+      return 0;
+    // narrow to the right type
+    _tao_objref =
+      IR::ConsumesDef::_unchecked_narrow (
+          obj.in (),
+          ACE_TRY_ENV
+        );
+    ACE_TRY_CHECK;
+    return 1;
+  }
+  ACE_CATCHANY
+  {
+    // do nothing
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &,
+    const IR::ComponentDef_ptr
+  );
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &,
+    IR::ComponentDef_ptr &
+  );
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &strm,
+    const IR::ComponentDef_ptr _tao_objref
+  )
+{
+  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
+  return (strm << _tao_corba_obj);
+}
+
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &strm,
+    IR::ComponentDef_ptr &_tao_objref
+  )
+{
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::Object_var obj;
+    if ((strm >> obj.inout ()) == 0)
+      return 0;
+    // narrow to the right type
+    _tao_objref =
+      IR::ComponentDef::_unchecked_narrow (
+          obj.in (),
+          ACE_TRY_ENV
+        );
+    ACE_TRY_CHECK;
+    return 1;
+  }
+  ACE_CATCHANY
+  {
+    // do nothing
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const IR::ComponentDescription &_tao_aggregate)
+{
+  if (
+    (strm << _tao_aggregate.name.in ()) &&
+    (strm << _tao_aggregate.id.in ()) &&
+    (strm << _tao_aggregate.defined_in.in ()) &&
+    (strm << _tao_aggregate.version.in ()) &&
+    (strm << _tao_aggregate.base_component.in ()) &&
+    (strm << _tao_aggregate.supports_interfaces) &&
+    (strm << _tao_aggregate.provides_interfaces) &&
+    (strm << _tao_aggregate.uses_interfaces) &&
+    (strm << _tao_aggregate.attributes) &&
+    (strm << _tao_aggregate.emits_events) &&
+    (strm << _tao_aggregate.publishes_events) &&
+    (strm << _tao_aggregate.consumes_events) &&
+    (strm << CORBA::Any::from_boolean (_tao_aggregate.is_basic))
+  )
+    return 1;
+  else
+    return 0;
+  
+}
+
+ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, IR::ComponentDescription &_tao_aggregate)
+{
+  if (
+    (strm >> _tao_aggregate.name.out ()) &&
+    (strm >> _tao_aggregate.id.out ()) &&
+    (strm >> _tao_aggregate.defined_in.out ()) &&
+    (strm >> _tao_aggregate.version.out ()) &&
+    (strm >> _tao_aggregate.base_component.out ()) &&
+    (strm >> _tao_aggregate.supports_interfaces) &&
+    (strm >> _tao_aggregate.provides_interfaces) &&
+    (strm >> _tao_aggregate.uses_interfaces) &&
+    (strm >> _tao_aggregate.attributes) &&
+    (strm >> _tao_aggregate.emits_events) &&
+    (strm >> _tao_aggregate.publishes_events) &&
+    (strm >> _tao_aggregate.consumes_events) &&
+    (strm >> CORBA::Any::to_boolean (_tao_aggregate.is_basic))
+  )
+    return 1;
+  else
+    return 0;
+  
+}
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &,
+    const IR::PrimaryKeyDef_ptr
+  );
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &,
+    IR::PrimaryKeyDef_ptr &
+  );
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &strm,
+    const IR::PrimaryKeyDef_ptr _tao_objref
+  )
+{
+  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
+  return (strm << _tao_corba_obj);
+}
+
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &strm,
+    IR::PrimaryKeyDef_ptr &_tao_objref
+  )
+{
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::Object_var obj;
+    if ((strm >> obj.inout ()) == 0)
+      return 0;
+    // narrow to the right type
+    _tao_objref =
+      IR::PrimaryKeyDef::_unchecked_narrow (
+          obj.in (),
+          ACE_TRY_ENV
+        );
+    ACE_TRY_CHECK;
+    return 1;
+  }
+  ACE_CATCHANY
+  {
+    // do nothing
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const IR::PrimaryKeyDescription &_tao_aggregate)
+{
+  if (
+    (strm << _tao_aggregate.name.in ()) &&
+    (strm << _tao_aggregate.id.in ()) &&
+    (strm << _tao_aggregate.defined_in.in ()) &&
+    (strm << _tao_aggregate.version.in ()) &&
+    (strm << _tao_aggregate.primary_key.in ())
+  )
+    return 1;
+  else
+    return 0;
+  
+}
+
+ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, IR::PrimaryKeyDescription &_tao_aggregate)
+{
+  if (
+    (strm >> _tao_aggregate.name.out ()) &&
+    (strm >> _tao_aggregate.id.out ()) &&
+    (strm >> _tao_aggregate.defined_in.out ()) &&
+    (strm >> _tao_aggregate.version.out ()) &&
+    (strm >> _tao_aggregate.primary_key.out ())
+  )
+    return 1;
+  else
+    return 0;
+  
+}
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &,
+    const IR::FactoryDef_ptr
+  );
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &,
+    IR::FactoryDef_ptr &
+  );
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &strm,
+    const IR::FactoryDef_ptr _tao_objref
+  )
+{
+  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
+  return (strm << _tao_corba_obj);
+}
+
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &strm,
+    IR::FactoryDef_ptr &_tao_objref
+  )
+{
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::Object_var obj;
+    if ((strm >> obj.inout ()) == 0)
+      return 0;
+    // narrow to the right type
+    _tao_objref =
+      IR::FactoryDef::_unchecked_narrow (
+          obj.in (),
+          ACE_TRY_ENV
+        );
+    ACE_TRY_CHECK;
+    return 1;
+  }
+  ACE_CATCHANY
+  {
+    // do nothing
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &,
+    const IR::FinderDef_ptr
+  );
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &,
+    IR::FinderDef_ptr &
+  );
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &strm,
+    const IR::FinderDef_ptr _tao_objref
+  )
+{
+  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
+  return (strm << _tao_corba_obj);
+}
+
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &strm,
+    IR::FinderDef_ptr &_tao_objref
+  )
+{
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::Object_var obj;
+    if ((strm >> obj.inout ()) == 0)
+      return 0;
+    // narrow to the right type
+    _tao_objref =
+      IR::FinderDef::_unchecked_narrow (
+          obj.in (),
+          ACE_TRY_ENV
+        );
+    ACE_TRY_CHECK;
+    return 1;
+  }
+  ACE_CATCHANY
+  {
+    // do nothing
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &,
+    const IR::HomeDef_ptr
+  );
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &,
+    IR::HomeDef_ptr &
+  );
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &strm,
+    const IR::HomeDef_ptr _tao_objref
+  )
+{
+  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
+  return (strm << _tao_corba_obj);
+}
+
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &strm,
+    IR::HomeDef_ptr &_tao_objref
+  )
+{
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::Object_var obj;
+    if ((strm >> obj.inout ()) == 0)
+      return 0;
+    // narrow to the right type
+    _tao_objref =
+      IR::HomeDef::_unchecked_narrow (
+          obj.in (),
+          ACE_TRY_ENV
+        );
+    ACE_TRY_CHECK;
+    return 1;
+  }
+  ACE_CATCHANY
+  {
+    // do nothing
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const IR::HomeDescription &_tao_aggregate)
+{
+  if (
+    (strm << _tao_aggregate.name.in ()) &&
+    (strm << _tao_aggregate.id.in ()) &&
+    (strm << _tao_aggregate.defined_in.in ()) &&
+    (strm << _tao_aggregate.version.in ()) &&
+    (strm << _tao_aggregate.base_home.in ()) &&
+    (strm << _tao_aggregate.managed_component.in ()) &&
+    (strm << _tao_aggregate.primary_key_def.in ()) &&
+    (strm << _tao_aggregate.factories) &&
+    (strm << _tao_aggregate.finders) &&
+    (strm << _tao_aggregate.operations) &&
+    (strm << _tao_aggregate.attributes) &&
+    (strm << CORBA::Any::from_boolean (_tao_aggregate.is_basic))
+  )
+    return 1;
+  else
+    return 0;
+  
+}
+
+ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, IR::HomeDescription &_tao_aggregate)
+{
+  if (
+    (strm >> _tao_aggregate.name.out ()) &&
+    (strm >> _tao_aggregate.id.out ()) &&
+    (strm >> _tao_aggregate.defined_in.out ()) &&
+    (strm >> _tao_aggregate.version.out ()) &&
+    (strm >> _tao_aggregate.base_home.out ()) &&
+    (strm >> _tao_aggregate.managed_component.out ()) &&
+    (strm >> _tao_aggregate.primary_key_def.out ()) &&
+    (strm >> _tao_aggregate.factories) &&
+    (strm >> _tao_aggregate.finders) &&
+    (strm >> _tao_aggregate.operations) &&
+    (strm >> _tao_aggregate.attributes) &&
+    (strm >> CORBA::Any::to_boolean (_tao_aggregate.is_basic))
+  )
+    return 1;
+  else
+    return 0;
+  
+}
+
diff --git a/TAO/tao/IFR_Client/IFR_Extended.pidl b/TAO/tao/IFR_Client/IFR_Extended.pidl
new file mode 100644
index 00000000000..f64d02c111d
--- /dev/null
+++ b/TAO/tao/IFR_Client/IFR_Extended.pidl
@@ -0,0 +1,168 @@
+//
+// $Id$
+//
+// ================================================================
+//
+// = LIBRARY
+//   TAO_IFR_Client
+//
+// = FILENAME
+//   IFR_Extended.pidl
+//
+// = DESCRIPTION
+//   This file was used to generate the code in IFR_ExtendedC.{h,i,cpp}.
+//   The original file Interface.idl was split into four pieces, to
+//   keep the generated files to a manageable size and reduce build
+//   time. This IDL file contains all the interfaces and other data
+//   types related to fixed types and valuetypes.
+//
+//   The command used to generate code from this IDL file is:
+//
+//     tao_idl -o orig -Ge 1 \
+//          -Wb,export_macro=TAO_IFR_Client_Export \
+//          -Wb,export_include=ifr_client_export.h \
+//          -Wb,pre_include="ace/pre.h" \
+//          -Wb,post_include="ace/post.h" \
+//          IFR_Extended.pidl
+//
+//   To regenerate the skeleton files IFR_ExtendedS.{h,i,cpp} and 
+//   IFR_ExtendedS_T.{h,i.cpp} in ACE_ROOT/TAO/orbsvcs/IFR_Service,
+//   use the command
+//
+//     tao_idl -o ../../orbsvcs/IFR_Service/orig -Ge 1 \
+//          -Wb,pre_include="ace/pre.h" \
+//          -Wb,post_include="ace/post.h" \
+//          IFR_Extended.pidl
+//
+// ================================================================
+
+#ifndef _IFR_EXTENDED_IDL_
+#define _IFR_EXTENDED_IDL_
+
+#include "IFR_Basic.pidl"
+
+#pragma prefix "omg.org"
+
+module CORBA
+{
+  typedef short ValueModifier; // PIDL
+  const ValueModifier VM_NONE = 0;
+  const ValueModifier VM_CUSTOM = 1;
+  const ValueModifier VM_ABSTRACT = 2;
+  const ValueModifier VM_TRUNCATABLE = 3;
+
+  typedef short Visibility;
+  const Visibility PRIVATE_MEMBER = 0;
+  const Visibility PUBLIC_MEMBER = 1;
+
+  interface FixedDef : IDLType 
+  {
+    attribute unsigned short digits;
+    attribute short scale;
+  };
+
+  struct ValueMember 
+  {
+    Identifier name;
+    RepositoryId id;
+    RepositoryId defined_in;
+    VersionSpec version;
+    TypeCode type;
+    IDLType type_def;
+    Visibility access;
+  };
+
+  typedef sequence <ValueMember> ValueMemberSeq;
+
+  interface ValueMemberDef : Contained 
+  {
+    readonly attribute TypeCode type;
+    attribute IDLType type_def;
+    attribute Visibility access;
+  };
+
+  interface ValueDef : Container, Contained, IDLType 
+  {
+    // read/write interface
+    attribute InterfaceDefSeq supported_interfaces;
+    attribute InitializerSeq initializers;
+    attribute ValueDef base_value;
+    attribute ValueDefSeq abstract_base_values;
+    // read interface
+    attribute boolean is_abstract;
+    attribute boolean is_custom;
+    attribute boolean is_truncatable;
+    boolean is_a (
+        in RepositoryId id
+      );
+
+    struct FullValueDescription 
+    {
+      Identifier name;
+      RepositoryId id;
+      boolean is_abstract;
+      boolean is_custom;
+      RepositoryId defined_in;
+      VersionSpec version;
+      OpDescriptionSeq operations;
+      AttrDescriptionSeq attributes;
+      ValueMemberSeq members;
+      InitializerSeq initializers;
+      RepositoryIdSeq supported_interfaces;
+      RepositoryIdSeq abstract_base_values;
+      boolean is_truncatable;
+      RepositoryId base_value;
+      TypeCode type;
+    };
+
+    FullValueDescription describe_value ();
+      
+    ValueMemberDef create_value_member  (
+        in RepositoryId id,
+        in Identifier name,
+        in VersionSpec version,
+        in IDLType type,
+        in Visibility access
+      );
+    AttributeDef create_attribute (
+        in RepositoryId id,
+        in Identifier name,
+        in VersionSpec version,
+        in IDLType type,
+        in AttributeMode mode
+      );
+    OperationDef create_operation (
+        in RepositoryId id,
+        in Identifier name,
+        in VersionSpec version,
+        in IDLType result,
+        in OperationMode mode,
+        in ParDescriptionSeq params,
+        in ExceptionDefSeq exceptions,
+        in ContextIdSeq contexts
+      );
+  };
+
+  struct ValueDescription 
+  {
+    Identifier name;
+    RepositoryId id;
+    boolean is_abstract;
+    boolean is_custom;
+    RepositoryId defined_in;
+    VersionSpec version;
+    RepositoryIdSeq supported_interfaces;
+    RepositoryIdSeq abstract_base_values;
+    boolean is_truncatable;
+    RepositoryId base_value;
+  };
+
+  interface ValueBoxDef : TypedefDef 
+  {
+    attribute IDLType original_type_def;
+  };
+};
+
+#pragma prefix ""
+
+#endif /* _IFR_EXTENDED_IDL_ */
diff --git a/TAO/tao/IFR_Client/IFR_ExtendedC.cpp b/TAO/tao/IFR_Client/IFR_ExtendedC.cpp
new file mode 100644
index 00000000000..45a9975bc61
--- /dev/null
+++ b/TAO/tao/IFR_Client/IFR_ExtendedC.cpp
@@ -0,0 +1,11253 @@
+// -*- C++ -*-
+//
+// $Id$
+
+// ****  Code generated by the The ACE ORB (TAO) IDL Compiler ****
+// TAO and the TAO IDL Compiler have been developed by:
+//       Center for Distributed Object Computing
+//       Washington University
+//       St. Louis, MO
+//       USA
+//       http://www.cs.wustl.edu/~schmidt/doc-center.html
+// and
+//       Distributed Object Computing Laboratory
+//       University of California at Irvine
+//       Irvine, CA
+//       USA
+//       http://doc.ece.uci.edu/
+//
+// Information about TAO is available at:
+//     http://www.cs.wustl.edu/~schmidt/TAO.html
+
+#include "IFR_ExtendedC.h"
+
+#if TAO_HAS_INTERCEPTORS == 1
+#include "tao/RequestInfo_Util.h"
+#endif  /* TAO_HAS_INTERCEPTORS == 1 */
+
+#if defined (__BORLANDC__)
+#pragma option -w-rvl -w-rch -w-ccc -w-aus
+#endif /* __BORLANDC__ */
+
+#if !defined (__ACE_INLINE__)
+#include "IFR_ExtendedC.i"
+#endif /* !defined INLINE */
+
+// ********************************************************************
+// Methods for sequences classes moved from IFR_BaseC.cpp
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_VALUEDEFSEQ_CS_)
+#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_VALUEDEFSEQ_CS_
+
+  // The Base_Sequence functions, please see tao/Sequence.h
+  void
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::_allocate_buffer (CORBA::ULong length)
+  {
+    CORBA::ValueDef **tmp = 0;
+    tmp = _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::allocbuf (length);
+    
+    if (this->buffer_ != 0)
+    {
+      CORBA::ValueDef **old = ACE_reinterpret_cast (CORBA::ValueDef**, this->buffer_);
+      for (CORBA::ULong i = 0; i < this->length_; ++i)
+        if (!this->release_)
+          tmp[i] = CORBA::ValueDef::_duplicate (old[i]);
+        else
+          tmp[i] = old[i];
+        
+      if (this->release_)
+        delete[] old;
+      
+    }
+    this->buffer_ = tmp;
+  }
+  
+  void
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::_deallocate_buffer (void)
+  {
+    if (this->buffer_ == 0 || this->release_ == 0)
+      return;
+    CORBA::ValueDef **tmp = ACE_reinterpret_cast (CORBA::ValueDef**, this->buffer_);
+    for (CORBA::ULong i = 0; i < this->length_; ++i)
+    {
+      CORBA::release (tmp[i]);
+      tmp[i] = CORBA::ValueDef::_nil ();
+    }
+    _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::freebuf (tmp);
+    this->buffer_ = 0;
+  }
+  
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::~_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq (void)
+  {
+    this->_deallocate_buffer ();
+  }
+  
+  void
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::_shrink_buffer (CORBA::ULong nl, CORBA::ULong ol)
+  {
+    CORBA::ValueDef **tmp = ACE_reinterpret_cast (CORBA::ValueDef**, this->buffer_);
+    
+    for (CORBA::ULong i = nl; i < ol; ++i)
+    {
+      CORBA::release (tmp[i]);
+      tmp[i] = CORBA::ValueDef::_nil ();
+    }
+  }
+  void 
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::_downcast (
+      void* target,
+      CORBA_Object *src,
+      CORBA_Environment &ACE_TRY_ENV
+    )
+  {
+    CORBA::ValueDef **tmp = ACE_static_cast (CORBA::ValueDef**, target);
+    *tmp = CORBA::ValueDef::_narrow (src, ACE_TRY_ENV);
+    ACE_CHECK;
+  }
+
+  CORBA_Object*
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::_upcast (void *src) const
+  {
+    CORBA::ValueDef **tmp = ACE_static_cast (CORBA::ValueDef**, src);
+    return *tmp;
+  }
+  
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_CORBA_VALUEDEFSEQ_CS_)
+#define _CORBA_VALUEDEFSEQ_CS_
+
+// *************************************************************
+// CORBA_ValueDefSeq
+// *************************************************************
+
+CORBA_ValueDefSeq::CORBA_ValueDefSeq (void)
+{}
+CORBA_ValueDefSeq::CORBA_ValueDefSeq (CORBA::ULong max) // uses max size
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<CORBA::ValueDef,CORBA::ValueDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (max)
+{}
+CORBA_ValueDefSeq::CORBA_ValueDefSeq (CORBA::ULong max, CORBA::ULong length, CORBA::ValueDef_ptr *buffer, CORBA::Boolean release)
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<CORBA::ValueDef,CORBA::ValueDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (max, length, buffer, release)
+{}
+CORBA_ValueDefSeq::CORBA_ValueDefSeq (const CORBA_ValueDefSeq &seq) // copy ctor
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<CORBA::ValueDef,CORBA::ValueDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (seq)
+{}
+CORBA_ValueDefSeq::~CORBA_ValueDefSeq (void) // dtor
+{}
+void CORBA_ValueDefSeq::_tao_any_destructor (void *x)
+{
+  CORBA_ValueDefSeq *tmp = ACE_static_cast (CORBA_ValueDefSeq*,x);
+  delete tmp;
+}
+
+
+#endif /* end #if !defined */
+
+// **************************************************************
+// Repository::create_fixed methods from IFR_BasicC.cpp
+
+CORBA::FixedDef_ptr _TAO_Repository_Remote_Proxy_Impl::create_fixed (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::UShort digits,
+    CORBA::Short scale,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  CORBA::FixedDef_ptr _tao_retval = CORBA::FixedDef::_nil ();
+  CORBA::FixedDef_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "create_fixed",
+      12,
+      1,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::Repository::TAO_ClientRequestInfo_CORBA_Repository_create_fixed ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        digits,
+        scale,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+          if (!(
+                            (_tao_out << digits) &&
+              (_tao_out << scale)
+            ))
+            TAO_INTERCEPTOR_THROW_RETURN (
+              CORBA::MARSHAL (),
+              0
+            );
+            
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::FixedDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+CORBA::Any * 
+CORBA::Repository::TAO_ClientRequestInfo_CORBA_Repository_create_fixed::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+// *******************************************************************
+// Container::create_value* methods from IFR_BaseC.cpp
+
+CORBA::ValueDef_ptr _TAO_Container_Remote_Proxy_Impl::create_value (
+    CORBA_Object *_collocated_tao_target_,
+    const char * id,
+    const char * name,
+    const char * version,
+    CORBA::Boolean is_custom,
+    CORBA::Boolean is_abstract,
+    CORBA::ValueDef_ptr base_value,
+    CORBA::Boolean is_truncatable,
+    const CORBA::ValueDefSeq & abstract_base_values,
+    const CORBA::InterfaceDefSeq & supported_interfaces,
+    const CORBA::InitializerSeq & initializers,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  CORBA::ValueDef_ptr _tao_retval = CORBA::ValueDef::_nil ();
+  CORBA::ValueDef_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "create_value",
+      12,
+      1,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_create_value ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        id,
+        name,
+        version,
+        is_custom,
+        is_abstract,
+        base_value,
+        is_truncatable,
+        abstract_base_values,
+        supported_interfaces,
+        initializers,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+          if (!(
+                            (_tao_out << id) &&
+              (_tao_out << name) &&
+              (_tao_out << version) &&
+              (_tao_out << CORBA::Any::from_boolean (is_custom)) &&
+              (_tao_out << CORBA::Any::from_boolean (is_abstract)) &&
+              (_tao_out << base_value) &&
+              (_tao_out << CORBA::Any::from_boolean (is_truncatable)) &&
+              (_tao_out << abstract_base_values) &&
+              (_tao_out << supported_interfaces) &&
+              (_tao_out << initializers)
+            ))
+            TAO_INTERCEPTOR_THROW_RETURN (
+              CORBA::MARSHAL (),
+              0
+            );
+            
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::ValueDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+CORBA::ValueBoxDef_ptr _TAO_Container_Remote_Proxy_Impl::create_value_box (
+    CORBA_Object *_collocated_tao_target_,
+    const char * id,
+    const char * name,
+    const char * version,
+    CORBA::IDLType_ptr original_type_def,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  CORBA::ValueBoxDef_ptr _tao_retval = CORBA::ValueBoxDef::_nil ();
+  CORBA::ValueBoxDef_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "create_value_box",
+      16,
+      1,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_create_value_box ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        id,
+        name,
+        version,
+        original_type_def,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+          if (!(
+                            (_tao_out << id) &&
+              (_tao_out << name) &&
+              (_tao_out << version) &&
+              (_tao_out << original_type_def)
+            ))
+            TAO_INTERCEPTOR_THROW_RETURN (
+              CORBA::MARSHAL (),
+              0
+            );
+            
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::ValueBoxDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+Dynamic::ParameterList *
+CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_create_value::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
+    
+  CORBA::ULong length_id = parameter_list->length ();
+  parameter_list->length (length_id + 1);
+  (*parameter_list)[length_id].argument <<= id_;
+  (*parameter_list)[length_id].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_name = parameter_list->length ();
+  parameter_list->length (length_name + 1);
+  (*parameter_list)[length_name].argument <<= name_;
+  (*parameter_list)[length_name].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_version = parameter_list->length ();
+  parameter_list->length (length_version + 1);
+  (*parameter_list)[length_version].argument <<= version_;
+  (*parameter_list)[length_version].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_is_custom = parameter_list->length ();
+  parameter_list->length (length_is_custom + 1);
+  (*parameter_list)[length_is_custom].argument <<= CORBA::Any::from_boolean (this->is_custom_);
+  (*parameter_list)[length_is_custom].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_is_abstract = parameter_list->length ();
+  parameter_list->length (length_is_abstract + 1);
+  (*parameter_list)[length_is_abstract].argument <<= CORBA::Any::from_boolean (this->is_abstract_);
+  (*parameter_list)[length_is_abstract].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_base_value = parameter_list->length ();
+  parameter_list->length (length_base_value + 1);
+  (*parameter_list)[length_base_value].argument <<=  this->base_value_;
+  
+  (*parameter_list)[length_base_value].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_is_truncatable = parameter_list->length ();
+  parameter_list->length (length_is_truncatable + 1);
+  (*parameter_list)[length_is_truncatable].argument <<= CORBA::Any::from_boolean (this->is_truncatable_);
+  (*parameter_list)[length_is_truncatable].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_abstract_base_values = parameter_list->length ();
+  parameter_list->length (length_abstract_base_values + 1);
+  (*parameter_list)[length_abstract_base_values].argument <<=  this->abstract_base_values_;
+  
+  (*parameter_list)[length_abstract_base_values].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_supported_interfaces = parameter_list->length ();
+  parameter_list->length (length_supported_interfaces + 1);
+  (*parameter_list)[length_supported_interfaces].argument <<=  this->supported_interfaces_;
+  
+  (*parameter_list)[length_supported_interfaces].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_initializers = parameter_list->length ();
+  parameter_list->length (length_initializers + 1);
+  (*parameter_list)[length_initializers].argument <<=  this->initializers_;
+  
+  (*parameter_list)[length_initializers].mode = Dynamic::PARAM_IN;
+  
+  return safe_parameter_list._retn ();
+}
+
+CORBA::Any * 
+CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_create_value::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+CORBA::Any * 
+CORBA::Container::TAO_ClientRequestInfo_CORBA_Container_create_value_box::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+// **********************************************************************
+
+///////////////////////////////////////////////////////////////////////
+//                Base & Remote Proxy  Implementation. 
+//
+
+_TAO_FixedDef_Proxy_Impl::_TAO_FixedDef_Proxy_Impl (void)
+{}
+
+_TAO_FixedDef_Remote_Proxy_Impl::_TAO_FixedDef_Remote_Proxy_Impl (void)
+{}
+
+// Remote Implementation of the IDL interface methods
+
+CORBA::UShort _TAO_FixedDef_Remote_Proxy_Impl::digits (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::UShort _tao_retval = 0;
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), _tao_retval);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_digits",
+      11,
+      0,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::FixedDef::TAO_ClientRequestInfo_CORBA_FixedDef_digits_get ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN  (_tao_retval);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                _tao_retval
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_retval)
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                _tao_retval
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::UShort  _tao_retval_info = _tao_retval;
+               ri.result (_tao_retval_info);
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN  (_tao_retval);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_retval;
+}
+
+void _TAO_FixedDef_Remote_Proxy_Impl::digits (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::UShort digits,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW (CORBA::INTERNAL ());
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_set_digits",
+      11,
+      1,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::FixedDef::TAO_ClientRequestInfo_CORBA_FixedDef_digits_set ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        digits,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK;
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK;
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK;
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK;
+          
+          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+          if (!(
+                            (_tao_out << digits)
+            ))
+            TAO_INTERCEPTOR_THROW (
+              CORBA::MARSHAL ()
+            );
+            
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK;
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)
+              );
+              
+            }
+          
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK;
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK;
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  
+}
+
+CORBA::Short _TAO_FixedDef_Remote_Proxy_Impl::scale (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::Short _tao_retval = 0;
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), _tao_retval);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_scale",
+      10,
+      0,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::FixedDef::TAO_ClientRequestInfo_CORBA_FixedDef_scale_get ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN  (_tao_retval);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                _tao_retval
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_retval)
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                _tao_retval
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::Short  _tao_retval_info = _tao_retval;
+               ri.result (_tao_retval_info);
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN  (_tao_retval);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_retval;
+}
+
+void _TAO_FixedDef_Remote_Proxy_Impl::scale (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::Short scale,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW (CORBA::INTERNAL ());
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_set_scale",
+      10,
+      1,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::FixedDef::TAO_ClientRequestInfo_CORBA_FixedDef_scale_set ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        scale,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK;
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK;
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK;
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK;
+          
+          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+          if (!(
+                            (_tao_out << scale)
+            ))
+            TAO_INTERCEPTOR_THROW (
+              CORBA::MARSHAL ()
+            );
+            
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK;
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)
+              );
+              
+            }
+          
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK;
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK;
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  
+}
+
+
+//
+//            End  Base & Remote  Proxy Implemeentation. 
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//           Remote & Base  Proxy Broker Implementation
+//
+
+_TAO_FixedDef_Proxy_Broker::_TAO_FixedDef_Proxy_Broker (void)
+{
+}
+
+_TAO_FixedDef_Proxy_Broker::~_TAO_FixedDef_Proxy_Broker (void)
+{
+}
+
+_TAO_FixedDef_Proxy_Broker * (*CORBA__TAO_FixedDef_Proxy_Broker_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  ) = 0;
+
+// Factory Member function Implementation.
+_TAO_FixedDef_Remote_Proxy_Broker *
+_TAO_FixedDef_Remote_Proxy_Broker::the_TAO_FixedDef_Remote_Proxy_Broker (void)
+{
+  static ::_TAO_FixedDef_Remote_Proxy_Broker remote_proxy_broker;
+  return &remote_proxy_broker;
+}
+
+_TAO_FixedDef_Remote_Proxy_Broker::_TAO_FixedDef_Remote_Proxy_Broker (void)
+{
+}
+
+_TAO_FixedDef_Remote_Proxy_Broker::~_TAO_FixedDef_Remote_Proxy_Broker (void)
+{
+}
+
+_TAO_FixedDef_Proxy_Impl&
+_TAO_FixedDef_Remote_Proxy_Broker::select_proxy (
+  ::CORBA_FixedDef *,
+  CORBA::Environment &
+)
+{
+  return this->remote_proxy_impl_;
+}
+
+
+//
+//           End Remote & Base Proxy Broker Implementation
+///////////////////////////////////////////////////////////////////////
+
+
+// default constructor
+CORBA::FixedDef::FixedDef (int collocated)
+{
+  this->CORBA_FixedDef_setup_collocation (collocated);
+}
+
+// destructor
+CORBA::FixedDef::~FixedDef (void)
+{}
+
+void
+CORBA::FixedDef::CORBA_FixedDef_setup_collocation (int collocated)
+{
+  if (collocated)
+    this->the_TAO_FixedDef_Proxy_Broker_ =
+      ::CORBA__TAO_FixedDef_Proxy_Broker_Factory_function_pointer (this);
+  else
+    this->the_TAO_FixedDef_Proxy_Broker_ =
+      ::_TAO_FixedDef_Remote_Proxy_Broker::the_TAO_FixedDef_Remote_Proxy_Broker ();
+  
+  this->CORBA_IDLType_setup_collocation (collocated);
+}
+
+void CORBA::FixedDef::_tao_any_destructor (void *x)
+{
+  CORBA_FixedDef *tmp = ACE_static_cast (CORBA_FixedDef*,x);
+  CORBA::release (tmp);
+}
+
+CORBA::FixedDef_ptr CORBA::FixedDef::_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+{
+  if (CORBA::is_nil (obj))
+    return CORBA::FixedDef::_nil ();
+  if (! obj->_is_local ())
+    {
+      CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/CORBA/FixedDef:1.0", ACE_TRY_ENV);
+      ACE_CHECK_RETURN (CORBA::FixedDef::_nil ());
+      if (is_a == 0)
+        return CORBA::FixedDef::_nil ();
+    }
+  return CORBA::FixedDef::_unchecked_narrow (obj, ACE_TRY_ENV);
+}
+
+CORBA::FixedDef_ptr CORBA::FixedDef::_unchecked_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &
+  )
+{
+  if (CORBA::is_nil (obj))
+    return CORBA::FixedDef::_nil ();
+  if (! obj->_is_local ())
+    {
+      TAO_Stub* stub = obj->_stubobj ();
+      if (stub)
+        stub->_incr_refcnt ();
+      CORBA::FixedDef_ptr default_proxy = CORBA::FixedDef::_nil ();
+
+      if (
+          !CORBA::is_nil (stub->servant_orb_var ().ptr ()) &&
+          stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects () &&
+          obj->_is_collocated () &&CORBA__TAO_FixedDef_Proxy_Broker_Factory_function_pointer != 0
+        )
+      {
+        ACE_NEW_RETURN (
+          default_proxy,
+          ::CORBA::FixedDef (
+            stub,
+            1,
+            obj->_servant ()),
+            
+          CORBA::FixedDef::_nil ());
+        }
+      if (CORBA::is_nil (default_proxy))
+        ACE_NEW_RETURN (default_proxy, ::CORBA::FixedDef (stub, 0, obj->_servant ()), CORBA::FixedDef::_nil ());
+        return default_proxy;
+      }
+    else 
+      return
+        ACE_reinterpret_cast
+          (
+            CORBA_FixedDef_ptr,
+              obj->_tao_QueryInterface
+                (
+                  ACE_reinterpret_cast
+                    (
+                      ptr_arith_t,
+                      &CORBA_FixedDef::_narrow
+                    )
+                )
+          );
+}
+
+CORBA::FixedDef_ptr
+CORBA::FixedDef::_duplicate (CORBA::FixedDef_ptr obj)
+{
+  if (!CORBA::is_nil (obj))
+    obj->_add_ref ();
+  return obj;
+}
+
+CORBA::Boolean CORBA::FixedDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
+{
+  if (
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/FixedDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IDLType:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
+  return 1; // success using local knowledge
+  else
+    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
+}
+
+void *CORBA::FixedDef::_tao_QueryInterface (ptr_arith_t type)
+{
+  void *retv = 0;
+  if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      CORBA_FixedDef::_narrow))
+    retv = ACE_reinterpret_cast (void*, this);
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::IDLType::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::IDLType_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::IRObject::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::IRObject_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
+    retv = ACE_reinterpret_cast (void *,
+      ACE_static_cast (CORBA::Object_ptr, this));
+    
+  if (retv)
+    this->_add_ref ();
+  return retv;
+}
+
+const char* CORBA::FixedDef::_interface_repository_id (void) const
+{
+  return "IDL:omg.org/CORBA/FixedDef:1.0";
+}
+
+CORBA::UShort CORBA::FixedDef::digits (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_FixedDef_Proxy_Impl &proxy = 
+    this->the_TAO_FixedDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.digits (
+      this,
+      ACE_TRY_ENV
+    );
+}
+
+void CORBA::FixedDef::digits (
+    CORBA::UShort digits,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_FixedDef_Proxy_Impl &proxy = 
+    this->the_TAO_FixedDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK;
+  
+  proxy.digits (
+      this,
+      digits,
+      ACE_TRY_ENV
+    );
+}
+
+CORBA::Short CORBA::FixedDef::scale (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_FixedDef_Proxy_Impl &proxy = 
+    this->the_TAO_FixedDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.scale (
+      this,
+      ACE_TRY_ENV
+    );
+}
+
+void CORBA::FixedDef::scale (
+    CORBA::Short scale,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_FixedDef_Proxy_Impl &proxy = 
+    this->the_TAO_FixedDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK;
+  
+  proxy.scale (
+      this,
+      scale,
+      ACE_TRY_ENV
+    );
+}
+
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+CORBA::FixedDef::TAO_ClientRequestInfo_CORBA_FixedDef_digits_get::TAO_ClientRequestInfo_CORBA_FixedDef_digits_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
+{}
+
+Dynamic::ParameterList *
+CORBA::FixedDef::TAO_ClientRequestInfo_CORBA_FixedDef_digits_get::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return parameter_list;
+}
+
+Dynamic::ExceptionList *
+CORBA::FixedDef::TAO_ClientRequestInfo_CORBA_FixedDef_digits_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::FixedDef::TAO_ClientRequestInfo_CORBA_FixedDef_digits_get::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+CORBA::FixedDef::TAO_ClientRequestInfo_CORBA_FixedDef_digits_get::result (CORBA::UShort result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+CORBA::FixedDef::TAO_ClientRequestInfo_CORBA_FixedDef_digits_set::TAO_ClientRequestInfo_CORBA_FixedDef_digits_set (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const CORBA::UShort & digits,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
+    digits_ (digits)
+{}
+
+Dynamic::ParameterList *
+CORBA::FixedDef::TAO_ClientRequestInfo_CORBA_FixedDef_digits_set::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
+    
+  CORBA::ULong length_digits = parameter_list->length ();
+  parameter_list->length (length_digits + 1);
+  (*parameter_list)[length_digits].argument <<= digits_;
+  (*parameter_list)[length_digits].mode = Dynamic::PARAM_IN;
+  
+  return safe_parameter_list._retn ();
+}
+
+Dynamic::ExceptionList *
+CORBA::FixedDef::TAO_ClientRequestInfo_CORBA_FixedDef_digits_set::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::FixedDef::TAO_ClientRequestInfo_CORBA_FixedDef_digits_set::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 1;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return result_any;
+}
+
+CORBA::FixedDef::TAO_ClientRequestInfo_CORBA_FixedDef_scale_get::TAO_ClientRequestInfo_CORBA_FixedDef_scale_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
+{}
+
+Dynamic::ParameterList *
+CORBA::FixedDef::TAO_ClientRequestInfo_CORBA_FixedDef_scale_get::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return parameter_list;
+}
+
+Dynamic::ExceptionList *
+CORBA::FixedDef::TAO_ClientRequestInfo_CORBA_FixedDef_scale_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::FixedDef::TAO_ClientRequestInfo_CORBA_FixedDef_scale_get::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+CORBA::FixedDef::TAO_ClientRequestInfo_CORBA_FixedDef_scale_get::result (CORBA::Short result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+CORBA::FixedDef::TAO_ClientRequestInfo_CORBA_FixedDef_scale_set::TAO_ClientRequestInfo_CORBA_FixedDef_scale_set (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const CORBA::Short & scale,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
+    scale_ (scale)
+{}
+
+Dynamic::ParameterList *
+CORBA::FixedDef::TAO_ClientRequestInfo_CORBA_FixedDef_scale_set::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
+    
+  CORBA::ULong length_scale = parameter_list->length ();
+  parameter_list->length (length_scale + 1);
+  (*parameter_list)[length_scale].argument <<= scale_;
+  (*parameter_list)[length_scale].mode = Dynamic::PARAM_IN;
+  
+  return safe_parameter_list._retn ();
+}
+
+Dynamic::ExceptionList *
+CORBA::FixedDef::TAO_ClientRequestInfo_CORBA_FixedDef_scale_set::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::FixedDef::TAO_ClientRequestInfo_CORBA_FixedDef_scale_set::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 1;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return result_any;
+}
+
+#endif /* TAO_HAS_INTERCEPTORS */
+
+void CORBA::ValueMember::_tao_any_destructor (void *x)
+{
+  CORBA_ValueMember *tmp = ACE_static_cast (CORBA_ValueMember*,x);
+  delete tmp;
+}
+
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_SEQUENCE_CORBA_VALUEMEMBERSEQ_CS_)
+#define __TAO_UNBOUNDED_SEQUENCE_CORBA_VALUEMEMBERSEQ_CS_
+
+  void
+  CORBA::_TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::_allocate_buffer (CORBA::ULong length)
+  {
+    CORBA::ValueMember* tmp = 0;
+    tmp = _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::allocbuf (length);
+    
+    if (this->buffer_ != 0)
+    {
+      CORBA::ValueMember *old = ACE_reinterpret_cast (CORBA::ValueMember *,this->buffer_);
+      
+      for (CORBA::ULong i = 0; i < this->length_; ++i)
+        tmp[i] = old[i];
+      
+      if (this->release_)
+        _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::freebuf (old);
+      
+    }
+    this->buffer_ = tmp;
+  }
+  
+  void
+  CORBA::_TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::_deallocate_buffer (void)
+  {
+    if (this->buffer_ == 0 || this->release_ == 0)
+      return;
+    
+    CORBA::ValueMember *tmp = ACE_reinterpret_cast (CORBA::ValueMember *,this->buffer_);
+    
+    _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::freebuf (tmp);
+    this->buffer_ = 0;
+  } 
+  
+  CORBA::_TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::~_TAO_Unbounded_Sequence_CORBA_ValueMemberSeq (void) // Dtor.
+  {
+    this->_deallocate_buffer ();
+  }
+  
+  
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_CORBA_VALUEMEMBERSEQ_CS_)
+#define _CORBA_VALUEMEMBERSEQ_CS_
+
+// *************************************************************
+// CORBA_ValueMemberSeq
+// *************************************************************
+
+CORBA_ValueMemberSeq::CORBA_ValueMemberSeq (void)
+{}
+CORBA_ValueMemberSeq::CORBA_ValueMemberSeq (CORBA::ULong max) // uses max size
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<CORBA::ValueMember>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (max)
+{}
+CORBA_ValueMemberSeq::CORBA_ValueMemberSeq (CORBA::ULong max, CORBA::ULong length, CORBA::ValueMember *buffer, CORBA::Boolean release)
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<CORBA::ValueMember>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (max, length, buffer, release)
+{}
+CORBA_ValueMemberSeq::CORBA_ValueMemberSeq (const CORBA_ValueMemberSeq &seq) // copy ctor
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<CORBA::ValueMember>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (seq)
+{}
+CORBA_ValueMemberSeq::~CORBA_ValueMemberSeq (void) // dtor
+{}
+void CORBA_ValueMemberSeq::_tao_any_destructor (void *x)
+{
+  CORBA_ValueMemberSeq *tmp = ACE_static_cast (CORBA_ValueMemberSeq*,x);
+  delete tmp;
+}
+
+
+#endif /* end #if !defined */
+
+///////////////////////////////////////////////////////////////////////
+//                Base & Remote Proxy  Implementation. 
+//
+
+_TAO_ValueMemberDef_Proxy_Impl::_TAO_ValueMemberDef_Proxy_Impl (void)
+{}
+
+_TAO_ValueMemberDef_Remote_Proxy_Impl::_TAO_ValueMemberDef_Remote_Proxy_Impl (void)
+{}
+
+// Remote Implementation of the IDL interface methods
+
+CORBA::TypeCode_ptr _TAO_ValueMemberDef_Remote_Proxy_Impl::type (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::TypeCode_ptr _tao_retval = CORBA::TypeCode::_nil ();
+  CORBA::TypeCode_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_type",
+      9,
+      0,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::ValueMemberDef::TAO_ClientRequestInfo_CORBA_ValueMemberDef_type_get ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::TypeCode_ptr _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+CORBA::IDLType_ptr _TAO_ValueMemberDef_Remote_Proxy_Impl::type_def (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::IDLType_ptr _tao_retval = CORBA::IDLType::_nil ();
+  CORBA::IDLType_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_type_def",
+      13,
+      0,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::ValueMemberDef::TAO_ClientRequestInfo_CORBA_ValueMemberDef_type_def_get ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::IDLType_ptr _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+void _TAO_ValueMemberDef_Remote_Proxy_Impl::type_def (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::IDLType_ptr type_def,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW (CORBA::INTERNAL ());
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_set_type_def",
+      13,
+      1,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::ValueMemberDef::TAO_ClientRequestInfo_CORBA_ValueMemberDef_type_def_set ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        type_def,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK;
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK;
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK;
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK;
+          
+          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+          if (!(
+                            (_tao_out << type_def)
+            ))
+            TAO_INTERCEPTOR_THROW (
+              CORBA::MARSHAL ()
+            );
+            
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK;
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)
+              );
+              
+            }
+          
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK;
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK;
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  
+}
+
+CORBA::Visibility _TAO_ValueMemberDef_Remote_Proxy_Impl::access (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::Visibility _tao_retval = 0;
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), _tao_retval);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_access",
+      11,
+      0,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::ValueMemberDef::TAO_ClientRequestInfo_CORBA_ValueMemberDef_access_get ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN  (_tao_retval);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                _tao_retval
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_retval)
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                _tao_retval
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::Visibility  _tao_retval_info = _tao_retval;
+               ri.result (_tao_retval_info);
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN  (_tao_retval);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_retval;
+}
+
+void _TAO_ValueMemberDef_Remote_Proxy_Impl::access (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::Visibility access,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW (CORBA::INTERNAL ());
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_set_access",
+      11,
+      1,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::ValueMemberDef::TAO_ClientRequestInfo_CORBA_ValueMemberDef_access_set ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        access,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK;
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK;
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK;
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK;
+          
+          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+          if (!(
+                            (_tao_out << access)
+            ))
+            TAO_INTERCEPTOR_THROW (
+              CORBA::MARSHAL ()
+            );
+            
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK;
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)
+              );
+              
+            }
+          
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK;
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK;
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  
+}
+
+
+//
+//            End  Base & Remote  Proxy Implemeentation. 
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//           Remote & Base  Proxy Broker Implementation
+//
+
+_TAO_ValueMemberDef_Proxy_Broker::_TAO_ValueMemberDef_Proxy_Broker (void)
+{
+}
+
+_TAO_ValueMemberDef_Proxy_Broker::~_TAO_ValueMemberDef_Proxy_Broker (void)
+{
+}
+
+_TAO_ValueMemberDef_Proxy_Broker * (*CORBA__TAO_ValueMemberDef_Proxy_Broker_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  ) = 0;
+
+// Factory Member function Implementation.
+_TAO_ValueMemberDef_Remote_Proxy_Broker *
+_TAO_ValueMemberDef_Remote_Proxy_Broker::the_TAO_ValueMemberDef_Remote_Proxy_Broker (void)
+{
+  static ::_TAO_ValueMemberDef_Remote_Proxy_Broker remote_proxy_broker;
+  return &remote_proxy_broker;
+}
+
+_TAO_ValueMemberDef_Remote_Proxy_Broker::_TAO_ValueMemberDef_Remote_Proxy_Broker (void)
+{
+}
+
+_TAO_ValueMemberDef_Remote_Proxy_Broker::~_TAO_ValueMemberDef_Remote_Proxy_Broker (void)
+{
+}
+
+_TAO_ValueMemberDef_Proxy_Impl&
+_TAO_ValueMemberDef_Remote_Proxy_Broker::select_proxy (
+  ::CORBA_ValueMemberDef *,
+  CORBA::Environment &
+)
+{
+  return this->remote_proxy_impl_;
+}
+
+
+//
+//           End Remote & Base Proxy Broker Implementation
+///////////////////////////////////////////////////////////////////////
+
+
+// default constructor
+CORBA::ValueMemberDef::ValueMemberDef (int collocated)
+{
+  this->CORBA_ValueMemberDef_setup_collocation (collocated);
+}
+
+// destructor
+CORBA::ValueMemberDef::~ValueMemberDef (void)
+{}
+
+void
+CORBA::ValueMemberDef::CORBA_ValueMemberDef_setup_collocation (int collocated)
+{
+  if (collocated)
+    this->the_TAO_ValueMemberDef_Proxy_Broker_ =
+      ::CORBA__TAO_ValueMemberDef_Proxy_Broker_Factory_function_pointer (this);
+  else
+    this->the_TAO_ValueMemberDef_Proxy_Broker_ =
+      ::_TAO_ValueMemberDef_Remote_Proxy_Broker::the_TAO_ValueMemberDef_Remote_Proxy_Broker ();
+  
+  this->CORBA_Contained_setup_collocation (collocated);
+}
+
+void CORBA::ValueMemberDef::_tao_any_destructor (void *x)
+{
+  CORBA_ValueMemberDef *tmp = ACE_static_cast (CORBA_ValueMemberDef*,x);
+  CORBA::release (tmp);
+}
+
+CORBA::ValueMemberDef_ptr CORBA::ValueMemberDef::_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+{
+  if (CORBA::is_nil (obj))
+    return CORBA::ValueMemberDef::_nil ();
+  if (! obj->_is_local ())
+    {
+      CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/CORBA/ValueMemberDef:1.0", ACE_TRY_ENV);
+      ACE_CHECK_RETURN (CORBA::ValueMemberDef::_nil ());
+      if (is_a == 0)
+        return CORBA::ValueMemberDef::_nil ();
+    }
+  return CORBA::ValueMemberDef::_unchecked_narrow (obj, ACE_TRY_ENV);
+}
+
+CORBA::ValueMemberDef_ptr CORBA::ValueMemberDef::_unchecked_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &
+  )
+{
+  if (CORBA::is_nil (obj))
+    return CORBA::ValueMemberDef::_nil ();
+  if (! obj->_is_local ())
+    {
+      TAO_Stub* stub = obj->_stubobj ();
+      if (stub)
+        stub->_incr_refcnt ();
+      CORBA::ValueMemberDef_ptr default_proxy = CORBA::ValueMemberDef::_nil ();
+
+      if (
+          !CORBA::is_nil (stub->servant_orb_var ().ptr ()) &&
+          stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects () &&
+          obj->_is_collocated () &&CORBA__TAO_ValueMemberDef_Proxy_Broker_Factory_function_pointer != 0
+        )
+      {
+        ACE_NEW_RETURN (
+          default_proxy,
+          ::CORBA::ValueMemberDef (
+            stub,
+            1,
+            obj->_servant ()),
+            
+          CORBA::ValueMemberDef::_nil ());
+        }
+      if (CORBA::is_nil (default_proxy))
+        ACE_NEW_RETURN (default_proxy, ::CORBA::ValueMemberDef (stub, 0, obj->_servant ()), CORBA::ValueMemberDef::_nil ());
+        return default_proxy;
+      }
+    else 
+      return
+        ACE_reinterpret_cast
+          (
+            CORBA_ValueMemberDef_ptr,
+              obj->_tao_QueryInterface
+                (
+                  ACE_reinterpret_cast
+                    (
+                      ptr_arith_t,
+                      &CORBA_ValueMemberDef::_narrow
+                    )
+                )
+          );
+}
+
+CORBA::ValueMemberDef_ptr
+CORBA::ValueMemberDef::_duplicate (CORBA::ValueMemberDef_ptr obj)
+{
+  if (!CORBA::is_nil (obj))
+    obj->_add_ref ();
+  return obj;
+}
+
+CORBA::Boolean CORBA::ValueMemberDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
+{
+  if (
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/ValueMemberDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Contained:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
+  return 1; // success using local knowledge
+  else
+    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
+}
+
+void *CORBA::ValueMemberDef::_tao_QueryInterface (ptr_arith_t type)
+{
+  void *retv = 0;
+  if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      CORBA_ValueMemberDef::_narrow))
+    retv = ACE_reinterpret_cast (void*, this);
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::Contained::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::Contained_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::IRObject::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::IRObject_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
+    retv = ACE_reinterpret_cast (void *,
+      ACE_static_cast (CORBA::Object_ptr, this));
+    
+  if (retv)
+    this->_add_ref ();
+  return retv;
+}
+
+const char* CORBA::ValueMemberDef::_interface_repository_id (void) const
+{
+  return "IDL:omg.org/CORBA/ValueMemberDef:1.0";
+}
+
+CORBA::TypeCode_ptr CORBA::ValueMemberDef::type (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_ValueMemberDef_Proxy_Impl &proxy = 
+    this->the_TAO_ValueMemberDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.type (
+      this,
+      ACE_TRY_ENV
+    );
+}
+
+CORBA::IDLType_ptr CORBA::ValueMemberDef::type_def (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_ValueMemberDef_Proxy_Impl &proxy = 
+    this->the_TAO_ValueMemberDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.type_def (
+      this,
+      ACE_TRY_ENV
+    );
+}
+
+void CORBA::ValueMemberDef::type_def (
+    CORBA::IDLType_ptr type_def,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_ValueMemberDef_Proxy_Impl &proxy = 
+    this->the_TAO_ValueMemberDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK;
+  
+  proxy.type_def (
+      this,
+      type_def,
+      ACE_TRY_ENV
+    );
+}
+
+CORBA::Visibility CORBA::ValueMemberDef::access (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_ValueMemberDef_Proxy_Impl &proxy = 
+    this->the_TAO_ValueMemberDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.access (
+      this,
+      ACE_TRY_ENV
+    );
+}
+
+void CORBA::ValueMemberDef::access (
+    CORBA::Visibility access,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_ValueMemberDef_Proxy_Impl &proxy = 
+    this->the_TAO_ValueMemberDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK;
+  
+  proxy.access (
+      this,
+      access,
+      ACE_TRY_ENV
+    );
+}
+
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+CORBA::ValueMemberDef::TAO_ClientRequestInfo_CORBA_ValueMemberDef_type_get::TAO_ClientRequestInfo_CORBA_ValueMemberDef_type_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
+{}
+
+Dynamic::ParameterList *
+CORBA::ValueMemberDef::TAO_ClientRequestInfo_CORBA_ValueMemberDef_type_get::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return parameter_list;
+}
+
+Dynamic::ExceptionList *
+CORBA::ValueMemberDef::TAO_ClientRequestInfo_CORBA_ValueMemberDef_type_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::ValueMemberDef::TAO_ClientRequestInfo_CORBA_ValueMemberDef_type_get::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+CORBA::ValueMemberDef::TAO_ClientRequestInfo_CORBA_ValueMemberDef_type_get::result (CORBA::TypeCode_ptr result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+CORBA::ValueMemberDef::TAO_ClientRequestInfo_CORBA_ValueMemberDef_type_def_get::TAO_ClientRequestInfo_CORBA_ValueMemberDef_type_def_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
+{}
+
+Dynamic::ParameterList *
+CORBA::ValueMemberDef::TAO_ClientRequestInfo_CORBA_ValueMemberDef_type_def_get::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return parameter_list;
+}
+
+Dynamic::ExceptionList *
+CORBA::ValueMemberDef::TAO_ClientRequestInfo_CORBA_ValueMemberDef_type_def_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::ValueMemberDef::TAO_ClientRequestInfo_CORBA_ValueMemberDef_type_def_get::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+CORBA::ValueMemberDef::TAO_ClientRequestInfo_CORBA_ValueMemberDef_type_def_get::result (CORBA::IDLType_ptr result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+CORBA::ValueMemberDef::TAO_ClientRequestInfo_CORBA_ValueMemberDef_type_def_set::TAO_ClientRequestInfo_CORBA_ValueMemberDef_type_def_set (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::IDLType_ptr type_def,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
+    type_def_ (type_def)
+{}
+
+Dynamic::ParameterList *
+CORBA::ValueMemberDef::TAO_ClientRequestInfo_CORBA_ValueMemberDef_type_def_set::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
+    
+  CORBA::ULong length_type_def = parameter_list->length ();
+  parameter_list->length (length_type_def + 1);
+  (*parameter_list)[length_type_def].argument <<=  this->type_def_;
+  
+  (*parameter_list)[length_type_def].mode = Dynamic::PARAM_IN;
+  
+  return safe_parameter_list._retn ();
+}
+
+Dynamic::ExceptionList *
+CORBA::ValueMemberDef::TAO_ClientRequestInfo_CORBA_ValueMemberDef_type_def_set::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::ValueMemberDef::TAO_ClientRequestInfo_CORBA_ValueMemberDef_type_def_set::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 1;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return result_any;
+}
+
+CORBA::ValueMemberDef::TAO_ClientRequestInfo_CORBA_ValueMemberDef_access_get::TAO_ClientRequestInfo_CORBA_ValueMemberDef_access_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
+{}
+
+Dynamic::ParameterList *
+CORBA::ValueMemberDef::TAO_ClientRequestInfo_CORBA_ValueMemberDef_access_get::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return parameter_list;
+}
+
+Dynamic::ExceptionList *
+CORBA::ValueMemberDef::TAO_ClientRequestInfo_CORBA_ValueMemberDef_access_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::ValueMemberDef::TAO_ClientRequestInfo_CORBA_ValueMemberDef_access_get::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+CORBA::ValueMemberDef::TAO_ClientRequestInfo_CORBA_ValueMemberDef_access_get::result (CORBA::Visibility result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+CORBA::ValueMemberDef::TAO_ClientRequestInfo_CORBA_ValueMemberDef_access_set::TAO_ClientRequestInfo_CORBA_ValueMemberDef_access_set (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const CORBA::Visibility & access,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
+    access_ (access)
+{}
+
+Dynamic::ParameterList *
+CORBA::ValueMemberDef::TAO_ClientRequestInfo_CORBA_ValueMemberDef_access_set::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
+    
+  CORBA::ULong length_access = parameter_list->length ();
+  parameter_list->length (length_access + 1);
+  (*parameter_list)[length_access].argument <<= access_;
+  (*parameter_list)[length_access].mode = Dynamic::PARAM_IN;
+  
+  return safe_parameter_list._retn ();
+}
+
+Dynamic::ExceptionList *
+CORBA::ValueMemberDef::TAO_ClientRequestInfo_CORBA_ValueMemberDef_access_set::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::ValueMemberDef::TAO_ClientRequestInfo_CORBA_ValueMemberDef_access_set::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 1;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return result_any;
+}
+
+#endif /* TAO_HAS_INTERCEPTORS */
+
+///////////////////////////////////////////////////////////////////////
+//                Base & Remote Proxy  Implementation. 
+//
+
+_TAO_ValueDef_Proxy_Impl::_TAO_ValueDef_Proxy_Impl (void)
+{}
+
+_TAO_ValueDef_Remote_Proxy_Impl::_TAO_ValueDef_Remote_Proxy_Impl (void)
+{}
+
+// Remote Implementation of the IDL interface methods
+
+CORBA::InterfaceDefSeq * _TAO_ValueDef_Remote_Proxy_Impl::supported_interfaces (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::InterfaceDefSeq *_tao_retval = 0;
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  ACE_NEW_RETURN (_tao_retval, CORBA::InterfaceDefSeq, _tao_retval);
+  CORBA::InterfaceDefSeq_var _tao_safe_retval (_tao_retval);
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_supported_interfaces",
+      25,
+      0,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_supported_interfaces_get ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::InterfaceDefSeq * _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+void _TAO_ValueDef_Remote_Proxy_Impl::supported_interfaces (
+    CORBA_Object *_collocated_tao_target_,
+    const CORBA::InterfaceDefSeq & supported_interfaces,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW (CORBA::INTERNAL ());
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_set_supported_interfaces",
+      25,
+      1,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_supported_interfaces_set ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        supported_interfaces,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK;
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK;
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK;
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK;
+          
+          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+          if (!(
+                            (_tao_out << supported_interfaces)
+            ))
+            TAO_INTERCEPTOR_THROW (
+              CORBA::MARSHAL ()
+            );
+            
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK;
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)
+              );
+              
+            }
+          
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK;
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK;
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  
+}
+
+CORBA::InitializerSeq * _TAO_ValueDef_Remote_Proxy_Impl::initializers (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::InitializerSeq *_tao_retval = 0;
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  ACE_NEW_RETURN (_tao_retval, CORBA::InitializerSeq, _tao_retval);
+  CORBA::InitializerSeq_var _tao_safe_retval (_tao_retval);
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_initializers",
+      17,
+      0,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_initializers_get ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::InitializerSeq * _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+void _TAO_ValueDef_Remote_Proxy_Impl::initializers (
+    CORBA_Object *_collocated_tao_target_,
+    const CORBA::InitializerSeq & initializers,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW (CORBA::INTERNAL ());
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_set_initializers",
+      17,
+      1,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_initializers_set ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        initializers,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK;
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK;
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK;
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK;
+          
+          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+          if (!(
+                            (_tao_out << initializers)
+            ))
+            TAO_INTERCEPTOR_THROW (
+              CORBA::MARSHAL ()
+            );
+            
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK;
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)
+              );
+              
+            }
+          
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK;
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK;
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  
+}
+
+CORBA::ValueDef_ptr _TAO_ValueDef_Remote_Proxy_Impl::base_value (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::ValueDef_ptr _tao_retval = CORBA::ValueDef::_nil ();
+  CORBA::ValueDef_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_base_value",
+      15,
+      0,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_base_value_get ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::ValueDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+void _TAO_ValueDef_Remote_Proxy_Impl::base_value (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::ValueDef_ptr base_value,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW (CORBA::INTERNAL ());
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_set_base_value",
+      15,
+      1,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_base_value_set ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        base_value,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK;
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK;
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK;
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK;
+          
+          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+          if (!(
+                            (_tao_out << base_value)
+            ))
+            TAO_INTERCEPTOR_THROW (
+              CORBA::MARSHAL ()
+            );
+            
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK;
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)
+              );
+              
+            }
+          
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK;
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK;
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  
+}
+
+CORBA::ValueDefSeq * _TAO_ValueDef_Remote_Proxy_Impl::abstract_base_values (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::ValueDefSeq *_tao_retval = 0;
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  ACE_NEW_RETURN (_tao_retval, CORBA::ValueDefSeq, _tao_retval);
+  CORBA::ValueDefSeq_var _tao_safe_retval (_tao_retval);
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_abstract_base_values",
+      25,
+      0,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_abstract_base_values_get ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::ValueDefSeq * _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+void _TAO_ValueDef_Remote_Proxy_Impl::abstract_base_values (
+    CORBA_Object *_collocated_tao_target_,
+    const CORBA::ValueDefSeq & abstract_base_values,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW (CORBA::INTERNAL ());
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_set_abstract_base_values",
+      25,
+      1,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_abstract_base_values_set ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        abstract_base_values,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK;
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK;
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK;
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK;
+          
+          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+          if (!(
+                            (_tao_out << abstract_base_values)
+            ))
+            TAO_INTERCEPTOR_THROW (
+              CORBA::MARSHAL ()
+            );
+            
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK;
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)
+              );
+              
+            }
+          
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK;
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK;
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  
+}
+
+CORBA::Boolean _TAO_ValueDef_Remote_Proxy_Impl::is_abstract (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::Boolean _tao_retval = 0;
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), _tao_retval);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_is_abstract",
+      16,
+      0,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_is_abstract_get ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN  (_tao_retval);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                _tao_retval
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> CORBA::Any::to_boolean (_tao_retval))
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                _tao_retval
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::Boolean  _tao_retval_info = _tao_retval;
+               ri.result (_tao_retval_info);
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN  (_tao_retval);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_retval;
+}
+
+void _TAO_ValueDef_Remote_Proxy_Impl::is_abstract (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::Boolean is_abstract,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW (CORBA::INTERNAL ());
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_set_is_abstract",
+      16,
+      1,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_is_abstract_set ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        is_abstract,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK;
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK;
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK;
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK;
+          
+          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+          if (!(
+                            (_tao_out << CORBA::Any::from_boolean (is_abstract))
+            ))
+            TAO_INTERCEPTOR_THROW (
+              CORBA::MARSHAL ()
+            );
+            
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK;
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)
+              );
+              
+            }
+          
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK;
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK;
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  
+}
+
+CORBA::Boolean _TAO_ValueDef_Remote_Proxy_Impl::is_custom (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::Boolean _tao_retval = 0;
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), _tao_retval);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_is_custom",
+      14,
+      0,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_is_custom_get ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN  (_tao_retval);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                _tao_retval
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> CORBA::Any::to_boolean (_tao_retval))
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                _tao_retval
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::Boolean  _tao_retval_info = _tao_retval;
+               ri.result (_tao_retval_info);
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN  (_tao_retval);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_retval;
+}
+
+void _TAO_ValueDef_Remote_Proxy_Impl::is_custom (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::Boolean is_custom,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW (CORBA::INTERNAL ());
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_set_is_custom",
+      14,
+      1,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_is_custom_set ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        is_custom,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK;
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK;
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK;
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK;
+          
+          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+          if (!(
+                            (_tao_out << CORBA::Any::from_boolean (is_custom))
+            ))
+            TAO_INTERCEPTOR_THROW (
+              CORBA::MARSHAL ()
+            );
+            
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK;
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)
+              );
+              
+            }
+          
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK;
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK;
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  
+}
+
+CORBA::Boolean _TAO_ValueDef_Remote_Proxy_Impl::is_truncatable (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::Boolean _tao_retval = 0;
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), _tao_retval);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_is_truncatable",
+      19,
+      0,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_is_truncatable_get ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN  (_tao_retval);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                _tao_retval
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> CORBA::Any::to_boolean (_tao_retval))
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                _tao_retval
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::Boolean  _tao_retval_info = _tao_retval;
+               ri.result (_tao_retval_info);
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN  (_tao_retval);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_retval;
+}
+
+void _TAO_ValueDef_Remote_Proxy_Impl::is_truncatable (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::Boolean is_truncatable,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW (CORBA::INTERNAL ());
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_set_is_truncatable",
+      19,
+      1,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_is_truncatable_set ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        is_truncatable,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK;
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK;
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK;
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK;
+          
+          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+          if (!(
+                            (_tao_out << CORBA::Any::from_boolean (is_truncatable))
+            ))
+            TAO_INTERCEPTOR_THROW (
+              CORBA::MARSHAL ()
+            );
+            
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK;
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)
+              );
+              
+            }
+          
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK;
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK;
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  
+}
+
+CORBA::Boolean _TAO_ValueDef_Remote_Proxy_Impl::is_a (
+    CORBA_Object *_collocated_tao_target_,
+    const char * id,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::Boolean _tao_retval = 0;
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), _tao_retval);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "is_a",
+      4,
+      1,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_is_a ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        id,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN  (_tao_retval);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          
+          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+          if (!(
+                            (_tao_out << id)
+            ))
+            TAO_INTERCEPTOR_THROW_RETURN (
+              CORBA::MARSHAL (),
+              _tao_retval
+            );
+            
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                _tao_retval
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> CORBA::Any::to_boolean (_tao_retval))
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                _tao_retval
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::Boolean  _tao_retval_info = _tao_retval;
+               ri.result (_tao_retval_info);
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN  (_tao_retval);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_retval;
+}
+
+CORBA::ValueDef::FullValueDescription * _TAO_ValueDef_Remote_Proxy_Impl::describe_value (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::ValueDef::FullValueDescription *_tao_retval = 0;
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  ACE_NEW_RETURN (_tao_retval, CORBA::ValueDef::FullValueDescription, _tao_retval);
+  CORBA::ValueDef::FullValueDescription_var _tao_safe_retval (_tao_retval);
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "describe_value",
+      14,
+      0,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_describe_value ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::ValueDef::FullValueDescription * _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+CORBA::ValueMemberDef_ptr _TAO_ValueDef_Remote_Proxy_Impl::create_value_member (
+    CORBA_Object *_collocated_tao_target_,
+    const char * id,
+    const char * name,
+    const char * version,
+    CORBA::IDLType_ptr type,
+    CORBA::Visibility access,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::ValueMemberDef_ptr _tao_retval = CORBA::ValueMemberDef::_nil ();
+  CORBA::ValueMemberDef_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "create_value_member",
+      19,
+      1,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_create_value_member ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        id,
+        name,
+        version,
+        type,
+        access,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+          if (!(
+                            (_tao_out << id) &&
+              (_tao_out << name) &&
+              (_tao_out << version) &&
+              (_tao_out << type) &&
+              (_tao_out << access)
+            ))
+            TAO_INTERCEPTOR_THROW_RETURN (
+              CORBA::MARSHAL (),
+              0
+            );
+            
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::ValueMemberDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+CORBA::AttributeDef_ptr _TAO_ValueDef_Remote_Proxy_Impl::create_attribute (
+    CORBA_Object *_collocated_tao_target_,
+    const char * id,
+    const char * name,
+    const char * version,
+    CORBA::IDLType_ptr type,
+    CORBA::AttributeMode mode,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::AttributeDef_ptr _tao_retval = CORBA::AttributeDef::_nil ();
+  CORBA::AttributeDef_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "create_attribute",
+      16,
+      1,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_create_attribute ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        id,
+        name,
+        version,
+        type,
+        mode,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+          if (!(
+                            (_tao_out << id) &&
+              (_tao_out << name) &&
+              (_tao_out << version) &&
+              (_tao_out << type) &&
+              (_tao_out << mode)
+            ))
+            TAO_INTERCEPTOR_THROW_RETURN (
+              CORBA::MARSHAL (),
+              0
+            );
+            
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::AttributeDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+CORBA::OperationDef_ptr _TAO_ValueDef_Remote_Proxy_Impl::create_operation (
+    CORBA_Object *_collocated_tao_target_,
+    const char * id,
+    const char * name,
+    const char * version,
+    CORBA::IDLType_ptr result,
+    CORBA::OperationMode mode,
+    const CORBA::ParDescriptionSeq & params,
+    const CORBA::ExceptionDefSeq & exceptions,
+    const CORBA::ContextIdSeq & contexts,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::OperationDef_ptr _tao_retval = CORBA::OperationDef::_nil ();
+  CORBA::OperationDef_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "create_operation",
+      16,
+      1,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_create_operation ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        id,
+        name,
+        version,
+        result,
+        mode,
+        params,
+        exceptions,
+        contexts,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+          if (!(
+                            (_tao_out << id) &&
+              (_tao_out << name) &&
+              (_tao_out << version) &&
+              (_tao_out << result) &&
+              (_tao_out << mode) &&
+              (_tao_out << params) &&
+              (_tao_out << exceptions) &&
+              (_tao_out << contexts)
+            ))
+            TAO_INTERCEPTOR_THROW_RETURN (
+              CORBA::MARSHAL (),
+              0
+            );
+            
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::OperationDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+
+//
+//            End  Base & Remote  Proxy Implemeentation. 
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//           Remote & Base  Proxy Broker Implementation
+//
+
+_TAO_ValueDef_Proxy_Broker::_TAO_ValueDef_Proxy_Broker (void)
+{
+}
+
+_TAO_ValueDef_Proxy_Broker::~_TAO_ValueDef_Proxy_Broker (void)
+{
+}
+
+_TAO_ValueDef_Proxy_Broker * (*CORBA__TAO_ValueDef_Proxy_Broker_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  ) = 0;
+
+// Factory Member function Implementation.
+_TAO_ValueDef_Remote_Proxy_Broker *
+_TAO_ValueDef_Remote_Proxy_Broker::the_TAO_ValueDef_Remote_Proxy_Broker (void)
+{
+  static ::_TAO_ValueDef_Remote_Proxy_Broker remote_proxy_broker;
+  return &remote_proxy_broker;
+}
+
+_TAO_ValueDef_Remote_Proxy_Broker::_TAO_ValueDef_Remote_Proxy_Broker (void)
+{
+}
+
+_TAO_ValueDef_Remote_Proxy_Broker::~_TAO_ValueDef_Remote_Proxy_Broker (void)
+{
+}
+
+_TAO_ValueDef_Proxy_Impl&
+_TAO_ValueDef_Remote_Proxy_Broker::select_proxy (
+  ::CORBA_ValueDef *,
+  CORBA::Environment &
+)
+{
+  return this->remote_proxy_impl_;
+}
+
+
+//
+//           End Remote & Base Proxy Broker Implementation
+///////////////////////////////////////////////////////////////////////
+
+
+// default constructor
+CORBA::ValueDef::ValueDef (int collocated)
+{
+  this->CORBA_ValueDef_setup_collocation (collocated);
+}
+
+// destructor
+CORBA::ValueDef::~ValueDef (void)
+{}
+
+void
+CORBA::ValueDef::CORBA_ValueDef_setup_collocation (int collocated)
+{
+  if (collocated)
+    this->the_TAO_ValueDef_Proxy_Broker_ =
+      ::CORBA__TAO_ValueDef_Proxy_Broker_Factory_function_pointer (this);
+  else
+    this->the_TAO_ValueDef_Proxy_Broker_ =
+      ::_TAO_ValueDef_Remote_Proxy_Broker::the_TAO_ValueDef_Remote_Proxy_Broker ();
+  
+  this->CORBA_Container_setup_collocation (collocated);
+  
+  this->CORBA_Contained_setup_collocation (collocated);
+  
+  this->CORBA_IDLType_setup_collocation (collocated);
+}
+
+void CORBA::ValueDef::_tao_any_destructor (void *x)
+{
+  CORBA_ValueDef *tmp = ACE_static_cast (CORBA_ValueDef*,x);
+  CORBA::release (tmp);
+}
+
+CORBA::ValueDef_ptr CORBA::ValueDef::_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+{
+  if (CORBA::is_nil (obj))
+    return CORBA::ValueDef::_nil ();
+  if (! obj->_is_local ())
+    {
+      CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/CORBA/ValueDef:1.0", ACE_TRY_ENV);
+      ACE_CHECK_RETURN (CORBA::ValueDef::_nil ());
+      if (is_a == 0)
+        return CORBA::ValueDef::_nil ();
+    }
+  return CORBA::ValueDef::_unchecked_narrow (obj, ACE_TRY_ENV);
+}
+
+CORBA::ValueDef_ptr CORBA::ValueDef::_unchecked_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &
+  )
+{
+  if (CORBA::is_nil (obj))
+    return CORBA::ValueDef::_nil ();
+  if (! obj->_is_local ())
+    {
+      TAO_Stub* stub = obj->_stubobj ();
+      if (stub)
+        stub->_incr_refcnt ();
+      CORBA::ValueDef_ptr default_proxy = CORBA::ValueDef::_nil ();
+
+      if (
+          !CORBA::is_nil (stub->servant_orb_var ().ptr ()) &&
+          stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects () &&
+          obj->_is_collocated () &&CORBA__TAO_ValueDef_Proxy_Broker_Factory_function_pointer != 0
+        )
+      {
+        ACE_NEW_RETURN (
+          default_proxy,
+          ::CORBA::ValueDef (
+            stub,
+            1,
+            obj->_servant ()),
+            
+          CORBA::ValueDef::_nil ());
+        }
+      if (CORBA::is_nil (default_proxy))
+        ACE_NEW_RETURN (default_proxy, ::CORBA::ValueDef (stub, 0, obj->_servant ()), CORBA::ValueDef::_nil ());
+        return default_proxy;
+      }
+    else 
+      return
+        ACE_reinterpret_cast
+          (
+            CORBA_ValueDef_ptr,
+              obj->_tao_QueryInterface
+                (
+                  ACE_reinterpret_cast
+                    (
+                      ptr_arith_t,
+                      &CORBA_ValueDef::_narrow
+                    )
+                )
+          );
+}
+
+CORBA::ValueDef_ptr
+CORBA::ValueDef::_duplicate (CORBA::ValueDef_ptr obj)
+{
+  if (!CORBA::is_nil (obj))
+    obj->_add_ref ();
+  return obj;
+}
+
+CORBA::Boolean CORBA::ValueDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
+{
+  if (
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/ValueDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Container:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Contained:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IDLType:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
+  return 1; // success using local knowledge
+  else
+    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
+}
+
+void *CORBA::ValueDef::_tao_QueryInterface (ptr_arith_t type)
+{
+  void *retv = 0;
+  if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      CORBA_ValueDef::_narrow))
+    retv = ACE_reinterpret_cast (void*, this);
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::Container::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::Container_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::Contained::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::Contained_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::IDLType::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::IDLType_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::IRObject::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::IRObject_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
+    retv = ACE_reinterpret_cast (void *,
+      ACE_static_cast (CORBA::Object_ptr, this));
+    
+  if (retv)
+    this->_add_ref ();
+  return retv;
+}
+
+const char* CORBA::ValueDef::_interface_repository_id (void) const
+{
+  return "IDL:omg.org/CORBA/ValueDef:1.0";
+}
+
+CORBA::InterfaceDefSeq * CORBA::ValueDef::supported_interfaces (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_ValueDef_Proxy_Impl &proxy = 
+    this->the_TAO_ValueDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.supported_interfaces (
+      this,
+      ACE_TRY_ENV
+    );
+}
+
+void CORBA::ValueDef::supported_interfaces (
+    const CORBA::InterfaceDefSeq & supported_interfaces,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_ValueDef_Proxy_Impl &proxy = 
+    this->the_TAO_ValueDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK;
+  
+  proxy.supported_interfaces (
+      this,
+      supported_interfaces,
+      ACE_TRY_ENV
+    );
+}
+
+CORBA::InitializerSeq * CORBA::ValueDef::initializers (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_ValueDef_Proxy_Impl &proxy = 
+    this->the_TAO_ValueDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.initializers (
+      this,
+      ACE_TRY_ENV
+    );
+}
+
+void CORBA::ValueDef::initializers (
+    const CORBA::InitializerSeq & initializers,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_ValueDef_Proxy_Impl &proxy = 
+    this->the_TAO_ValueDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK;
+  
+  proxy.initializers (
+      this,
+      initializers,
+      ACE_TRY_ENV
+    );
+}
+
+CORBA::ValueDef_ptr CORBA::ValueDef::base_value (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_ValueDef_Proxy_Impl &proxy = 
+    this->the_TAO_ValueDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.base_value (
+      this,
+      ACE_TRY_ENV
+    );
+}
+
+void CORBA::ValueDef::base_value (
+    CORBA::ValueDef_ptr base_value,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_ValueDef_Proxy_Impl &proxy = 
+    this->the_TAO_ValueDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK;
+  
+  proxy.base_value (
+      this,
+      base_value,
+      ACE_TRY_ENV
+    );
+}
+
+CORBA::ValueDefSeq * CORBA::ValueDef::abstract_base_values (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_ValueDef_Proxy_Impl &proxy = 
+    this->the_TAO_ValueDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.abstract_base_values (
+      this,
+      ACE_TRY_ENV
+    );
+}
+
+void CORBA::ValueDef::abstract_base_values (
+    const CORBA::ValueDefSeq & abstract_base_values,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_ValueDef_Proxy_Impl &proxy = 
+    this->the_TAO_ValueDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK;
+  
+  proxy.abstract_base_values (
+      this,
+      abstract_base_values,
+      ACE_TRY_ENV
+    );
+}
+
+CORBA::Boolean CORBA::ValueDef::is_abstract (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_ValueDef_Proxy_Impl &proxy = 
+    this->the_TAO_ValueDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.is_abstract (
+      this,
+      ACE_TRY_ENV
+    );
+}
+
+void CORBA::ValueDef::is_abstract (
+    CORBA::Boolean is_abstract,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_ValueDef_Proxy_Impl &proxy = 
+    this->the_TAO_ValueDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK;
+  
+  proxy.is_abstract (
+      this,
+      is_abstract,
+      ACE_TRY_ENV
+    );
+}
+
+CORBA::Boolean CORBA::ValueDef::is_custom (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_ValueDef_Proxy_Impl &proxy = 
+    this->the_TAO_ValueDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.is_custom (
+      this,
+      ACE_TRY_ENV
+    );
+}
+
+void CORBA::ValueDef::is_custom (
+    CORBA::Boolean is_custom,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_ValueDef_Proxy_Impl &proxy = 
+    this->the_TAO_ValueDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK;
+  
+  proxy.is_custom (
+      this,
+      is_custom,
+      ACE_TRY_ENV
+    );
+}
+
+CORBA::Boolean CORBA::ValueDef::is_truncatable (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_ValueDef_Proxy_Impl &proxy = 
+    this->the_TAO_ValueDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.is_truncatable (
+      this,
+      ACE_TRY_ENV
+    );
+}
+
+void CORBA::ValueDef::is_truncatable (
+    CORBA::Boolean is_truncatable,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_ValueDef_Proxy_Impl &proxy = 
+    this->the_TAO_ValueDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK;
+  
+  proxy.is_truncatable (
+      this,
+      is_truncatable,
+      ACE_TRY_ENV
+    );
+}
+
+CORBA::Boolean CORBA::ValueDef::is_a (
+    const char * id,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_ValueDef_Proxy_Impl &proxy = 
+    this->the_TAO_ValueDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.is_a (
+      this,
+      id,
+      ACE_TRY_ENV
+    );
+}
+
+static const CORBA::Long _oc_CORBA_ValueDef_FullValueDescription[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  52,
+  ACE_NTOHL (0x49444c3a), 
+  ACE_NTOHL (0x6f6d672e), 
+  ACE_NTOHL (0x6f72672f), 
+  ACE_NTOHL (0x434f5242), 
+  ACE_NTOHL (0x412f5661), 
+  ACE_NTOHL (0x6c756544), 
+  ACE_NTOHL (0x65662f46), 
+  ACE_NTOHL (0x756c6c56), 
+  ACE_NTOHL (0x616c7565), 
+  ACE_NTOHL (0x44657363), 
+  ACE_NTOHL (0x72697074), 
+  ACE_NTOHL (0x696f6e3a), 
+  ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/ValueDef/FullValueDescription:1.0
+  21,
+  ACE_NTOHL (0x46756c6c), 
+  ACE_NTOHL (0x56616c75), 
+  ACE_NTOHL (0x65446573), 
+  ACE_NTOHL (0x63726970), 
+  ACE_NTOHL (0x74696f6e), 
+  ACE_NTOHL (0x0),  // name = FullValueDescription
+  15, // member count
+  5,
+  ACE_NTOHL (0x6e616d65), 
+  ACE_NTOHL (0x0),  // name = name
+  CORBA::tk_alias, // typecode kind for typedefs
+  68, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    33,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x434f5242), 
+    ACE_NTOHL (0x412f4964), 
+    ACE_NTOHL (0x656e7469), 
+    ACE_NTOHL (0x66696572), 
+    ACE_NTOHL (0x3a312e30), 
+    ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+    11,
+    ACE_NTOHL (0x4964656e), 
+    ACE_NTOHL (0x74696669), 
+    ACE_NTOHL (0x65720000),  // name = Identifier
+    CORBA::tk_string, 
+    0U, // string length
+
+  3,
+  ACE_NTOHL (0x69640000),  // name = id
+  CORBA::tk_alias, // typecode kind for typedefs
+  72, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    35,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x434f5242), 
+    ACE_NTOHL (0x412f5265), 
+    ACE_NTOHL (0x706f7369), 
+    ACE_NTOHL (0x746f7279), 
+    ACE_NTOHL (0x49643a31), 
+    ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+    13,
+    ACE_NTOHL (0x5265706f), 
+    ACE_NTOHL (0x7369746f), 
+    ACE_NTOHL (0x72794964), 
+    ACE_NTOHL (0x0),  // name = RepositoryId
+    CORBA::tk_string, 
+    0U, // string length
+
+  12,
+  ACE_NTOHL (0x69735f61), 
+  ACE_NTOHL (0x62737472), 
+  ACE_NTOHL (0x61637400),  // name = is_abstract
+  CORBA::tk_boolean,
+
+  10,
+  ACE_NTOHL (0x69735f63), 
+  ACE_NTOHL (0x7573746f), 
+  ACE_NTOHL (0x6d000000),  // name = is_custom
+  CORBA::tk_boolean,
+
+  11,
+  ACE_NTOHL (0x64656669), 
+  ACE_NTOHL (0x6e65645f), 
+  ACE_NTOHL (0x696e0000),  // name = defined_in
+  CORBA::tk_alias, // typecode kind for typedefs
+  72, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    35,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x434f5242), 
+    ACE_NTOHL (0x412f5265), 
+    ACE_NTOHL (0x706f7369), 
+    ACE_NTOHL (0x746f7279), 
+    ACE_NTOHL (0x49643a31), 
+    ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+    13,
+    ACE_NTOHL (0x5265706f), 
+    ACE_NTOHL (0x7369746f), 
+    ACE_NTOHL (0x72794964), 
+    ACE_NTOHL (0x0),  // name = RepositoryId
+    CORBA::tk_string, 
+    0U, // string length
+
+  8,
+  ACE_NTOHL (0x76657273), 
+  ACE_NTOHL (0x696f6e00),  // name = version
+  CORBA::tk_alias, // typecode kind for typedefs
+  68, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    34,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x434f5242), 
+    ACE_NTOHL (0x412f5665), 
+    ACE_NTOHL (0x7273696f), 
+    ACE_NTOHL (0x6e537065), 
+    ACE_NTOHL (0x633a312e), 
+    ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/VersionSpec:1.0
+    12,
+    ACE_NTOHL (0x56657273), 
+    ACE_NTOHL (0x696f6e53), 
+    ACE_NTOHL (0x70656300),  // name = VersionSpec
+    CORBA::tk_string, 
+    0U, // string length
+
+  11,
+  ACE_NTOHL (0x6f706572), 
+  ACE_NTOHL (0x6174696f), 
+  ACE_NTOHL (0x6e730000),  // name = operations
+  CORBA::tk_alias, // typecode kind for typedefs
+  2036, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    39,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x434f5242), 
+    ACE_NTOHL (0x412f4f70), 
+    ACE_NTOHL (0x44657363), 
+    ACE_NTOHL (0x72697074), 
+    ACE_NTOHL (0x696f6e53), 
+    ACE_NTOHL (0x65713a31), 
+    ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/OpDescriptionSeq:1.0
+    17,
+    ACE_NTOHL (0x4f704465), 
+    ACE_NTOHL (0x73637269), 
+    ACE_NTOHL (0x7074696f), 
+    ACE_NTOHL (0x6e536571), 
+    ACE_NTOHL (0x0),  // name = OpDescriptionSeq
+    CORBA::tk_sequence, // typecode kind
+    1956, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      CORBA::tk_struct, // typecode kind
+      1940, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        43,
+        ACE_NTOHL (0x49444c3a), 
+        ACE_NTOHL (0x6f6d672e), 
+        ACE_NTOHL (0x6f72672f), 
+        ACE_NTOHL (0x434f5242), 
+        ACE_NTOHL (0x412f4f70), 
+        ACE_NTOHL (0x65726174), 
+        ACE_NTOHL (0x696f6e44), 
+        ACE_NTOHL (0x65736372), 
+        ACE_NTOHL (0x69707469), 
+        ACE_NTOHL (0x6f6e3a31), 
+        ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/OperationDescription:1.0
+        21,
+        ACE_NTOHL (0x4f706572), 
+        ACE_NTOHL (0x6174696f), 
+        ACE_NTOHL (0x6e446573), 
+        ACE_NTOHL (0x63726970), 
+        ACE_NTOHL (0x74696f6e), 
+        ACE_NTOHL (0x0),  // name = OperationDescription
+        9, // member count
+        5,
+        ACE_NTOHL (0x6e616d65), 
+        ACE_NTOHL (0x0),  // name = name
+        CORBA::tk_alias, // typecode kind for typedefs
+        68, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          33,
+          ACE_NTOHL (0x49444c3a), 
+          ACE_NTOHL (0x6f6d672e), 
+          ACE_NTOHL (0x6f72672f), 
+          ACE_NTOHL (0x434f5242), 
+          ACE_NTOHL (0x412f4964), 
+          ACE_NTOHL (0x656e7469), 
+          ACE_NTOHL (0x66696572), 
+          ACE_NTOHL (0x3a312e30), 
+          ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+          11,
+          ACE_NTOHL (0x4964656e), 
+          ACE_NTOHL (0x74696669), 
+          ACE_NTOHL (0x65720000),  // name = Identifier
+          CORBA::tk_string, 
+          0U, // string length
+
+        3,
+        ACE_NTOHL (0x69640000),  // name = id
+        CORBA::tk_alias, // typecode kind for typedefs
+        72, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          35,
+          ACE_NTOHL (0x49444c3a), 
+          ACE_NTOHL (0x6f6d672e), 
+          ACE_NTOHL (0x6f72672f), 
+          ACE_NTOHL (0x434f5242), 
+          ACE_NTOHL (0x412f5265), 
+          ACE_NTOHL (0x706f7369), 
+          ACE_NTOHL (0x746f7279), 
+          ACE_NTOHL (0x49643a31), 
+          ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+          13,
+          ACE_NTOHL (0x5265706f), 
+          ACE_NTOHL (0x7369746f), 
+          ACE_NTOHL (0x72794964), 
+          ACE_NTOHL (0x0),  // name = RepositoryId
+          CORBA::tk_string, 
+          0U, // string length
+
+        11,
+        ACE_NTOHL (0x64656669), 
+        ACE_NTOHL (0x6e65645f), 
+        ACE_NTOHL (0x696e0000),  // name = defined_in
+        CORBA::tk_alias, // typecode kind for typedefs
+        72, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          35,
+          ACE_NTOHL (0x49444c3a), 
+          ACE_NTOHL (0x6f6d672e), 
+          ACE_NTOHL (0x6f72672f), 
+          ACE_NTOHL (0x434f5242), 
+          ACE_NTOHL (0x412f5265), 
+          ACE_NTOHL (0x706f7369), 
+          ACE_NTOHL (0x746f7279), 
+          ACE_NTOHL (0x49643a31), 
+          ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+          13,
+          ACE_NTOHL (0x5265706f), 
+          ACE_NTOHL (0x7369746f), 
+          ACE_NTOHL (0x72794964), 
+          ACE_NTOHL (0x0),  // name = RepositoryId
+          CORBA::tk_string, 
+          0U, // string length
+
+        8,
+        ACE_NTOHL (0x76657273), 
+        ACE_NTOHL (0x696f6e00),  // name = version
+        CORBA::tk_alias, // typecode kind for typedefs
+        68, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          34,
+          ACE_NTOHL (0x49444c3a), 
+          ACE_NTOHL (0x6f6d672e), 
+          ACE_NTOHL (0x6f72672f), 
+          ACE_NTOHL (0x434f5242), 
+          ACE_NTOHL (0x412f5665), 
+          ACE_NTOHL (0x7273696f), 
+          ACE_NTOHL (0x6e537065), 
+          ACE_NTOHL (0x633a312e), 
+          ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/VersionSpec:1.0
+          12,
+          ACE_NTOHL (0x56657273), 
+          ACE_NTOHL (0x696f6e53), 
+          ACE_NTOHL (0x70656300),  // name = VersionSpec
+          CORBA::tk_string, 
+          0U, // string length
+
+        7,
+        ACE_NTOHL (0x72657375), 
+        ACE_NTOHL (0x6c740000),  // name = result
+        CORBA::tk_TypeCode,
+
+        5,
+        ACE_NTOHL (0x6d6f6465), 
+        ACE_NTOHL (0x0),  // name = mode
+        CORBA::tk_enum, // typecode kind
+        100, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          36,
+          ACE_NTOHL (0x49444c3a), 
+          ACE_NTOHL (0x6f6d672e), 
+          ACE_NTOHL (0x6f72672f), 
+          ACE_NTOHL (0x434f5242), 
+          ACE_NTOHL (0x412f4f70), 
+          ACE_NTOHL (0x65726174), 
+          ACE_NTOHL (0x696f6e4d), 
+          ACE_NTOHL (0x6f64653a), 
+          ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/OperationMode:1.0
+          14,
+          ACE_NTOHL (0x4f706572), 
+          ACE_NTOHL (0x6174696f), 
+          ACE_NTOHL (0x6e4d6f64), 
+          ACE_NTOHL (0x65000000),  // name = OperationMode
+          2, // member count
+          10,
+          ACE_NTOHL (0x4f505f4e), 
+          ACE_NTOHL (0x4f524d41), 
+          ACE_NTOHL (0x4c000000),  // name = OP_NORMAL
+          10,
+          ACE_NTOHL (0x4f505f4f), 
+          ACE_NTOHL (0x4e455741), 
+          ACE_NTOHL (0x59000000),  // name = OP_ONEWAY
+
+        9,
+        ACE_NTOHL (0x636f6e74), 
+        ACE_NTOHL (0x65787473), 
+        ACE_NTOHL (0x0),  // name = contexts
+        CORBA::tk_alias, // typecode kind for typedefs
+        236, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          35,
+          ACE_NTOHL (0x49444c3a), 
+          ACE_NTOHL (0x6f6d672e), 
+          ACE_NTOHL (0x6f72672f), 
+          ACE_NTOHL (0x434f5242), 
+          ACE_NTOHL (0x412f436f), 
+          ACE_NTOHL (0x6e746578), 
+          ACE_NTOHL (0x74496453), 
+          ACE_NTOHL (0x65713a31), 
+          ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/ContextIdSeq:1.0
+          13,
+          ACE_NTOHL (0x436f6e74), 
+          ACE_NTOHL (0x65787449), 
+          ACE_NTOHL (0x64536571), 
+          ACE_NTOHL (0x0),  // name = ContextIdSeq
+          CORBA::tk_sequence, // typecode kind
+          164, // encapsulation length
+            TAO_ENCAP_BYTE_ORDER, // byte order
+            CORBA::tk_alias, // typecode kind for typedefs
+            148, // encapsulation length
+              TAO_ENCAP_BYTE_ORDER, // byte order
+              40,
+              ACE_NTOHL (0x49444c3a), 
+              ACE_NTOHL (0x6f6d672e), 
+              ACE_NTOHL (0x6f72672f), 
+              ACE_NTOHL (0x434f5242), 
+              ACE_NTOHL (0x412f436f), 
+              ACE_NTOHL (0x6e746578), 
+              ACE_NTOHL (0x74496465), 
+              ACE_NTOHL (0x6e746966), 
+              ACE_NTOHL (0x6965723a), 
+              ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/ContextIdentifier:1.0
+              18,
+              ACE_NTOHL (0x436f6e74), 
+              ACE_NTOHL (0x65787449), 
+              ACE_NTOHL (0x64656e74), 
+              ACE_NTOHL (0x69666965), 
+              ACE_NTOHL (0x72000000),  // name = ContextIdentifier
+              CORBA::tk_alias, // typecode kind for typedefs
+              68, // encapsulation length
+                TAO_ENCAP_BYTE_ORDER, // byte order
+                33,
+                ACE_NTOHL (0x49444c3a), 
+                ACE_NTOHL (0x6f6d672e), 
+                ACE_NTOHL (0x6f72672f), 
+                ACE_NTOHL (0x434f5242), 
+                ACE_NTOHL (0x412f4964), 
+                ACE_NTOHL (0x656e7469), 
+                ACE_NTOHL (0x66696572), 
+                ACE_NTOHL (0x3a312e30), 
+                ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+                11,
+                ACE_NTOHL (0x4964656e), 
+                ACE_NTOHL (0x74696669), 
+                ACE_NTOHL (0x65720000),  // name = Identifier
+                CORBA::tk_string, 
+                0U, // string length
+
+
+            0U,
+
+
+        11,
+        ACE_NTOHL (0x70617261), 
+        ACE_NTOHL (0x6d657465), 
+        ACE_NTOHL (0x72730000),  // name = parameters
+        CORBA::tk_alias, // typecode kind for typedefs
+        496, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          40,
+          ACE_NTOHL (0x49444c3a), 
+          ACE_NTOHL (0x6f6d672e), 
+          ACE_NTOHL (0x6f72672f), 
+          ACE_NTOHL (0x434f5242), 
+          ACE_NTOHL (0x412f5061), 
+          ACE_NTOHL (0x72446573), 
+          ACE_NTOHL (0x63726970), 
+          ACE_NTOHL (0x74696f6e), 
+          ACE_NTOHL (0x5365713a), 
+          ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/ParDescriptionSeq:1.0
+          18,
+          ACE_NTOHL (0x50617244), 
+          ACE_NTOHL (0x65736372), 
+          ACE_NTOHL (0x69707469), 
+          ACE_NTOHL (0x6f6e5365), 
+          ACE_NTOHL (0x71000000),  // name = ParDescriptionSeq
+          CORBA::tk_sequence, // typecode kind
+          416, // encapsulation length
+            TAO_ENCAP_BYTE_ORDER, // byte order
+            CORBA::tk_struct, // typecode kind
+            400, // encapsulation length
+              TAO_ENCAP_BYTE_ORDER, // byte order
+              43,
+              ACE_NTOHL (0x49444c3a), 
+              ACE_NTOHL (0x6f6d672e), 
+              ACE_NTOHL (0x6f72672f), 
+              ACE_NTOHL (0x434f5242), 
+              ACE_NTOHL (0x412f5061), 
+              ACE_NTOHL (0x72616d65), 
+              ACE_NTOHL (0x74657244), 
+              ACE_NTOHL (0x65736372), 
+              ACE_NTOHL (0x69707469), 
+              ACE_NTOHL (0x6f6e3a31), 
+              ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/ParameterDescription:1.0
+              21,
+              ACE_NTOHL (0x50617261), 
+              ACE_NTOHL (0x6d657465), 
+              ACE_NTOHL (0x72446573), 
+              ACE_NTOHL (0x63726970), 
+              ACE_NTOHL (0x74696f6e), 
+              ACE_NTOHL (0x0),  // name = ParameterDescription
+              4, // member count
+              5,
+              ACE_NTOHL (0x6e616d65), 
+              ACE_NTOHL (0x0),  // name = name
+              CORBA::tk_alias, // typecode kind for typedefs
+              68, // encapsulation length
+                TAO_ENCAP_BYTE_ORDER, // byte order
+                33,
+                ACE_NTOHL (0x49444c3a), 
+                ACE_NTOHL (0x6f6d672e), 
+                ACE_NTOHL (0x6f72672f), 
+                ACE_NTOHL (0x434f5242), 
+                ACE_NTOHL (0x412f4964), 
+                ACE_NTOHL (0x656e7469), 
+                ACE_NTOHL (0x66696572), 
+                ACE_NTOHL (0x3a312e30), 
+                ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+                11,
+                ACE_NTOHL (0x4964656e), 
+                ACE_NTOHL (0x74696669), 
+                ACE_NTOHL (0x65720000),  // name = Identifier
+                CORBA::tk_string, 
+                0U, // string length
+
+              5,
+              ACE_NTOHL (0x74797065), 
+              ACE_NTOHL (0x0),  // name = type
+              CORBA::tk_TypeCode,
+
+              9,
+              ACE_NTOHL (0x74797065), 
+              ACE_NTOHL (0x5f646566), 
+              ACE_NTOHL (0x0),  // name = type_def
+              CORBA::tk_objref, // typecode kind
+              52, // encapsulation length
+                TAO_ENCAP_BYTE_ORDER, // byte order
+                30,
+                ACE_NTOHL (0x49444c3a), 
+                ACE_NTOHL (0x6f6d672e), 
+                ACE_NTOHL (0x6f72672f), 
+                ACE_NTOHL (0x434f5242), 
+                ACE_NTOHL (0x412f4944), 
+                ACE_NTOHL (0x4c547970), 
+                ACE_NTOHL (0x653a312e), 
+                ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/IDLType:1.0
+                8,
+                ACE_NTOHL (0x49444c54), 
+                ACE_NTOHL (0x79706500),  // name = IDLType
+
+              5,
+              ACE_NTOHL (0x6d6f6465), 
+              ACE_NTOHL (0x0),  // name = mode
+              CORBA::tk_enum, // typecode kind
+              116, // encapsulation length
+                TAO_ENCAP_BYTE_ORDER, // byte order
+                36,
+                ACE_NTOHL (0x49444c3a), 
+                ACE_NTOHL (0x6f6d672e), 
+                ACE_NTOHL (0x6f72672f), 
+                ACE_NTOHL (0x434f5242), 
+                ACE_NTOHL (0x412f5061), 
+                ACE_NTOHL (0x72616d65), 
+                ACE_NTOHL (0x7465724d), 
+                ACE_NTOHL (0x6f64653a), 
+                ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/ParameterMode:1.0
+                14,
+                ACE_NTOHL (0x50617261), 
+                ACE_NTOHL (0x6d657465), 
+                ACE_NTOHL (0x724d6f64), 
+                ACE_NTOHL (0x65000000),  // name = ParameterMode
+                3, // member count
+                9,
+                ACE_NTOHL (0x50415241), 
+                ACE_NTOHL (0x4d5f494e), 
+                ACE_NTOHL (0x0),  // name = PARAM_IN
+                10,
+                ACE_NTOHL (0x50415241), 
+                ACE_NTOHL (0x4d5f4f55), 
+                ACE_NTOHL (0x54000000),  // name = PARAM_OUT
+                12,
+                ACE_NTOHL (0x50415241), 
+                ACE_NTOHL (0x4d5f494e), 
+                ACE_NTOHL (0x4f555400),  // name = PARAM_INOUT
+
+
+            0U,
+
+
+        11,
+        ACE_NTOHL (0x65786365), 
+        ACE_NTOHL (0x7074696f), 
+        ACE_NTOHL (0x6e730000),  // name = exceptions
+        CORBA::tk_alias, // typecode kind for typedefs
+        556, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          40,
+          ACE_NTOHL (0x49444c3a), 
+          ACE_NTOHL (0x6f6d672e), 
+          ACE_NTOHL (0x6f72672f), 
+          ACE_NTOHL (0x434f5242), 
+          ACE_NTOHL (0x412f4578), 
+          ACE_NTOHL (0x63446573), 
+          ACE_NTOHL (0x63726970), 
+          ACE_NTOHL (0x74696f6e), 
+          ACE_NTOHL (0x5365713a), 
+          ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/ExcDescriptionSeq:1.0
+          18,
+          ACE_NTOHL (0x45786344), 
+          ACE_NTOHL (0x65736372), 
+          ACE_NTOHL (0x69707469), 
+          ACE_NTOHL (0x6f6e5365), 
+          ACE_NTOHL (0x71000000),  // name = ExcDescriptionSeq
+          CORBA::tk_sequence, // typecode kind
+          476, // encapsulation length
+            TAO_ENCAP_BYTE_ORDER, // byte order
+            CORBA::tk_struct, // typecode kind
+            460, // encapsulation length
+              TAO_ENCAP_BYTE_ORDER, // byte order
+              43,
+              ACE_NTOHL (0x49444c3a), 
+              ACE_NTOHL (0x6f6d672e), 
+              ACE_NTOHL (0x6f72672f), 
+              ACE_NTOHL (0x434f5242), 
+              ACE_NTOHL (0x412f4578), 
+              ACE_NTOHL (0x63657074), 
+              ACE_NTOHL (0x696f6e44), 
+              ACE_NTOHL (0x65736372), 
+              ACE_NTOHL (0x69707469), 
+              ACE_NTOHL (0x6f6e3a31), 
+              ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/ExceptionDescription:1.0
+              21,
+              ACE_NTOHL (0x45786365), 
+              ACE_NTOHL (0x7074696f), 
+              ACE_NTOHL (0x6e446573), 
+              ACE_NTOHL (0x63726970), 
+              ACE_NTOHL (0x74696f6e), 
+              ACE_NTOHL (0x0),  // name = ExceptionDescription
+              5, // member count
+              5,
+              ACE_NTOHL (0x6e616d65), 
+              ACE_NTOHL (0x0),  // name = name
+              CORBA::tk_alias, // typecode kind for typedefs
+              68, // encapsulation length
+                TAO_ENCAP_BYTE_ORDER, // byte order
+                33,
+                ACE_NTOHL (0x49444c3a), 
+                ACE_NTOHL (0x6f6d672e), 
+                ACE_NTOHL (0x6f72672f), 
+                ACE_NTOHL (0x434f5242), 
+                ACE_NTOHL (0x412f4964), 
+                ACE_NTOHL (0x656e7469), 
+                ACE_NTOHL (0x66696572), 
+                ACE_NTOHL (0x3a312e30), 
+                ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+                11,
+                ACE_NTOHL (0x4964656e), 
+                ACE_NTOHL (0x74696669), 
+                ACE_NTOHL (0x65720000),  // name = Identifier
+                CORBA::tk_string, 
+                0U, // string length
+
+              3,
+              ACE_NTOHL (0x69640000),  // name = id
+              CORBA::tk_alias, // typecode kind for typedefs
+              72, // encapsulation length
+                TAO_ENCAP_BYTE_ORDER, // byte order
+                35,
+                ACE_NTOHL (0x49444c3a), 
+                ACE_NTOHL (0x6f6d672e), 
+                ACE_NTOHL (0x6f72672f), 
+                ACE_NTOHL (0x434f5242), 
+                ACE_NTOHL (0x412f5265), 
+                ACE_NTOHL (0x706f7369), 
+                ACE_NTOHL (0x746f7279), 
+                ACE_NTOHL (0x49643a31), 
+                ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+                13,
+                ACE_NTOHL (0x5265706f), 
+                ACE_NTOHL (0x7369746f), 
+                ACE_NTOHL (0x72794964), 
+                ACE_NTOHL (0x0),  // name = RepositoryId
+                CORBA::tk_string, 
+                0U, // string length
+
+              11,
+              ACE_NTOHL (0x64656669), 
+              ACE_NTOHL (0x6e65645f), 
+              ACE_NTOHL (0x696e0000),  // name = defined_in
+              CORBA::tk_alias, // typecode kind for typedefs
+              72, // encapsulation length
+                TAO_ENCAP_BYTE_ORDER, // byte order
+                35,
+                ACE_NTOHL (0x49444c3a), 
+                ACE_NTOHL (0x6f6d672e), 
+                ACE_NTOHL (0x6f72672f), 
+                ACE_NTOHL (0x434f5242), 
+                ACE_NTOHL (0x412f5265), 
+                ACE_NTOHL (0x706f7369), 
+                ACE_NTOHL (0x746f7279), 
+                ACE_NTOHL (0x49643a31), 
+                ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+                13,
+                ACE_NTOHL (0x5265706f), 
+                ACE_NTOHL (0x7369746f), 
+                ACE_NTOHL (0x72794964), 
+                ACE_NTOHL (0x0),  // name = RepositoryId
+                CORBA::tk_string, 
+                0U, // string length
+
+              8,
+              ACE_NTOHL (0x76657273), 
+              ACE_NTOHL (0x696f6e00),  // name = version
+              CORBA::tk_alias, // typecode kind for typedefs
+              68, // encapsulation length
+                TAO_ENCAP_BYTE_ORDER, // byte order
+                34,
+                ACE_NTOHL (0x49444c3a), 
+                ACE_NTOHL (0x6f6d672e), 
+                ACE_NTOHL (0x6f72672f), 
+                ACE_NTOHL (0x434f5242), 
+                ACE_NTOHL (0x412f5665), 
+                ACE_NTOHL (0x7273696f), 
+                ACE_NTOHL (0x6e537065), 
+                ACE_NTOHL (0x633a312e), 
+                ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/VersionSpec:1.0
+                12,
+                ACE_NTOHL (0x56657273), 
+                ACE_NTOHL (0x696f6e53), 
+                ACE_NTOHL (0x70656300),  // name = VersionSpec
+                CORBA::tk_string, 
+                0U, // string length
+
+              5,
+              ACE_NTOHL (0x74797065), 
+              ACE_NTOHL (0x0),  // name = type
+              CORBA::tk_TypeCode,
+
+
+            0U,
+
+
+
+      0U,
+
+
+  11,
+  ACE_NTOHL (0x61747472), 
+  ACE_NTOHL (0x69627574), 
+  ACE_NTOHL (0x65730000),  // name = attributes
+  CORBA::tk_alias, // typecode kind for typedefs
+  684, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    41,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x434f5242), 
+    ACE_NTOHL (0x412f4174), 
+    ACE_NTOHL (0x74724465), 
+    ACE_NTOHL (0x73637269), 
+    ACE_NTOHL (0x7074696f), 
+    ACE_NTOHL (0x6e536571), 
+    ACE_NTOHL (0x3a312e30), 
+    ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/AttrDescriptionSeq:1.0
+    19,
+    ACE_NTOHL (0x41747472), 
+    ACE_NTOHL (0x44657363), 
+    ACE_NTOHL (0x72697074), 
+    ACE_NTOHL (0x696f6e53), 
+    ACE_NTOHL (0x65710000),  // name = AttrDescriptionSeq
+    CORBA::tk_sequence, // typecode kind
+    600, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      CORBA::tk_struct, // typecode kind
+      584, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        43,
+        ACE_NTOHL (0x49444c3a), 
+        ACE_NTOHL (0x6f6d672e), 
+        ACE_NTOHL (0x6f72672f), 
+        ACE_NTOHL (0x434f5242), 
+        ACE_NTOHL (0x412f4174), 
+        ACE_NTOHL (0x74726962), 
+        ACE_NTOHL (0x75746544), 
+        ACE_NTOHL (0x65736372), 
+        ACE_NTOHL (0x69707469), 
+        ACE_NTOHL (0x6f6e3a31), 
+        ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/AttributeDescription:1.0
+        21,
+        ACE_NTOHL (0x41747472), 
+        ACE_NTOHL (0x69627574), 
+        ACE_NTOHL (0x65446573), 
+        ACE_NTOHL (0x63726970), 
+        ACE_NTOHL (0x74696f6e), 
+        ACE_NTOHL (0x0),  // name = AttributeDescription
+        6, // member count
+        5,
+        ACE_NTOHL (0x6e616d65), 
+        ACE_NTOHL (0x0),  // name = name
+        CORBA::tk_alias, // typecode kind for typedefs
+        68, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          33,
+          ACE_NTOHL (0x49444c3a), 
+          ACE_NTOHL (0x6f6d672e), 
+          ACE_NTOHL (0x6f72672f), 
+          ACE_NTOHL (0x434f5242), 
+          ACE_NTOHL (0x412f4964), 
+          ACE_NTOHL (0x656e7469), 
+          ACE_NTOHL (0x66696572), 
+          ACE_NTOHL (0x3a312e30), 
+          ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+          11,
+          ACE_NTOHL (0x4964656e), 
+          ACE_NTOHL (0x74696669), 
+          ACE_NTOHL (0x65720000),  // name = Identifier
+          CORBA::tk_string, 
+          0U, // string length
+
+        3,
+        ACE_NTOHL (0x69640000),  // name = id
+        CORBA::tk_alias, // typecode kind for typedefs
+        72, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          35,
+          ACE_NTOHL (0x49444c3a), 
+          ACE_NTOHL (0x6f6d672e), 
+          ACE_NTOHL (0x6f72672f), 
+          ACE_NTOHL (0x434f5242), 
+          ACE_NTOHL (0x412f5265), 
+          ACE_NTOHL (0x706f7369), 
+          ACE_NTOHL (0x746f7279), 
+          ACE_NTOHL (0x49643a31), 
+          ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+          13,
+          ACE_NTOHL (0x5265706f), 
+          ACE_NTOHL (0x7369746f), 
+          ACE_NTOHL (0x72794964), 
+          ACE_NTOHL (0x0),  // name = RepositoryId
+          CORBA::tk_string, 
+          0U, // string length
+
+        11,
+        ACE_NTOHL (0x64656669), 
+        ACE_NTOHL (0x6e65645f), 
+        ACE_NTOHL (0x696e0000),  // name = defined_in
+        CORBA::tk_alias, // typecode kind for typedefs
+        72, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          35,
+          ACE_NTOHL (0x49444c3a), 
+          ACE_NTOHL (0x6f6d672e), 
+          ACE_NTOHL (0x6f72672f), 
+          ACE_NTOHL (0x434f5242), 
+          ACE_NTOHL (0x412f5265), 
+          ACE_NTOHL (0x706f7369), 
+          ACE_NTOHL (0x746f7279), 
+          ACE_NTOHL (0x49643a31), 
+          ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+          13,
+          ACE_NTOHL (0x5265706f), 
+          ACE_NTOHL (0x7369746f), 
+          ACE_NTOHL (0x72794964), 
+          ACE_NTOHL (0x0),  // name = RepositoryId
+          CORBA::tk_string, 
+          0U, // string length
+
+        8,
+        ACE_NTOHL (0x76657273), 
+        ACE_NTOHL (0x696f6e00),  // name = version
+        CORBA::tk_alias, // typecode kind for typedefs
+        68, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          34,
+          ACE_NTOHL (0x49444c3a), 
+          ACE_NTOHL (0x6f6d672e), 
+          ACE_NTOHL (0x6f72672f), 
+          ACE_NTOHL (0x434f5242), 
+          ACE_NTOHL (0x412f5665), 
+          ACE_NTOHL (0x7273696f), 
+          ACE_NTOHL (0x6e537065), 
+          ACE_NTOHL (0x633a312e), 
+          ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/VersionSpec:1.0
+          12,
+          ACE_NTOHL (0x56657273), 
+          ACE_NTOHL (0x696f6e53), 
+          ACE_NTOHL (0x70656300),  // name = VersionSpec
+          CORBA::tk_string, 
+          0U, // string length
+
+        5,
+        ACE_NTOHL (0x74797065), 
+        ACE_NTOHL (0x0),  // name = type
+        CORBA::tk_TypeCode,
+
+        5,
+        ACE_NTOHL (0x6d6f6465), 
+        ACE_NTOHL (0x0),  // name = mode
+        CORBA::tk_enum, // typecode kind
+        104, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          36,
+          ACE_NTOHL (0x49444c3a), 
+          ACE_NTOHL (0x6f6d672e), 
+          ACE_NTOHL (0x6f72672f), 
+          ACE_NTOHL (0x434f5242), 
+          ACE_NTOHL (0x412f4174), 
+          ACE_NTOHL (0x74726962), 
+          ACE_NTOHL (0x7574654d), 
+          ACE_NTOHL (0x6f64653a), 
+          ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/AttributeMode:1.0
+          14,
+          ACE_NTOHL (0x41747472), 
+          ACE_NTOHL (0x69627574), 
+          ACE_NTOHL (0x654d6f64), 
+          ACE_NTOHL (0x65000000),  // name = AttributeMode
+          2, // member count
+          12,
+          ACE_NTOHL (0x41545452), 
+          ACE_NTOHL (0x5f4e4f52), 
+          ACE_NTOHL (0x4d414c00),  // name = ATTR_NORMAL
+          14,
+          ACE_NTOHL (0x41545452), 
+          ACE_NTOHL (0x5f524541), 
+          ACE_NTOHL (0x444f4e4c), 
+          ACE_NTOHL (0x59000000),  // name = ATTR_READONLY
+
+
+      0U,
+
+
+  8,
+  ACE_NTOHL (0x6d656d62), 
+  ACE_NTOHL (0x65727300),  // name = members
+  CORBA::tk_alias, // typecode kind for typedefs
+  692, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    37,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x434f5242), 
+    ACE_NTOHL (0x412f5661), 
+    ACE_NTOHL (0x6c75654d), 
+    ACE_NTOHL (0x656d6265), 
+    ACE_NTOHL (0x72536571), 
+    ACE_NTOHL (0x3a312e30), 
+    ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/ValueMemberSeq:1.0
+    15,
+    ACE_NTOHL (0x56616c75), 
+    ACE_NTOHL (0x654d656d), 
+    ACE_NTOHL (0x62657253), 
+    ACE_NTOHL (0x65710000),  // name = ValueMemberSeq
+    CORBA::tk_sequence, // typecode kind
+    616, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      CORBA::tk_struct, // typecode kind
+      600, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        34,
+        ACE_NTOHL (0x49444c3a), 
+        ACE_NTOHL (0x6f6d672e), 
+        ACE_NTOHL (0x6f72672f), 
+        ACE_NTOHL (0x434f5242), 
+        ACE_NTOHL (0x412f5661), 
+        ACE_NTOHL (0x6c75654d), 
+        ACE_NTOHL (0x656d6265), 
+        ACE_NTOHL (0x723a312e), 
+        ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/ValueMember:1.0
+        12,
+        ACE_NTOHL (0x56616c75), 
+        ACE_NTOHL (0x654d656d), 
+        ACE_NTOHL (0x62657200),  // name = ValueMember
+        7, // member count
+        5,
+        ACE_NTOHL (0x6e616d65), 
+        ACE_NTOHL (0x0),  // name = name
+        CORBA::tk_alias, // typecode kind for typedefs
+        68, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          33,
+          ACE_NTOHL (0x49444c3a), 
+          ACE_NTOHL (0x6f6d672e), 
+          ACE_NTOHL (0x6f72672f), 
+          ACE_NTOHL (0x434f5242), 
+          ACE_NTOHL (0x412f4964), 
+          ACE_NTOHL (0x656e7469), 
+          ACE_NTOHL (0x66696572), 
+          ACE_NTOHL (0x3a312e30), 
+          ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+          11,
+          ACE_NTOHL (0x4964656e), 
+          ACE_NTOHL (0x74696669), 
+          ACE_NTOHL (0x65720000),  // name = Identifier
+          CORBA::tk_string, 
+          0U, // string length
+
+        3,
+        ACE_NTOHL (0x69640000),  // name = id
+        CORBA::tk_alias, // typecode kind for typedefs
+        72, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          35,
+          ACE_NTOHL (0x49444c3a), 
+          ACE_NTOHL (0x6f6d672e), 
+          ACE_NTOHL (0x6f72672f), 
+          ACE_NTOHL (0x434f5242), 
+          ACE_NTOHL (0x412f5265), 
+          ACE_NTOHL (0x706f7369), 
+          ACE_NTOHL (0x746f7279), 
+          ACE_NTOHL (0x49643a31), 
+          ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+          13,
+          ACE_NTOHL (0x5265706f), 
+          ACE_NTOHL (0x7369746f), 
+          ACE_NTOHL (0x72794964), 
+          ACE_NTOHL (0x0),  // name = RepositoryId
+          CORBA::tk_string, 
+          0U, // string length
+
+        11,
+        ACE_NTOHL (0x64656669), 
+        ACE_NTOHL (0x6e65645f), 
+        ACE_NTOHL (0x696e0000),  // name = defined_in
+        CORBA::tk_alias, // typecode kind for typedefs
+        72, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          35,
+          ACE_NTOHL (0x49444c3a), 
+          ACE_NTOHL (0x6f6d672e), 
+          ACE_NTOHL (0x6f72672f), 
+          ACE_NTOHL (0x434f5242), 
+          ACE_NTOHL (0x412f5265), 
+          ACE_NTOHL (0x706f7369), 
+          ACE_NTOHL (0x746f7279), 
+          ACE_NTOHL (0x49643a31), 
+          ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+          13,
+          ACE_NTOHL (0x5265706f), 
+          ACE_NTOHL (0x7369746f), 
+          ACE_NTOHL (0x72794964), 
+          ACE_NTOHL (0x0),  // name = RepositoryId
+          CORBA::tk_string, 
+          0U, // string length
+
+        8,
+        ACE_NTOHL (0x76657273), 
+        ACE_NTOHL (0x696f6e00),  // name = version
+        CORBA::tk_alias, // typecode kind for typedefs
+        68, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          34,
+          ACE_NTOHL (0x49444c3a), 
+          ACE_NTOHL (0x6f6d672e), 
+          ACE_NTOHL (0x6f72672f), 
+          ACE_NTOHL (0x434f5242), 
+          ACE_NTOHL (0x412f5665), 
+          ACE_NTOHL (0x7273696f), 
+          ACE_NTOHL (0x6e537065), 
+          ACE_NTOHL (0x633a312e), 
+          ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/VersionSpec:1.0
+          12,
+          ACE_NTOHL (0x56657273), 
+          ACE_NTOHL (0x696f6e53), 
+          ACE_NTOHL (0x70656300),  // name = VersionSpec
+          CORBA::tk_string, 
+          0U, // string length
+
+        5,
+        ACE_NTOHL (0x74797065), 
+        ACE_NTOHL (0x0),  // name = type
+        CORBA::tk_TypeCode,
+
+        9,
+        ACE_NTOHL (0x74797065), 
+        ACE_NTOHL (0x5f646566), 
+        ACE_NTOHL (0x0),  // name = type_def
+        CORBA::tk_objref, // typecode kind
+        52, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          30,
+          ACE_NTOHL (0x49444c3a), 
+          ACE_NTOHL (0x6f6d672e), 
+          ACE_NTOHL (0x6f72672f), 
+          ACE_NTOHL (0x434f5242), 
+          ACE_NTOHL (0x412f4944), 
+          ACE_NTOHL (0x4c547970), 
+          ACE_NTOHL (0x653a312e), 
+          ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/IDLType:1.0
+          8,
+          ACE_NTOHL (0x49444c54), 
+          ACE_NTOHL (0x79706500),  // name = IDLType
+
+        7,
+        ACE_NTOHL (0x61636365), 
+        ACE_NTOHL (0x73730000),  // name = access
+        CORBA::tk_alias, // typecode kind for typedefs
+        64, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          33,
+          ACE_NTOHL (0x49444c3a), 
+          ACE_NTOHL (0x6f6d672e), 
+          ACE_NTOHL (0x6f72672f), 
+          ACE_NTOHL (0x434f5242), 
+          ACE_NTOHL (0x412f5669), 
+          ACE_NTOHL (0x73696269), 
+          ACE_NTOHL (0x6c697479), 
+          ACE_NTOHL (0x3a312e30), 
+          ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Visibility:1.0
+          11,
+          ACE_NTOHL (0x56697369), 
+          ACE_NTOHL (0x62696c69), 
+          ACE_NTOHL (0x74790000),  // name = Visibility
+          CORBA::tk_short,
+
+
+
+      0U,
+
+
+  13,
+  ACE_NTOHL (0x696e6974), 
+  ACE_NTOHL (0x69616c69), 
+  ACE_NTOHL (0x7a657273), 
+  ACE_NTOHL (0x0),  // name = initializers
+  CORBA::tk_alias, // typecode kind for typedefs
+  604, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    37,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x434f5242), 
+    ACE_NTOHL (0x412f496e), 
+    ACE_NTOHL (0x69746961), 
+    ACE_NTOHL (0x6c697a65), 
+    ACE_NTOHL (0x72536571), 
+    ACE_NTOHL (0x3a312e30), 
+    ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/InitializerSeq:1.0
+    15,
+    ACE_NTOHL (0x496e6974), 
+    ACE_NTOHL (0x69616c69), 
+    ACE_NTOHL (0x7a657253), 
+    ACE_NTOHL (0x65710000),  // name = InitializerSeq
+    CORBA::tk_sequence, // typecode kind
+    528, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      CORBA::tk_struct, // typecode kind
+      512, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        34,
+        ACE_NTOHL (0x49444c3a), 
+        ACE_NTOHL (0x6f6d672e), 
+        ACE_NTOHL (0x6f72672f), 
+        ACE_NTOHL (0x434f5242), 
+        ACE_NTOHL (0x412f496e), 
+        ACE_NTOHL (0x69746961), 
+        ACE_NTOHL (0x6c697a65), 
+        ACE_NTOHL (0x723a312e), 
+        ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/Initializer:1.0
+        12,
+        ACE_NTOHL (0x496e6974), 
+        ACE_NTOHL (0x69616c69), 
+        ACE_NTOHL (0x7a657200),  // name = Initializer
+        2, // member count
+        8,
+        ACE_NTOHL (0x6d656d62), 
+        ACE_NTOHL (0x65727300),  // name = members
+        CORBA::tk_alias, // typecode kind for typedefs
+        340, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          38,
+          ACE_NTOHL (0x49444c3a), 
+          ACE_NTOHL (0x6f6d672e), 
+          ACE_NTOHL (0x6f72672f), 
+          ACE_NTOHL (0x434f5242), 
+          ACE_NTOHL (0x412f5374), 
+          ACE_NTOHL (0x72756374), 
+          ACE_NTOHL (0x4d656d62), 
+          ACE_NTOHL (0x65725365), 
+          ACE_NTOHL (0x713a312e), 
+          ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/StructMemberSeq:1.0
+          16,
+          ACE_NTOHL (0x53747275), 
+          ACE_NTOHL (0x63744d65), 
+          ACE_NTOHL (0x6d626572), 
+          ACE_NTOHL (0x53657100),  // name = StructMemberSeq
+          CORBA::tk_sequence, // typecode kind
+          264, // encapsulation length
+            TAO_ENCAP_BYTE_ORDER, // byte order
+            CORBA::tk_struct, // typecode kind
+            248, // encapsulation length
+              TAO_ENCAP_BYTE_ORDER, // byte order
+              35,
+              ACE_NTOHL (0x49444c3a), 
+              ACE_NTOHL (0x6f6d672e), 
+              ACE_NTOHL (0x6f72672f), 
+              ACE_NTOHL (0x434f5242), 
+              ACE_NTOHL (0x412f5374), 
+              ACE_NTOHL (0x72756374), 
+              ACE_NTOHL (0x4d656d62), 
+              ACE_NTOHL (0x65723a31), 
+              ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/StructMember:1.0
+              13,
+              ACE_NTOHL (0x53747275), 
+              ACE_NTOHL (0x63744d65), 
+              ACE_NTOHL (0x6d626572), 
+              ACE_NTOHL (0x0),  // name = StructMember
+              3, // member count
+              5,
+              ACE_NTOHL (0x6e616d65), 
+              ACE_NTOHL (0x0),  // name = name
+              CORBA::tk_alias, // typecode kind for typedefs
+              68, // encapsulation length
+                TAO_ENCAP_BYTE_ORDER, // byte order
+                33,
+                ACE_NTOHL (0x49444c3a), 
+                ACE_NTOHL (0x6f6d672e), 
+                ACE_NTOHL (0x6f72672f), 
+                ACE_NTOHL (0x434f5242), 
+                ACE_NTOHL (0x412f4964), 
+                ACE_NTOHL (0x656e7469), 
+                ACE_NTOHL (0x66696572), 
+                ACE_NTOHL (0x3a312e30), 
+                ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+                11,
+                ACE_NTOHL (0x4964656e), 
+                ACE_NTOHL (0x74696669), 
+                ACE_NTOHL (0x65720000),  // name = Identifier
+                CORBA::tk_string, 
+                0U, // string length
+
+              5,
+              ACE_NTOHL (0x74797065), 
+              ACE_NTOHL (0x0),  // name = type
+              CORBA::tk_TypeCode,
+
+              9,
+              ACE_NTOHL (0x74797065), 
+              ACE_NTOHL (0x5f646566), 
+              ACE_NTOHL (0x0),  // name = type_def
+              CORBA::tk_objref, // typecode kind
+              52, // encapsulation length
+                TAO_ENCAP_BYTE_ORDER, // byte order
+                30,
+                ACE_NTOHL (0x49444c3a), 
+                ACE_NTOHL (0x6f6d672e), 
+                ACE_NTOHL (0x6f72672f), 
+                ACE_NTOHL (0x434f5242), 
+                ACE_NTOHL (0x412f4944), 
+                ACE_NTOHL (0x4c547970), 
+                ACE_NTOHL (0x653a312e), 
+                ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/IDLType:1.0
+                8,
+                ACE_NTOHL (0x49444c54), 
+                ACE_NTOHL (0x79706500),  // name = IDLType
+
+
+            0U,
+
+
+        5,
+        ACE_NTOHL (0x6e616d65), 
+        ACE_NTOHL (0x0),  // name = name
+        CORBA::tk_alias, // typecode kind for typedefs
+        68, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          33,
+          ACE_NTOHL (0x49444c3a), 
+          ACE_NTOHL (0x6f6d672e), 
+          ACE_NTOHL (0x6f72672f), 
+          ACE_NTOHL (0x434f5242), 
+          ACE_NTOHL (0x412f4964), 
+          ACE_NTOHL (0x656e7469), 
+          ACE_NTOHL (0x66696572), 
+          ACE_NTOHL (0x3a312e30), 
+          ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+          11,
+          ACE_NTOHL (0x4964656e), 
+          ACE_NTOHL (0x74696669), 
+          ACE_NTOHL (0x65720000),  // name = Identifier
+          CORBA::tk_string, 
+          0U, // string length
+
+
+      0U,
+
+
+  21,
+  ACE_NTOHL (0x73757070), 
+  ACE_NTOHL (0x6f727465), 
+  ACE_NTOHL (0x645f696e), 
+  ACE_NTOHL (0x74657266), 
+  ACE_NTOHL (0x61636573), 
+  ACE_NTOHL (0x0),  // name = supported_interfaces
+  CORBA::tk_alias, // typecode kind for typedefs
+  164, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    38,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x434f5242), 
+    ACE_NTOHL (0x412f5265), 
+    ACE_NTOHL (0x706f7369), 
+    ACE_NTOHL (0x746f7279), 
+    ACE_NTOHL (0x49645365), 
+    ACE_NTOHL (0x713a312e), 
+    ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/RepositoryIdSeq:1.0
+    16,
+    ACE_NTOHL (0x5265706f), 
+    ACE_NTOHL (0x7369746f), 
+    ACE_NTOHL (0x72794964), 
+    ACE_NTOHL (0x53657100),  // name = RepositoryIdSeq
+    CORBA::tk_sequence, // typecode kind
+    88, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      CORBA::tk_alias, // typecode kind for typedefs
+      72, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        35,
+        ACE_NTOHL (0x49444c3a), 
+        ACE_NTOHL (0x6f6d672e), 
+        ACE_NTOHL (0x6f72672f), 
+        ACE_NTOHL (0x434f5242), 
+        ACE_NTOHL (0x412f5265), 
+        ACE_NTOHL (0x706f7369), 
+        ACE_NTOHL (0x746f7279), 
+        ACE_NTOHL (0x49643a31), 
+        ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+        13,
+        ACE_NTOHL (0x5265706f), 
+        ACE_NTOHL (0x7369746f), 
+        ACE_NTOHL (0x72794964), 
+        ACE_NTOHL (0x0),  // name = RepositoryId
+        CORBA::tk_string, 
+        0U, // string length
+
+      0U,
+
+
+  21,
+  ACE_NTOHL (0x61627374), 
+  ACE_NTOHL (0x72616374), 
+  ACE_NTOHL (0x5f626173), 
+  ACE_NTOHL (0x655f7661), 
+  ACE_NTOHL (0x6c756573), 
+  ACE_NTOHL (0x0),  // name = abstract_base_values
+  CORBA::tk_alias, // typecode kind for typedefs
+  164, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    38,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x434f5242), 
+    ACE_NTOHL (0x412f5265), 
+    ACE_NTOHL (0x706f7369), 
+    ACE_NTOHL (0x746f7279), 
+    ACE_NTOHL (0x49645365), 
+    ACE_NTOHL (0x713a312e), 
+    ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/RepositoryIdSeq:1.0
+    16,
+    ACE_NTOHL (0x5265706f), 
+    ACE_NTOHL (0x7369746f), 
+    ACE_NTOHL (0x72794964), 
+    ACE_NTOHL (0x53657100),  // name = RepositoryIdSeq
+    CORBA::tk_sequence, // typecode kind
+    88, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      CORBA::tk_alias, // typecode kind for typedefs
+      72, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        35,
+        ACE_NTOHL (0x49444c3a), 
+        ACE_NTOHL (0x6f6d672e), 
+        ACE_NTOHL (0x6f72672f), 
+        ACE_NTOHL (0x434f5242), 
+        ACE_NTOHL (0x412f5265), 
+        ACE_NTOHL (0x706f7369), 
+        ACE_NTOHL (0x746f7279), 
+        ACE_NTOHL (0x49643a31), 
+        ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+        13,
+        ACE_NTOHL (0x5265706f), 
+        ACE_NTOHL (0x7369746f), 
+        ACE_NTOHL (0x72794964), 
+        ACE_NTOHL (0x0),  // name = RepositoryId
+        CORBA::tk_string, 
+        0U, // string length
+
+      0U,
+
+
+  15,
+  ACE_NTOHL (0x69735f74), 
+  ACE_NTOHL (0x72756e63), 
+  ACE_NTOHL (0x61746162), 
+  ACE_NTOHL (0x6c650000),  // name = is_truncatable
+  CORBA::tk_boolean,
+
+  11,
+  ACE_NTOHL (0x62617365), 
+  ACE_NTOHL (0x5f76616c), 
+  ACE_NTOHL (0x75650000),  // name = base_value
+  CORBA::tk_alias, // typecode kind for typedefs
+  72, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    35,
+    ACE_NTOHL (0x49444c3a), 
+    ACE_NTOHL (0x6f6d672e), 
+    ACE_NTOHL (0x6f72672f), 
+    ACE_NTOHL (0x434f5242), 
+    ACE_NTOHL (0x412f5265), 
+    ACE_NTOHL (0x706f7369), 
+    ACE_NTOHL (0x746f7279), 
+    ACE_NTOHL (0x49643a31), 
+    ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+    13,
+    ACE_NTOHL (0x5265706f), 
+    ACE_NTOHL (0x7369746f), 
+    ACE_NTOHL (0x72794964), 
+    ACE_NTOHL (0x0),  // name = RepositoryId
+    CORBA::tk_string, 
+    0U, // string length
+
+  5,
+  ACE_NTOHL (0x74797065), 
+  ACE_NTOHL (0x0),  // name = type
+  CORBA::tk_TypeCode,
+
+};
+
+static CORBA::TypeCode _tc_TAO_tc_CORBA_ValueDef_FullValueDescription (
+    CORBA::tk_struct,
+    sizeof (_oc_CORBA_ValueDef_FullValueDescription),
+    (char *) &_oc_CORBA_ValueDef_FullValueDescription,
+    0,
+    sizeof (CORBA::ValueDef::FullValueDescription)
+  );
+
+CORBA::TypeCode_ptr CORBA::ValueDef::_tc_FullValueDescription =
+  &_tc_TAO_tc_CORBA_ValueDef_FullValueDescription;
+
+void CORBA::ValueDef::FullValueDescription::_tao_any_destructor (void *x)
+{
+  FullValueDescription *tmp = ACE_static_cast (FullValueDescription*,x);
+  delete tmp;
+}
+
+CORBA::ValueDef::FullValueDescription * CORBA::ValueDef::describe_value (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_ValueDef_Proxy_Impl &proxy = 
+    this->the_TAO_ValueDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.describe_value (
+      this,
+      ACE_TRY_ENV
+    );
+}
+
+CORBA::ValueMemberDef_ptr CORBA::ValueDef::create_value_member (
+    const char * id,
+    const char * name,
+    const char * version,
+    CORBA::IDLType_ptr type,
+    CORBA::Visibility access,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_ValueDef_Proxy_Impl &proxy = 
+    this->the_TAO_ValueDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.create_value_member (
+      this,
+      id,
+      name,
+      version,
+      type,
+      access,
+      ACE_TRY_ENV
+    );
+}
+
+CORBA::AttributeDef_ptr CORBA::ValueDef::create_attribute (
+    const char * id,
+    const char * name,
+    const char * version,
+    CORBA::IDLType_ptr type,
+    CORBA::AttributeMode mode,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_ValueDef_Proxy_Impl &proxy = 
+    this->the_TAO_ValueDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.create_attribute (
+      this,
+      id,
+      name,
+      version,
+      type,
+      mode,
+      ACE_TRY_ENV
+    );
+}
+
+CORBA::OperationDef_ptr CORBA::ValueDef::create_operation (
+    const char * id,
+    const char * name,
+    const char * version,
+    CORBA::IDLType_ptr result,
+    CORBA::OperationMode mode,
+    const CORBA::ParDescriptionSeq & params,
+    const CORBA::ExceptionDefSeq & exceptions,
+    const CORBA::ContextIdSeq & contexts,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_ValueDef_Proxy_Impl &proxy = 
+    this->the_TAO_ValueDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.create_operation (
+      this,
+      id,
+      name,
+      version,
+      result,
+      mode,
+      params,
+      exceptions,
+      contexts,
+      ACE_TRY_ENV
+    );
+}
+
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_supported_interfaces_get::TAO_ClientRequestInfo_CORBA_ValueDef_supported_interfaces_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
+{}
+
+Dynamic::ParameterList *
+CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_supported_interfaces_get::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return parameter_list;
+}
+
+Dynamic::ExceptionList *
+CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_supported_interfaces_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_supported_interfaces_get::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_supported_interfaces_get::result (CORBA::InterfaceDefSeq * result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_supported_interfaces_set::TAO_ClientRequestInfo_CORBA_ValueDef_supported_interfaces_set (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const CORBA::InterfaceDefSeq & supported_interfaces,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
+    supported_interfaces_ (supported_interfaces)
+{}
+
+Dynamic::ParameterList *
+CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_supported_interfaces_set::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
+    
+  CORBA::ULong length_supported_interfaces = parameter_list->length ();
+  parameter_list->length (length_supported_interfaces + 1);
+  (*parameter_list)[length_supported_interfaces].argument <<=  this->supported_interfaces_;
+  
+  (*parameter_list)[length_supported_interfaces].mode = Dynamic::PARAM_IN;
+  
+  return safe_parameter_list._retn ();
+}
+
+Dynamic::ExceptionList *
+CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_supported_interfaces_set::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_supported_interfaces_set::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 1;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return result_any;
+}
+
+CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_initializers_get::TAO_ClientRequestInfo_CORBA_ValueDef_initializers_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
+{}
+
+Dynamic::ParameterList *
+CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_initializers_get::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return parameter_list;
+}
+
+Dynamic::ExceptionList *
+CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_initializers_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_initializers_get::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_initializers_get::result (CORBA::InitializerSeq * result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_initializers_set::TAO_ClientRequestInfo_CORBA_ValueDef_initializers_set (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const CORBA::InitializerSeq & initializers,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
+    initializers_ (initializers)
+{}
+
+Dynamic::ParameterList *
+CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_initializers_set::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
+    
+  CORBA::ULong length_initializers = parameter_list->length ();
+  parameter_list->length (length_initializers + 1);
+  (*parameter_list)[length_initializers].argument <<=  this->initializers_;
+  
+  (*parameter_list)[length_initializers].mode = Dynamic::PARAM_IN;
+  
+  return safe_parameter_list._retn ();
+}
+
+Dynamic::ExceptionList *
+CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_initializers_set::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_initializers_set::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 1;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return result_any;
+}
+
+CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_base_value_get::TAO_ClientRequestInfo_CORBA_ValueDef_base_value_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
+{}
+
+Dynamic::ParameterList *
+CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_base_value_get::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return parameter_list;
+}
+
+Dynamic::ExceptionList *
+CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_base_value_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_base_value_get::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_base_value_get::result (CORBA::ValueDef_ptr result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_base_value_set::TAO_ClientRequestInfo_CORBA_ValueDef_base_value_set (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::ValueDef_ptr base_value,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
+    base_value_ (base_value)
+{}
+
+Dynamic::ParameterList *
+CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_base_value_set::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
+    
+  CORBA::ULong length_base_value = parameter_list->length ();
+  parameter_list->length (length_base_value + 1);
+  (*parameter_list)[length_base_value].argument <<=  this->base_value_;
+  
+  (*parameter_list)[length_base_value].mode = Dynamic::PARAM_IN;
+  
+  return safe_parameter_list._retn ();
+}
+
+Dynamic::ExceptionList *
+CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_base_value_set::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_base_value_set::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 1;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return result_any;
+}
+
+CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_abstract_base_values_get::TAO_ClientRequestInfo_CORBA_ValueDef_abstract_base_values_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
+{}
+
+Dynamic::ParameterList *
+CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_abstract_base_values_get::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return parameter_list;
+}
+
+Dynamic::ExceptionList *
+CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_abstract_base_values_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_abstract_base_values_get::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_abstract_base_values_get::result (CORBA::ValueDefSeq * result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_abstract_base_values_set::TAO_ClientRequestInfo_CORBA_ValueDef_abstract_base_values_set (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const CORBA::ValueDefSeq & abstract_base_values,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
+    abstract_base_values_ (abstract_base_values)
+{}
+
+Dynamic::ParameterList *
+CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_abstract_base_values_set::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
+    
+  CORBA::ULong length_abstract_base_values = parameter_list->length ();
+  parameter_list->length (length_abstract_base_values + 1);
+  (*parameter_list)[length_abstract_base_values].argument <<=  this->abstract_base_values_;
+  
+  (*parameter_list)[length_abstract_base_values].mode = Dynamic::PARAM_IN;
+  
+  return safe_parameter_list._retn ();
+}
+
+Dynamic::ExceptionList *
+CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_abstract_base_values_set::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_abstract_base_values_set::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 1;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return result_any;
+}
+
+CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_is_abstract_get::TAO_ClientRequestInfo_CORBA_ValueDef_is_abstract_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
+{}
+
+Dynamic::ParameterList *
+CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_is_abstract_get::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return parameter_list;
+}
+
+Dynamic::ExceptionList *
+CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_is_abstract_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_is_abstract_get::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= CORBA::Any::from_boolean (this->_result);
+  return safe_result_any._retn ();
+}
+
+void 
+CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_is_abstract_get::result (CORBA::Boolean result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_is_abstract_set::TAO_ClientRequestInfo_CORBA_ValueDef_is_abstract_set (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const CORBA::Boolean & is_abstract,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
+    is_abstract_ (is_abstract)
+{}
+
+Dynamic::ParameterList *
+CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_is_abstract_set::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
+    
+  CORBA::ULong length_is_abstract = parameter_list->length ();
+  parameter_list->length (length_is_abstract + 1);
+  (*parameter_list)[length_is_abstract].argument <<= CORBA::Any::from_boolean (this->is_abstract_);
+  (*parameter_list)[length_is_abstract].mode = Dynamic::PARAM_IN;
+  
+  return safe_parameter_list._retn ();
+}
+
+Dynamic::ExceptionList *
+CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_is_abstract_set::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_is_abstract_set::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 1;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return result_any;
+}
+
+CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_is_custom_get::TAO_ClientRequestInfo_CORBA_ValueDef_is_custom_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
+{}
+
+Dynamic::ParameterList *
+CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_is_custom_get::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return parameter_list;
+}
+
+Dynamic::ExceptionList *
+CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_is_custom_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_is_custom_get::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= CORBA::Any::from_boolean (this->_result);
+  return safe_result_any._retn ();
+}
+
+void 
+CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_is_custom_get::result (CORBA::Boolean result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_is_custom_set::TAO_ClientRequestInfo_CORBA_ValueDef_is_custom_set (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const CORBA::Boolean & is_custom,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
+    is_custom_ (is_custom)
+{}
+
+Dynamic::ParameterList *
+CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_is_custom_set::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
+    
+  CORBA::ULong length_is_custom = parameter_list->length ();
+  parameter_list->length (length_is_custom + 1);
+  (*parameter_list)[length_is_custom].argument <<= CORBA::Any::from_boolean (this->is_custom_);
+  (*parameter_list)[length_is_custom].mode = Dynamic::PARAM_IN;
+  
+  return safe_parameter_list._retn ();
+}
+
+Dynamic::ExceptionList *
+CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_is_custom_set::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_is_custom_set::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 1;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return result_any;
+}
+
+CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_is_truncatable_get::TAO_ClientRequestInfo_CORBA_ValueDef_is_truncatable_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
+{}
+
+Dynamic::ParameterList *
+CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_is_truncatable_get::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return parameter_list;
+}
+
+Dynamic::ExceptionList *
+CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_is_truncatable_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_is_truncatable_get::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= CORBA::Any::from_boolean (this->_result);
+  return safe_result_any._retn ();
+}
+
+void 
+CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_is_truncatable_get::result (CORBA::Boolean result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_is_truncatable_set::TAO_ClientRequestInfo_CORBA_ValueDef_is_truncatable_set (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const CORBA::Boolean & is_truncatable,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
+    is_truncatable_ (is_truncatable)
+{}
+
+Dynamic::ParameterList *
+CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_is_truncatable_set::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
+    
+  CORBA::ULong length_is_truncatable = parameter_list->length ();
+  parameter_list->length (length_is_truncatable + 1);
+  (*parameter_list)[length_is_truncatable].argument <<= CORBA::Any::from_boolean (this->is_truncatable_);
+  (*parameter_list)[length_is_truncatable].mode = Dynamic::PARAM_IN;
+  
+  return safe_parameter_list._retn ();
+}
+
+Dynamic::ExceptionList *
+CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_is_truncatable_set::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_is_truncatable_set::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 1;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return result_any;
+}
+
+CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_is_a::TAO_ClientRequestInfo_CORBA_ValueDef_is_a (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const char * id,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
+    id_ (id)
+{}
+
+Dynamic::ParameterList *
+CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_is_a::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
+    
+  CORBA::ULong length_id = parameter_list->length ();
+  parameter_list->length (length_id + 1);
+  (*parameter_list)[length_id].argument <<= id_;
+  (*parameter_list)[length_id].mode = Dynamic::PARAM_IN;
+  
+  return safe_parameter_list._retn ();
+}
+
+Dynamic::ExceptionList *
+CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_is_a::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_is_a::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= CORBA::Any::from_boolean (this->_result);
+  return safe_result_any._retn ();
+}
+
+void 
+CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_is_a::result (CORBA::Boolean result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_describe_value::TAO_ClientRequestInfo_CORBA_ValueDef_describe_value (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
+{}
+
+Dynamic::ParameterList *
+CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_describe_value::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return parameter_list;
+}
+
+Dynamic::ExceptionList *
+CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_describe_value::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_describe_value::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_describe_value::result (ACE_NESTED_CLASS (CORBA::ValueDef,FullValueDescription) * result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_create_value_member::TAO_ClientRequestInfo_CORBA_ValueDef_create_value_member (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const char * id,
+    const char * name,
+    const char * version,
+    CORBA::IDLType_ptr type,
+    const CORBA::Visibility & access,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
+    id_ (id),
+    name_ (name),
+    version_ (version),
+    type_ (type),
+    access_ (access)
+{}
+
+Dynamic::ParameterList *
+CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_create_value_member::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
+    
+  CORBA::ULong length_id = parameter_list->length ();
+  parameter_list->length (length_id + 1);
+  (*parameter_list)[length_id].argument <<= id_;
+  (*parameter_list)[length_id].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_name = parameter_list->length ();
+  parameter_list->length (length_name + 1);
+  (*parameter_list)[length_name].argument <<= name_;
+  (*parameter_list)[length_name].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_version = parameter_list->length ();
+  parameter_list->length (length_version + 1);
+  (*parameter_list)[length_version].argument <<= version_;
+  (*parameter_list)[length_version].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_type = parameter_list->length ();
+  parameter_list->length (length_type + 1);
+  (*parameter_list)[length_type].argument <<=  this->type_;
+  
+  (*parameter_list)[length_type].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_access = parameter_list->length ();
+  parameter_list->length (length_access + 1);
+  (*parameter_list)[length_access].argument <<= access_;
+  (*parameter_list)[length_access].mode = Dynamic::PARAM_IN;
+  
+  return safe_parameter_list._retn ();
+}
+
+Dynamic::ExceptionList *
+CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_create_value_member::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_create_value_member::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_create_value_member::result (CORBA::ValueMemberDef_ptr result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_create_attribute::TAO_ClientRequestInfo_CORBA_ValueDef_create_attribute (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const char * id,
+    const char * name,
+    const char * version,
+    CORBA::IDLType_ptr type,
+    CORBA::AttributeMode & mode,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
+    id_ (id),
+    name_ (name),
+    version_ (version),
+    type_ (type),
+    mode_ (mode)
+{}
+
+Dynamic::ParameterList *
+CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_create_attribute::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
+    
+  CORBA::ULong length_id = parameter_list->length ();
+  parameter_list->length (length_id + 1);
+  (*parameter_list)[length_id].argument <<= id_;
+  (*parameter_list)[length_id].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_name = parameter_list->length ();
+  parameter_list->length (length_name + 1);
+  (*parameter_list)[length_name].argument <<= name_;
+  (*parameter_list)[length_name].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_version = parameter_list->length ();
+  parameter_list->length (length_version + 1);
+  (*parameter_list)[length_version].argument <<= version_;
+  (*parameter_list)[length_version].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_type = parameter_list->length ();
+  parameter_list->length (length_type + 1);
+  (*parameter_list)[length_type].argument <<=  this->type_;
+  
+  (*parameter_list)[length_type].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_mode = parameter_list->length ();
+  parameter_list->length (length_mode + 1);
+  (*parameter_list)[length_mode].argument <<=  this->mode_;
+  
+  (*parameter_list)[length_mode].mode = Dynamic::PARAM_IN;
+  
+  return safe_parameter_list._retn ();
+}
+
+Dynamic::ExceptionList *
+CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_create_attribute::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_create_attribute::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_create_attribute::result (CORBA::AttributeDef_ptr result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_create_operation::TAO_ClientRequestInfo_CORBA_ValueDef_create_operation (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const char * id,
+    const char * name,
+    const char * version,
+    CORBA::IDLType_ptr result,
+    CORBA::OperationMode & mode,
+    const CORBA::ParDescriptionSeq & params,
+    const CORBA::ExceptionDefSeq & exceptions,
+    const CORBA::ContextIdSeq & contexts,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
+    id_ (id),
+    name_ (name),
+    version_ (version),
+    result_ (result),
+    mode_ (mode),
+    params_ (params),
+    exceptions_ (exceptions),
+    contexts_ (contexts)
+{}
+
+Dynamic::ParameterList *
+CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_create_operation::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
+    
+  CORBA::ULong length_id = parameter_list->length ();
+  parameter_list->length (length_id + 1);
+  (*parameter_list)[length_id].argument <<= id_;
+  (*parameter_list)[length_id].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_name = parameter_list->length ();
+  parameter_list->length (length_name + 1);
+  (*parameter_list)[length_name].argument <<= name_;
+  (*parameter_list)[length_name].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_version = parameter_list->length ();
+  parameter_list->length (length_version + 1);
+  (*parameter_list)[length_version].argument <<= version_;
+  (*parameter_list)[length_version].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_result = parameter_list->length ();
+  parameter_list->length (length_result + 1);
+  (*parameter_list)[length_result].argument <<=  this->result_;
+  
+  (*parameter_list)[length_result].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_mode = parameter_list->length ();
+  parameter_list->length (length_mode + 1);
+  (*parameter_list)[length_mode].argument <<=  this->mode_;
+  
+  (*parameter_list)[length_mode].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_params = parameter_list->length ();
+  parameter_list->length (length_params + 1);
+  (*parameter_list)[length_params].argument <<=  this->params_;
+  
+  (*parameter_list)[length_params].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_exceptions = parameter_list->length ();
+  parameter_list->length (length_exceptions + 1);
+  (*parameter_list)[length_exceptions].argument <<=  this->exceptions_;
+  
+  (*parameter_list)[length_exceptions].mode = Dynamic::PARAM_IN;
+    
+  CORBA::ULong length_contexts = parameter_list->length ();
+  parameter_list->length (length_contexts + 1);
+  (*parameter_list)[length_contexts].argument <<=  this->contexts_;
+  
+  (*parameter_list)[length_contexts].mode = Dynamic::PARAM_IN;
+  
+  return safe_parameter_list._retn ();
+}
+
+Dynamic::ExceptionList *
+CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_create_operation::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_create_operation::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+CORBA::ValueDef::TAO_ClientRequestInfo_CORBA_ValueDef_create_operation::result (CORBA::OperationDef_ptr result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+#endif /* TAO_HAS_INTERCEPTORS */
+
+void CORBA::ValueDescription::_tao_any_destructor (void *x)
+{
+  CORBA_ValueDescription *tmp = ACE_static_cast (CORBA_ValueDescription*,x);
+  delete tmp;
+}
+
+
+///////////////////////////////////////////////////////////////////////
+//                Base & Remote Proxy  Implementation. 
+//
+
+_TAO_ValueBoxDef_Proxy_Impl::_TAO_ValueBoxDef_Proxy_Impl (void)
+{}
+
+_TAO_ValueBoxDef_Remote_Proxy_Impl::_TAO_ValueBoxDef_Remote_Proxy_Impl (void)
+{}
+
+// Remote Implementation of the IDL interface methods
+
+CORBA::IDLType_ptr _TAO_ValueBoxDef_Remote_Proxy_Impl::original_type_def (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::IDLType_ptr _tao_retval = CORBA::IDLType::_nil ();
+  CORBA::IDLType_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_original_type_def",
+      22,
+      0,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::ValueBoxDef::TAO_ClientRequestInfo_CORBA_ValueBoxDef_original_type_def_get ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK_RETURN (0);
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+          if (!(
+                            (_tao_in >> _tao_safe_retval.inout ())
+              ))
+            {
+              TAO_INTERCEPTOR_THROW_RETURN (
+                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
+                0
+              );
+              
+            }
+          
+          TAO_INTERCEPTOR (
+              CORBA::IDLType_ptr _tao_retval_info = _tao_safe_retval._retn ();
+              ri.result (_tao_retval_info);
+              _tao_safe_retval = _tao_retval_info;
+            );
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK_RETURN (0);
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK_RETURN (0);
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  return _tao_safe_retval._retn ();
+}
+
+void _TAO_ValueBoxDef_Remote_Proxy_Impl::original_type_def (
+    CORBA_Object *_collocated_tao_target_,
+    CORBA::IDLType_ptr original_type_def,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+
+  
+  
+  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
+  if (istub == 0)
+    ACE_THROW (CORBA::INTERNAL ());
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_set_original_type_def",
+      22,
+      1,
+      istub->orb_core ()
+    );
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
+      istub->orb_core ()->client_request_interceptors ()
+    );
+  
+#endif  /* TAO_HAS_INTERCEPTORS */
+  
+  for (;;)
+    {
+      int _invoke_status = TAO_INVOKE_EXCEPTION;
+      
+#if TAO_HAS_INTERCEPTORS == 1
+      CORBA::ValueBoxDef::TAO_ClientRequestInfo_CORBA_ValueBoxDef_original_type_def_set ri (
+        &_tao_call,
+        _collocated_tao_target_,
+        original_type_def,
+        ACE_TRY_ENV
+      );
+      ACE_CHECK;
+      
+      ACE_TRY
+        {
+#endif /* TAO_HAS_INTERCEPTORS */
+        
+          _tao_call.start (ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK;
+          
+          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
+          TAO_INTERCEPTOR (ri.response_expected (1));
+          
+          TAO_INTERCEPTOR (
+            _tao_vfr.send_request (
+              &ri,
+              ACE_TRY_ENV
+            )
+          );
+          TAO_INTERCEPTOR_CHECK;
+          
+          _tao_call.prepare_header (
+              ACE_static_cast (CORBA::Octet, _tao_response_flag),
+              ACE_TRY_ENV
+            );
+          TAO_INTERCEPTOR_CHECK;
+          
+          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+          if (!(
+                            (_tao_out << original_type_def)
+            ))
+            TAO_INTERCEPTOR_THROW (
+              CORBA::MARSHAL ()
+            );
+            
+          _invoke_status =
+            _tao_call.invoke (0, 0, ACE_TRY_ENV);
+          TAO_INTERCEPTOR_CHECK;
+          
+          if (_invoke_status == TAO_INVOKE_EXCEPTION)
+            {
+              TAO_INTERCEPTOR_THROW (
+                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)
+              );
+              
+            }
+          
+          
+          TAO_INTERCEPTOR (
+            ri.reply_status (_invoke_status);
+            if (_invoke_status == TAO_INVOKE_OK)
+              {
+                _tao_vfr.receive_reply (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            else
+              {
+                _tao_vfr.receive_other (
+                  &ri,
+                  ACE_TRY_ENV
+                );
+              }
+            
+          );
+          TAO_INTERCEPTOR_CHECK;
+          
+#if TAO_HAS_INTERCEPTORS == 1
+        }
+      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
+        {
+          _invoke_status =
+            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+          
+          ri.forward_reference (exc); 
+          _tao_vfr.receive_other (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY
+        {
+          ri.exception (&ACE_ANY_EXCEPTION);
+          _tao_vfr.receive_exception (
+            &ri,
+            ACE_TRY_ENV
+          );
+          ACE_TRY_CHECK;
+          ACE_RE_THROW;
+        }
+      ACE_ENDTRY;
+      ACE_CHECK;
+      
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      if (_invoke_status == TAO_INVOKE_RESTART)
+        {
+          _tao_call.restart_flag (1);
+          continue;
+        }
+      
+      break;
+    }
+  
+}
+
+
+//
+//            End  Base & Remote  Proxy Implemeentation. 
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//           Remote & Base  Proxy Broker Implementation
+//
+
+_TAO_ValueBoxDef_Proxy_Broker::_TAO_ValueBoxDef_Proxy_Broker (void)
+{
+}
+
+_TAO_ValueBoxDef_Proxy_Broker::~_TAO_ValueBoxDef_Proxy_Broker (void)
+{
+}
+
+_TAO_ValueBoxDef_Proxy_Broker * (*CORBA__TAO_ValueBoxDef_Proxy_Broker_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  ) = 0;
+
+// Factory Member function Implementation.
+_TAO_ValueBoxDef_Remote_Proxy_Broker *
+_TAO_ValueBoxDef_Remote_Proxy_Broker::the_TAO_ValueBoxDef_Remote_Proxy_Broker (void)
+{
+  static ::_TAO_ValueBoxDef_Remote_Proxy_Broker remote_proxy_broker;
+  return &remote_proxy_broker;
+}
+
+_TAO_ValueBoxDef_Remote_Proxy_Broker::_TAO_ValueBoxDef_Remote_Proxy_Broker (void)
+{
+}
+
+_TAO_ValueBoxDef_Remote_Proxy_Broker::~_TAO_ValueBoxDef_Remote_Proxy_Broker (void)
+{
+}
+
+_TAO_ValueBoxDef_Proxy_Impl&
+_TAO_ValueBoxDef_Remote_Proxy_Broker::select_proxy (
+  ::CORBA_ValueBoxDef *,
+  CORBA::Environment &
+)
+{
+  return this->remote_proxy_impl_;
+}
+
+
+//
+//           End Remote & Base Proxy Broker Implementation
+///////////////////////////////////////////////////////////////////////
+
+
+// default constructor
+CORBA::ValueBoxDef::ValueBoxDef (int collocated)
+{
+  this->CORBA_ValueBoxDef_setup_collocation (collocated);
+}
+
+// destructor
+CORBA::ValueBoxDef::~ValueBoxDef (void)
+{}
+
+void
+CORBA::ValueBoxDef::CORBA_ValueBoxDef_setup_collocation (int collocated)
+{
+  if (collocated)
+    this->the_TAO_ValueBoxDef_Proxy_Broker_ =
+      ::CORBA__TAO_ValueBoxDef_Proxy_Broker_Factory_function_pointer (this);
+  else
+    this->the_TAO_ValueBoxDef_Proxy_Broker_ =
+      ::_TAO_ValueBoxDef_Remote_Proxy_Broker::the_TAO_ValueBoxDef_Remote_Proxy_Broker ();
+  
+  this->CORBA_TypedefDef_setup_collocation (collocated);
+}
+
+void CORBA::ValueBoxDef::_tao_any_destructor (void *x)
+{
+  CORBA_ValueBoxDef *tmp = ACE_static_cast (CORBA_ValueBoxDef*,x);
+  CORBA::release (tmp);
+}
+
+CORBA::ValueBoxDef_ptr CORBA::ValueBoxDef::_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+{
+  if (CORBA::is_nil (obj))
+    return CORBA::ValueBoxDef::_nil ();
+  if (! obj->_is_local ())
+    {
+      CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/CORBA/ValueBoxDef:1.0", ACE_TRY_ENV);
+      ACE_CHECK_RETURN (CORBA::ValueBoxDef::_nil ());
+      if (is_a == 0)
+        return CORBA::ValueBoxDef::_nil ();
+    }
+  return CORBA::ValueBoxDef::_unchecked_narrow (obj, ACE_TRY_ENV);
+}
+
+CORBA::ValueBoxDef_ptr CORBA::ValueBoxDef::_unchecked_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &
+  )
+{
+  if (CORBA::is_nil (obj))
+    return CORBA::ValueBoxDef::_nil ();
+  if (! obj->_is_local ())
+    {
+      TAO_Stub* stub = obj->_stubobj ();
+      if (stub)
+        stub->_incr_refcnt ();
+      CORBA::ValueBoxDef_ptr default_proxy = CORBA::ValueBoxDef::_nil ();
+
+      if (
+          !CORBA::is_nil (stub->servant_orb_var ().ptr ()) &&
+          stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects () &&
+          obj->_is_collocated () &&CORBA__TAO_ValueBoxDef_Proxy_Broker_Factory_function_pointer != 0
+        )
+      {
+        ACE_NEW_RETURN (
+          default_proxy,
+          ::CORBA::ValueBoxDef (
+            stub,
+            1,
+            obj->_servant ()),
+            
+          CORBA::ValueBoxDef::_nil ());
+        }
+      if (CORBA::is_nil (default_proxy))
+        ACE_NEW_RETURN (default_proxy, ::CORBA::ValueBoxDef (stub, 0, obj->_servant ()), CORBA::ValueBoxDef::_nil ());
+        return default_proxy;
+      }
+    else 
+      return
+        ACE_reinterpret_cast
+          (
+            CORBA_ValueBoxDef_ptr,
+              obj->_tao_QueryInterface
+                (
+                  ACE_reinterpret_cast
+                    (
+                      ptr_arith_t,
+                      &CORBA_ValueBoxDef::_narrow
+                    )
+                )
+          );
+}
+
+CORBA::ValueBoxDef_ptr
+CORBA::ValueBoxDef::_duplicate (CORBA::ValueBoxDef_ptr obj)
+{
+  if (!CORBA::is_nil (obj))
+    obj->_add_ref ();
+  return obj;
+}
+
+CORBA::Boolean CORBA::ValueBoxDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
+{
+  if (
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/ValueBoxDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/TypedefDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Contained:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IDLType:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
+  return 1; // success using local knowledge
+  else
+    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
+}
+
+void *CORBA::ValueBoxDef::_tao_QueryInterface (ptr_arith_t type)
+{
+  void *retv = 0;
+  if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      CORBA_ValueBoxDef::_narrow))
+    retv = ACE_reinterpret_cast (void*, this);
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::TypedefDef::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::TypedefDef_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::Contained::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::Contained_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::IDLType::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::IDLType_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &::CORBA::IRObject::_narrow))
+    retv = ACE_reinterpret_cast
+      (
+        void *,
+        ACE_static_cast
+          (
+            CORBA::IRObject_ptr,
+            this
+          )
+      );
+  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
+    retv = ACE_reinterpret_cast (void *,
+      ACE_static_cast (CORBA::Object_ptr, this));
+    
+  if (retv)
+    this->_add_ref ();
+  return retv;
+}
+
+const char* CORBA::ValueBoxDef::_interface_repository_id (void) const
+{
+  return "IDL:omg.org/CORBA/ValueBoxDef:1.0";
+}
+
+CORBA::IDLType_ptr CORBA::ValueBoxDef::original_type_def (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_ValueBoxDef_Proxy_Impl &proxy = 
+    this->the_TAO_ValueBoxDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return proxy.original_type_def (
+      this,
+      ACE_TRY_ENV
+    );
+}
+
+void CORBA::ValueBoxDef::original_type_def (
+    CORBA::IDLType_ptr original_type_def,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  _TAO_ValueBoxDef_Proxy_Impl &proxy = 
+    this->the_TAO_ValueBoxDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK;
+  
+  proxy.original_type_def (
+      this,
+      original_type_def,
+      ACE_TRY_ENV
+    );
+}
+
+
+#if (TAO_HAS_INTERCEPTORS == 1)
+CORBA::ValueBoxDef::TAO_ClientRequestInfo_CORBA_ValueBoxDef_original_type_def_get::TAO_ClientRequestInfo_CORBA_ValueBoxDef_original_type_def_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
+{}
+
+Dynamic::ParameterList *
+CORBA::ValueBoxDef::TAO_ClientRequestInfo_CORBA_ValueBoxDef_original_type_def_get::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return parameter_list;
+}
+
+Dynamic::ExceptionList *
+CORBA::ValueBoxDef::TAO_ClientRequestInfo_CORBA_ValueBoxDef_original_type_def_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::ValueBoxDef::TAO_ClientRequestInfo_CORBA_ValueBoxDef_original_type_def_get::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 0;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  CORBA::Any_var safe_result_any = result_any;
+  
+  (*result_any) <<= this->_result;
+  return safe_result_any._retn ();
+}
+
+void 
+CORBA::ValueBoxDef::TAO_ClientRequestInfo_CORBA_ValueBoxDef_original_type_def_get::result (CORBA::IDLType_ptr result)
+{
+  // update the result 
+  this->_result = result;
+}
+
+CORBA::ValueBoxDef::TAO_ClientRequestInfo_CORBA_ValueBoxDef_original_type_def_set::TAO_ClientRequestInfo_CORBA_ValueBoxDef_original_type_def_set (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::IDLType_ptr original_type_def,
+    CORBA::Environment &    
+  )
+  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
+    original_type_def_ (original_type_def)
+{}
+
+Dynamic::ParameterList *
+CORBA::ValueBoxDef::TAO_ClientRequestInfo_CORBA_ValueBoxDef_original_type_def_set::arguments (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the argument list on demand.
+  Dynamic::ParameterList *parameter_list =
+    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
+    
+  CORBA::ULong length_original_type_def = parameter_list->length ();
+  parameter_list->length (length_original_type_def + 1);
+  (*parameter_list)[length_original_type_def].argument <<=  this->original_type_def_;
+  
+  (*parameter_list)[length_original_type_def].mode = Dynamic::PARAM_IN;
+  
+  return safe_parameter_list._retn ();
+}
+
+Dynamic::ExceptionList *
+CORBA::ValueBoxDef::TAO_ClientRequestInfo_CORBA_ValueBoxDef_original_type_def_set::exceptions (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the exception list on demand.
+  Dynamic::ExceptionList *exception_list =
+    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return exception_list;
+}
+
+
+CORBA::Any * 
+CORBA::ValueBoxDef::TAO_ClientRequestInfo_CORBA_ValueBoxDef_original_type_def_set::result (CORBA::Environment &ACE_TRY_ENV)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // Generate the result on demand.
+  CORBA::Boolean tk_void_any = 1;
+  CORBA::Any *result_any =
+    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
+  
+  return result_any;
+}
+
+#endif /* TAO_HAS_INTERCEPTORS */
+
+// ***************************************************************
+// Any operators for sequence class moved from IFR_BaseC.cpp
+
+void operator<<= (
+    CORBA::Any &_tao_any,
+    const CORBA::ValueDefSeq &_tao_elem
+  ) // copying
+{
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        CORBA::_tc_ValueDefSeq,
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin ()
+      );
+  }
+}
+
+void operator<<= (CORBA::Any &_tao_any, CORBA::ValueDefSeq *_tao_elem) // non copying
+{
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      CORBA::_tc_ValueDefSeq,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      CORBA::ValueDefSeq::_tao_any_destructor
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ValueDefSeq *&_tao_elem)
+{
+  return _tao_any >>= ACE_const_cast(
+      const CORBA::ValueDefSeq*&,
+      _tao_elem
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::ValueDefSeq *&_tao_elem)
+{
+  _tao_elem = 0;
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (CORBA::_tc_ValueDefSeq, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    if (_tao_any.any_owns_data ())
+    {
+      _tao_elem = ACE_static_cast(
+          const CORBA::ValueDefSeq*,
+          _tao_any.value ()
+        );
+      return 1;
+    }
+    else
+    {
+      CORBA::ValueDefSeq *tmp;
+      ACE_NEW_RETURN (tmp, CORBA::ValueDefSeq, 0);
+      TAO_InputCDR stream (
+          _tao_any._tao_get_cdr (),
+          _tao_any._tao_byte_order ()
+        );
+      if (stream >> *tmp)
+      {
+        ((CORBA::Any *)&_tao_any)->_tao_replace (
+            CORBA::_tc_ValueDefSeq,
+            1,
+            ACE_static_cast (void *, tmp),
+            CORBA::ValueDefSeq::_tao_any_destructor
+          );
+        _tao_elem = tmp;
+        return 1;
+      }
+      else
+      {
+        delete tmp;
+      }
+    }
+  }
+  ACE_CATCHANY
+  {
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+// ******************************************************************
+
+void operator<<= (CORBA::Any &_tao_any, CORBA::FixedDef_ptr _tao_elem)
+{
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        CORBA::_tc_FixedDef, 
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin (),
+        1,
+        CORBA::FixedDef::_duplicate (_tao_elem),
+        CORBA::FixedDef::_tao_any_destructor
+      );
+  }
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::FixedDef_ptr &_tao_elem)
+{
+  ACE_TRY_NEW_ENV
+  {
+    _tao_elem = CORBA::FixedDef::_nil ();
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (CORBA::_tc_FixedDef, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    TAO_InputCDR stream (
+        _tao_any._tao_get_cdr (),
+        _tao_any._tao_byte_order ()
+      );
+    if (stream >> _tao_elem)
+    {
+      ((CORBA::Any *)&_tao_any)->_tao_replace (
+          CORBA::_tc_FixedDef,
+          1,
+          _tao_elem,
+          CORBA::FixedDef::_tao_any_destructor
+        );
+      return 1;
+    }
+  }
+  ACE_CATCHANY
+  {
+    _tao_elem = CORBA::FixedDef::_nil ();
+    return 0;
+  }
+  ACE_ENDTRY;
+  _tao_elem = CORBA::FixedDef::_nil ();
+  return 0;
+}
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
+    defined (ACE_HAS_GNU_REPO)
+    template class TAO_Object_Manager<CORBA::FixedDef,CORBA::FixedDef_var>;
+  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+  #  pragma instantiate TAO_Object_Manager<CORBA::FixedDef,CORBA::FixedDef_var>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+void operator<<= (CORBA::Any &_tao_any, const CORBA::ValueMember &_tao_elem) // copying
+{
+  TAO_OutputCDR stream;
+  stream << _tao_elem;
+  _tao_any._tao_replace (
+      CORBA::_tc_ValueMember,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin ()
+    );
+}
+
+void operator<<= (CORBA::Any &_tao_any, CORBA::ValueMember *_tao_elem) // non copying
+{
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      CORBA::_tc_ValueMember,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      CORBA::ValueMember::_tao_any_destructor
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ValueMember *&_tao_elem)
+{
+  return _tao_any >>= ACE_const_cast(const CORBA::ValueMember*&,_tao_elem);
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::ValueMember *&_tao_elem)
+{
+  _tao_elem = 0;
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (CORBA::_tc_ValueMember, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    if (_tao_any.any_owns_data ())
+    {
+      _tao_elem = ACE_static_cast(
+          const CORBA::ValueMember*,
+          _tao_any.value ()
+        );
+      return 1;
+    }
+    else
+    {
+      CORBA::ValueMember *tmp;
+      ACE_NEW_RETURN (tmp, CORBA::ValueMember, 0);
+      TAO_InputCDR stream (
+          _tao_any._tao_get_cdr (),
+          _tao_any._tao_byte_order ()
+        );
+      if (stream >> *tmp)
+      {
+        ((CORBA::Any *)&_tao_any)->_tao_replace (
+            CORBA::_tc_ValueMember,
+            1,
+            ACE_static_cast (void *, tmp),
+            CORBA::ValueMember::_tao_any_destructor
+          );
+        _tao_elem = tmp;
+        return 1;
+      }
+      else
+      {
+        delete tmp;
+      }
+    }
+  }
+  ACE_CATCHANY
+  {
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+void operator<<= (
+    CORBA::Any &_tao_any,
+    const CORBA::ValueMemberSeq &_tao_elem
+  ) // copying
+{
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        CORBA::_tc_ValueMemberSeq,
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin ()
+      );
+  }
+}
+
+void operator<<= (CORBA::Any &_tao_any, CORBA::ValueMemberSeq *_tao_elem) // non copying
+{
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      CORBA::_tc_ValueMemberSeq,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      CORBA::ValueMemberSeq::_tao_any_destructor
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ValueMemberSeq *&_tao_elem)
+{
+  return _tao_any >>= ACE_const_cast(
+      const CORBA::ValueMemberSeq*&,
+      _tao_elem
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::ValueMemberSeq *&_tao_elem)
+{
+  _tao_elem = 0;
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (CORBA::_tc_ValueMemberSeq, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    if (_tao_any.any_owns_data ())
+    {
+      _tao_elem = ACE_static_cast(
+          const CORBA::ValueMemberSeq*,
+          _tao_any.value ()
+        );
+      return 1;
+    }
+    else
+    {
+      CORBA::ValueMemberSeq *tmp;
+      ACE_NEW_RETURN (tmp, CORBA::ValueMemberSeq, 0);
+      TAO_InputCDR stream (
+          _tao_any._tao_get_cdr (),
+          _tao_any._tao_byte_order ()
+        );
+      if (stream >> *tmp)
+      {
+        ((CORBA::Any *)&_tao_any)->_tao_replace (
+            CORBA::_tc_ValueMemberSeq,
+            1,
+            ACE_static_cast (void *, tmp),
+            CORBA::ValueMemberSeq::_tao_any_destructor
+          );
+        _tao_elem = tmp;
+        return 1;
+      }
+      else
+      {
+        delete tmp;
+      }
+    }
+  }
+  ACE_CATCHANY
+  {
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+void operator<<= (CORBA::Any &_tao_any, CORBA::ValueMemberDef_ptr _tao_elem)
+{
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        CORBA::_tc_ValueMemberDef, 
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin (),
+        1,
+        CORBA::ValueMemberDef::_duplicate (_tao_elem),
+        CORBA::ValueMemberDef::_tao_any_destructor
+      );
+  }
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ValueMemberDef_ptr &_tao_elem)
+{
+  ACE_TRY_NEW_ENV
+  {
+    _tao_elem = CORBA::ValueMemberDef::_nil ();
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (CORBA::_tc_ValueMemberDef, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    TAO_InputCDR stream (
+        _tao_any._tao_get_cdr (),
+        _tao_any._tao_byte_order ()
+      );
+    if (stream >> _tao_elem)
+    {
+      ((CORBA::Any *)&_tao_any)->_tao_replace (
+          CORBA::_tc_ValueMemberDef,
+          1,
+          _tao_elem,
+          CORBA::ValueMemberDef::_tao_any_destructor
+        );
+      return 1;
+    }
+  }
+  ACE_CATCHANY
+  {
+    _tao_elem = CORBA::ValueMemberDef::_nil ();
+    return 0;
+  }
+  ACE_ENDTRY;
+  _tao_elem = CORBA::ValueMemberDef::_nil ();
+  return 0;
+}
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
+    defined (ACE_HAS_GNU_REPO)
+    template class TAO_Object_Manager<CORBA::ValueMemberDef,CORBA::ValueMemberDef_var>;
+  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+  #  pragma instantiate TAO_Object_Manager<CORBA::ValueMemberDef,CORBA::ValueMemberDef_var>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+void operator<<= (CORBA::Any &_tao_any, CORBA::ValueDef_ptr _tao_elem)
+{
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        CORBA::_tc_ValueDef, 
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin (),
+        1,
+        CORBA::ValueDef::_duplicate (_tao_elem),
+        CORBA::ValueDef::_tao_any_destructor
+      );
+  }
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ValueDef_ptr &_tao_elem)
+{
+  ACE_TRY_NEW_ENV
+  {
+    _tao_elem = CORBA::ValueDef::_nil ();
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (CORBA::_tc_ValueDef, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    TAO_InputCDR stream (
+        _tao_any._tao_get_cdr (),
+        _tao_any._tao_byte_order ()
+      );
+    if (stream >> _tao_elem)
+    {
+      ((CORBA::Any *)&_tao_any)->_tao_replace (
+          CORBA::_tc_ValueDef,
+          1,
+          _tao_elem,
+          CORBA::ValueDef::_tao_any_destructor
+        );
+      return 1;
+    }
+  }
+  ACE_CATCHANY
+  {
+    _tao_elem = CORBA::ValueDef::_nil ();
+    return 0;
+  }
+  ACE_ENDTRY;
+  _tao_elem = CORBA::ValueDef::_nil ();
+  return 0;
+}
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
+    defined (ACE_HAS_GNU_REPO)
+    template class TAO_Object_Manager<CORBA::ValueDef,CORBA::ValueDef_var>;
+  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+  #  pragma instantiate TAO_Object_Manager<CORBA::ValueDef,CORBA::ValueDef_var>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+void operator<<= (CORBA::Any &_tao_any, const CORBA::ValueDef::FullValueDescription &_tao_elem) // copying
+{
+  TAO_OutputCDR stream;
+  stream << _tao_elem;
+  _tao_any._tao_replace (
+      CORBA::ValueDef::_tc_FullValueDescription,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin ()
+    );
+}
+
+void operator<<= (CORBA::Any &_tao_any, CORBA::ValueDef::FullValueDescription *_tao_elem) // non copying
+{
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      CORBA::ValueDef::_tc_FullValueDescription,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      CORBA::ValueDef::FullValueDescription::_tao_any_destructor
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ValueDef::FullValueDescription *&_tao_elem)
+{
+  return _tao_any >>= ACE_const_cast(const CORBA::ValueDef::FullValueDescription*&,_tao_elem);
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::ValueDef::FullValueDescription *&_tao_elem)
+{
+  _tao_elem = 0;
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (CORBA::ValueDef::_tc_FullValueDescription, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    if (_tao_any.any_owns_data ())
+    {
+      _tao_elem = ACE_static_cast(
+          const CORBA::ValueDef::FullValueDescription*,
+          _tao_any.value ()
+        );
+      return 1;
+    }
+    else
+    {
+      CORBA::ValueDef::FullValueDescription *tmp;
+      ACE_NEW_RETURN (tmp, CORBA::ValueDef::FullValueDescription, 0);
+      TAO_InputCDR stream (
+          _tao_any._tao_get_cdr (),
+          _tao_any._tao_byte_order ()
+        );
+      if (stream >> *tmp)
+      {
+        ((CORBA::Any *)&_tao_any)->_tao_replace (
+            CORBA::ValueDef::_tc_FullValueDescription,
+            1,
+            ACE_static_cast (void *, tmp),
+            CORBA::ValueDef::FullValueDescription::_tao_any_destructor
+          );
+        _tao_elem = tmp;
+        return 1;
+      }
+      else
+      {
+        delete tmp;
+      }
+    }
+  }
+  ACE_CATCHANY
+  {
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+void operator<<= (CORBA::Any &_tao_any, const CORBA::ValueDescription &_tao_elem) // copying
+{
+  TAO_OutputCDR stream;
+  stream << _tao_elem;
+  _tao_any._tao_replace (
+      CORBA::_tc_ValueDescription,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin ()
+    );
+}
+
+void operator<<= (CORBA::Any &_tao_any, CORBA::ValueDescription *_tao_elem) // non copying
+{
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      CORBA::_tc_ValueDescription,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      CORBA::ValueDescription::_tao_any_destructor
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ValueDescription *&_tao_elem)
+{
+  return _tao_any >>= ACE_const_cast(const CORBA::ValueDescription*&,_tao_elem);
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::ValueDescription *&_tao_elem)
+{
+  _tao_elem = 0;
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (CORBA::_tc_ValueDescription, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    if (_tao_any.any_owns_data ())
+    {
+      _tao_elem = ACE_static_cast(
+          const CORBA::ValueDescription*,
+          _tao_any.value ()
+        );
+      return 1;
+    }
+    else
+    {
+      CORBA::ValueDescription *tmp;
+      ACE_NEW_RETURN (tmp, CORBA::ValueDescription, 0);
+      TAO_InputCDR stream (
+          _tao_any._tao_get_cdr (),
+          _tao_any._tao_byte_order ()
+        );
+      if (stream >> *tmp)
+      {
+        ((CORBA::Any *)&_tao_any)->_tao_replace (
+            CORBA::_tc_ValueDescription,
+            1,
+            ACE_static_cast (void *, tmp),
+            CORBA::ValueDescription::_tao_any_destructor
+          );
+        _tao_elem = tmp;
+        return 1;
+      }
+      else
+      {
+        delete tmp;
+      }
+    }
+  }
+  ACE_CATCHANY
+  {
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+void operator<<= (CORBA::Any &_tao_any, CORBA::ValueBoxDef_ptr _tao_elem)
+{
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        CORBA::_tc_ValueBoxDef, 
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin (),
+        1,
+        CORBA::ValueBoxDef::_duplicate (_tao_elem),
+        CORBA::ValueBoxDef::_tao_any_destructor
+      );
+  }
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ValueBoxDef_ptr &_tao_elem)
+{
+  ACE_TRY_NEW_ENV
+  {
+    _tao_elem = CORBA::ValueBoxDef::_nil ();
+    CORBA::TypeCode_var type = _tao_any.type ();
+    
+    CORBA::Boolean result = type->equivalent (CORBA::_tc_ValueBoxDef, ACE_TRY_ENV);
+    ACE_TRY_CHECK;
+    
+    if (!result)
+      return 0; // not equivalent
+    
+    TAO_InputCDR stream (
+        _tao_any._tao_get_cdr (),
+        _tao_any._tao_byte_order ()
+      );
+    if (stream >> _tao_elem)
+    {
+      ((CORBA::Any *)&_tao_any)->_tao_replace (
+          CORBA::_tc_ValueBoxDef,
+          1,
+          _tao_elem,
+          CORBA::ValueBoxDef::_tao_any_destructor
+        );
+      return 1;
+    }
+  }
+  ACE_CATCHANY
+  {
+    _tao_elem = CORBA::ValueBoxDef::_nil ();
+    return 0;
+  }
+  ACE_ENDTRY;
+  _tao_elem = CORBA::ValueBoxDef::_nil ();
+  return 0;
+}
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
+    defined (ACE_HAS_GNU_REPO)
+    template class TAO_Object_Manager<CORBA::ValueBoxDef,CORBA::ValueBoxDef_var>;
+  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+  #  pragma instantiate TAO_Object_Manager<CORBA::ValueBoxDef,CORBA::ValueBoxDef_var>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+// *********************************************************************
+// CDR operators from sequence class moved from IFR_BaseC.cpp
+
+CORBA::Boolean operator<< (
+    TAO_OutputCDR &strm,
+    const CORBA::ValueDefSeq &_tao_sequence
+  )
+{
+  if (strm << _tao_sequence.length ())
+  {
+    // encode all elements
+    CORBA::Boolean _tao_marshal_flag = 1;
+    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
+      _tao_marshal_flag = (strm << _tao_sequence[i].in ());
+    }
+    return _tao_marshal_flag;
+  }
+  return 0; // error
+}
+
+CORBA::Boolean operator>> (
+    TAO_InputCDR &strm,
+    CORBA::ValueDefSeq &_tao_sequence
+  )
+{
+  CORBA::ULong _tao_seq_len;
+  if (strm >> _tao_seq_len)
+  {
+    // set the length of the sequence
+    _tao_sequence.length (_tao_seq_len);
+    // If length is 0 we return true.
+    if (0 >= _tao_seq_len) 
+      return 1;
+    // retrieve all the elements
+    CORBA::Boolean _tao_marshal_flag = 1;
+    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
+      _tao_marshal_flag = (strm >> _tao_sequence[i].out ());
+    }
+    return _tao_marshal_flag;
+  }
+  return 0; // error
+}
+
+// *************************************************************
+
+CORBA::Boolean operator<< (
+    TAO_OutputCDR &strm,
+    const CORBA::ValueMemberSeq &_tao_sequence
+  )
+{
+  if (strm << _tao_sequence.length ())
+  {
+    // encode all elements
+    CORBA::Boolean _tao_marshal_flag = 1;
+    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
+      _tao_marshal_flag = (strm << _tao_sequence[i]);
+    }
+    return _tao_marshal_flag;
+  }
+  return 0; // error
+}
+
+CORBA::Boolean operator>> (
+    TAO_InputCDR &strm,
+    CORBA::ValueMemberSeq &_tao_sequence
+  )
+{
+  CORBA::ULong _tao_seq_len;
+  if (strm >> _tao_seq_len)
+  {
+    // set the length of the sequence
+    _tao_sequence.length (_tao_seq_len);
+    // If length is 0 we return true.
+    if (0 >= _tao_seq_len) 
+      return 1;
+    // retrieve all the elements
+    CORBA::Boolean _tao_marshal_flag = 1;
+    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
+      _tao_marshal_flag = (strm >> _tao_sequence[i]);
+    }
+    return _tao_marshal_flag;
+  }
+  return 0; // error
+}
+
diff --git a/TAO/tao/IFR_Client/IFR_ExtendedC.h b/TAO/tao/IFR_Client/IFR_ExtendedC.h
new file mode 100644
index 00000000000..d529f9319cb
--- /dev/null
+++ b/TAO/tao/IFR_Client/IFR_ExtendedC.h
@@ -0,0 +1,3836 @@
+// -*- C++ -*-
+//
+// $Id$
+
+// ****  Code generated by the The ACE ORB (TAO) IDL Compiler ****
+// TAO and the TAO IDL Compiler have been developed by:
+//       Center for Distributed Object Computing
+//       Washington University
+//       St. Louis, MO
+//       USA
+//       http://www.cs.wustl.edu/~schmidt/doc-center.html
+// and
+//       Distributed Object Computing Laboratory
+//       University of California at Irvine
+//       Irvine, CA
+//       USA
+//       http://doc.ece.uci.edu/
+//
+// Information about TAO is available at:
+//     http://www.cs.wustl.edu/~schmidt/TAO.html
+
+#ifndef TAO_IDL_IFR_EXTENDEDC_H
+#define TAO_IDL_IFR_EXTENDEDC_H
+
+#include "ace/pre.h"
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+# pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+#include "IFR_BasicC.h"
+
+#if defined (TAO_EXPORT_MACRO)
+#undef TAO_EXPORT_MACRO
+#endif
+#define TAO_EXPORT_MACRO TAO_IFR_Client_Export
+
+#if defined (TAO_EXPORT_NESTED_CLASSES)
+#  if defined (TAO_EXPORT_NESTED_MACRO)
+#    undef TAO_EXPORT_NESTED_MACRO
+#  endif /* defined (TAO_EXPORT_NESTED_MACRO) */
+#  define TAO_EXPORT_NESTED_MACRO TAO_IFR_Client_Export
+#endif /* TAO_EXPORT_NESTED_CLASSES */
+
+#if defined(_MSC_VER)
+#if (_MSC_VER >= 1200)
+#pragma warning(push)
+#endif /* _MSC_VER >= 1200 */
+#pragma warning(disable:4250)
+#endif /* _MSC_VER */
+
+#if defined (__BORLANDC__)
+#pragma option push -w-rvl -w-rch -w-ccc -w-inl
+#endif /* __BORLANDC__ */
+
+// **********************************************************
+// Sequence classes moved from IFR_BaseC.h
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_VALUEDEFSEQ_CH_)
+#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_VALUEDEFSEQ_CH_
+
+  class _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq : public TAO_Unbounded_Base_Sequence
+  {
+  public:
+    // = Initialization and termination methods.
+    
+    _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq (void);
+    _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq (CORBA::ULong maximum);
+    _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq (CORBA::ULong maximum,
+      CORBA::ULong length,
+      CORBA_ValueDef* *value,
+      CORBA::Boolean release = 0);
+    _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq(const _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq &rhs);
+    virtual ~_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq (void);
+    _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq &operator= (const _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq &rhs);
+    TAO_Object_Manager<CORBA::ValueDef,CORBA::ValueDef_var> operator[] (CORBA::ULong index) const;
+    static CORBA_ValueDef **allocbuf (CORBA::ULong nelems);
+    static void freebuf (CORBA_ValueDef **buffer);
+    // The Base_Sequence functions, please see tao/Sequence.h
+    virtual void _allocate_buffer (CORBA::ULong length);
+    virtual void _deallocate_buffer (void);
+    CORBA_ValueDef* *get_buffer (CORBA::Boolean orphan = 0);
+    const CORBA_ValueDef* *get_buffer (void) const;
+    virtual void _shrink_buffer (CORBA::ULong nl, CORBA::ULong ol);
+    virtual void _downcast (
+        void* target,
+        CORBA_Object *src,
+        CORBA_Environment &ACE_TRY_ENV = 
+          TAO_default_environment ()
+      );
+    virtual CORBA_Object* _upcast (void *src) const;
+    
+  };
+
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_CORBA_VALUEDEFSEQ_CH_)
+#define _CORBA_VALUEDEFSEQ_CH_
+
+class CORBA_ValueDefSeq;
+class CORBA_ValueDefSeq_var;
+
+// *************************************************************
+// CORBA_ValueDefSeq
+// *************************************************************
+
+class TAO_IFR_Client_Export CORBA_ValueDefSeq : public 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<CORBA_ValueDef,CORBA_ValueDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+{
+public:
+  CORBA_ValueDefSeq (void); // default ctor
+  CORBA_ValueDefSeq (CORBA::ULong max); // uses max size
+  CORBA_ValueDefSeq (
+    CORBA::ULong max, 
+    CORBA::ULong length, 
+    CORBA_ValueDef_ptr *buffer, 
+    CORBA::Boolean release = 0
+  );
+  CORBA_ValueDefSeq (const CORBA_ValueDefSeq &); // copy ctor
+  ~CORBA_ValueDefSeq (void);
+  static void _tao_any_destructor (void*);
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef CORBA_ValueDefSeq_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+};
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_VALUEDEFSEQ___VAR_CH_)
+#define _CORBA_VALUEDEFSEQ___VAR_CH_
+
+// *************************************************************
+// class CORBA_ValueDefSeq_var
+// *************************************************************
+
+class TAO_IFR_Client_Export CORBA_ValueDefSeq_var
+{
+public:
+  CORBA_ValueDefSeq_var (void); // default constructor
+  CORBA_ValueDefSeq_var (CORBA_ValueDefSeq *);
+  CORBA_ValueDefSeq_var (const CORBA_ValueDefSeq_var &); // copy constructor
+  ~CORBA_ValueDefSeq_var (void); // destructor
+  
+  CORBA_ValueDefSeq_var &operator= (CORBA_ValueDefSeq *);
+  CORBA_ValueDefSeq_var &operator= (const CORBA_ValueDefSeq_var &);
+  CORBA_ValueDefSeq *operator-> (void);
+  const CORBA_ValueDefSeq *operator-> (void) const;
+  
+  operator const CORBA_ValueDefSeq &() const;
+  operator CORBA_ValueDefSeq &();
+  operator CORBA_ValueDefSeq &() const;
+  operator CORBA_ValueDefSeq *&(); // variable-size base types only
+  
+  TAO_Object_Manager<CORBA::ValueDef, CORBA::ValueDef_var> operator[] (CORBA::ULong index);
+  
+  // in, inout, out, _retn 
+  const CORBA_ValueDefSeq &in (void) const;
+  CORBA_ValueDefSeq &inout (void);
+  CORBA_ValueDefSeq *&out (void);
+  CORBA_ValueDefSeq *_retn (void);
+  CORBA_ValueDefSeq *ptr (void) const;
+
+private:
+  CORBA_ValueDefSeq *ptr_;
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_VALUEDEFSEQ___OUT_CH_)
+#define _CORBA_VALUEDEFSEQ___OUT_CH_
+
+class TAO_IFR_Client_Export CORBA_ValueDefSeq_out
+{
+public:
+  CORBA_ValueDefSeq_out (CORBA_ValueDefSeq *&);
+  CORBA_ValueDefSeq_out (CORBA_ValueDefSeq_var &);
+  CORBA_ValueDefSeq_out (const CORBA_ValueDefSeq_out &);
+  CORBA_ValueDefSeq_out &operator= (const CORBA_ValueDefSeq_out &);
+  CORBA_ValueDefSeq_out &operator= (CORBA_ValueDefSeq *);
+  operator CORBA_ValueDefSeq *&();
+  CORBA_ValueDefSeq *&ptr (void);
+  CORBA_ValueDefSeq *operator-> (void);
+  TAO_Object_Manager<CORBA::ValueDef, CORBA::ValueDef_var> operator[] (CORBA::ULong index);
+  
+private:
+  CORBA_ValueDefSeq *&ptr_;
+  // assignment from T_var not allowed
+  void operator= (const CORBA_ValueDefSeq_var &);
+};
+
+
+#endif /* end #if !defined */
+
+// ***************************************************************
+
+  typedef CORBA::Short ValueModifier;
+  typedef CORBA::Short_out ValueModifier_out;
+    TAO_NAMESPACE_STORAGE_CLASS const CORBA::Short VM_NONE;
+
+  TAO_NAMESPACE_STORAGE_CLASS const CORBA::Short VM_CUSTOM;
+
+  TAO_NAMESPACE_STORAGE_CLASS const CORBA::Short VM_ABSTRACT;
+
+  TAO_NAMESPACE_STORAGE_CLASS const CORBA::Short VM_TRUNCATABLE;
+
+  typedef CORBA::Short Visibility;
+  typedef CORBA::Short_out Visibility_out;
+    TAO_NAMESPACE_STORAGE_CLASS const CORBA::Short PRIVATE_MEMBER;
+
+  TAO_NAMESPACE_STORAGE_CLASS const CORBA::Short PUBLIC_MEMBER;
+
+
+#if !defined (_CORBA_FIXEDDEF___VAR_CH_)
+#define _CORBA_FIXEDDEF___VAR_CH_
+
+  class TAO_IFR_Client_Export CORBA_FixedDef_var : public TAO_Base_var
+  {
+  public:
+    CORBA_FixedDef_var (void); // default constructor
+    CORBA_FixedDef_var (CORBA_FixedDef_ptr p) : ptr_ (p) {} 
+    CORBA_FixedDef_var (const CORBA_FixedDef_var &); // copy constructor
+    ~CORBA_FixedDef_var (void); // destructor
+    
+    CORBA_FixedDef_var &operator= (CORBA_FixedDef_ptr);
+    CORBA_FixedDef_var &operator= (const CORBA_FixedDef_var &);
+    CORBA_FixedDef_ptr operator-> (void) const;
+    
+    operator const CORBA_FixedDef_ptr &() const;
+    operator CORBA_FixedDef_ptr &();
+    // in, inout, out, _retn 
+    CORBA_FixedDef_ptr in (void) const;
+    CORBA_FixedDef_ptr &inout (void);
+    CORBA_FixedDef_ptr &out (void);
+    CORBA_FixedDef_ptr _retn (void);
+    CORBA_FixedDef_ptr ptr (void) const;
+
+  private:
+    CORBA_FixedDef_ptr ptr_;
+    // Unimplemented - prevents widening assignment.
+    CORBA_FixedDef_var (const TAO_Base_var &rhs);
+    CORBA_FixedDef_var &operator= (const TAO_Base_var &rhs);
+  };
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_FIXEDDEF___OUT_CH_)
+#define _CORBA_FIXEDDEF___OUT_CH_
+
+  class TAO_IFR_Client_Export CORBA_FixedDef_out
+  {
+  public:
+    CORBA_FixedDef_out (CORBA_FixedDef_ptr &);
+    CORBA_FixedDef_out (CORBA_FixedDef_var &);
+    CORBA_FixedDef_out (const CORBA_FixedDef_out &);
+    CORBA_FixedDef_out &operator= (const CORBA_FixedDef_out &);
+    CORBA_FixedDef_out &operator= (const CORBA_FixedDef_var &);
+    CORBA_FixedDef_out &operator= (CORBA_FixedDef_ptr);
+    operator CORBA_FixedDef_ptr &();
+    CORBA_FixedDef_ptr &ptr (void);
+    CORBA_FixedDef_ptr operator-> (void);
+    
+  private:
+    CORBA_FixedDef_ptr &ptr_;
+  };
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_FIXEDDEF_CH_)
+#define _CORBA_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_IFR_Client_Export CORBA_FixedDef: public virtual CORBA_IDLType
+  {
+  public:
+  #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+    typedef CORBA_FixedDef_ptr _ptr_type;
+    typedef CORBA_FixedDef_var _var_type;
+  #endif /* ! __GNUC__ || g++ >= 2.8 */
+
+    // the static operations
+    static CORBA_FixedDef_ptr _duplicate (CORBA_FixedDef_ptr obj);
+    static CORBA_FixedDef_ptr _narrow (
+        CORBA::Object_ptr obj,
+        CORBA::Environment &ACE_TRY_ENV = 
+          TAO_default_environment ()
+      );
+    static CORBA_FixedDef_ptr _unchecked_narrow (
+        CORBA::Object_ptr obj,
+        CORBA::Environment &ACE_TRY_ENV = 
+          TAO_default_environment ()
+      );
+    static CORBA_FixedDef_ptr _nil (void)
+      {
+        return (CORBA_FixedDef_ptr)0;
+      }
+
+    static void _tao_any_destructor (void*);
+
+    virtual CORBA::UShort digits (
+        CORBA::Environment &ACE_TRY_ENV = 
+          TAO_default_environment ()
+      )
+      ACE_THROW_SPEC ((
+        CORBA::SystemException
+      ));
+
+    virtual void digits (
+        CORBA::UShort digits,
+        CORBA::Environment &ACE_TRY_ENV = 
+          TAO_default_environment ()
+      )
+      ACE_THROW_SPEC ((
+        CORBA::SystemException
+      ));
+
+    virtual CORBA::Short scale (
+        CORBA::Environment &ACE_TRY_ENV = 
+          TAO_default_environment ()
+      )
+      ACE_THROW_SPEC ((
+        CORBA::SystemException
+      ));
+
+    virtual void scale (
+        CORBA::Short scale,
+        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_FixedDef_Proxy_Broker *the_TAO_FixedDef_Proxy_Broker_;
+    
+  protected:
+    CORBA_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 CORBA_FixedDef_setup_collocation (int collocated);
+      
+      CORBA_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 ~CORBA_FixedDef (void);
+  private:
+    CORBA_FixedDef (const CORBA_FixedDef &);
+    void operator= (const CORBA_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_CORBA_FixedDef_digits_get : public TAO_ClientRequestInfo
+    {
+    public:
+      friend class CORBA_FixedDef;
+      
+      friend class _TAO_FixedDef_Remote_Proxy_Impl;
+      friend class _TAO_FixedDef_ThruPOA_Proxy_Impl;
+      friend class _TAO_FixedDef_Direct_Proxy_Impl;
+    
+    TAO_ClientRequestInfo_CORBA_FixedDef_digits_get (
+        TAO_GIOP_Invocation *_tao_invocation,
+        CORBA::Object_ptr _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_FixedDef_digits_get (const TAO_ClientRequestInfo_CORBA_FixedDef_digits_get &);
+    void operator= (const TAO_ClientRequestInfo_CORBA_FixedDef_digits_get &);
+    void result (CORBA::UShort result);
+    // update the result 
+    CORBA::UShort _result;
+  };
+  
+  class TAO_ClientRequestInfo_CORBA_FixedDef_digits_set : public TAO_ClientRequestInfo
+  {
+  public:
+    friend class CORBA_FixedDef;
+    
+    friend class _TAO_FixedDef_Remote_Proxy_Impl;
+    friend class _TAO_FixedDef_ThruPOA_Proxy_Impl;
+    friend class _TAO_FixedDef_Direct_Proxy_Impl;
+  
+  TAO_ClientRequestInfo_CORBA_FixedDef_digits_set (
+      TAO_GIOP_Invocation *_tao_invocation,
+      CORBA::Object_ptr _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_CORBA_FixedDef_digits_set (const TAO_ClientRequestInfo_CORBA_FixedDef_digits_set &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_FixedDef_digits_set &);
+  const CORBA::UShort & digits_;
+  
+};
+
+class TAO_ClientRequestInfo_CORBA_FixedDef_scale_get : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_FixedDef;
+  
+  friend class _TAO_FixedDef_Remote_Proxy_Impl;
+  friend class _TAO_FixedDef_ThruPOA_Proxy_Impl;
+  friend class _TAO_FixedDef_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_FixedDef_scale_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _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_FixedDef_scale_get (const TAO_ClientRequestInfo_CORBA_FixedDef_scale_get &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_FixedDef_scale_get &);
+  void result (CORBA::Short result);
+  // update the result 
+  CORBA::Short _result;
+};
+
+class TAO_ClientRequestInfo_CORBA_FixedDef_scale_set : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_FixedDef;
+  
+  friend class _TAO_FixedDef_Remote_Proxy_Impl;
+  friend class _TAO_FixedDef_ThruPOA_Proxy_Impl;
+  friend class _TAO_FixedDef_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_FixedDef_scale_set (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _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));
+
+private:
+  TAO_ClientRequestInfo_CORBA_FixedDef_scale_set (const TAO_ClientRequestInfo_CORBA_FixedDef_scale_set &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_FixedDef_scale_set &);
+  const CORBA::Short & scale_;
+  
+};
+
+#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_IFR_Client_Export _TAO_FixedDef_Proxy_Impl : 
+  public virtual _TAO_IDLType_Proxy_Impl
+{
+public:
+  virtual ~_TAO_FixedDef_Proxy_Impl (void) { }
+  
+    virtual CORBA::UShort digits (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual void digits (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::UShort digits,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual CORBA::Short scale (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual void scale (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Short scale,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+protected:
+  _TAO_FixedDef_Proxy_Impl (void);
+
+};
+//
+//                Base  Proxy Impl. Declaration
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//                    Remote  Impl. Declaration
+//
+
+class TAO_IFR_Client_Export _TAO_FixedDef_Remote_Proxy_Impl : 
+  public virtual _TAO_FixedDef_Proxy_Impl,
+  public virtual TAO_Remote_Object_Proxy_Impl,
+  public virtual _TAO_IDLType_Remote_Proxy_Impl
+  
+{
+public:
+  _TAO_FixedDef_Remote_Proxy_Impl (void);
+  
+  virtual ~_TAO_FixedDef_Remote_Proxy_Impl (void) { }
+  
+    virtual CORBA::UShort digits (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void digits (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::UShort digits,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::Short scale (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void scale (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Short scale,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+};
+
+//
+//                Base  Proxy Impl. Declaration
+///////////////////////////////////////////////////////////////////////
+
+
+// The Proxy Brokers are used by each interface to get
+// the right proxy for performing a call. In the new 
+// collocation scheme, the proxy to be used can vary on
+// a call by call basis. 
+
+
+
+///////////////////////////////////////////////////////////////////////
+//                 Base Proxy Broker Declaration 
+//
+
+class TAO_IFR_Client_Export _TAO_FixedDef_Proxy_Broker
+{
+public:
+  virtual ~_TAO_FixedDef_Proxy_Broker (void);
+  virtual _TAO_FixedDef_Proxy_Impl &select_proxy (
+    CORBA_FixedDef *object,
+    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
+  ) = 0;
+
+protected:
+  _TAO_FixedDef_Proxy_Broker (void);
+  
+};
+
+//
+//              End Base Proxy Broker Declaration 
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//                 Remote Proxy Broker Declaration 
+//
+
+class TAO_IFR_Client_Export _TAO_FixedDef_Remote_Proxy_Broker : public virtual _TAO_FixedDef_Proxy_Broker
+{
+public: 
+  _TAO_FixedDef_Remote_Proxy_Broker (void);
+  
+  virtual ~_TAO_FixedDef_Remote_Proxy_Broker (void);
+  
+  virtual _TAO_FixedDef_Proxy_Impl &select_proxy (
+    CORBA_FixedDef *object,
+    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
+  );
+
+private:
+  _TAO_FixedDef_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_FixedDef_Remote_Proxy_Broker *the_TAO_FixedDef_Remote_Proxy_Broker (void);
+};
+
+
+//
+//              End Remote Proxy Broker Declaration 
+///////////////////////////////////////////////////////////////////////
+
+
+#endif /* end #if !defined */
+
+struct CORBA_ValueMember;
+class CORBA_ValueMember_var;
+
+struct TAO_IFR_Client_Export CORBA_ValueMember
+{
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef CORBA_ValueMember_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  static void _tao_any_destructor (void*);
+
+  TAO_String_Manager name;
+  TAO_String_Manager id;
+  TAO_String_Manager defined_in;
+  TAO_String_Manager version;
+  CORBA::TypeCode_var type;
+  CORBA::IDLType_var type_def;
+  ACE_NESTED_CLASS (CORBA, Visibility) access;
+};
+
+class TAO_IFR_Client_Export CORBA_ValueMember_var
+{
+public:
+  CORBA_ValueMember_var (void); // default constructor
+  CORBA_ValueMember_var (CORBA_ValueMember *);
+  CORBA_ValueMember_var (const CORBA_ValueMember_var &); // copy constructor
+  ~CORBA_ValueMember_var (void); // destructor
+  
+  CORBA_ValueMember_var &operator= (CORBA_ValueMember *);
+  CORBA_ValueMember_var &operator= (const CORBA_ValueMember_var &);
+  CORBA_ValueMember *operator-> (void);
+  const CORBA_ValueMember *operator-> (void) const;
+  
+  operator const CORBA_ValueMember &() const;
+  operator CORBA_ValueMember &();
+  operator CORBA_ValueMember &() const;
+  operator CORBA_ValueMember *&(); // variable-size types only
+  
+  // in, inout, out, _retn 
+  const CORBA_ValueMember &in (void) const;
+  CORBA_ValueMember &inout (void);
+  CORBA_ValueMember *&out (void);
+  CORBA_ValueMember *_retn (void);
+  CORBA_ValueMember *ptr (void) const;
+
+private:
+  CORBA_ValueMember *ptr_;
+};
+
+class TAO_IFR_Client_Export CORBA_ValueMember_out
+{
+public:
+  CORBA_ValueMember_out (CORBA_ValueMember *&);
+  CORBA_ValueMember_out (CORBA_ValueMember_var &);
+  CORBA_ValueMember_out (const CORBA_ValueMember_out &);
+  CORBA_ValueMember_out &operator= (const CORBA_ValueMember_out &);
+  CORBA_ValueMember_out &operator= (CORBA_ValueMember *);
+  operator CORBA_ValueMember *&();
+  CORBA_ValueMember *&ptr (void);
+  CORBA_ValueMember *operator-> (void);
+  
+private:
+  CORBA_ValueMember *&ptr_;
+  // assignment from T_var not allowed
+  void operator= (const CORBA_ValueMember_var &);
+};
+
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_SEQUENCE_CORBA_VALUEMEMBERSEQ_CH_)
+#define __TAO_UNBOUNDED_SEQUENCE_CORBA_VALUEMEMBERSEQ_CH_
+
+  class TAO_EXPORT_NESTED_MACRO _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq : public TAO_Unbounded_Base_Sequence
+  {
+  public:
+    // = Initialization and termination methods.
+    
+    _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq (void); // Default constructor.
+    _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq (CORBA::ULong maximum); 
+    _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq (CORBA::ULong maximum,
+      CORBA::ULong length,
+      CORBA_ValueMember *data,
+      CORBA::Boolean release = 0);
+    _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq (const _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq &rhs);
+    _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq &operator= (const _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq &rhs);
+    virtual ~_TAO_Unbounded_Sequence_CORBA_ValueMemberSeq (void); // Dtor.
+    // = Accessors.
+    CORBA_ValueMember &operator[] (CORBA::ULong i);
+    const CORBA_ValueMember &operator[] (CORBA::ULong i) const;
+    // = Static operations.
+    static CORBA_ValueMember *allocbuf (CORBA::ULong size);
+    static void freebuf (CORBA_ValueMember *buffer);
+    virtual void _allocate_buffer (CORBA::ULong length);
+    virtual void _deallocate_buffer (void);
+    // Implement the TAO_Base_Sequence methods (see Sequence.h)
+    
+    CORBA_ValueMember *get_buffer (CORBA::Boolean orphan = 0);
+    const CORBA_ValueMember *get_buffer (void) const;
+    void replace (CORBA::ULong max,
+      CORBA::ULong length,
+      CORBA_ValueMember *data,
+      CORBA::Boolean release);
+  };
+
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_CORBA_VALUEMEMBERSEQ_CH_)
+#define _CORBA_VALUEMEMBERSEQ_CH_
+
+class CORBA_ValueMemberSeq;
+class CORBA_ValueMemberSeq_var;
+
+// *************************************************************
+// CORBA_ValueMemberSeq
+// *************************************************************
+
+class TAO_IFR_Client_Export CORBA_ValueMemberSeq : public 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<CORBA_ValueMember>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+{
+public:
+  CORBA_ValueMemberSeq (void); // default ctor
+  CORBA_ValueMemberSeq (CORBA::ULong max); // uses max size
+  CORBA_ValueMemberSeq (
+    CORBA::ULong max, 
+    CORBA::ULong length, 
+    CORBA::ValueMember *buffer, 
+    CORBA::Boolean release = 0
+  );
+  CORBA_ValueMemberSeq (const CORBA_ValueMemberSeq &); // copy ctor
+  ~CORBA_ValueMemberSeq (void);
+  static void _tao_any_destructor (void*);
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef CORBA_ValueMemberSeq_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+};
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_VALUEMEMBERSEQ___VAR_CH_)
+#define _CORBA_VALUEMEMBERSEQ___VAR_CH_
+
+// *************************************************************
+// class CORBA_ValueMemberSeq_var
+// *************************************************************
+
+class TAO_IFR_Client_Export CORBA_ValueMemberSeq_var
+{
+public:
+  CORBA_ValueMemberSeq_var (void); // default constructor
+  CORBA_ValueMemberSeq_var (CORBA_ValueMemberSeq *);
+  CORBA_ValueMemberSeq_var (const CORBA_ValueMemberSeq_var &); // copy constructor
+  ~CORBA_ValueMemberSeq_var (void); // destructor
+  
+  CORBA_ValueMemberSeq_var &operator= (CORBA_ValueMemberSeq *);
+  CORBA_ValueMemberSeq_var &operator= (const CORBA_ValueMemberSeq_var &);
+  CORBA_ValueMemberSeq *operator-> (void);
+  const CORBA_ValueMemberSeq *operator-> (void) const;
+  
+  operator const CORBA_ValueMemberSeq &() const;
+  operator CORBA_ValueMemberSeq &();
+  operator CORBA_ValueMemberSeq &() const;
+  operator CORBA_ValueMemberSeq *&(); // variable-size base types only
+  
+  CORBA::ValueMember & operator[] (CORBA::ULong index);
+  const CORBA::ValueMember & operator[] (CORBA::ULong index) const;
+  
+  // in, inout, out, _retn 
+  const CORBA_ValueMemberSeq &in (void) const;
+  CORBA_ValueMemberSeq &inout (void);
+  CORBA_ValueMemberSeq *&out (void);
+  CORBA_ValueMemberSeq *_retn (void);
+  CORBA_ValueMemberSeq *ptr (void) const;
+
+private:
+  CORBA_ValueMemberSeq *ptr_;
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_VALUEMEMBERSEQ___OUT_CH_)
+#define _CORBA_VALUEMEMBERSEQ___OUT_CH_
+
+class TAO_IFR_Client_Export CORBA_ValueMemberSeq_out
+{
+public:
+  CORBA_ValueMemberSeq_out (CORBA_ValueMemberSeq *&);
+  CORBA_ValueMemberSeq_out (CORBA_ValueMemberSeq_var &);
+  CORBA_ValueMemberSeq_out (const CORBA_ValueMemberSeq_out &);
+  CORBA_ValueMemberSeq_out &operator= (const CORBA_ValueMemberSeq_out &);
+  CORBA_ValueMemberSeq_out &operator= (CORBA_ValueMemberSeq *);
+  operator CORBA_ValueMemberSeq *&();
+  CORBA_ValueMemberSeq *&ptr (void);
+  CORBA_ValueMemberSeq *operator-> (void);
+  CORBA::ValueMember & operator[] (CORBA::ULong index);
+  
+private:
+  CORBA_ValueMemberSeq *&ptr_;
+  // assignment from T_var not allowed
+  void operator= (const CORBA_ValueMemberSeq_var &);
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_VALUEMEMBERDEF___VAR_CH_)
+#define _CORBA_VALUEMEMBERDEF___VAR_CH_
+
+class TAO_IFR_Client_Export CORBA_ValueMemberDef_var : public TAO_Base_var
+{
+public:
+  CORBA_ValueMemberDef_var (void); // default constructor
+  CORBA_ValueMemberDef_var (CORBA_ValueMemberDef_ptr p) : ptr_ (p) {} 
+  CORBA_ValueMemberDef_var (const CORBA_ValueMemberDef_var &); // copy constructor
+  ~CORBA_ValueMemberDef_var (void); // destructor
+  
+  CORBA_ValueMemberDef_var &operator= (CORBA_ValueMemberDef_ptr);
+  CORBA_ValueMemberDef_var &operator= (const CORBA_ValueMemberDef_var &);
+  CORBA_ValueMemberDef_ptr operator-> (void) const;
+  
+  operator const CORBA_ValueMemberDef_ptr &() const;
+  operator CORBA_ValueMemberDef_ptr &();
+  // in, inout, out, _retn 
+  CORBA_ValueMemberDef_ptr in (void) const;
+  CORBA_ValueMemberDef_ptr &inout (void);
+  CORBA_ValueMemberDef_ptr &out (void);
+  CORBA_ValueMemberDef_ptr _retn (void);
+  CORBA_ValueMemberDef_ptr ptr (void) const;
+
+private:
+  CORBA_ValueMemberDef_ptr ptr_;
+  // Unimplemented - prevents widening assignment.
+  CORBA_ValueMemberDef_var (const TAO_Base_var &rhs);
+  CORBA_ValueMemberDef_var &operator= (const TAO_Base_var &rhs);
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_VALUEMEMBERDEF___OUT_CH_)
+#define _CORBA_VALUEMEMBERDEF___OUT_CH_
+
+class TAO_IFR_Client_Export CORBA_ValueMemberDef_out
+{
+public:
+  CORBA_ValueMemberDef_out (CORBA_ValueMemberDef_ptr &);
+  CORBA_ValueMemberDef_out (CORBA_ValueMemberDef_var &);
+  CORBA_ValueMemberDef_out (const CORBA_ValueMemberDef_out &);
+  CORBA_ValueMemberDef_out &operator= (const CORBA_ValueMemberDef_out &);
+  CORBA_ValueMemberDef_out &operator= (const CORBA_ValueMemberDef_var &);
+  CORBA_ValueMemberDef_out &operator= (CORBA_ValueMemberDef_ptr);
+  operator CORBA_ValueMemberDef_ptr &();
+  CORBA_ValueMemberDef_ptr &ptr (void);
+  CORBA_ValueMemberDef_ptr operator-> (void);
+  
+private:
+  CORBA_ValueMemberDef_ptr &ptr_;
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_VALUEMEMBERDEF_CH_)
+#define _CORBA_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_IFR_Client_Export CORBA_ValueMemberDef: public virtual CORBA_Contained
+{
+public:
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef CORBA_ValueMemberDef_ptr _ptr_type;
+  typedef CORBA_ValueMemberDef_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  // the static operations
+  static CORBA_ValueMemberDef_ptr _duplicate (CORBA_ValueMemberDef_ptr obj);
+  static CORBA_ValueMemberDef_ptr _narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    );
+  static CORBA_ValueMemberDef_ptr _unchecked_narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    );
+  static CORBA_ValueMemberDef_ptr _nil (void)
+    {
+      return (CORBA_ValueMemberDef_ptr)0;
+    }
+
+  static void _tao_any_destructor (void*);
+
+  virtual CORBA::TypeCode_ptr type (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::IDLType_ptr type_def (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void type_def (
+      CORBA::IDLType_ptr type_def,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::Visibility access (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void access (
+      CORBA::Visibility access,
+      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_ValueMemberDef_Proxy_Broker *the_TAO_ValueMemberDef_Proxy_Broker_;
+  
+protected:
+  CORBA_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 CORBA_ValueMemberDef_setup_collocation (int collocated);
+    
+    CORBA_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;
+  
+  virtual ~CORBA_ValueMemberDef (void);
+private:
+  CORBA_ValueMemberDef (const CORBA_ValueMemberDef &);
+  void operator= (const CORBA_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_CORBA_ValueMemberDef_type_get : public TAO_ClientRequestInfo
+  {
+  public:
+    friend class CORBA_ValueMemberDef;
+    
+    friend class _TAO_ValueMemberDef_Remote_Proxy_Impl;
+    friend class _TAO_ValueMemberDef_ThruPOA_Proxy_Impl;
+    friend class _TAO_ValueMemberDef_Direct_Proxy_Impl;
+  
+  TAO_ClientRequestInfo_CORBA_ValueMemberDef_type_get (
+      TAO_GIOP_Invocation *_tao_invocation,
+      CORBA::Object_ptr _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_ValueMemberDef_type_get (const TAO_ClientRequestInfo_CORBA_ValueMemberDef_type_get &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_ValueMemberDef_type_get &);
+  void result (CORBA::TypeCode_ptr result);
+  // update the result 
+  CORBA::TypeCode_ptr _result;
+};
+
+class TAO_ClientRequestInfo_CORBA_ValueMemberDef_type_def_get : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_ValueMemberDef;
+  
+  friend class _TAO_ValueMemberDef_Remote_Proxy_Impl;
+  friend class _TAO_ValueMemberDef_ThruPOA_Proxy_Impl;
+  friend class _TAO_ValueMemberDef_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_ValueMemberDef_type_def_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _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_ValueMemberDef_type_def_get (const TAO_ClientRequestInfo_CORBA_ValueMemberDef_type_def_get &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_ValueMemberDef_type_def_get &);
+  void result (CORBA::IDLType_ptr result);
+  // update the result 
+  CORBA::IDLType_ptr _result;
+};
+
+class TAO_ClientRequestInfo_CORBA_ValueMemberDef_type_def_set : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_ValueMemberDef;
+  
+  friend class _TAO_ValueMemberDef_Remote_Proxy_Impl;
+  friend class _TAO_ValueMemberDef_ThruPOA_Proxy_Impl;
+  friend class _TAO_ValueMemberDef_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_ValueMemberDef_type_def_set (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::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_CORBA_ValueMemberDef_type_def_set (const TAO_ClientRequestInfo_CORBA_ValueMemberDef_type_def_set &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_ValueMemberDef_type_def_set &);
+  CORBA::IDLType_ptr type_def_;
+  
+};
+
+class TAO_ClientRequestInfo_CORBA_ValueMemberDef_access_get : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_ValueMemberDef;
+  
+  friend class _TAO_ValueMemberDef_Remote_Proxy_Impl;
+  friend class _TAO_ValueMemberDef_ThruPOA_Proxy_Impl;
+  friend class _TAO_ValueMemberDef_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_ValueMemberDef_access_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _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_ValueMemberDef_access_get (const TAO_ClientRequestInfo_CORBA_ValueMemberDef_access_get &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_ValueMemberDef_access_get &);
+  void result (CORBA::Visibility result);
+  // update the result 
+  CORBA::Visibility _result;
+};
+
+class TAO_ClientRequestInfo_CORBA_ValueMemberDef_access_set : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_ValueMemberDef;
+  
+  friend class _TAO_ValueMemberDef_Remote_Proxy_Impl;
+  friend class _TAO_ValueMemberDef_ThruPOA_Proxy_Impl;
+  friend class _TAO_ValueMemberDef_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_ValueMemberDef_access_set (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _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_CORBA_ValueMemberDef_access_set (const TAO_ClientRequestInfo_CORBA_ValueMemberDef_access_set &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_ValueMemberDef_access_set &);
+  const CORBA::Visibility & access_;
+  
+};
+
+#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_IFR_Client_Export _TAO_ValueMemberDef_Proxy_Impl : 
+  public virtual _TAO_Contained_Proxy_Impl
+{
+public:
+  virtual ~_TAO_ValueMemberDef_Proxy_Impl (void) { }
+  
+    virtual CORBA::TypeCode_ptr type (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual CORBA::IDLType_ptr type_def (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual void type_def (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::IDLType_ptr type_def,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual CORBA::Visibility access (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual void access (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Visibility access,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+protected:
+  _TAO_ValueMemberDef_Proxy_Impl (void);
+
+};
+//
+//                Base  Proxy Impl. Declaration
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//                    Remote  Impl. Declaration
+//
+
+class TAO_IFR_Client_Export _TAO_ValueMemberDef_Remote_Proxy_Impl : 
+  public virtual _TAO_ValueMemberDef_Proxy_Impl,
+  public virtual TAO_Remote_Object_Proxy_Impl,
+  public virtual _TAO_Contained_Remote_Proxy_Impl
+  
+{
+public:
+  _TAO_ValueMemberDef_Remote_Proxy_Impl (void);
+  
+  virtual ~_TAO_ValueMemberDef_Remote_Proxy_Impl (void) { }
+  
+    virtual CORBA::TypeCode_ptr type (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::IDLType_ptr type_def (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void type_def (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::IDLType_ptr type_def,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::Visibility access (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void access (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Visibility access,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+};
+
+//
+//                Base  Proxy Impl. Declaration
+///////////////////////////////////////////////////////////////////////
+
+
+// The Proxy Brokers are used by each interface to get
+// the right proxy for performing a call. In the new 
+// collocation scheme, the proxy to be used can vary on
+// a call by call basis. 
+
+
+
+///////////////////////////////////////////////////////////////////////
+//                 Base Proxy Broker Declaration 
+//
+
+class TAO_IFR_Client_Export _TAO_ValueMemberDef_Proxy_Broker
+{
+public:
+  virtual ~_TAO_ValueMemberDef_Proxy_Broker (void);
+  virtual _TAO_ValueMemberDef_Proxy_Impl &select_proxy (
+    CORBA_ValueMemberDef *object,
+    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
+  ) = 0;
+
+protected:
+  _TAO_ValueMemberDef_Proxy_Broker (void);
+  
+};
+
+//
+//              End Base Proxy Broker Declaration 
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//                 Remote Proxy Broker Declaration 
+//
+
+class TAO_IFR_Client_Export _TAO_ValueMemberDef_Remote_Proxy_Broker : public virtual _TAO_ValueMemberDef_Proxy_Broker
+{
+public: 
+  _TAO_ValueMemberDef_Remote_Proxy_Broker (void);
+  
+  virtual ~_TAO_ValueMemberDef_Remote_Proxy_Broker (void);
+  
+  virtual _TAO_ValueMemberDef_Proxy_Impl &select_proxy (
+    CORBA_ValueMemberDef *object,
+    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
+  );
+
+private:
+  _TAO_ValueMemberDef_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_ValueMemberDef_Remote_Proxy_Broker *the_TAO_ValueMemberDef_Remote_Proxy_Broker (void);
+};
+
+
+//
+//              End Remote Proxy Broker Declaration 
+///////////////////////////////////////////////////////////////////////
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_VALUEDEF___VAR_CH_)
+#define _CORBA_VALUEDEF___VAR_CH_
+
+class TAO_IFR_Client_Export CORBA_ValueDef_var : public TAO_Base_var
+{
+public:
+  CORBA_ValueDef_var (void); // default constructor
+  CORBA_ValueDef_var (CORBA_ValueDef_ptr p) : ptr_ (p) {} 
+  CORBA_ValueDef_var (const CORBA_ValueDef_var &); // copy constructor
+  ~CORBA_ValueDef_var (void); // destructor
+  
+  CORBA_ValueDef_var &operator= (CORBA_ValueDef_ptr);
+  CORBA_ValueDef_var &operator= (const CORBA_ValueDef_var &);
+  CORBA_ValueDef_ptr operator-> (void) const;
+  
+  operator const CORBA_ValueDef_ptr &() const;
+  operator CORBA_ValueDef_ptr &();
+  // in, inout, out, _retn 
+  CORBA_ValueDef_ptr in (void) const;
+  CORBA_ValueDef_ptr &inout (void);
+  CORBA_ValueDef_ptr &out (void);
+  CORBA_ValueDef_ptr _retn (void);
+  CORBA_ValueDef_ptr ptr (void) const;
+
+private:
+  CORBA_ValueDef_ptr ptr_;
+  // Unimplemented - prevents widening assignment.
+  CORBA_ValueDef_var (const TAO_Base_var &rhs);
+  CORBA_ValueDef_var &operator= (const TAO_Base_var &rhs);
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_VALUEDEF___OUT_CH_)
+#define _CORBA_VALUEDEF___OUT_CH_
+
+class TAO_IFR_Client_Export CORBA_ValueDef_out
+{
+public:
+  CORBA_ValueDef_out (CORBA_ValueDef_ptr &);
+  CORBA_ValueDef_out (CORBA_ValueDef_var &);
+  CORBA_ValueDef_out (const CORBA_ValueDef_out &);
+  CORBA_ValueDef_out &operator= (const CORBA_ValueDef_out &);
+  CORBA_ValueDef_out &operator= (const CORBA_ValueDef_var &);
+  CORBA_ValueDef_out &operator= (CORBA_ValueDef_ptr);
+  operator CORBA_ValueDef_ptr &();
+  CORBA_ValueDef_ptr &ptr (void);
+  CORBA_ValueDef_ptr operator-> (void);
+  
+private:
+  CORBA_ValueDef_ptr &ptr_;
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_VALUEDEF_CH_)
+#define _CORBA_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_IFR_Client_Export CORBA_ValueDef: public virtual CORBA_Container, public virtual CORBA_Contained, public virtual CORBA_IDLType
+{
+public:
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef CORBA_ValueDef_ptr _ptr_type;
+  typedef CORBA_ValueDef_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  // the static operations
+  static CORBA_ValueDef_ptr _duplicate (CORBA_ValueDef_ptr obj);
+  static CORBA_ValueDef_ptr _narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    );
+  static CORBA_ValueDef_ptr _unchecked_narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    );
+  static CORBA_ValueDef_ptr _nil (void)
+    {
+      return (CORBA_ValueDef_ptr)0;
+    }
+
+  static void _tao_any_destructor (void*);
+
+  virtual CORBA::InterfaceDefSeq * supported_interfaces (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void supported_interfaces (
+      const CORBA::InterfaceDefSeq & supported_interfaces,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::InitializerSeq * initializers (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void initializers (
+      const CORBA::InitializerSeq & initializers,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::ValueDef_ptr base_value (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void base_value (
+      CORBA::ValueDef_ptr base_value,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::ValueDefSeq * abstract_base_values (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void abstract_base_values (
+      const CORBA::ValueDefSeq & abstract_base_values,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::Boolean is_abstract (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void is_abstract (
+      CORBA::Boolean is_abstract,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::Boolean is_custom (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void is_custom (
+      CORBA::Boolean is_custom,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::Boolean is_truncatable (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void is_truncatable (
+      CORBA::Boolean is_truncatable,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::Boolean is_a (
+      const char * id,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  struct FullValueDescription;
+  class FullValueDescription_var;
+  
+  struct TAO_IFR_Client_Export FullValueDescription
+  {
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+    typedef FullValueDescription_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+    static void _tao_any_destructor (void*);
+
+    TAO_String_Manager name;
+    TAO_String_Manager id;
+    CORBA::Boolean is_abstract;
+    CORBA::Boolean is_custom;
+    TAO_String_Manager defined_in;
+    TAO_String_Manager version;
+    CORBA::OpDescriptionSeq operations;
+    CORBA::AttrDescriptionSeq attributes;
+    CORBA::ValueMemberSeq members;
+    CORBA::InitializerSeq initializers;
+    CORBA::RepositoryIdSeq supported_interfaces;
+    CORBA::RepositoryIdSeq abstract_base_values;
+    CORBA::Boolean is_truncatable;
+    TAO_String_Manager base_value;
+    CORBA::TypeCode_var type;
+  };
+
+  class TAO_IFR_Client_Export FullValueDescription_var
+  {
+  public:
+    FullValueDescription_var (void); // default constructor
+    FullValueDescription_var (FullValueDescription *);
+    FullValueDescription_var (const FullValueDescription_var &); // copy constructor
+    ~FullValueDescription_var (void); // destructor
+    
+    FullValueDescription_var &operator= (FullValueDescription *);
+    FullValueDescription_var &operator= (const FullValueDescription_var &);
+    FullValueDescription *operator-> (void);
+    const FullValueDescription *operator-> (void) const;
+    
+    operator const FullValueDescription &() const;
+    operator FullValueDescription &();
+    operator FullValueDescription &() const;
+    operator FullValueDescription *&(); // variable-size types only
+    
+    // in, inout, out, _retn 
+    const FullValueDescription &in (void) const;
+    FullValueDescription &inout (void);
+    FullValueDescription *&out (void);
+    FullValueDescription *_retn (void);
+    FullValueDescription *ptr (void) const;
+
+  private:
+    FullValueDescription *ptr_;
+  };
+
+  class TAO_IFR_Client_Export FullValueDescription_out
+  {
+  public:
+    FullValueDescription_out (FullValueDescription *&);
+    FullValueDescription_out (FullValueDescription_var &);
+    FullValueDescription_out (const FullValueDescription_out &);
+    FullValueDescription_out &operator= (const FullValueDescription_out &);
+    FullValueDescription_out &operator= (FullValueDescription *);
+    operator FullValueDescription *&();
+    FullValueDescription *&ptr (void);
+    FullValueDescription *operator-> (void);
+    
+  private:
+    FullValueDescription *&ptr_;
+    // assignment from T_var not allowed
+    void operator= (const FullValueDescription_var &);
+  };
+
+  static CORBA::TypeCode_ptr _tc_FullValueDescription;
+
+  virtual CORBA::ValueDef::FullValueDescription * describe_value (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::ValueMemberDef_ptr create_value_member (
+      const char * id,
+      const char * name,
+      const char * version,
+      CORBA::IDLType_ptr type,
+      CORBA::Visibility access,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::AttributeDef_ptr create_attribute (
+      const char * id,
+      const char * name,
+      const char * version,
+      CORBA::IDLType_ptr type,
+      CORBA::AttributeMode mode,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::OperationDef_ptr create_operation (
+      const char * id,
+      const char * name,
+      const char * version,
+      CORBA::IDLType_ptr result,
+      CORBA::OperationMode mode,
+      const CORBA::ParDescriptionSeq & params,
+      const CORBA::ExceptionDefSeq & exceptions,
+      const CORBA::ContextIdSeq & contexts,
+      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_ValueDef_Proxy_Broker *the_TAO_ValueDef_Proxy_Broker_;
+  
+protected:
+  CORBA_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 CORBA_ValueDef_setup_collocation (int collocated);
+    
+    CORBA_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 ~CORBA_ValueDef (void);
+private:
+  CORBA_ValueDef (const CORBA_ValueDef &);
+  void operator= (const CORBA_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_CORBA_ValueDef_supported_interfaces_get : public TAO_ClientRequestInfo
+  {
+  public:
+    friend class CORBA_ValueDef;
+    
+    friend class _TAO_ValueDef_Remote_Proxy_Impl;
+    friend class _TAO_ValueDef_ThruPOA_Proxy_Impl;
+    friend class _TAO_ValueDef_Direct_Proxy_Impl;
+  
+  TAO_ClientRequestInfo_CORBA_ValueDef_supported_interfaces_get (
+      TAO_GIOP_Invocation *_tao_invocation,
+      CORBA::Object_ptr _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_ValueDef_supported_interfaces_get (const TAO_ClientRequestInfo_CORBA_ValueDef_supported_interfaces_get &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_ValueDef_supported_interfaces_get &);
+  void result (CORBA::InterfaceDefSeq * result);
+  // update the result 
+  CORBA::InterfaceDefSeq * _result;
+};
+
+class TAO_ClientRequestInfo_CORBA_ValueDef_supported_interfaces_set : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_ValueDef;
+  
+  friend class _TAO_ValueDef_Remote_Proxy_Impl;
+  friend class _TAO_ValueDef_ThruPOA_Proxy_Impl;
+  friend class _TAO_ValueDef_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_ValueDef_supported_interfaces_set (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const CORBA::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_CORBA_ValueDef_supported_interfaces_set (const TAO_ClientRequestInfo_CORBA_ValueDef_supported_interfaces_set &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_ValueDef_supported_interfaces_set &);
+  const CORBA::InterfaceDefSeq & supported_interfaces_;
+  
+};
+
+class TAO_ClientRequestInfo_CORBA_ValueDef_initializers_get : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_ValueDef;
+  
+  friend class _TAO_ValueDef_Remote_Proxy_Impl;
+  friend class _TAO_ValueDef_ThruPOA_Proxy_Impl;
+  friend class _TAO_ValueDef_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_ValueDef_initializers_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _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_ValueDef_initializers_get (const TAO_ClientRequestInfo_CORBA_ValueDef_initializers_get &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_ValueDef_initializers_get &);
+  void result (CORBA::InitializerSeq * result);
+  // update the result 
+  CORBA::InitializerSeq * _result;
+};
+
+class TAO_ClientRequestInfo_CORBA_ValueDef_initializers_set : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_ValueDef;
+  
+  friend class _TAO_ValueDef_Remote_Proxy_Impl;
+  friend class _TAO_ValueDef_ThruPOA_Proxy_Impl;
+  friend class _TAO_ValueDef_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_ValueDef_initializers_set (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const CORBA::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_CORBA_ValueDef_initializers_set (const TAO_ClientRequestInfo_CORBA_ValueDef_initializers_set &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_ValueDef_initializers_set &);
+  const CORBA::InitializerSeq & initializers_;
+  
+};
+
+class TAO_ClientRequestInfo_CORBA_ValueDef_base_value_get : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_ValueDef;
+  
+  friend class _TAO_ValueDef_Remote_Proxy_Impl;
+  friend class _TAO_ValueDef_ThruPOA_Proxy_Impl;
+  friend class _TAO_ValueDef_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_ValueDef_base_value_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _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_ValueDef_base_value_get (const TAO_ClientRequestInfo_CORBA_ValueDef_base_value_get &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_ValueDef_base_value_get &);
+  void result (CORBA::ValueDef_ptr result);
+  // update the result 
+  CORBA::ValueDef_ptr _result;
+};
+
+class TAO_ClientRequestInfo_CORBA_ValueDef_base_value_set : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_ValueDef;
+  
+  friend class _TAO_ValueDef_Remote_Proxy_Impl;
+  friend class _TAO_ValueDef_ThruPOA_Proxy_Impl;
+  friend class _TAO_ValueDef_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_ValueDef_base_value_set (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::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_CORBA_ValueDef_base_value_set (const TAO_ClientRequestInfo_CORBA_ValueDef_base_value_set &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_ValueDef_base_value_set &);
+  CORBA::ValueDef_ptr base_value_;
+  
+};
+
+class TAO_ClientRequestInfo_CORBA_ValueDef_abstract_base_values_get : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_ValueDef;
+  
+  friend class _TAO_ValueDef_Remote_Proxy_Impl;
+  friend class _TAO_ValueDef_ThruPOA_Proxy_Impl;
+  friend class _TAO_ValueDef_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_ValueDef_abstract_base_values_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _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_ValueDef_abstract_base_values_get (const TAO_ClientRequestInfo_CORBA_ValueDef_abstract_base_values_get &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_ValueDef_abstract_base_values_get &);
+  void result (CORBA::ValueDefSeq * result);
+  // update the result 
+  CORBA::ValueDefSeq * _result;
+};
+
+class TAO_ClientRequestInfo_CORBA_ValueDef_abstract_base_values_set : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_ValueDef;
+  
+  friend class _TAO_ValueDef_Remote_Proxy_Impl;
+  friend class _TAO_ValueDef_ThruPOA_Proxy_Impl;
+  friend class _TAO_ValueDef_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_ValueDef_abstract_base_values_set (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const CORBA::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_CORBA_ValueDef_abstract_base_values_set (const TAO_ClientRequestInfo_CORBA_ValueDef_abstract_base_values_set &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_ValueDef_abstract_base_values_set &);
+  const CORBA::ValueDefSeq & abstract_base_values_;
+  
+};
+
+class TAO_ClientRequestInfo_CORBA_ValueDef_is_abstract_get : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_ValueDef;
+  
+  friend class _TAO_ValueDef_Remote_Proxy_Impl;
+  friend class _TAO_ValueDef_ThruPOA_Proxy_Impl;
+  friend class _TAO_ValueDef_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_ValueDef_is_abstract_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _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_ValueDef_is_abstract_get (const TAO_ClientRequestInfo_CORBA_ValueDef_is_abstract_get &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_ValueDef_is_abstract_get &);
+  void result (CORBA::Boolean result);
+  // update the result 
+  CORBA::Boolean _result;
+};
+
+class TAO_ClientRequestInfo_CORBA_ValueDef_is_abstract_set : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_ValueDef;
+  
+  friend class _TAO_ValueDef_Remote_Proxy_Impl;
+  friend class _TAO_ValueDef_ThruPOA_Proxy_Impl;
+  friend class _TAO_ValueDef_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_ValueDef_is_abstract_set (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _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_CORBA_ValueDef_is_abstract_set (const TAO_ClientRequestInfo_CORBA_ValueDef_is_abstract_set &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_ValueDef_is_abstract_set &);
+  const CORBA::Boolean & is_abstract_;
+  
+};
+
+class TAO_ClientRequestInfo_CORBA_ValueDef_is_custom_get : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_ValueDef;
+  
+  friend class _TAO_ValueDef_Remote_Proxy_Impl;
+  friend class _TAO_ValueDef_ThruPOA_Proxy_Impl;
+  friend class _TAO_ValueDef_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_ValueDef_is_custom_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _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_ValueDef_is_custom_get (const TAO_ClientRequestInfo_CORBA_ValueDef_is_custom_get &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_ValueDef_is_custom_get &);
+  void result (CORBA::Boolean result);
+  // update the result 
+  CORBA::Boolean _result;
+};
+
+class TAO_ClientRequestInfo_CORBA_ValueDef_is_custom_set : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_ValueDef;
+  
+  friend class _TAO_ValueDef_Remote_Proxy_Impl;
+  friend class _TAO_ValueDef_ThruPOA_Proxy_Impl;
+  friend class _TAO_ValueDef_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_ValueDef_is_custom_set (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _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_CORBA_ValueDef_is_custom_set (const TAO_ClientRequestInfo_CORBA_ValueDef_is_custom_set &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_ValueDef_is_custom_set &);
+  const CORBA::Boolean & is_custom_;
+  
+};
+
+class TAO_ClientRequestInfo_CORBA_ValueDef_is_truncatable_get : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_ValueDef;
+  
+  friend class _TAO_ValueDef_Remote_Proxy_Impl;
+  friend class _TAO_ValueDef_ThruPOA_Proxy_Impl;
+  friend class _TAO_ValueDef_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_ValueDef_is_truncatable_get (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _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_ValueDef_is_truncatable_get (const TAO_ClientRequestInfo_CORBA_ValueDef_is_truncatable_get &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_ValueDef_is_truncatable_get &);
+  void result (CORBA::Boolean result);
+  // update the result 
+  CORBA::Boolean _result;
+};
+
+class TAO_ClientRequestInfo_CORBA_ValueDef_is_truncatable_set : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_ValueDef;
+  
+  friend class _TAO_ValueDef_Remote_Proxy_Impl;
+  friend class _TAO_ValueDef_ThruPOA_Proxy_Impl;
+  friend class _TAO_ValueDef_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_ValueDef_is_truncatable_set (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _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_CORBA_ValueDef_is_truncatable_set (const TAO_ClientRequestInfo_CORBA_ValueDef_is_truncatable_set &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_ValueDef_is_truncatable_set &);
+  const CORBA::Boolean & is_truncatable_;
+  
+};
+
+class TAO_ClientRequestInfo_CORBA_ValueDef_is_a : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_ValueDef;
+  
+  friend class _TAO_ValueDef_Remote_Proxy_Impl;
+  friend class _TAO_ValueDef_ThruPOA_Proxy_Impl;
+  friend class _TAO_ValueDef_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_ValueDef_is_a (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _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_CORBA_ValueDef_is_a (const TAO_ClientRequestInfo_CORBA_ValueDef_is_a &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_ValueDef_is_a &);
+  const char * id_;
+  void result (CORBA::Boolean result);
+  // update the result 
+  CORBA::Boolean _result;
+};
+
+class TAO_ClientRequestInfo_CORBA_ValueDef_describe_value : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_ValueDef;
+  
+  friend class _TAO_ValueDef_Remote_Proxy_Impl;
+  friend class _TAO_ValueDef_ThruPOA_Proxy_Impl;
+  friend class _TAO_ValueDef_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_ValueDef_describe_value (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _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_ValueDef_describe_value (const TAO_ClientRequestInfo_CORBA_ValueDef_describe_value &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_ValueDef_describe_value &);
+  void result (ACE_NESTED_CLASS (CORBA::ValueDef,FullValueDescription) * result);
+  // update the result 
+  ACE_NESTED_CLASS (CORBA::ValueDef,FullValueDescription) * _result;
+};
+
+class TAO_ClientRequestInfo_CORBA_ValueDef_create_value_member : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_ValueDef;
+  
+  friend class _TAO_ValueDef_Remote_Proxy_Impl;
+  friend class _TAO_ValueDef_ThruPOA_Proxy_Impl;
+  friend class _TAO_ValueDef_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_ValueDef_create_value_member (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const char * id,
+    const char * name,
+    const char * version,
+    CORBA::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_CORBA_ValueDef_create_value_member (const TAO_ClientRequestInfo_CORBA_ValueDef_create_value_member &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_ValueDef_create_value_member &);
+  const char * id_;
+  const char * name_;
+  const char * version_;
+  CORBA::IDLType_ptr type_;
+  const CORBA::Visibility & access_;
+  void result (CORBA::ValueMemberDef_ptr result);
+  // update the result 
+  CORBA::ValueMemberDef_ptr _result;
+};
+
+class TAO_ClientRequestInfo_CORBA_ValueDef_create_attribute : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_ValueDef;
+  
+  friend class _TAO_ValueDef_Remote_Proxy_Impl;
+  friend class _TAO_ValueDef_ThruPOA_Proxy_Impl;
+  friend class _TAO_ValueDef_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_ValueDef_create_attribute (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const char * id,
+    const char * name,
+    const char * version,
+    CORBA::IDLType_ptr type,
+    CORBA::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));
+
+private:
+  TAO_ClientRequestInfo_CORBA_ValueDef_create_attribute (const TAO_ClientRequestInfo_CORBA_ValueDef_create_attribute &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_ValueDef_create_attribute &);
+  const char * id_;
+  const char * name_;
+  const char * version_;
+  CORBA::IDLType_ptr type_;
+  const CORBA::AttributeMode & mode_;
+  void result (CORBA::AttributeDef_ptr result);
+  // update the result 
+  CORBA::AttributeDef_ptr _result;
+};
+
+class TAO_ClientRequestInfo_CORBA_ValueDef_create_operation : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_ValueDef;
+  
+  friend class _TAO_ValueDef_Remote_Proxy_Impl;
+  friend class _TAO_ValueDef_ThruPOA_Proxy_Impl;
+  friend class _TAO_ValueDef_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_ValueDef_create_operation (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    const char * id,
+    const char * name,
+    const char * version,
+    CORBA::IDLType_ptr result,
+    CORBA::OperationMode & mode,
+    const CORBA::ParDescriptionSeq & params,
+    const CORBA::ExceptionDefSeq & exceptions,
+    const CORBA::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_CORBA_ValueDef_create_operation (const TAO_ClientRequestInfo_CORBA_ValueDef_create_operation &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_ValueDef_create_operation &);
+  const char * id_;
+  const char * name_;
+  const char * version_;
+  CORBA::IDLType_ptr result_;
+  const CORBA::OperationMode & mode_;
+  const CORBA::ParDescriptionSeq & params_;
+  const CORBA::ExceptionDefSeq & exceptions_;
+  const CORBA::ContextIdSeq & contexts_;
+  void result (CORBA::OperationDef_ptr result);
+  // update the result 
+  CORBA::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_IFR_Client_Export _TAO_ValueDef_Proxy_Impl : 
+  public virtual _TAO_Container_Proxy_Impl, 
+  public virtual _TAO_Contained_Proxy_Impl, 
+  public virtual _TAO_IDLType_Proxy_Impl
+{
+public:
+  virtual ~_TAO_ValueDef_Proxy_Impl (void) { }
+  
+    virtual CORBA::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 CORBA::InterfaceDefSeq & supported_interfaces,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual CORBA::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 CORBA::InitializerSeq & initializers,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual CORBA::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_,
+      CORBA::ValueDef_ptr base_value,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual CORBA::ValueDefSeq * abstract_base_values (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual void abstract_base_values (
+      CORBA_Object *_collocated_tao_target_,
+      const CORBA::ValueDefSeq & abstract_base_values,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual CORBA::Boolean is_abstract (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual void is_abstract (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Boolean is_abstract,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual CORBA::Boolean is_custom (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual void is_custom (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Boolean is_custom,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual CORBA::Boolean is_truncatable (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual void is_truncatable (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Boolean is_truncatable,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual CORBA::Boolean is_a (
+      CORBA_Object *_collocated_tao_target_,
+      const char * id,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual CORBA::ValueDef::FullValueDescription * describe_value (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual CORBA::ValueMemberDef_ptr create_value_member (
+      CORBA_Object *_collocated_tao_target_,
+      const char * id,
+      const char * name,
+      const char * version,
+      CORBA::IDLType_ptr type,
+      CORBA::Visibility access,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual CORBA::AttributeDef_ptr create_attribute (
+      CORBA_Object *_collocated_tao_target_,
+      const char * id,
+      const char * name,
+      const char * version,
+      CORBA::IDLType_ptr type,
+      CORBA::AttributeMode mode,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual CORBA::OperationDef_ptr create_operation (
+      CORBA_Object *_collocated_tao_target_,
+      const char * id,
+      const char * name,
+      const char * version,
+      CORBA::IDLType_ptr result,
+      CORBA::OperationMode mode,
+      const CORBA::ParDescriptionSeq & params,
+      const CORBA::ExceptionDefSeq & exceptions,
+      const CORBA::ContextIdSeq & contexts,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+protected:
+  _TAO_ValueDef_Proxy_Impl (void);
+
+};
+//
+//                Base  Proxy Impl. Declaration
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//                    Remote  Impl. Declaration
+//
+
+class TAO_IFR_Client_Export _TAO_ValueDef_Remote_Proxy_Impl : 
+  public virtual _TAO_ValueDef_Proxy_Impl,
+  public virtual TAO_Remote_Object_Proxy_Impl,
+  public virtual _TAO_Container_Remote_Proxy_Impl, 
+  public virtual _TAO_Contained_Remote_Proxy_Impl, 
+  public virtual _TAO_IDLType_Remote_Proxy_Impl
+  
+{
+public:
+  _TAO_ValueDef_Remote_Proxy_Impl (void);
+  
+  virtual ~_TAO_ValueDef_Remote_Proxy_Impl (void) { }
+  
+    virtual CORBA::InterfaceDefSeq * supported_interfaces (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void supported_interfaces (
+      CORBA_Object *_collocated_tao_target_,
+      const CORBA::InterfaceDefSeq & supported_interfaces,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::InitializerSeq * initializers (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void initializers (
+      CORBA_Object *_collocated_tao_target_,
+      const CORBA::InitializerSeq & initializers,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::ValueDef_ptr base_value (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void base_value (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::ValueDef_ptr base_value,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::ValueDefSeq * abstract_base_values (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void abstract_base_values (
+      CORBA_Object *_collocated_tao_target_,
+      const CORBA::ValueDefSeq & abstract_base_values,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::Boolean is_abstract (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void is_abstract (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Boolean is_abstract,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::Boolean is_custom (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void is_custom (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Boolean is_custom,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::Boolean is_truncatable (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void is_truncatable (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Boolean is_truncatable,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::Boolean is_a (
+      CORBA_Object *_collocated_tao_target_,
+      const char * id,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::ValueDef::FullValueDescription * describe_value (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::ValueMemberDef_ptr create_value_member (
+      CORBA_Object *_collocated_tao_target_,
+      const char * id,
+      const char * name,
+      const char * version,
+      CORBA::IDLType_ptr type,
+      CORBA::Visibility access,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::AttributeDef_ptr create_attribute (
+      CORBA_Object *_collocated_tao_target_,
+      const char * id,
+      const char * name,
+      const char * version,
+      CORBA::IDLType_ptr type,
+      CORBA::AttributeMode mode,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::OperationDef_ptr create_operation (
+      CORBA_Object *_collocated_tao_target_,
+      const char * id,
+      const char * name,
+      const char * version,
+      CORBA::IDLType_ptr result,
+      CORBA::OperationMode mode,
+      const CORBA::ParDescriptionSeq & params,
+      const CORBA::ExceptionDefSeq & exceptions,
+      const CORBA::ContextIdSeq & contexts,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+};
+
+//
+//                Base  Proxy Impl. Declaration
+///////////////////////////////////////////////////////////////////////
+
+
+// The Proxy Brokers are used by each interface to get
+// the right proxy for performing a call. In the new 
+// collocation scheme, the proxy to be used can vary on
+// a call by call basis. 
+
+
+
+///////////////////////////////////////////////////////////////////////
+//                 Base Proxy Broker Declaration 
+//
+
+class TAO_IFR_Client_Export _TAO_ValueDef_Proxy_Broker
+{
+public:
+  virtual ~_TAO_ValueDef_Proxy_Broker (void);
+  virtual _TAO_ValueDef_Proxy_Impl &select_proxy (
+    CORBA_ValueDef *object,
+    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
+  ) = 0;
+
+protected:
+  _TAO_ValueDef_Proxy_Broker (void);
+  
+};
+
+//
+//              End Base Proxy Broker Declaration 
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//                 Remote Proxy Broker Declaration 
+//
+
+class TAO_IFR_Client_Export _TAO_ValueDef_Remote_Proxy_Broker : public virtual _TAO_ValueDef_Proxy_Broker
+{
+public: 
+  _TAO_ValueDef_Remote_Proxy_Broker (void);
+  
+  virtual ~_TAO_ValueDef_Remote_Proxy_Broker (void);
+  
+  virtual _TAO_ValueDef_Proxy_Impl &select_proxy (
+    CORBA_ValueDef *object,
+    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
+  );
+
+private:
+  _TAO_ValueDef_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_ValueDef_Remote_Proxy_Broker *the_TAO_ValueDef_Remote_Proxy_Broker (void);
+};
+
+
+//
+//              End Remote Proxy Broker Declaration 
+///////////////////////////////////////////////////////////////////////
+
+
+#endif /* end #if !defined */
+
+struct CORBA_ValueDescription;
+class CORBA_ValueDescription_var;
+
+struct TAO_IFR_Client_Export CORBA_ValueDescription
+{
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef CORBA_ValueDescription_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  static void _tao_any_destructor (void*);
+
+  TAO_String_Manager name;
+  TAO_String_Manager id;
+  CORBA::Boolean is_abstract;
+  CORBA::Boolean is_custom;
+  TAO_String_Manager defined_in;
+  TAO_String_Manager version;
+  CORBA::RepositoryIdSeq supported_interfaces;
+  CORBA::RepositoryIdSeq abstract_base_values;
+  CORBA::Boolean is_truncatable;
+  TAO_String_Manager base_value;
+};
+
+class TAO_IFR_Client_Export CORBA_ValueDescription_var
+{
+public:
+  CORBA_ValueDescription_var (void); // default constructor
+  CORBA_ValueDescription_var (CORBA_ValueDescription *);
+  CORBA_ValueDescription_var (const CORBA_ValueDescription_var &); // copy constructor
+  ~CORBA_ValueDescription_var (void); // destructor
+  
+  CORBA_ValueDescription_var &operator= (CORBA_ValueDescription *);
+  CORBA_ValueDescription_var &operator= (const CORBA_ValueDescription_var &);
+  CORBA_ValueDescription *operator-> (void);
+  const CORBA_ValueDescription *operator-> (void) const;
+  
+  operator const CORBA_ValueDescription &() const;
+  operator CORBA_ValueDescription &();
+  operator CORBA_ValueDescription &() const;
+  operator CORBA_ValueDescription *&(); // variable-size types only
+  
+  // in, inout, out, _retn 
+  const CORBA_ValueDescription &in (void) const;
+  CORBA_ValueDescription &inout (void);
+  CORBA_ValueDescription *&out (void);
+  CORBA_ValueDescription *_retn (void);
+  CORBA_ValueDescription *ptr (void) const;
+
+private:
+  CORBA_ValueDescription *ptr_;
+};
+
+class TAO_IFR_Client_Export CORBA_ValueDescription_out
+{
+public:
+  CORBA_ValueDescription_out (CORBA_ValueDescription *&);
+  CORBA_ValueDescription_out (CORBA_ValueDescription_var &);
+  CORBA_ValueDescription_out (const CORBA_ValueDescription_out &);
+  CORBA_ValueDescription_out &operator= (const CORBA_ValueDescription_out &);
+  CORBA_ValueDescription_out &operator= (CORBA_ValueDescription *);
+  operator CORBA_ValueDescription *&();
+  CORBA_ValueDescription *&ptr (void);
+  CORBA_ValueDescription *operator-> (void);
+  
+private:
+  CORBA_ValueDescription *&ptr_;
+  // assignment from T_var not allowed
+  void operator= (const CORBA_ValueDescription_var &);
+};
+
+
+#if !defined (_CORBA_VALUEBOXDEF___VAR_CH_)
+#define _CORBA_VALUEBOXDEF___VAR_CH_
+
+class TAO_IFR_Client_Export CORBA_ValueBoxDef_var : public TAO_Base_var
+{
+public:
+  CORBA_ValueBoxDef_var (void); // default constructor
+  CORBA_ValueBoxDef_var (CORBA_ValueBoxDef_ptr p) : ptr_ (p) {} 
+  CORBA_ValueBoxDef_var (const CORBA_ValueBoxDef_var &); // copy constructor
+  ~CORBA_ValueBoxDef_var (void); // destructor
+  
+  CORBA_ValueBoxDef_var &operator= (CORBA_ValueBoxDef_ptr);
+  CORBA_ValueBoxDef_var &operator= (const CORBA_ValueBoxDef_var &);
+  CORBA_ValueBoxDef_ptr operator-> (void) const;
+  
+  operator const CORBA_ValueBoxDef_ptr &() const;
+  operator CORBA_ValueBoxDef_ptr &();
+  // in, inout, out, _retn 
+  CORBA_ValueBoxDef_ptr in (void) const;
+  CORBA_ValueBoxDef_ptr &inout (void);
+  CORBA_ValueBoxDef_ptr &out (void);
+  CORBA_ValueBoxDef_ptr _retn (void);
+  CORBA_ValueBoxDef_ptr ptr (void) const;
+
+private:
+  CORBA_ValueBoxDef_ptr ptr_;
+  // Unimplemented - prevents widening assignment.
+  CORBA_ValueBoxDef_var (const TAO_Base_var &rhs);
+  CORBA_ValueBoxDef_var &operator= (const TAO_Base_var &rhs);
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_VALUEBOXDEF___OUT_CH_)
+#define _CORBA_VALUEBOXDEF___OUT_CH_
+
+class TAO_IFR_Client_Export CORBA_ValueBoxDef_out
+{
+public:
+  CORBA_ValueBoxDef_out (CORBA_ValueBoxDef_ptr &);
+  CORBA_ValueBoxDef_out (CORBA_ValueBoxDef_var &);
+  CORBA_ValueBoxDef_out (const CORBA_ValueBoxDef_out &);
+  CORBA_ValueBoxDef_out &operator= (const CORBA_ValueBoxDef_out &);
+  CORBA_ValueBoxDef_out &operator= (const CORBA_ValueBoxDef_var &);
+  CORBA_ValueBoxDef_out &operator= (CORBA_ValueBoxDef_ptr);
+  operator CORBA_ValueBoxDef_ptr &();
+  CORBA_ValueBoxDef_ptr &ptr (void);
+  CORBA_ValueBoxDef_ptr operator-> (void);
+  
+private:
+  CORBA_ValueBoxDef_ptr &ptr_;
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_VALUEBOXDEF_CH_)
+#define _CORBA_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_IFR_Client_Export CORBA_ValueBoxDef: public virtual CORBA_TypedefDef
+{
+public:
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef CORBA_ValueBoxDef_ptr _ptr_type;
+  typedef CORBA_ValueBoxDef_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  // the static operations
+  static CORBA_ValueBoxDef_ptr _duplicate (CORBA_ValueBoxDef_ptr obj);
+  static CORBA_ValueBoxDef_ptr _narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    );
+  static CORBA_ValueBoxDef_ptr _unchecked_narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    );
+  static CORBA_ValueBoxDef_ptr _nil (void)
+    {
+      return (CORBA_ValueBoxDef_ptr)0;
+    }
+
+  static void _tao_any_destructor (void*);
+
+  virtual CORBA::IDLType_ptr original_type_def (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void original_type_def (
+      CORBA::IDLType_ptr original_type_def,
+      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_ValueBoxDef_Proxy_Broker *the_TAO_ValueBoxDef_Proxy_Broker_;
+  
+protected:
+  CORBA_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 CORBA_ValueBoxDef_setup_collocation (int collocated);
+    
+    CORBA_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 ~CORBA_ValueBoxDef (void);
+private:
+  CORBA_ValueBoxDef (const CORBA_ValueBoxDef &);
+  void operator= (const CORBA_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_CORBA_ValueBoxDef_original_type_def_get : public TAO_ClientRequestInfo
+  {
+  public:
+    friend class CORBA_ValueBoxDef;
+    
+    friend class _TAO_ValueBoxDef_Remote_Proxy_Impl;
+    friend class _TAO_ValueBoxDef_ThruPOA_Proxy_Impl;
+    friend class _TAO_ValueBoxDef_Direct_Proxy_Impl;
+  
+  TAO_ClientRequestInfo_CORBA_ValueBoxDef_original_type_def_get (
+      TAO_GIOP_Invocation *_tao_invocation,
+      CORBA::Object_ptr _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_ValueBoxDef_original_type_def_get (const TAO_ClientRequestInfo_CORBA_ValueBoxDef_original_type_def_get &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_ValueBoxDef_original_type_def_get &);
+  void result (CORBA::IDLType_ptr result);
+  // update the result 
+  CORBA::IDLType_ptr _result;
+};
+
+class TAO_ClientRequestInfo_CORBA_ValueBoxDef_original_type_def_set : public TAO_ClientRequestInfo
+{
+public:
+  friend class CORBA_ValueBoxDef;
+  
+  friend class _TAO_ValueBoxDef_Remote_Proxy_Impl;
+  friend class _TAO_ValueBoxDef_ThruPOA_Proxy_Impl;
+  friend class _TAO_ValueBoxDef_Direct_Proxy_Impl;
+
+TAO_ClientRequestInfo_CORBA_ValueBoxDef_original_type_def_set (
+    TAO_GIOP_Invocation *_tao_invocation,
+    CORBA::Object_ptr _tao_target,
+    CORBA::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_CORBA_ValueBoxDef_original_type_def_set (const TAO_ClientRequestInfo_CORBA_ValueBoxDef_original_type_def_set &);
+  void operator= (const TAO_ClientRequestInfo_CORBA_ValueBoxDef_original_type_def_set &);
+  CORBA::IDLType_ptr original_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_IFR_Client_Export _TAO_ValueBoxDef_Proxy_Impl : 
+  public virtual _TAO_TypedefDef_Proxy_Impl
+{
+public:
+  virtual ~_TAO_ValueBoxDef_Proxy_Impl (void) { }
+  
+    virtual CORBA::IDLType_ptr original_type_def (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual void original_type_def (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::IDLType_ptr original_type_def,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+protected:
+  _TAO_ValueBoxDef_Proxy_Impl (void);
+
+};
+//
+//                Base  Proxy Impl. Declaration
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//                    Remote  Impl. Declaration
+//
+
+class TAO_IFR_Client_Export _TAO_ValueBoxDef_Remote_Proxy_Impl : 
+  public virtual _TAO_ValueBoxDef_Proxy_Impl,
+  public virtual TAO_Remote_Object_Proxy_Impl,
+  public virtual _TAO_TypedefDef_Remote_Proxy_Impl
+  
+{
+public:
+  _TAO_ValueBoxDef_Remote_Proxy_Impl (void);
+  
+  virtual ~_TAO_ValueBoxDef_Remote_Proxy_Impl (void) { }
+  
+    virtual CORBA::IDLType_ptr original_type_def (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void original_type_def (
+      CORBA_Object *_collocated_tao_target_,
+      CORBA::IDLType_ptr original_type_def,
+      CORBA::Environment &ACE_TRY_ENV
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+};
+
+//
+//                Base  Proxy Impl. Declaration
+///////////////////////////////////////////////////////////////////////
+
+
+// The Proxy Brokers are used by each interface to get
+// the right proxy for performing a call. In the new 
+// collocation scheme, the proxy to be used can vary on
+// a call by call basis. 
+
+
+
+///////////////////////////////////////////////////////////////////////
+//                 Base Proxy Broker Declaration 
+//
+
+class TAO_IFR_Client_Export _TAO_ValueBoxDef_Proxy_Broker
+{
+public:
+  virtual ~_TAO_ValueBoxDef_Proxy_Broker (void);
+  virtual _TAO_ValueBoxDef_Proxy_Impl &select_proxy (
+    CORBA_ValueBoxDef *object,
+    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
+  ) = 0;
+
+protected:
+  _TAO_ValueBoxDef_Proxy_Broker (void);
+  
+};
+
+//
+//              End Base Proxy Broker Declaration 
+///////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////
+//                 Remote Proxy Broker Declaration 
+//
+
+class TAO_IFR_Client_Export _TAO_ValueBoxDef_Remote_Proxy_Broker : public virtual _TAO_ValueBoxDef_Proxy_Broker
+{
+public: 
+  _TAO_ValueBoxDef_Remote_Proxy_Broker (void);
+  
+  virtual ~_TAO_ValueBoxDef_Remote_Proxy_Broker (void);
+  
+  virtual _TAO_ValueBoxDef_Proxy_Impl &select_proxy (
+    CORBA_ValueBoxDef *object,
+    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
+  );
+
+private:
+  _TAO_ValueBoxDef_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_ValueBoxDef_Remote_Proxy_Broker *the_TAO_ValueBoxDef_Remote_Proxy_Broker (void);
+};
+
+
+//
+//              End Remote Proxy Broker Declaration 
+///////////////////////////////////////////////////////////////////////
+
+
+#endif /* end #if !defined */
+
+// Proxy Broker Factory function pointer declarations.
+
+extern TAO_IFR_Client_Export _TAO_FixedDef_Proxy_Broker * (*CORBA__TAO_FixedDef_Proxy_Broker_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  );
+
+extern TAO_IFR_Client_Export _TAO_ValueMemberDef_Proxy_Broker * (*CORBA__TAO_ValueMemberDef_Proxy_Broker_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  );
+
+extern TAO_IFR_Client_Export _TAO_ValueDef_Proxy_Broker * (*CORBA__TAO_ValueDef_Proxy_Broker_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  );
+
+extern TAO_IFR_Client_Export _TAO_ValueBoxDef_Proxy_Broker * (*CORBA__TAO_ValueBoxDef_Proxy_Broker_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  );
+
+// *************************************************************
+// Any operators for class moved from IFR_BaseC.h
+
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const CORBA::ValueDefSeq &); // copying version
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, CORBA::ValueDefSeq*); // noncopying version
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::ValueDefSeq *&); // deprecated
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA::ValueDefSeq *&);
+
+// *************************************************************
+
+// Any operators for interface CORBA::FixedDef
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, CORBA::FixedDef_ptr);
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::FixedDef *&);
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const CORBA::ValueMember &); // copying version
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, CORBA::ValueMember*); // noncopying version
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::ValueMember *&); // deprecated
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA::ValueMember *&);
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const CORBA::ValueMemberSeq &); // copying version
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, CORBA::ValueMemberSeq*); // noncopying version
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::ValueMemberSeq *&); // deprecated
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA::ValueMemberSeq *&);
+// Any operators for interface CORBA::ValueMemberDef
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, CORBA::ValueMemberDef_ptr);
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::ValueMemberDef *&);
+// Any operators for interface CORBA::ValueDef
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, CORBA::ValueDef_ptr);
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::ValueDef *&);
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const CORBA::ValueDef::FullValueDescription &); // copying version
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, CORBA::ValueDef::FullValueDescription*); // noncopying version
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::ValueDef::FullValueDescription *&); // deprecated
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA::ValueDef::FullValueDescription *&);
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const CORBA::ValueDescription &); // copying version
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, CORBA::ValueDescription*); // noncopying version
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::ValueDescription *&); // deprecated
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA::ValueDescription *&);
+// Any operators for interface CORBA::ValueBoxDef
+TAO_IFR_Client_Export void operator<<= (CORBA::Any &, CORBA::ValueBoxDef_ptr);
+TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::ValueBoxDef *&);
+
+#ifndef __ACE_INLINE__
+
+// **************************************************************
+// CDR operators for class moved from IFR_BaseC.h
+
+#if !defined _TAO_CDR_OP_CORBA_ValueDefSeq_H_
+#define _TAO_CDR_OP_CORBA_ValueDefSeq_H_
+
+TAO_IFR_Client_Export CORBA::Boolean operator<< (
+    TAO_OutputCDR &,
+    const CORBA::ValueDefSeq &
+  );
+TAO_IFR_Client_Export CORBA::Boolean operator>> (
+    TAO_InputCDR &,
+    CORBA::ValueDefSeq &
+  );
+
+#endif /* _TAO_CDR_OP_CORBA_ValueDefSeq_H_ */
+
+// **************************************************************
+
+TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::FixedDef_ptr );
+TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::FixedDef_ptr &);
+TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::ValueMember &);
+TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::ValueMember &);
+
+#if !defined _TAO_CDR_OP_CORBA_ValueMemberSeq_H_
+#define _TAO_CDR_OP_CORBA_ValueMemberSeq_H_
+
+TAO_IFR_Client_Export CORBA::Boolean operator<< (
+    TAO_OutputCDR &,
+    const CORBA::ValueMemberSeq &
+  );
+TAO_IFR_Client_Export CORBA::Boolean operator>> (
+    TAO_InputCDR &,
+    CORBA::ValueMemberSeq &
+  );
+
+#endif /* _TAO_CDR_OP_CORBA_ValueMemberSeq_H_ */
+
+TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::ValueMemberDef_ptr );
+TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::ValueMemberDef_ptr &);
+TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::ValueDef_ptr );
+TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::ValueDef_ptr &);
+TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::ValueDef::FullValueDescription &);
+TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::ValueDef::FullValueDescription &);
+TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::ValueDescription &);
+TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::ValueDescription &);
+TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::ValueBoxDef_ptr );
+TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::ValueBoxDef_ptr &);
+
+#endif /* __ACE_INLINE__ */
+
+
+#if defined (__ACE_INLINE__)
+#include "IFR_ExtendedC.i"
+#endif /* defined INLINE */
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+#pragma warning(pop)
+#endif /* _MSC_VER */
+
+#if defined (__BORLANDC__)
+#pragma option pop
+#endif /* __BORLANDC__ */
+
+#include "ace/post.h"
+#endif /* ifndef */
diff --git a/TAO/tao/IFR_Client/IFR_ExtendedC.i b/TAO/tao/IFR_Client/IFR_ExtendedC.i
new file mode 100644
index 00000000000..ea9fef81789
--- /dev/null
+++ b/TAO/tao/IFR_Client/IFR_ExtendedC.i
@@ -0,0 +1,2448 @@
+// -*- C++ -*-
+//
+// $Id$
+
+// ****  Code generated by the The ACE ORB (TAO) IDL Compiler ****
+// TAO and the TAO IDL Compiler have been developed by:
+//       Center for Distributed Object Computing
+//       Washington University
+//       St. Louis, MO
+//       USA
+//       http://www.cs.wustl.edu/~schmidt/doc-center.html
+// and
+//       Distributed Object Computing Laboratory
+//       University of California at Irvine
+//       Irvine, CA
+//       USA
+//       http://doc.ece.uci.edu/
+//
+// Information about TAO is available at:
+//     http://www.cs.wustl.edu/~schmidt/TAO.html
+
+// ************************************************************
+// Methods for classes moved from IFR_BaseC.i
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_VALUEDEFSEQ_CI_)
+#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_VALUEDEFSEQ_CI_
+
+  ACE_INLINE CORBA::ValueDef **
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::allocbuf (CORBA::ULong nelems)
+  {
+    CORBA::ValueDef **buf = 0;
+    
+    ACE_NEW_RETURN (buf, CORBA::ValueDef*[nelems], 0);
+    
+    for (CORBA::ULong i = 0; i < nelems; i++)
+      buf[i] = CORBA::ValueDef::_nil ();
+    
+    return buf;
+  }
+  
+  ACE_INLINE void 
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::freebuf (CORBA::ValueDef **buffer)
+  {
+    if (buffer == 0)
+      return;
+    delete[] buffer;
+  }
+  
+  ACE_INLINE
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq (void)
+  {
+  }
+  
+  ACE_INLINE
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq (CORBA::ULong maximum)
+    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::allocbuf (maximum))
+  {
+  }
+  
+  ACE_INLINE
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq (CORBA::ULong maximum,
+    CORBA::ULong length,
+    CORBA::ValueDef* *value,
+    CORBA::Boolean release)
+  : TAO_Unbounded_Base_Sequence (maximum, length, value, release)
+  {
+  }
+  
+  ACE_INLINE
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq(const _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq &rhs)
+    : TAO_Unbounded_Base_Sequence (rhs)
+  {
+    if (rhs.buffer_ != 0)
+    {
+      CORBA::ValueDef **tmp1 = _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::allocbuf (this->maximum_);
+      CORBA::ValueDef ** const tmp2 = ACE_reinterpret_cast (CORBA::ValueDef ** ACE_CAST_CONST, rhs.buffer_);
+      
+      for (CORBA::ULong i = 0; i < rhs.length_; ++i)
+        tmp1[i] = CORBA::ValueDef::_duplicate (tmp2[i]);
+      
+      this->buffer_ = tmp1;
+    }
+    else
+    {
+      this->buffer_ = 0;
+    }
+  }
+  
+  ACE_INLINE CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq &
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::operator= (const _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq &rhs)
+  {
+    if (this == &rhs)
+      return *this;
+    
+    if (this->release_)
+    {
+      CORBA::ValueDef **tmp = ACE_reinterpret_cast (CORBA::ValueDef **, this->buffer_);
+      
+      for (CORBA::ULong i = 0; i < this->length_; ++i)
+      {
+        CORBA::release (tmp[i]);
+        tmp[i] = CORBA::ValueDef::_nil ();
+      }
+      if (this->maximum_ < rhs.maximum_)
+      {
+        _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::freebuf (tmp);
+        this->buffer_ = _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::allocbuf (rhs.maximum_);
+      }
+    }
+    else
+      this->buffer_ = _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::allocbuf (rhs.maximum_);
+    
+    TAO_Unbounded_Base_Sequence::operator= (rhs);
+    
+    CORBA::ValueDef **tmp1 = ACE_reinterpret_cast (CORBA::ValueDef **, this->buffer_);
+    CORBA::ValueDef ** const tmp2 = ACE_reinterpret_cast (CORBA::ValueDef ** ACE_CAST_CONST, rhs.buffer_);
+    
+    for (CORBA::ULong i = 0; i < rhs.length_; ++i)
+      tmp1[i] = CORBA::ValueDef::_duplicate (tmp2[i]);
+    
+    return *this;
+  }
+  
+  ACE_INLINE TAO_Object_Manager<CORBA::ValueDef,CORBA::ValueDef_var>
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::operator[] (CORBA::ULong index) const
+  // read-write accessor
+  {
+    ACE_ASSERT (index < this->maximum_);
+    CORBA::ValueDef ** const tmp = ACE_reinterpret_cast (CORBA::ValueDef ** ACE_CAST_CONST, this->buffer_);
+    return TAO_Object_Manager<CORBA::ValueDef,CORBA::ValueDef_var> (tmp + index, this->release_);
+  }
+  
+  ACE_INLINE CORBA::ValueDef* *
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::get_buffer (CORBA::Boolean orphan)
+  {
+    CORBA::ValueDef **result = 0;
+    if (orphan == 0)
+    {
+      // We retain ownership.
+      if (this->buffer_ == 0)
+      {
+        result = _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::allocbuf (this->maximum_);
+        this->buffer_ = result;
+        this->release_ = 1;
+      }
+      else
+      {
+        result = ACE_reinterpret_cast (CORBA::ValueDef**, this->buffer_);
+      }
+    }
+    else // if (orphan == 1)
+    {
+      if (this->release_ != 0)
+      {
+        // We set the state back to default and relinquish
+        // ownership.
+        result = ACE_reinterpret_cast(CORBA::ValueDef**,this->buffer_);
+        this->maximum_ = 0;
+        this->length_ = 0;
+        this->buffer_ = 0;
+        this->release_ = 0;
+      }
+    }
+    return result;
+  }
+  
+  ACE_INLINE const CORBA::ValueDef* *
+  CORBA::_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::get_buffer (void) const
+  {
+    return ACE_reinterpret_cast(const CORBA::ValueDef ** ACE_CAST_CONST, this->buffer_);
+  }
+  
+  
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_CORBA_VALUEDEFSEQ_CI_)
+#define _CORBA_VALUEDEFSEQ_CI_
+
+// *************************************************************
+// Inline operations for class CORBA_ValueDefSeq_var
+// *************************************************************
+
+ACE_INLINE
+CORBA_ValueDefSeq_var::CORBA_ValueDefSeq_var (void) // default constructor
+  : ptr_ (0)
+{}
+
+ACE_INLINE
+CORBA_ValueDefSeq_var::CORBA_ValueDefSeq_var (CORBA_ValueDefSeq *p)
+  : ptr_ (p)
+{}
+
+ACE_INLINE
+CORBA_ValueDefSeq_var::CORBA_ValueDefSeq_var (const ::CORBA_ValueDefSeq_var &p) // copy constructor
+{
+  if (p.ptr_)
+    ACE_NEW (this->ptr_, ::CORBA_ValueDefSeq (*p.ptr_));
+  else
+    this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA_ValueDefSeq_var::~CORBA_ValueDefSeq_var (void) // destructor
+{
+  delete this->ptr_;
+}
+
+ACE_INLINE CORBA_ValueDefSeq_var &
+CORBA_ValueDefSeq_var::operator= (CORBA_ValueDefSeq *p)
+{
+  delete this->ptr_;
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE ::CORBA_ValueDefSeq_var &
+CORBA_ValueDefSeq_var::operator= (const ::CORBA_ValueDefSeq_var &p)
+{
+  if (this != &p)
+    {
+      if (p.ptr_ == 0)
+        {
+          delete this->ptr_;
+          this->ptr_ = 0;
+        }
+      else
+        {
+          CORBA_ValueDefSeq *deep_copy =
+            new CORBA_ValueDefSeq (*p.ptr_);
+          
+          if (deep_copy != 0)
+            {
+              CORBA_ValueDefSeq *tmp = deep_copy;
+              deep_copy = this->ptr_;
+              this->ptr_ = tmp;
+              delete deep_copy;
+            }
+        }
+    }
+  
+  return *this;
+}
+
+ACE_INLINE const ::CORBA_ValueDefSeq *
+CORBA_ValueDefSeq_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ValueDefSeq *
+CORBA_ValueDefSeq_var::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+CORBA_ValueDefSeq_var::operator const ::CORBA_ValueDefSeq &() const // cast
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE 
+CORBA_ValueDefSeq_var::operator ::CORBA_ValueDefSeq &() // cast 
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE 
+CORBA_ValueDefSeq_var::operator ::CORBA_ValueDefSeq &() const // cast 
+{
+  return *this->ptr_;
+}
+
+// variable-size types only
+ACE_INLINE
+CORBA_ValueDefSeq_var::operator ::CORBA_ValueDefSeq *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE TAO_Object_Manager<CORBA::ValueDef, CORBA::ValueDef_var>
+CORBA_ValueDefSeq_var::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+ACE_INLINE const ::CORBA_ValueDefSeq &
+CORBA_ValueDefSeq_var::in (void) const
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ValueDefSeq &
+CORBA_ValueDefSeq_var::inout (void)
+{
+  return *this->ptr_;
+}
+
+// mapping for variable size 
+ACE_INLINE ::CORBA_ValueDefSeq *&
+CORBA_ValueDefSeq_var::out (void)
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ValueDefSeq *
+CORBA_ValueDefSeq_var::_retn (void)
+{
+  ::CORBA_ValueDefSeq *tmp = this->ptr_;
+  this->ptr_ = 0;
+  return tmp;
+}
+
+ACE_INLINE ::CORBA_ValueDefSeq *
+CORBA_ValueDefSeq_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+// *************************************************************
+// Inline operations for class CORBA_ValueDefSeq_out
+// *************************************************************
+
+ACE_INLINE
+CORBA_ValueDefSeq_out::CORBA_ValueDefSeq_out (CORBA_ValueDefSeq *&p)
+  : ptr_ (p)
+{
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA_ValueDefSeq_out::CORBA_ValueDefSeq_out (CORBA_ValueDefSeq_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA_ValueDefSeq_out::CORBA_ValueDefSeq_out (const ::CORBA_ValueDefSeq_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (CORBA_ValueDefSeq_out&, p).ptr_)
+{}
+
+ACE_INLINE ::CORBA_ValueDefSeq_out &
+CORBA_ValueDefSeq_out::operator= (const ::CORBA_ValueDefSeq_out &p)
+{
+  this->ptr_ = ACE_const_cast (CORBA_ValueDefSeq_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE ::CORBA_ValueDefSeq_out &
+CORBA_ValueDefSeq_out::operator= (CORBA_ValueDefSeq *p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+CORBA_ValueDefSeq_out::operator ::CORBA_ValueDefSeq *&() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ValueDefSeq *&
+CORBA_ValueDefSeq_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ValueDefSeq *
+CORBA_ValueDefSeq_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE TAO_Object_Manager<CORBA::ValueDef, CORBA::ValueDef_var>
+CORBA_ValueDefSeq_out::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+
+#endif /* end #if !defined */
+
+// ******************************************************************
+
+#if !defined (_CORBA_FIXEDDEF___CI_)
+#define _CORBA_FIXEDDEF___CI_
+
+ACE_INLINE
+CORBA_FixedDef::CORBA_FixedDef (
+    TAO_Stub *objref,
+    CORBA::Boolean _tao_collocated,
+    TAO_Abstract_ServantBase *servant
+  )
+  : CORBA_Object (objref, _tao_collocated, servant)
+{
+  this->CORBA_FixedDef_setup_collocation (_tao_collocated);
+}
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_FIXEDDEF___VAR_CI_)
+#define _CORBA_FIXEDDEF___VAR_CI_
+
+// *************************************************************
+// Inline operations for class CORBA_FixedDef_var
+// *************************************************************
+
+ACE_INLINE
+CORBA_FixedDef_var::CORBA_FixedDef_var (void) // default constructor
+  : ptr_ (CORBA_FixedDef::_nil ())
+{}
+
+ACE_INLINE ::CORBA_FixedDef_ptr
+CORBA_FixedDef_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+CORBA_FixedDef_var::CORBA_FixedDef_var (const ::CORBA_FixedDef_var &p) // copy constructor
+  : TAO_Base_var (),
+    ptr_ (CORBA_FixedDef::_duplicate (p.ptr ()))
+{}
+
+ACE_INLINE
+CORBA_FixedDef_var::~CORBA_FixedDef_var (void) // destructor
+{
+  CORBA::release (this->ptr_);
+}
+
+ACE_INLINE CORBA_FixedDef_var &
+CORBA_FixedDef_var::operator= (CORBA_FixedDef_ptr p)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE CORBA_FixedDef_var &
+CORBA_FixedDef_var::operator= (const ::CORBA_FixedDef_var &p)
+{
+  if (this != &p)
+  {
+    CORBA::release (this->ptr_);
+    this->ptr_ = ::CORBA_FixedDef::_duplicate (p.ptr ());
+  }
+  return *this;
+}
+
+ACE_INLINE 
+CORBA_FixedDef_var::operator const ::CORBA_FixedDef_ptr &() const // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+CORBA_FixedDef_var::operator ::CORBA_FixedDef_ptr &() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_FixedDef_ptr
+CORBA_FixedDef_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_FixedDef_ptr
+CORBA_FixedDef_var::in (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_FixedDef_ptr &
+CORBA_FixedDef_var::inout (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_FixedDef_ptr &
+CORBA_FixedDef_var::out (void)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = ::CORBA_FixedDef::_nil ();
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_FixedDef_ptr
+CORBA_FixedDef_var::_retn (void)
+{
+  // yield ownership of managed obj reference
+  ::CORBA_FixedDef_ptr val = this->ptr_;
+  this->ptr_ = ::CORBA_FixedDef::_nil ();
+  return val;
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_FIXEDDEF___OUT_CI_)
+#define _CORBA_FIXEDDEF___OUT_CI_
+
+// *************************************************************
+// Inline operations for class CORBA_FixedDef_out
+// *************************************************************
+
+ACE_INLINE
+CORBA_FixedDef_out::CORBA_FixedDef_out (CORBA_FixedDef_ptr &p)
+  : ptr_ (p)
+{
+  this->ptr_ = ::CORBA_FixedDef::_nil ();
+}
+
+ACE_INLINE
+CORBA_FixedDef_out::CORBA_FixedDef_out (CORBA_FixedDef_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = ::CORBA_FixedDef::_nil ();
+}
+
+ACE_INLINE
+CORBA_FixedDef_out::CORBA_FixedDef_out (const ::CORBA_FixedDef_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (CORBA_FixedDef_out &, p).ptr_)
+{}
+
+ACE_INLINE ::CORBA_FixedDef_out &
+CORBA_FixedDef_out::operator= (const ::CORBA_FixedDef_out &p)
+{
+  this->ptr_ = ACE_const_cast (CORBA_FixedDef_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE CORBA_FixedDef_out &
+CORBA_FixedDef_out::operator= (const ::CORBA_FixedDef_var &p)
+{
+  this->ptr_ = ::CORBA_FixedDef::_duplicate (p.ptr ());
+  return *this;
+}
+
+ACE_INLINE CORBA_FixedDef_out &
+CORBA_FixedDef_out::operator= (CORBA_FixedDef_ptr p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+CORBA_FixedDef_out::operator ::CORBA_FixedDef_ptr &() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_FixedDef_ptr &
+CORBA_FixedDef_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_FixedDef_ptr
+CORBA_FixedDef_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+
+#endif /* end #if !defined */
+
+// *************************************************************
+// Inline operations for class CORBA_ValueMember_var
+// *************************************************************
+
+ACE_INLINE
+CORBA_ValueMember_var::CORBA_ValueMember_var (void) // default constructor
+  : ptr_ (0)
+{}
+
+ACE_INLINE
+CORBA_ValueMember_var::CORBA_ValueMember_var (CORBA_ValueMember *p)
+  : ptr_ (p)
+{}
+
+ACE_INLINE
+CORBA_ValueMember_var::CORBA_ValueMember_var (const ::CORBA_ValueMember_var &p) // copy constructor
+{
+  if (p.ptr_)
+    ACE_NEW (this->ptr_, ::CORBA_ValueMember (*p.ptr_));
+  else
+    this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA_ValueMember_var::~CORBA_ValueMember_var (void) // destructor
+{
+  delete this->ptr_;
+}
+
+ACE_INLINE CORBA_ValueMember_var &
+CORBA_ValueMember_var::operator= (CORBA_ValueMember *p)
+{
+  delete this->ptr_;
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE ::CORBA_ValueMember_var &
+CORBA_ValueMember_var::operator= (const ::CORBA_ValueMember_var &p)
+{
+  if (this != &p)
+    {
+      if (p.ptr_ == 0)
+        {
+          delete this->ptr_;
+          this->ptr_ = 0;
+        }
+      else
+        {
+          CORBA_ValueMember *deep_copy =
+            new CORBA_ValueMember (*p.ptr_);
+          
+          if (deep_copy != 0)
+            {
+              CORBA_ValueMember *tmp = deep_copy;
+              deep_copy = this->ptr_;
+              this->ptr_ = tmp;
+              delete deep_copy;
+            }
+        }
+    }
+  
+  return *this;
+}
+
+ACE_INLINE const ::CORBA_ValueMember *
+CORBA_ValueMember_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ValueMember *
+CORBA_ValueMember_var::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+CORBA_ValueMember_var::operator const ::CORBA_ValueMember &() const // cast
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE
+CORBA_ValueMember_var::operator ::CORBA_ValueMember &() // cast 
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE
+CORBA_ValueMember_var::operator ::CORBA_ValueMember &() const // cast 
+{
+  return *this->ptr_;
+}
+
+// variable-size types only
+ACE_INLINE
+CORBA_ValueMember_var::operator ::CORBA_ValueMember *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE const ::CORBA_ValueMember &
+CORBA_ValueMember_var::in (void) const
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ValueMember &
+CORBA_ValueMember_var::inout (void)
+{
+  return *this->ptr_;
+}
+
+// mapping for variable size 
+ACE_INLINE ::CORBA_ValueMember *&
+CORBA_ValueMember_var::out (void)
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ValueMember *
+CORBA_ValueMember_var::_retn (void)
+{
+  ::CORBA_ValueMember *tmp = this->ptr_;
+  this->ptr_ = 0;
+  return tmp;
+}
+
+ACE_INLINE ::CORBA_ValueMember *
+CORBA_ValueMember_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+// *************************************************************
+// Inline operations for class CORBA_ValueMember_out
+// *************************************************************
+
+ACE_INLINE
+CORBA_ValueMember_out::CORBA_ValueMember_out (::CORBA_ValueMember *&p)
+  : ptr_ (p)
+{
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA_ValueMember_out::CORBA_ValueMember_out (CORBA_ValueMember_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA_ValueMember_out::CORBA_ValueMember_out (const ::CORBA_ValueMember_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (CORBA_ValueMember_out&, p).ptr_)
+{}
+
+ACE_INLINE CORBA_ValueMember_out &
+CORBA_ValueMember_out::operator= (const ::CORBA_ValueMember_out &p)
+{
+  this->ptr_ = ACE_const_cast (CORBA_ValueMember_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE CORBA_ValueMember_out &
+CORBA_ValueMember_out::operator= (CORBA_ValueMember *p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+CORBA_ValueMember_out::operator ::CORBA_ValueMember *&() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ValueMember *&
+CORBA_ValueMember_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ValueMember *
+CORBA_ValueMember_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_SEQUENCE_CORBA_VALUEMEMBERSEQ_CI_)
+#define __TAO_UNBOUNDED_SEQUENCE_CORBA_VALUEMEMBERSEQ_CI_
+
+  // = Static operations.
+  ACE_INLINE CORBA::ValueMember *
+  CORBA::_TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::allocbuf (CORBA::ULong size)
+  // Allocate storage for the sequence.
+  {
+    CORBA::ValueMember *retval = 0;
+    ACE_NEW_RETURN (retval, CORBA::ValueMember[size], 0);
+    return retval;
+  }
+  
+  ACE_INLINE void CORBA::_TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::freebuf (CORBA::ValueMember *buffer)
+  // Free the sequence.
+  {
+    delete [] buffer;
+  }
+  
+  ACE_INLINE
+  CORBA::_TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::_TAO_Unbounded_Sequence_CORBA_ValueMemberSeq (void) // Default constructor.
+  {
+  }
+  
+  ACE_INLINE
+  CORBA::_TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::_TAO_Unbounded_Sequence_CORBA_ValueMemberSeq (CORBA::ULong maximum) // Constructor using a maximum length value.
+    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::allocbuf (maximum))
+  {
+  }
+  
+  ACE_INLINE
+  CORBA::_TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::_TAO_Unbounded_Sequence_CORBA_ValueMemberSeq (CORBA::ULong maximum,
+    CORBA::ULong length,
+    CORBA::ValueMember *data,
+    CORBA::Boolean release)
+  : TAO_Unbounded_Base_Sequence (maximum, length, data, release)
+  {
+  }
+  
+  ACE_INLINE
+  CORBA::_TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::_TAO_Unbounded_Sequence_CORBA_ValueMemberSeq (const _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq &rhs)
+  // Copy constructor.
+    : TAO_Unbounded_Base_Sequence (rhs)
+  {
+    if (rhs.buffer_ != 0)
+    {
+      CORBA::ValueMember *tmp1 = _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::allocbuf (this->maximum_);
+      CORBA::ValueMember * const tmp2 = ACE_reinterpret_cast (CORBA::ValueMember * ACE_CAST_CONST, rhs.buffer_);
+      
+      for (CORBA::ULong i = 0; i < this->length_; ++i)
+        tmp1[i] = tmp2[i];
+      
+      this->buffer_ = tmp1;
+    }
+    else
+    {
+      this->buffer_ = 0;
+    }
+  }
+  
+  ACE_INLINE CORBA::_TAO_Unbounded_Sequence_CORBA_ValueMemberSeq &
+  CORBA::_TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::operator= (const _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq &rhs)
+  // Assignment operator.
+  {
+    if (this == &rhs)
+      return *this;
+    
+    if (this->release_)
+    {
+      if (this->maximum_ < rhs.maximum_)
+      {
+        // free the old buffer
+        CORBA::ValueMember *tmp = ACE_reinterpret_cast (CORBA::ValueMember *, this->buffer_);
+        _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::freebuf (tmp);
+        this->buffer_ = _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::allocbuf (rhs.maximum_);
+      }
+    }
+    else
+      this->buffer_ = _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::allocbuf (rhs.maximum_);
+    
+    TAO_Unbounded_Base_Sequence::operator= (rhs);
+    
+    CORBA::ValueMember *tmp1 = ACE_reinterpret_cast (CORBA::ValueMember *, this->buffer_);
+    CORBA::ValueMember * const tmp2 = ACE_reinterpret_cast (CORBA::ValueMember * ACE_CAST_CONST, rhs.buffer_);
+    
+    for (CORBA::ULong i = 0; i < this->length_; ++i)
+      tmp1[i] = tmp2[i];
+    
+    return *this;
+  }
+  
+  // = Accessors.
+  ACE_INLINE CORBA::ValueMember &
+  CORBA::_TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::operator[] (CORBA::ULong i)
+  // operator []
+  {
+    ACE_ASSERT (i < this->maximum_);
+    CORBA::ValueMember* tmp = ACE_reinterpret_cast(CORBA::ValueMember*,this->buffer_);
+    return tmp[i];
+  }
+  
+  ACE_INLINE const CORBA::ValueMember &
+  CORBA::_TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::operator[] (CORBA::ULong i) const
+  // operator []
+  {
+    ACE_ASSERT (i < this->maximum_);
+    CORBA::ValueMember * const tmp = ACE_reinterpret_cast (CORBA::ValueMember* ACE_CAST_CONST, this->buffer_);
+    return tmp[i];
+  }
+  
+  // Implement the TAO_Base_Sequence methods (see Sequence.h)
+  
+  ACE_INLINE CORBA::ValueMember *
+  CORBA::_TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::get_buffer (CORBA::Boolean orphan)
+  {
+    CORBA::ValueMember *result = 0;
+    if (orphan == 0)
+    {
+      // We retain ownership.
+      if (this->buffer_ == 0)
+      {
+        result = _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::allocbuf (this->length_);
+        this->buffer_ = result;
+        this->release_ = 1;
+      }
+      else
+      {
+        result = ACE_reinterpret_cast (CORBA::ValueMember*, this->buffer_);
+      }
+    }
+    else // if (orphan == 1)
+    {
+      if (this->release_ != 0)
+      {
+        // We set the state back to default and relinquish
+        // ownership.
+        result = ACE_reinterpret_cast(CORBA::ValueMember*,this->buffer_);
+        this->maximum_ = 0;
+        this->length_ = 0;
+        this->buffer_ = 0;
+        this->release_ = 0;
+      }
+    }
+    return result;
+  }
+  
+  ACE_INLINE const CORBA::ValueMember *
+  CORBA::_TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::get_buffer (void) const
+  {
+    return ACE_reinterpret_cast(const CORBA::ValueMember * ACE_CAST_CONST, this->buffer_);
+  }
+  
+  ACE_INLINE void
+  CORBA::_TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::replace (CORBA::ULong max,
+  CORBA::ULong length,
+  CORBA::ValueMember *data,
+  CORBA::Boolean release)
+  {
+    this->maximum_ = max;
+    this->length_ = length;
+    if (this->buffer_ && this->release_ == 1)
+    {
+      CORBA::ValueMember *tmp = ACE_reinterpret_cast(CORBA::ValueMember*,this->buffer_);
+      _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::freebuf (tmp);
+    }
+    this->buffer_ = data;
+    this->release_ = release;
+  }
+  
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_CORBA_VALUEMEMBERSEQ_CI_)
+#define _CORBA_VALUEMEMBERSEQ_CI_
+
+// *************************************************************
+// Inline operations for class CORBA_ValueMemberSeq_var
+// *************************************************************
+
+ACE_INLINE
+CORBA_ValueMemberSeq_var::CORBA_ValueMemberSeq_var (void) // default constructor
+  : ptr_ (0)
+{}
+
+ACE_INLINE
+CORBA_ValueMemberSeq_var::CORBA_ValueMemberSeq_var (CORBA_ValueMemberSeq *p)
+  : ptr_ (p)
+{}
+
+ACE_INLINE
+CORBA_ValueMemberSeq_var::CORBA_ValueMemberSeq_var (const ::CORBA_ValueMemberSeq_var &p) // copy constructor
+{
+  if (p.ptr_)
+    ACE_NEW (this->ptr_, ::CORBA_ValueMemberSeq (*p.ptr_));
+  else
+    this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA_ValueMemberSeq_var::~CORBA_ValueMemberSeq_var (void) // destructor
+{
+  delete this->ptr_;
+}
+
+ACE_INLINE CORBA_ValueMemberSeq_var &
+CORBA_ValueMemberSeq_var::operator= (CORBA_ValueMemberSeq *p)
+{
+  delete this->ptr_;
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE ::CORBA_ValueMemberSeq_var &
+CORBA_ValueMemberSeq_var::operator= (const ::CORBA_ValueMemberSeq_var &p)
+{
+  if (this != &p)
+    {
+      if (p.ptr_ == 0)
+        {
+          delete this->ptr_;
+          this->ptr_ = 0;
+        }
+      else
+        {
+          CORBA_ValueMemberSeq *deep_copy =
+            new CORBA_ValueMemberSeq (*p.ptr_);
+          
+          if (deep_copy != 0)
+            {
+              CORBA_ValueMemberSeq *tmp = deep_copy;
+              deep_copy = this->ptr_;
+              this->ptr_ = tmp;
+              delete deep_copy;
+            }
+        }
+    }
+  
+  return *this;
+}
+
+ACE_INLINE const ::CORBA_ValueMemberSeq *
+CORBA_ValueMemberSeq_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ValueMemberSeq *
+CORBA_ValueMemberSeq_var::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+CORBA_ValueMemberSeq_var::operator const ::CORBA_ValueMemberSeq &() const // cast
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE 
+CORBA_ValueMemberSeq_var::operator ::CORBA_ValueMemberSeq &() // cast 
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE 
+CORBA_ValueMemberSeq_var::operator ::CORBA_ValueMemberSeq &() const // cast 
+{
+  return *this->ptr_;
+}
+
+// variable-size types only
+ACE_INLINE
+CORBA_ValueMemberSeq_var::operator ::CORBA_ValueMemberSeq *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE CORBA::ValueMember &
+CORBA_ValueMemberSeq_var::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+ACE_INLINE const CORBA::ValueMember &
+CORBA_ValueMemberSeq_var::operator[] (CORBA::ULong index) const
+{
+  return ACE_const_cast (const CORBA::ValueMember &, this->ptr_->operator[] (index));
+}
+
+ACE_INLINE const ::CORBA_ValueMemberSeq &
+CORBA_ValueMemberSeq_var::in (void) const
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ValueMemberSeq &
+CORBA_ValueMemberSeq_var::inout (void)
+{
+  return *this->ptr_;
+}
+
+// mapping for variable size 
+ACE_INLINE ::CORBA_ValueMemberSeq *&
+CORBA_ValueMemberSeq_var::out (void)
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ValueMemberSeq *
+CORBA_ValueMemberSeq_var::_retn (void)
+{
+  ::CORBA_ValueMemberSeq *tmp = this->ptr_;
+  this->ptr_ = 0;
+  return tmp;
+}
+
+ACE_INLINE ::CORBA_ValueMemberSeq *
+CORBA_ValueMemberSeq_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+// *************************************************************
+// Inline operations for class CORBA_ValueMemberSeq_out
+// *************************************************************
+
+ACE_INLINE
+CORBA_ValueMemberSeq_out::CORBA_ValueMemberSeq_out (CORBA_ValueMemberSeq *&p)
+  : ptr_ (p)
+{
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA_ValueMemberSeq_out::CORBA_ValueMemberSeq_out (CORBA_ValueMemberSeq_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA_ValueMemberSeq_out::CORBA_ValueMemberSeq_out (const ::CORBA_ValueMemberSeq_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (CORBA_ValueMemberSeq_out&, p).ptr_)
+{}
+
+ACE_INLINE ::CORBA_ValueMemberSeq_out &
+CORBA_ValueMemberSeq_out::operator= (const ::CORBA_ValueMemberSeq_out &p)
+{
+  this->ptr_ = ACE_const_cast (CORBA_ValueMemberSeq_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE ::CORBA_ValueMemberSeq_out &
+CORBA_ValueMemberSeq_out::operator= (CORBA_ValueMemberSeq *p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+CORBA_ValueMemberSeq_out::operator ::CORBA_ValueMemberSeq *&() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ValueMemberSeq *&
+CORBA_ValueMemberSeq_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ValueMemberSeq *
+CORBA_ValueMemberSeq_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE CORBA::ValueMember &
+CORBA_ValueMemberSeq_out::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_VALUEMEMBERDEF___CI_)
+#define _CORBA_VALUEMEMBERDEF___CI_
+
+ACE_INLINE
+CORBA_ValueMemberDef::CORBA_ValueMemberDef (
+    TAO_Stub *objref,
+    CORBA::Boolean _tao_collocated,
+    TAO_Abstract_ServantBase *servant
+  )
+  : CORBA_Object (objref, _tao_collocated, servant)
+{
+  this->CORBA_ValueMemberDef_setup_collocation (_tao_collocated);
+}
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_VALUEMEMBERDEF___VAR_CI_)
+#define _CORBA_VALUEMEMBERDEF___VAR_CI_
+
+// *************************************************************
+// Inline operations for class CORBA_ValueMemberDef_var
+// *************************************************************
+
+ACE_INLINE
+CORBA_ValueMemberDef_var::CORBA_ValueMemberDef_var (void) // default constructor
+  : ptr_ (CORBA_ValueMemberDef::_nil ())
+{}
+
+ACE_INLINE ::CORBA_ValueMemberDef_ptr
+CORBA_ValueMemberDef_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+CORBA_ValueMemberDef_var::CORBA_ValueMemberDef_var (const ::CORBA_ValueMemberDef_var &p) // copy constructor
+  : TAO_Base_var (),
+    ptr_ (CORBA_ValueMemberDef::_duplicate (p.ptr ()))
+{}
+
+ACE_INLINE
+CORBA_ValueMemberDef_var::~CORBA_ValueMemberDef_var (void) // destructor
+{
+  CORBA::release (this->ptr_);
+}
+
+ACE_INLINE CORBA_ValueMemberDef_var &
+CORBA_ValueMemberDef_var::operator= (CORBA_ValueMemberDef_ptr p)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE CORBA_ValueMemberDef_var &
+CORBA_ValueMemberDef_var::operator= (const ::CORBA_ValueMemberDef_var &p)
+{
+  if (this != &p)
+  {
+    CORBA::release (this->ptr_);
+    this->ptr_ = ::CORBA_ValueMemberDef::_duplicate (p.ptr ());
+  }
+  return *this;
+}
+
+ACE_INLINE 
+CORBA_ValueMemberDef_var::operator const ::CORBA_ValueMemberDef_ptr &() const // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+CORBA_ValueMemberDef_var::operator ::CORBA_ValueMemberDef_ptr &() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ValueMemberDef_ptr
+CORBA_ValueMemberDef_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ValueMemberDef_ptr
+CORBA_ValueMemberDef_var::in (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ValueMemberDef_ptr &
+CORBA_ValueMemberDef_var::inout (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ValueMemberDef_ptr &
+CORBA_ValueMemberDef_var::out (void)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = ::CORBA_ValueMemberDef::_nil ();
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ValueMemberDef_ptr
+CORBA_ValueMemberDef_var::_retn (void)
+{
+  // yield ownership of managed obj reference
+  ::CORBA_ValueMemberDef_ptr val = this->ptr_;
+  this->ptr_ = ::CORBA_ValueMemberDef::_nil ();
+  return val;
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_VALUEMEMBERDEF___OUT_CI_)
+#define _CORBA_VALUEMEMBERDEF___OUT_CI_
+
+// *************************************************************
+// Inline operations for class CORBA_ValueMemberDef_out
+// *************************************************************
+
+ACE_INLINE
+CORBA_ValueMemberDef_out::CORBA_ValueMemberDef_out (CORBA_ValueMemberDef_ptr &p)
+  : ptr_ (p)
+{
+  this->ptr_ = ::CORBA_ValueMemberDef::_nil ();
+}
+
+ACE_INLINE
+CORBA_ValueMemberDef_out::CORBA_ValueMemberDef_out (CORBA_ValueMemberDef_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = ::CORBA_ValueMemberDef::_nil ();
+}
+
+ACE_INLINE
+CORBA_ValueMemberDef_out::CORBA_ValueMemberDef_out (const ::CORBA_ValueMemberDef_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (CORBA_ValueMemberDef_out &, p).ptr_)
+{}
+
+ACE_INLINE ::CORBA_ValueMemberDef_out &
+CORBA_ValueMemberDef_out::operator= (const ::CORBA_ValueMemberDef_out &p)
+{
+  this->ptr_ = ACE_const_cast (CORBA_ValueMemberDef_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE CORBA_ValueMemberDef_out &
+CORBA_ValueMemberDef_out::operator= (const ::CORBA_ValueMemberDef_var &p)
+{
+  this->ptr_ = ::CORBA_ValueMemberDef::_duplicate (p.ptr ());
+  return *this;
+}
+
+ACE_INLINE CORBA_ValueMemberDef_out &
+CORBA_ValueMemberDef_out::operator= (CORBA_ValueMemberDef_ptr p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+CORBA_ValueMemberDef_out::operator ::CORBA_ValueMemberDef_ptr &() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ValueMemberDef_ptr &
+CORBA_ValueMemberDef_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ValueMemberDef_ptr
+CORBA_ValueMemberDef_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+
+#endif /* end #if !defined */
+
+// *************************************************************
+// Inline operations for class CORBA::ValueDef::FullValueDescription_var
+// *************************************************************
+
+ACE_INLINE
+CORBA::ValueDef::FullValueDescription_var::FullValueDescription_var (void) // default constructor
+  : ptr_ (0)
+{}
+
+ACE_INLINE
+CORBA::ValueDef::FullValueDescription_var::FullValueDescription_var (FullValueDescription *p)
+  : ptr_ (p)
+{}
+
+ACE_INLINE
+CORBA::ValueDef::FullValueDescription_var::FullValueDescription_var (const ::CORBA::ValueDef::FullValueDescription_var &p) // copy constructor
+{
+  if (p.ptr_)
+    ACE_NEW (this->ptr_, ::CORBA::ValueDef::FullValueDescription (*p.ptr_));
+  else
+    this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA::ValueDef::FullValueDescription_var::~FullValueDescription_var (void) // destructor
+{
+  delete this->ptr_;
+}
+
+ACE_INLINE CORBA::ValueDef::FullValueDescription_var &
+CORBA::ValueDef::FullValueDescription_var::operator= (FullValueDescription *p)
+{
+  delete this->ptr_;
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE ::CORBA::ValueDef::FullValueDescription_var &
+CORBA::ValueDef::FullValueDescription_var::operator= (const ::CORBA::ValueDef::FullValueDescription_var &p)
+{
+  if (this != &p)
+    {
+      if (p.ptr_ == 0)
+        {
+          delete this->ptr_;
+          this->ptr_ = 0;
+        }
+      else
+        {
+          FullValueDescription *deep_copy =
+            new FullValueDescription (*p.ptr_);
+          
+          if (deep_copy != 0)
+            {
+              FullValueDescription *tmp = deep_copy;
+              deep_copy = this->ptr_;
+              this->ptr_ = tmp;
+              delete deep_copy;
+            }
+        }
+    }
+  
+  return *this;
+}
+
+ACE_INLINE const ::CORBA::ValueDef::FullValueDescription *
+CORBA::ValueDef::FullValueDescription_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA::ValueDef::FullValueDescription *
+CORBA::ValueDef::FullValueDescription_var::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+CORBA::ValueDef::FullValueDescription_var::operator const ::CORBA::ValueDef::FullValueDescription &() const // cast
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE
+CORBA::ValueDef::FullValueDescription_var::operator ::CORBA::ValueDef::FullValueDescription &() // cast 
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE
+CORBA::ValueDef::FullValueDescription_var::operator ::CORBA::ValueDef::FullValueDescription &() const // cast 
+{
+  return *this->ptr_;
+}
+
+// variable-size types only
+ACE_INLINE
+CORBA::ValueDef::FullValueDescription_var::operator ::CORBA::ValueDef::FullValueDescription *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE const ::CORBA::ValueDef::FullValueDescription &
+CORBA::ValueDef::FullValueDescription_var::in (void) const
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE ::CORBA::ValueDef::FullValueDescription &
+CORBA::ValueDef::FullValueDescription_var::inout (void)
+{
+  return *this->ptr_;
+}
+
+// mapping for variable size 
+ACE_INLINE ::CORBA::ValueDef::FullValueDescription *&
+CORBA::ValueDef::FullValueDescription_var::out (void)
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA::ValueDef::FullValueDescription *
+CORBA::ValueDef::FullValueDescription_var::_retn (void)
+{
+  ::CORBA::ValueDef::FullValueDescription *tmp = this->ptr_;
+  this->ptr_ = 0;
+  return tmp;
+}
+
+ACE_INLINE ::CORBA::ValueDef::FullValueDescription *
+CORBA::ValueDef::FullValueDescription_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+// *************************************************************
+// Inline operations for class CORBA::ValueDef::FullValueDescription_out
+// *************************************************************
+
+ACE_INLINE
+CORBA::ValueDef::FullValueDescription_out::FullValueDescription_out (::CORBA::ValueDef::FullValueDescription *&p)
+  : ptr_ (p)
+{
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA::ValueDef::FullValueDescription_out::FullValueDescription_out (FullValueDescription_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA::ValueDef::FullValueDescription_out::FullValueDescription_out (const ::CORBA::ValueDef::FullValueDescription_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (FullValueDescription_out&, p).ptr_)
+{}
+
+ACE_INLINE CORBA::ValueDef::FullValueDescription_out &
+CORBA::ValueDef::FullValueDescription_out::operator= (const ::CORBA::ValueDef::FullValueDescription_out &p)
+{
+  this->ptr_ = ACE_const_cast (FullValueDescription_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE CORBA::ValueDef::FullValueDescription_out &
+CORBA::ValueDef::FullValueDescription_out::operator= (FullValueDescription *p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+CORBA::ValueDef::FullValueDescription_out::operator ::CORBA::ValueDef::FullValueDescription *&() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA::ValueDef::FullValueDescription *&
+CORBA::ValueDef::FullValueDescription_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA::ValueDef::FullValueDescription *
+CORBA::ValueDef::FullValueDescription_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+
+#if !defined (_CORBA_VALUEDEF___CI_)
+#define _CORBA_VALUEDEF___CI_
+
+ACE_INLINE
+CORBA_ValueDef::CORBA_ValueDef (
+    TAO_Stub *objref,
+    CORBA::Boolean _tao_collocated,
+    TAO_Abstract_ServantBase *servant
+  )
+  : CORBA_Object (objref, _tao_collocated, servant)
+{
+  this->CORBA_ValueDef_setup_collocation (_tao_collocated);
+}
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_VALUEDEF___VAR_CI_)
+#define _CORBA_VALUEDEF___VAR_CI_
+
+// *************************************************************
+// Inline operations for class CORBA_ValueDef_var
+// *************************************************************
+
+ACE_INLINE
+CORBA_ValueDef_var::CORBA_ValueDef_var (void) // default constructor
+  : ptr_ (CORBA_ValueDef::_nil ())
+{}
+
+ACE_INLINE ::CORBA_ValueDef_ptr
+CORBA_ValueDef_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+CORBA_ValueDef_var::CORBA_ValueDef_var (const ::CORBA_ValueDef_var &p) // copy constructor
+  : TAO_Base_var (),
+    ptr_ (CORBA_ValueDef::_duplicate (p.ptr ()))
+{}
+
+ACE_INLINE
+CORBA_ValueDef_var::~CORBA_ValueDef_var (void) // destructor
+{
+  CORBA::release (this->ptr_);
+}
+
+ACE_INLINE CORBA_ValueDef_var &
+CORBA_ValueDef_var::operator= (CORBA_ValueDef_ptr p)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE CORBA_ValueDef_var &
+CORBA_ValueDef_var::operator= (const ::CORBA_ValueDef_var &p)
+{
+  if (this != &p)
+  {
+    CORBA::release (this->ptr_);
+    this->ptr_ = ::CORBA_ValueDef::_duplicate (p.ptr ());
+  }
+  return *this;
+}
+
+ACE_INLINE 
+CORBA_ValueDef_var::operator const ::CORBA_ValueDef_ptr &() const // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+CORBA_ValueDef_var::operator ::CORBA_ValueDef_ptr &() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ValueDef_ptr
+CORBA_ValueDef_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ValueDef_ptr
+CORBA_ValueDef_var::in (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ValueDef_ptr &
+CORBA_ValueDef_var::inout (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ValueDef_ptr &
+CORBA_ValueDef_var::out (void)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = ::CORBA_ValueDef::_nil ();
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ValueDef_ptr
+CORBA_ValueDef_var::_retn (void)
+{
+  // yield ownership of managed obj reference
+  ::CORBA_ValueDef_ptr val = this->ptr_;
+  this->ptr_ = ::CORBA_ValueDef::_nil ();
+  return val;
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_VALUEDEF___OUT_CI_)
+#define _CORBA_VALUEDEF___OUT_CI_
+
+// *************************************************************
+// Inline operations for class CORBA_ValueDef_out
+// *************************************************************
+
+ACE_INLINE
+CORBA_ValueDef_out::CORBA_ValueDef_out (CORBA_ValueDef_ptr &p)
+  : ptr_ (p)
+{
+  this->ptr_ = ::CORBA_ValueDef::_nil ();
+}
+
+ACE_INLINE
+CORBA_ValueDef_out::CORBA_ValueDef_out (CORBA_ValueDef_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = ::CORBA_ValueDef::_nil ();
+}
+
+ACE_INLINE
+CORBA_ValueDef_out::CORBA_ValueDef_out (const ::CORBA_ValueDef_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (CORBA_ValueDef_out &, p).ptr_)
+{}
+
+ACE_INLINE ::CORBA_ValueDef_out &
+CORBA_ValueDef_out::operator= (const ::CORBA_ValueDef_out &p)
+{
+  this->ptr_ = ACE_const_cast (CORBA_ValueDef_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE CORBA_ValueDef_out &
+CORBA_ValueDef_out::operator= (const ::CORBA_ValueDef_var &p)
+{
+  this->ptr_ = ::CORBA_ValueDef::_duplicate (p.ptr ());
+  return *this;
+}
+
+ACE_INLINE CORBA_ValueDef_out &
+CORBA_ValueDef_out::operator= (CORBA_ValueDef_ptr p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+CORBA_ValueDef_out::operator ::CORBA_ValueDef_ptr &() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ValueDef_ptr &
+CORBA_ValueDef_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ValueDef_ptr
+CORBA_ValueDef_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+
+#endif /* end #if !defined */
+
+// *************************************************************
+// Inline operations for class CORBA_ValueDescription_var
+// *************************************************************
+
+ACE_INLINE
+CORBA_ValueDescription_var::CORBA_ValueDescription_var (void) // default constructor
+  : ptr_ (0)
+{}
+
+ACE_INLINE
+CORBA_ValueDescription_var::CORBA_ValueDescription_var (CORBA_ValueDescription *p)
+  : ptr_ (p)
+{}
+
+ACE_INLINE
+CORBA_ValueDescription_var::CORBA_ValueDescription_var (const ::CORBA_ValueDescription_var &p) // copy constructor
+{
+  if (p.ptr_)
+    ACE_NEW (this->ptr_, ::CORBA_ValueDescription (*p.ptr_));
+  else
+    this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA_ValueDescription_var::~CORBA_ValueDescription_var (void) // destructor
+{
+  delete this->ptr_;
+}
+
+ACE_INLINE CORBA_ValueDescription_var &
+CORBA_ValueDescription_var::operator= (CORBA_ValueDescription *p)
+{
+  delete this->ptr_;
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE ::CORBA_ValueDescription_var &
+CORBA_ValueDescription_var::operator= (const ::CORBA_ValueDescription_var &p)
+{
+  if (this != &p)
+    {
+      if (p.ptr_ == 0)
+        {
+          delete this->ptr_;
+          this->ptr_ = 0;
+        }
+      else
+        {
+          CORBA_ValueDescription *deep_copy =
+            new CORBA_ValueDescription (*p.ptr_);
+          
+          if (deep_copy != 0)
+            {
+              CORBA_ValueDescription *tmp = deep_copy;
+              deep_copy = this->ptr_;
+              this->ptr_ = tmp;
+              delete deep_copy;
+            }
+        }
+    }
+  
+  return *this;
+}
+
+ACE_INLINE const ::CORBA_ValueDescription *
+CORBA_ValueDescription_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ValueDescription *
+CORBA_ValueDescription_var::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+CORBA_ValueDescription_var::operator const ::CORBA_ValueDescription &() const // cast
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE
+CORBA_ValueDescription_var::operator ::CORBA_ValueDescription &() // cast 
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE
+CORBA_ValueDescription_var::operator ::CORBA_ValueDescription &() const // cast 
+{
+  return *this->ptr_;
+}
+
+// variable-size types only
+ACE_INLINE
+CORBA_ValueDescription_var::operator ::CORBA_ValueDescription *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE const ::CORBA_ValueDescription &
+CORBA_ValueDescription_var::in (void) const
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ValueDescription &
+CORBA_ValueDescription_var::inout (void)
+{
+  return *this->ptr_;
+}
+
+// mapping for variable size 
+ACE_INLINE ::CORBA_ValueDescription *&
+CORBA_ValueDescription_var::out (void)
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ValueDescription *
+CORBA_ValueDescription_var::_retn (void)
+{
+  ::CORBA_ValueDescription *tmp = this->ptr_;
+  this->ptr_ = 0;
+  return tmp;
+}
+
+ACE_INLINE ::CORBA_ValueDescription *
+CORBA_ValueDescription_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+// *************************************************************
+// Inline operations for class CORBA_ValueDescription_out
+// *************************************************************
+
+ACE_INLINE
+CORBA_ValueDescription_out::CORBA_ValueDescription_out (::CORBA_ValueDescription *&p)
+  : ptr_ (p)
+{
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA_ValueDescription_out::CORBA_ValueDescription_out (CORBA_ValueDescription_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+CORBA_ValueDescription_out::CORBA_ValueDescription_out (const ::CORBA_ValueDescription_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (CORBA_ValueDescription_out&, p).ptr_)
+{}
+
+ACE_INLINE CORBA_ValueDescription_out &
+CORBA_ValueDescription_out::operator= (const ::CORBA_ValueDescription_out &p)
+{
+  this->ptr_ = ACE_const_cast (CORBA_ValueDescription_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE CORBA_ValueDescription_out &
+CORBA_ValueDescription_out::operator= (CORBA_ValueDescription *p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+CORBA_ValueDescription_out::operator ::CORBA_ValueDescription *&() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ValueDescription *&
+CORBA_ValueDescription_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ValueDescription *
+CORBA_ValueDescription_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+
+#if !defined (_CORBA_VALUEBOXDEF___CI_)
+#define _CORBA_VALUEBOXDEF___CI_
+
+ACE_INLINE
+CORBA_ValueBoxDef::CORBA_ValueBoxDef (
+    TAO_Stub *objref,
+    CORBA::Boolean _tao_collocated,
+    TAO_Abstract_ServantBase *servant
+  )
+  : CORBA_Object (objref, _tao_collocated, servant)
+{
+  this->CORBA_ValueBoxDef_setup_collocation (_tao_collocated);
+}
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_VALUEBOXDEF___VAR_CI_)
+#define _CORBA_VALUEBOXDEF___VAR_CI_
+
+// *************************************************************
+// Inline operations for class CORBA_ValueBoxDef_var
+// *************************************************************
+
+ACE_INLINE
+CORBA_ValueBoxDef_var::CORBA_ValueBoxDef_var (void) // default constructor
+  : ptr_ (CORBA_ValueBoxDef::_nil ())
+{}
+
+ACE_INLINE ::CORBA_ValueBoxDef_ptr
+CORBA_ValueBoxDef_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+CORBA_ValueBoxDef_var::CORBA_ValueBoxDef_var (const ::CORBA_ValueBoxDef_var &p) // copy constructor
+  : TAO_Base_var (),
+    ptr_ (CORBA_ValueBoxDef::_duplicate (p.ptr ()))
+{}
+
+ACE_INLINE
+CORBA_ValueBoxDef_var::~CORBA_ValueBoxDef_var (void) // destructor
+{
+  CORBA::release (this->ptr_);
+}
+
+ACE_INLINE CORBA_ValueBoxDef_var &
+CORBA_ValueBoxDef_var::operator= (CORBA_ValueBoxDef_ptr p)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE CORBA_ValueBoxDef_var &
+CORBA_ValueBoxDef_var::operator= (const ::CORBA_ValueBoxDef_var &p)
+{
+  if (this != &p)
+  {
+    CORBA::release (this->ptr_);
+    this->ptr_ = ::CORBA_ValueBoxDef::_duplicate (p.ptr ());
+  }
+  return *this;
+}
+
+ACE_INLINE 
+CORBA_ValueBoxDef_var::operator const ::CORBA_ValueBoxDef_ptr &() const // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+CORBA_ValueBoxDef_var::operator ::CORBA_ValueBoxDef_ptr &() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ValueBoxDef_ptr
+CORBA_ValueBoxDef_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ValueBoxDef_ptr
+CORBA_ValueBoxDef_var::in (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ValueBoxDef_ptr &
+CORBA_ValueBoxDef_var::inout (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ValueBoxDef_ptr &
+CORBA_ValueBoxDef_var::out (void)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = ::CORBA_ValueBoxDef::_nil ();
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ValueBoxDef_ptr
+CORBA_ValueBoxDef_var::_retn (void)
+{
+  // yield ownership of managed obj reference
+  ::CORBA_ValueBoxDef_ptr val = this->ptr_;
+  this->ptr_ = ::CORBA_ValueBoxDef::_nil ();
+  return val;
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_VALUEBOXDEF___OUT_CI_)
+#define _CORBA_VALUEBOXDEF___OUT_CI_
+
+// *************************************************************
+// Inline operations for class CORBA_ValueBoxDef_out
+// *************************************************************
+
+ACE_INLINE
+CORBA_ValueBoxDef_out::CORBA_ValueBoxDef_out (CORBA_ValueBoxDef_ptr &p)
+  : ptr_ (p)
+{
+  this->ptr_ = ::CORBA_ValueBoxDef::_nil ();
+}
+
+ACE_INLINE
+CORBA_ValueBoxDef_out::CORBA_ValueBoxDef_out (CORBA_ValueBoxDef_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = ::CORBA_ValueBoxDef::_nil ();
+}
+
+ACE_INLINE
+CORBA_ValueBoxDef_out::CORBA_ValueBoxDef_out (const ::CORBA_ValueBoxDef_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (CORBA_ValueBoxDef_out &, p).ptr_)
+{}
+
+ACE_INLINE ::CORBA_ValueBoxDef_out &
+CORBA_ValueBoxDef_out::operator= (const ::CORBA_ValueBoxDef_out &p)
+{
+  this->ptr_ = ACE_const_cast (CORBA_ValueBoxDef_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE CORBA_ValueBoxDef_out &
+CORBA_ValueBoxDef_out::operator= (const ::CORBA_ValueBoxDef_var &p)
+{
+  this->ptr_ = ::CORBA_ValueBoxDef::_duplicate (p.ptr ());
+  return *this;
+}
+
+ACE_INLINE CORBA_ValueBoxDef_out &
+CORBA_ValueBoxDef_out::operator= (CORBA_ValueBoxDef_ptr p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+CORBA_ValueBoxDef_out::operator ::CORBA_ValueBoxDef_ptr &() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ValueBoxDef_ptr &
+CORBA_ValueBoxDef_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_ValueBoxDef_ptr
+CORBA_ValueBoxDef_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+
+#endif /* end #if !defined */
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &,
+    const CORBA::FixedDef_ptr
+  );
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &,
+    CORBA::FixedDef_ptr &
+  );
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &strm,
+    const CORBA::FixedDef_ptr _tao_objref
+  )
+{
+  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
+  return (strm << _tao_corba_obj);
+}
+
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &strm,
+    CORBA::FixedDef_ptr &_tao_objref
+  )
+{
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::Object_var obj;
+    if ((strm >> obj.inout ()) == 0)
+      return 0;
+    // narrow to the right type
+    _tao_objref =
+      CORBA::FixedDef::_unchecked_narrow (
+          obj.in (),
+          ACE_TRY_ENV
+        );
+    ACE_TRY_CHECK;
+    return 1;
+  }
+  ACE_CATCHANY
+  {
+    // do nothing
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA::ValueMember &_tao_aggregate)
+{
+  if (
+    (strm << _tao_aggregate.name.in ()) &&
+    (strm << _tao_aggregate.id.in ()) &&
+    (strm << _tao_aggregate.defined_in.in ()) &&
+    (strm << _tao_aggregate.version.in ()) &&
+    (strm << _tao_aggregate.type.in ()) &&
+    (strm << _tao_aggregate.type_def.in ()) &&
+    (strm << _tao_aggregate.access)
+  )
+    return 1;
+  else
+    return 0;
+  
+}
+
+ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA::ValueMember &_tao_aggregate)
+{
+  if (
+    (strm >> _tao_aggregate.name.out ()) &&
+    (strm >> _tao_aggregate.id.out ()) &&
+    (strm >> _tao_aggregate.defined_in.out ()) &&
+    (strm >> _tao_aggregate.version.out ()) &&
+    (strm >> _tao_aggregate.type.out ()) &&
+    (strm >> _tao_aggregate.type_def.out ()) &&
+    (strm >> _tao_aggregate.access)
+  )
+    return 1;
+  else
+    return 0;
+  
+}
+
+
+#if !defined _TAO_CDR_OP_CORBA_ValueMemberSeq_I_
+#define _TAO_CDR_OP_CORBA_ValueMemberSeq_I_
+
+CORBA::Boolean TAO_IFR_Client_Export operator<< (
+    TAO_OutputCDR &,
+    const CORBA::ValueMemberSeq &
+  );
+CORBA::Boolean TAO_IFR_Client_Export operator>> (
+    TAO_InputCDR &,
+    CORBA::ValueMemberSeq &
+  );
+
+#endif /* _TAO_CDR_OP_CORBA_ValueMemberSeq_I_ */
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &,
+    const CORBA::ValueMemberDef_ptr
+  );
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &,
+    CORBA::ValueMemberDef_ptr &
+  );
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &strm,
+    const CORBA::ValueMemberDef_ptr _tao_objref
+  )
+{
+  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
+  return (strm << _tao_corba_obj);
+}
+
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &strm,
+    CORBA::ValueMemberDef_ptr &_tao_objref
+  )
+{
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::Object_var obj;
+    if ((strm >> obj.inout ()) == 0)
+      return 0;
+    // narrow to the right type
+    _tao_objref =
+      CORBA::ValueMemberDef::_unchecked_narrow (
+          obj.in (),
+          ACE_TRY_ENV
+        );
+    ACE_TRY_CHECK;
+    return 1;
+  }
+  ACE_CATCHANY
+  {
+    // do nothing
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &,
+    const CORBA::ValueDef_ptr
+  );
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &,
+    CORBA::ValueDef_ptr &
+  );
+
+ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA::ValueDef::FullValueDescription &_tao_aggregate)
+{
+  if (
+    (strm << _tao_aggregate.name.in ()) &&
+    (strm << _tao_aggregate.id.in ()) &&
+    (strm << CORBA::Any::from_boolean (_tao_aggregate.is_abstract)) &&
+    (strm << CORBA::Any::from_boolean (_tao_aggregate.is_custom)) &&
+    (strm << _tao_aggregate.defined_in.in ()) &&
+    (strm << _tao_aggregate.version.in ()) &&
+    (strm << _tao_aggregate.operations) &&
+    (strm << _tao_aggregate.attributes) &&
+    (strm << _tao_aggregate.members) &&
+    (strm << _tao_aggregate.initializers) &&
+    (strm << _tao_aggregate.supported_interfaces) &&
+    (strm << _tao_aggregate.abstract_base_values) &&
+    (strm << CORBA::Any::from_boolean (_tao_aggregate.is_truncatable)) &&
+    (strm << _tao_aggregate.base_value.in ()) &&
+    (strm << _tao_aggregate.type.in ())
+  )
+    return 1;
+  else
+    return 0;
+  
+}
+
+ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA::ValueDef::FullValueDescription &_tao_aggregate)
+{
+  if (
+    (strm >> _tao_aggregate.name.out ()) &&
+    (strm >> _tao_aggregate.id.out ()) &&
+    (strm >> CORBA::Any::to_boolean (_tao_aggregate.is_abstract)) &&
+    (strm >> CORBA::Any::to_boolean (_tao_aggregate.is_custom)) &&
+    (strm >> _tao_aggregate.defined_in.out ()) &&
+    (strm >> _tao_aggregate.version.out ()) &&
+    (strm >> _tao_aggregate.operations) &&
+    (strm >> _tao_aggregate.attributes) &&
+    (strm >> _tao_aggregate.members) &&
+    (strm >> _tao_aggregate.initializers) &&
+    (strm >> _tao_aggregate.supported_interfaces) &&
+    (strm >> _tao_aggregate.abstract_base_values) &&
+    (strm >> CORBA::Any::to_boolean (_tao_aggregate.is_truncatable)) &&
+    (strm >> _tao_aggregate.base_value.out ()) &&
+    (strm >> _tao_aggregate.type.out ())
+  )
+    return 1;
+  else
+    return 0;
+  
+}
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &strm,
+    const CORBA::ValueDef_ptr _tao_objref
+  )
+{
+  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
+  return (strm << _tao_corba_obj);
+}
+
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &strm,
+    CORBA::ValueDef_ptr &_tao_objref
+  )
+{
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::Object_var obj;
+    if ((strm >> obj.inout ()) == 0)
+      return 0;
+    // narrow to the right type
+    _tao_objref =
+      CORBA::ValueDef::_unchecked_narrow (
+          obj.in (),
+          ACE_TRY_ENV
+        );
+    ACE_TRY_CHECK;
+    return 1;
+  }
+  ACE_CATCHANY
+  {
+    // do nothing
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA::ValueDescription &_tao_aggregate)
+{
+  if (
+    (strm << _tao_aggregate.name.in ()) &&
+    (strm << _tao_aggregate.id.in ()) &&
+    (strm << CORBA::Any::from_boolean (_tao_aggregate.is_abstract)) &&
+    (strm << CORBA::Any::from_boolean (_tao_aggregate.is_custom)) &&
+    (strm << _tao_aggregate.defined_in.in ()) &&
+    (strm << _tao_aggregate.version.in ()) &&
+    (strm << _tao_aggregate.supported_interfaces) &&
+    (strm << _tao_aggregate.abstract_base_values) &&
+    (strm << CORBA::Any::from_boolean (_tao_aggregate.is_truncatable)) &&
+    (strm << _tao_aggregate.base_value.in ())
+  )
+    return 1;
+  else
+    return 0;
+  
+}
+
+ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA::ValueDescription &_tao_aggregate)
+{
+  if (
+    (strm >> _tao_aggregate.name.out ()) &&
+    (strm >> _tao_aggregate.id.out ()) &&
+    (strm >> CORBA::Any::to_boolean (_tao_aggregate.is_abstract)) &&
+    (strm >> CORBA::Any::to_boolean (_tao_aggregate.is_custom)) &&
+    (strm >> _tao_aggregate.defined_in.out ()) &&
+    (strm >> _tao_aggregate.version.out ()) &&
+    (strm >> _tao_aggregate.supported_interfaces) &&
+    (strm >> _tao_aggregate.abstract_base_values) &&
+    (strm >> CORBA::Any::to_boolean (_tao_aggregate.is_truncatable)) &&
+    (strm >> _tao_aggregate.base_value.out ())
+  )
+    return 1;
+  else
+    return 0;
+  
+}
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &,
+    const CORBA::ValueBoxDef_ptr
+  );
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &,
+    CORBA::ValueBoxDef_ptr &
+  );
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &strm,
+    const CORBA::ValueBoxDef_ptr _tao_objref
+  )
+{
+  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
+  return (strm << _tao_corba_obj);
+}
+
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &strm,
+    CORBA::ValueBoxDef_ptr &_tao_objref
+  )
+{
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::Object_var obj;
+    if ((strm >> obj.inout ()) == 0)
+      return 0;
+    // narrow to the right type
+    _tao_objref =
+      CORBA::ValueBoxDef::_unchecked_narrow (
+          obj.in (),
+          ACE_TRY_ENV
+        );
+    ACE_TRY_CHECK;
+    return 1;
+  }
+  ACE_CATCHANY
+  {
+    // do nothing
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
diff --git a/TAO/tao/IFR_Client/Interface.pidl b/TAO/tao/IFR_Client/Interface.pidl
index de4c569cfa6..4a088f8b922 100644
--- a/TAO/tao/IFR_Client/Interface.pidl
+++ b/TAO/tao/IFR_Client/Interface.pidl
@@ -91,17 +91,25 @@ module IR
     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_Native
+
+    // CORBA 2.x specific.
+
+    ,dk_AbstractInterface
+    ,dk_LocalInterface
+
+    // CCM specific.
+
+    ,dk_Component
+    ,dk_Home
+    ,dk_Factory
+    ,dk_Finder
+    ,dk_PrimaryKey
+    ,dk_Emits 
+    ,dk_Publishes
+    ,dk_Consumes
+    ,dk_Provides
+    ,dk_Uses
   };
 };
 
@@ -184,6 +192,15 @@ module IR
   interface ValueDef;
   typedef sequence <ValueDef> ValueDefSeq;
   interface ValueBoxDef;
+  typedef sequence <Contained> ContainedSeq;
+
+  // CORBA 2.x specific.
+  interface AbstractInterfaceDef;
+  typedef sequence <AbstractInterfaceDef> AbstractInterfaceDefSeq;
+  interface LocalInterfaceDef;
+  typedef sequence <LocalInterfaceDef> LocalInterfaceDefSeq;
+  
+  // CCM specific.
   interface ComponentDef;
   typedef sequence <ComponentDef> ComponentDefSeq;
   interface ProvidesDef;
@@ -204,7 +221,6 @@ module IR
   interface FinderDef;
   typedef sequence <FinderDef> FinderDefSeq;
   interface PrimaryKeyDef;
-  typedef sequence <Contained> ContainedSeq;
 
   struct StructMember 
   {
@@ -306,9 +322,12 @@ module IR
         in RepositoryId id,
         in Identifier name,
         in VersionSpec version,
-        in InterfaceDefSeq base_interfaces,
-        in boolean is_abstract,
-        in boolean is_local
+        in InterfaceDefSeq base_interfaces
+
+        /* CCM specific.
+        ,in boolean is_abstract
+        ,in boolean is_local 
+        */
       );
     ValueDef create_value (
         in RepositoryId id,
@@ -339,6 +358,21 @@ module IR
         in Identifier name,
         in VersionSpec version
       );
+
+    // CORBA 2.x specific.
+
+    AbstractInterfaceDef create_abstract_interface (
+        in RepositoryId id,
+        in Identifier name,
+        in VersionSpec version,
+        in AbstractInterfaceDefSeq base_interfaces
+      );
+    LocalInterfaceDef create_local_interface (
+        in RepositoryId id,
+        in Identifier name,
+        in VersionSpec version,
+        in InterfaceDefSeq base_interfaces
+      );
   };
 
   interface IDLType : CORBA::IRObject 
@@ -412,6 +446,8 @@ module IR
       );
   };
 
+  // CCM specific.
+
   interface ComponentRepository : Repository
   {
     ComponentDef create_component (
@@ -573,8 +609,11 @@ module IR
     VersionSpec version;
     CORBA::TypeCode type;
     AttributeMode mode;
+
+    /* CCM specific.
     ExcDescriptionSeq get_exceptions;
     ExcDescriptionSeq put_exceptions;
+    */
   };
 
   enum OperationMode 
@@ -634,20 +673,44 @@ module IR
     // read/write interface
     attribute InterfaceDefSeq base_interfaces;
     // read interface
+
+    /* CCM specific.
     attribute boolean is_abstract;
     attribute boolean is_local;
+    */
+
     boolean is_a (
         in RepositoryId interface_id
       );
+
+    // CORBA 2.x specific.
+
+    struct FullInterfaceDescription 
+    {
+      Identifier name;
+      RepositoryId id;
+      RepositoryId defined_in;
+      VersionSpec version;
+      OpDescriptionSeq operations;
+      AttrDescriptionSeq attributes;
+      RepositoryIdSeq base_interfaces;
+      CORBA::TypeCode type;
+    };
+
+    FullInterfaceDescription describe_interface ();
+
     // write interface
     AttributeDef create_attribute (
         in RepositoryId id,
         in Identifier name,
         in VersionSpec version,
         in IDLType type,
-        in AttributeMode mode,
-        in ExceptionDefSeq get_exceptions,
-        in ExceptionDefSeq put_exceptions
+        in AttributeMode mode
+
+        /* CCM specific.
+        ,in ExceptionDefSeq get_exceptions
+        ,in ExceptionDefSeq put_exceptions
+        */
       );
     OperationDef create_operation (
         in RepositoryId id,
@@ -667,12 +730,19 @@ module IR
     RepositoryId id;
     RepositoryId defined_in;
     VersionSpec version;
+
+    /* CCM specific
     OpDescriptionSeq operations;
     AttrDescriptionSeq attributes;
+    */
+
     RepositoryIdSeq base_interfaces;
+
+    /* CCM specific.
     CORBA::TypeCode type;
     boolean is_abstract;
     boolean is_local;
+    */
   };
 
   struct ValueMember 
@@ -709,6 +779,30 @@ module IR
     boolean is_a (
         in RepositoryId id
       );
+
+    // CORBA 2.x specific.
+
+    struct FullValueDescription 
+    {
+      Identifier name;
+      RepositoryId id;
+      boolean is_abstract;
+      boolean is_custom;
+      RepositoryId defined_in;
+      VersionSpec version;
+      OpDescriptionSeq operations;
+      AttrDescriptionSeq attributes;
+      ValueMemberSeq members;
+      InitializerSeq initializers;
+      RepositoryIdSeq supported_interfaces;
+      RepositoryIdSeq abstract_base_values;
+      boolean is_truncatable;
+      RepositoryId base_value;
+      CORBA::TypeCode type;
+    };
+
+    FullValueDescription describe_value ();
+      
     ValueMemberDef create_value_member (
         in RepositoryId id,
         in Identifier name,
@@ -721,9 +815,12 @@ module IR
         in Identifier name,
         in VersionSpec version,
         in IDLType type,
-        in AttributeMode mode,
-        in ExceptionDefSeq get_exceptions,
-        in ExceptionDefSeq put_exceptions
+        in AttributeMode mode
+
+        /* CCM specific
+        ,in ExceptionDefSeq get_exceptions
+        ,in ExceptionDefSeq put_exceptions
+        */
       );
     OperationDef create_operation (
         in RepositoryId id,
@@ -745,15 +842,22 @@ module IR
     boolean is_custom;
     RepositoryId defined_in;
     VersionSpec version;
+
+    /* CCM specific.
     OpDescriptionSeq operations;
     AttrDescriptionSeq attributes;
     ValueMemberSeq members;
     InitializerSeq initializers;
+    */
+
     RepositoryIdSeq supported_interfaces;
     RepositoryIdSeq abstract_base_values;
     boolean is_truncatable;
     RepositoryId base_value;
+    
+    /* CCM specific
     CORBA::TypeCode type;
+    */
   };
 
   interface ValueBoxDef : TypedefDef 
@@ -761,6 +865,18 @@ module IR
     attribute IDLType original_type_def;
   };
 
+  // CORBA 2.x specific.
+
+  interface AbstractInterfaceDef : InterfaceDef 
+  {
+  };
+
+  interface LocalInterfaceDef : InterfaceDef 
+  {
+  };
+
+  // The rest of this file is CCM specific.
+
   interface ProvidesDef : Contained 
   {
     // read interface
diff --git a/TAO/tao/IFR_Client/InterfaceC.cpp b/TAO/tao/IFR_Client/InterfaceC.cpp
deleted file mode 100644
index e8815fb0db8..00000000000
--- a/TAO/tao/IFR_Client/InterfaceC.cpp
+++ /dev/null
@@ -1,62988 +0,0 @@
-// -*- C++ -*-
-//
-/* $Id$ */
-
-// ****  Code generated by the The ACE ORB (TAO) IDL Compiler ****
-// TAO and the TAO IDL Compiler have been developed by:
-//       Center for Distributed Object Computing
-//       Washington University
-//       St. Louis, MO
-//       USA
-//       http://www.cs.wustl.edu/~schmidt/doc-center.html
-// and
-//       Distributed Object Computing Laboratory
-//       University of California at Irvine
-//       Irvine, CA
-//       USA
-//       http://doc.ece.uci.edu/
-//
-// Information about TAO is available at:
-//     http://www.cs.wustl.edu/~schmidt/TAO.html
-
-#include "InterfaceC.h"
-#include "tao/Stub.h"
-#include "tao/Invocation.h"
-
-// The Following header must remain visible since it contains the
-// "TAO_INTERCEPTOR" macros.  Note that this won't cause problems when
-// portable interceptor support is disabled since those macros are
-// always visible, too.
-#include "tao/PortableInterceptor.h"
-
-#if TAO_HAS_INTERCEPTORS == 1
-#include "tao/RequestInfo_Util.h"
-#endif  /* TAO_HAS_INTERCEPTORS == 1 */
-
-#if defined (__BORLANDC__)
-#pragma option -w-rvl -w-rch -w-ccc -w-aus
-#endif /* __BORLANDC__ */
-
-#if !defined (__ACE_INLINE__)
-#include "InterfaceC.i"
-#endif /* !defined INLINE */
-
-static const CORBA::Long _oc_IR_DefinitionKind[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  34, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f44), ACE_NTOHL (0x6566696e), ACE_NTOHL (0x6974696f), ACE_NTOHL (0x6e4b696e), ACE_NTOHL (0x643a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/DefinitionKind:1.0
-  15, ACE_NTOHL (0x44656669), ACE_NTOHL (0x6e697469), ACE_NTOHL (0x6f6e4b69), ACE_NTOHL (0x6e640000),  // name = DefinitionKind
-  34, // member count
-  8, ACE_NTOHL (0x646b5f6e), ACE_NTOHL (0x6f6e6500),  // name = dk_none
-  7, ACE_NTOHL (0x646b5f61), ACE_NTOHL (0x6c6c0000),  // name = dk_all
-  13, ACE_NTOHL (0x646b5f41), ACE_NTOHL (0x74747269), ACE_NTOHL (0x62757465), ACE_NTOHL (0x0),  // name = dk_Attribute
-  12, ACE_NTOHL (0x646b5f43), ACE_NTOHL (0x6f6e7374), ACE_NTOHL (0x616e7400),  // name = dk_Constant
-  13, ACE_NTOHL (0x646b5f45), ACE_NTOHL (0x78636570), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = dk_Exception
-  13, ACE_NTOHL (0x646b5f49), ACE_NTOHL (0x6e746572), ACE_NTOHL (0x66616365), ACE_NTOHL (0x0),  // name = dk_Interface
-  10, ACE_NTOHL (0x646b5f4d), ACE_NTOHL (0x6f64756c), ACE_NTOHL (0x65000000),  // name = dk_Module
-  13, ACE_NTOHL (0x646b5f4f), ACE_NTOHL (0x70657261), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = dk_Operation
-  11, ACE_NTOHL (0x646b5f54), ACE_NTOHL (0x79706564), ACE_NTOHL (0x65660000),  // name = dk_Typedef
-  9, ACE_NTOHL (0x646b5f41), ACE_NTOHL (0x6c696173), ACE_NTOHL (0x0),  // name = dk_Alias
-  10, ACE_NTOHL (0x646b5f53), ACE_NTOHL (0x74727563), ACE_NTOHL (0x74000000),  // name = dk_Struct
-  9, ACE_NTOHL (0x646b5f55), ACE_NTOHL (0x6e696f6e), ACE_NTOHL (0x0),  // name = dk_Union
-  8, ACE_NTOHL (0x646b5f45), ACE_NTOHL (0x6e756d00),  // name = dk_Enum
-  13, ACE_NTOHL (0x646b5f50), ACE_NTOHL (0x72696d69), ACE_NTOHL (0x74697665), ACE_NTOHL (0x0),  // name = dk_Primitive
-  10, ACE_NTOHL (0x646b5f53), ACE_NTOHL (0x7472696e), ACE_NTOHL (0x67000000),  // name = dk_String
-  12, ACE_NTOHL (0x646b5f53), ACE_NTOHL (0x65717565), ACE_NTOHL (0x6e636500),  // name = dk_Sequence
-  9, ACE_NTOHL (0x646b5f41), ACE_NTOHL (0x72726179), ACE_NTOHL (0x0),  // name = dk_Array
-  14, ACE_NTOHL (0x646b5f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x79000000),  // name = dk_Repository
-  11, ACE_NTOHL (0x646b5f57), ACE_NTOHL (0x73747269), ACE_NTOHL (0x6e670000),  // name = dk_Wstring
-  9, ACE_NTOHL (0x646b5f46), ACE_NTOHL (0x69786564), ACE_NTOHL (0x0),  // name = dk_Fixed
-  9, ACE_NTOHL (0x646b5f56), ACE_NTOHL (0x616c7565), ACE_NTOHL (0x0),  // name = dk_Value
-  12, ACE_NTOHL (0x646b5f56), ACE_NTOHL (0x616c7565), ACE_NTOHL (0x426f7800),  // name = dk_ValueBox
-  15, ACE_NTOHL (0x646b5f56), ACE_NTOHL (0x616c7565), ACE_NTOHL (0x4d656d62), ACE_NTOHL (0x65720000),  // name = dk_ValueMember
-  10, ACE_NTOHL (0x646b5f4e), ACE_NTOHL (0x61746976), ACE_NTOHL (0x65000000),  // name = dk_Native
-  13, ACE_NTOHL (0x646b5f43), ACE_NTOHL (0x6f6d706f), ACE_NTOHL (0x6e656e74), ACE_NTOHL (0x0),  // name = dk_Component
-  8, ACE_NTOHL (0x646b5f48), ACE_NTOHL (0x6f6d6500),  // name = dk_Home
-  11, ACE_NTOHL (0x646b5f46), ACE_NTOHL (0x6163746f), ACE_NTOHL (0x72790000),  // name = dk_Factory
-  10, ACE_NTOHL (0x646b5f46), ACE_NTOHL (0x696e6465), ACE_NTOHL (0x72000000),  // name = dk_Finder
-  14, ACE_NTOHL (0x646b5f50), ACE_NTOHL (0x72696d61), ACE_NTOHL (0x72794b65), ACE_NTOHL (0x79000000),  // name = dk_PrimaryKey
-  9, ACE_NTOHL (0x646b5f45), ACE_NTOHL (0x6d697473), ACE_NTOHL (0x0),  // name = dk_Emits
-  13, ACE_NTOHL (0x646b5f50), ACE_NTOHL (0x75626c69), ACE_NTOHL (0x73686573), ACE_NTOHL (0x0),  // name = dk_Publishes
-  12, ACE_NTOHL (0x646b5f43), ACE_NTOHL (0x6f6e7375), ACE_NTOHL (0x6d657300),  // name = dk_Consumes
-  12, ACE_NTOHL (0x646b5f50), ACE_NTOHL (0x726f7669), ACE_NTOHL (0x64657300),  // name = dk_Provides
-  8, ACE_NTOHL (0x646b5f55), ACE_NTOHL (0x73657300),  // name = dk_Uses
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_DefinitionKind (CORBA::tk_enum, sizeof (_oc_IR_DefinitionKind), (char *) &_oc_IR_DefinitionKind, 0, sizeof (IR_DefinitionKind));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_DefinitionKind, &_tc_TAO_tc_IR_DefinitionKind)
-TAO_NAMESPACE_END
-
-///////////////////////////////////////////////////////////////////////
-//                Base & Remote Proxy  Implementation. 
-//
-
-_TAO_IRObject_Proxy_Impl::_TAO_IRObject_Proxy_Impl (void)
-{}
-
-_TAO_IRObject_Remote_Proxy_Impl::_TAO_IRObject_Remote_Proxy_Impl (void)
-{}
-
-// Remote Implementation of the IDL interface methods
-
-IR_DefinitionKind _TAO_IRObject_Remote_Proxy_Impl::def_kind (
-    CORBA_Object *_collocated_tao_target_,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  
-  IR_DefinitionKind _tao_retval = (IR_DefinitionKind)0;
-  
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), _tao_retval);
-
-  
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_get_def_kind",
-      13,
-      0,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      CORBA_IRObject::TAO_ClientRequestInfo_CORBA_IRObject_def_kind_get ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN  (_tao_retval);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                _tao_retval
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_retval)
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                _tao_retval
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              IR_DefinitionKind  _tao_retval_info = _tao_retval;
-               ri.result (_tao_retval_info);
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN  (_tao_retval);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_retval;
-}
-
-void _TAO_IRObject_Remote_Proxy_Impl::destroy (
-    CORBA_Object *_collocated_tao_target_,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW (CORBA::INTERNAL ());
-
-  
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "destroy",
-      7,
-      0,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      CORBA_IRObject::TAO_ClientRequestInfo_CORBA_IRObject_destroy ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK;
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK;
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK;
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK;
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK;
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)
-              );
-              
-            }
-          
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK;
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK;
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  
-}
-
-
-//
-//            End  Base & Remote  Proxy Implemeentation. 
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//           Remote & Base  Proxy Broker Implementation
-//
-
-_TAO_IRObject_Proxy_Broker::_TAO_IRObject_Proxy_Broker (void)
-{
-}
-
-_TAO_IRObject_Proxy_Broker::~_TAO_IRObject_Proxy_Broker (void)
-{
-}
-
-_TAO_IRObject_Proxy_Broker * (*_TAO_IRObject_Proxy_Broker_Factory_function_pointer) (
-    CORBA::Object_ptr obj
-  ) = 0;
-
-// Factory Member function Implementation.
-_TAO_IRObject_Remote_Proxy_Broker *
-_TAO_IRObject_Remote_Proxy_Broker::the_TAO_IRObject_Remote_Proxy_Broker (void)
-{
-  static ::_TAO_IRObject_Remote_Proxy_Broker remote_proxy_broker;
-  return &remote_proxy_broker;
-}
-_TAO_IRObject_Remote_Proxy_Broker::_TAO_IRObject_Remote_Proxy_Broker (void)
-{
-}
-
-_TAO_IRObject_Remote_Proxy_Broker::~_TAO_IRObject_Remote_Proxy_Broker (void)
-{
-}
-
-_TAO_IRObject_Proxy_Impl&
-_TAO_IRObject_Remote_Proxy_Broker::select_proxy (
-  CORBA_IRObject *object,
-  CORBA::Environment &ACE_TRY_ENV
-)
-{
-  ACE_UNUSED_ARG (object);
-  ACE_UNUSED_ARG (ACE_TRY_ENV);
-  return remote_proxy_impl_;
-}
-
-
-//
-//           End Remote & Base Proxy Broker Implementation
-///////////////////////////////////////////////////////////////////////
-
-
-// default constructor
-CORBA_IRObject::CORBA_IRObject (int collocated)
-{
-  this->CORBA_IRObject_setup_collocation (collocated);
-}
-
-// destructor
-CORBA_IRObject::~CORBA_IRObject (void)
-{}
-
-void
-CORBA_IRObject::CORBA_IRObject_setup_collocation (int collocated)
-{
-  if (collocated)
-    this->the_TAO_IRObject_Proxy_Broker_ =
-      _TAO_IRObject_Proxy_Broker_Factory_function_pointer (this);
-  else
-    this->the_TAO_IRObject_Proxy_Broker_ =
-      _TAO_IRObject_Remote_Proxy_Broker::the_TAO_IRObject_Remote_Proxy_Broker ();    
-}
-
-void CORBA_IRObject::_tao_any_destructor (void *x)
-{
-  CORBA_IRObject *tmp = ACE_static_cast (CORBA_IRObject*,x);
-  CORBA::release (tmp);
-}
-
-CORBA_IRObject_ptr CORBA_IRObject::_narrow (
-    CORBA::Object_ptr obj,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  if (CORBA::is_nil (obj))
-    return CORBA_IRObject::_nil ();
-  if (! obj->_is_local ())
-    {
-      CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/CORBA/IRObject:1.0", ACE_TRY_ENV);
-      ACE_CHECK_RETURN (CORBA_IRObject::_nil ());
-      if (is_a == 0)
-        return CORBA_IRObject::_nil ();
-    }
-  return CORBA_IRObject::_unchecked_narrow (obj, ACE_TRY_ENV);
-}
-
-CORBA_IRObject_ptr CORBA_IRObject::_unchecked_narrow (
-    CORBA::Object_ptr obj,
-    CORBA::Environment &
-  )
-{
-  if (CORBA::is_nil (obj))
-    return CORBA_IRObject::_nil ();
-  if (! obj->_is_local ())
-    {
-      TAO_Stub* stub = obj->_stubobj ();
-      if (stub)
-        stub->_incr_refcnt ();
-      CORBA_IRObject_ptr default_proxy = CORBA_IRObject::_nil ();
-
-      if (
-          !CORBA::is_nil (stub->servant_orb_var ().ptr ()) &&
-          stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects () &&
-          obj->_is_collocated () && _TAO_IRObject_Proxy_Broker_Factory_function_pointer != 0
-        )
-      {
-        ACE_NEW_RETURN (
-          default_proxy,
-          CORBA_IRObject (
-            stub,
-            1,
-            obj->_servant ()),
-            
-          CORBA_IRObject::_nil ());
-        }
-      if (CORBA::is_nil (default_proxy))
-        ACE_NEW_RETURN (default_proxy, CORBA_IRObject (stub, 0, obj->_servant ()), CORBA_IRObject::_nil ());
-        return default_proxy;
-      }
-    else 
-      return
-        ACE_reinterpret_cast
-          (
-            CORBA_IRObject_ptr,
-              obj->_tao_QueryInterface
-                (
-                  ACE_reinterpret_cast
-                    (
-                      ptr_arith_t,
-                      &CORBA_IRObject::_narrow
-                    )
-                )
-          );
-}
-
-CORBA_IRObject_ptr
-CORBA_IRObject::_duplicate (CORBA_IRObject_ptr obj)
-{
-  if (!CORBA::is_nil (obj))
-    obj->_add_ref ();
-  return obj;
-}
-
-CORBA::Boolean CORBA_IRObject::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
-{
-  if (
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
-  return 1; // success using local knowledge
-  else
-    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
-}
-
-void *CORBA_IRObject::_tao_QueryInterface (ptr_arith_t type)
-{
-  void *retv = 0;
-  if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &CORBA_IRObject::_narrow))
-    retv = ACE_reinterpret_cast (void*, this);
-  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
-    retv = ACE_reinterpret_cast (void *,
-      ACE_static_cast (CORBA::Object_ptr, this));
-    
-  if (retv)
-    this->_add_ref ();
-  return retv;
-}
-
-const char* CORBA_IRObject::_interface_repository_id (void) const
-{
-  return "IDL:omg.org/CORBA/IRObject:1.0";
-}
-
-IR_DefinitionKind CORBA_IRObject::def_kind (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_IRObject_Proxy_Impl &proxy = 
-    this->the_TAO_IRObject_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN ((IR_DefinitionKind)0);
-  
-  return proxy.def_kind (
-      this,
-      ACE_TRY_ENV
-    );
-}
-
-void CORBA_IRObject::destroy (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_IRObject_Proxy_Impl &proxy = 
-    this->the_TAO_IRObject_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK;
-  
-  proxy.destroy (
-      this,
-      ACE_TRY_ENV
-    );
-}
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-CORBA_IRObject::TAO_ClientRequestInfo_CORBA_IRObject_def_kind_get::TAO_ClientRequestInfo_CORBA_IRObject_def_kind_get (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
-{}
-
-Dynamic::ParameterList *
-CORBA_IRObject::TAO_ClientRequestInfo_CORBA_IRObject_def_kind_get::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return parameter_list;
-}
-
-Dynamic::ExceptionList *
-CORBA_IRObject::TAO_ClientRequestInfo_CORBA_IRObject_def_kind_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-CORBA_IRObject::TAO_ClientRequestInfo_CORBA_IRObject_def_kind_get::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-CORBA_IRObject::TAO_ClientRequestInfo_CORBA_IRObject_def_kind_get::result (IR_DefinitionKind result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-CORBA_IRObject::TAO_ClientRequestInfo_CORBA_IRObject_destroy::TAO_ClientRequestInfo_CORBA_IRObject_destroy (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
-{}
-
-Dynamic::ParameterList *
-CORBA_IRObject::TAO_ClientRequestInfo_CORBA_IRObject_destroy::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return parameter_list;
-}
-
-Dynamic::ExceptionList *
-CORBA_IRObject::TAO_ClientRequestInfo_CORBA_IRObject_destroy::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-CORBA_IRObject::TAO_ClientRequestInfo_CORBA_IRObject_destroy::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 1;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return result_any;
-}
-
-#endif /* TAO_HAS_INTERCEPTORS */
-
-static const CORBA::Long _oc_IR_Identifier[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
-  11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-  CORBA::tk_alias, // typecode kind for typedefs
-  68, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
-    11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-    CORBA::tk_string,
-    0U, // string length
-
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_Identifier (CORBA::tk_alias, sizeof (_oc_IR_Identifier), (char *) &_oc_IR_Identifier, 0, sizeof (IR::Identifier));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_Identifier, &_tc_TAO_tc_IR_Identifier)
-TAO_NAMESPACE_END
-
-static const CORBA::Long _oc_IR_ScopedName[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f53), ACE_NTOHL (0x636f7065), ACE_NTOHL (0x644e616d), ACE_NTOHL (0x653a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/ScopedName:1.0
-  11, ACE_NTOHL (0x53636f70), ACE_NTOHL (0x65644e61), ACE_NTOHL (0x6d650000),  // name = ScopedName
-  CORBA::tk_alias, // typecode kind for typedefs
-  68, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5363), ACE_NTOHL (0x6f706564), ACE_NTOHL (0x4e616d65), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/ScopedName:1.0
-    11, ACE_NTOHL (0x53636f70), ACE_NTOHL (0x65644e61), ACE_NTOHL (0x6d650000),  // name = ScopedName
-    CORBA::tk_string,
-    0U, // string length
-
-};
-
-static CORBA::TypeCode _tc_TAO_tc_IR_ScopedName (CORBA::tk_alias, sizeof (_oc_IR_ScopedName), (char *) &_oc_IR_ScopedName, 0, sizeof (IR::ScopedName));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ScopedName, &_tc_TAO_tc_IR_ScopedName)
-TAO_NAMESPACE_END
-
-static const CORBA::Long _oc_IR_RepositoryId[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-  13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = IR_RepositoryId
-  CORBA::tk_alias, // typecode kind for typedefs
-  72, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
-    13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = IR_RepositoryId
-    CORBA::tk_string,
-    0U, // string length
-
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_RepositoryId (CORBA::tk_alias, sizeof (_oc_IR_RepositoryId), (char *) &_oc_IR_RepositoryId, 0, sizeof (IR::RepositoryId));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_RepositoryId, &_tc_TAO_tc_IR_RepositoryId)
-TAO_NAMESPACE_END
-
-static const CORBA::Long _oc_IR_VersionSpec[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
-  12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
-  CORBA::tk_string, 
-  0U, // string length
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_VersionSpec (CORBA::tk_alias, sizeof (_oc_IR_VersionSpec), (char *) &_oc_IR_VersionSpec, 0, sizeof (IR::VersionSpec));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_VersionSpec, &_tc_TAO_tc_IR_VersionSpec)
-TAO_NAMESPACE_END
-
-///////////////////////////////////////////////////////////////////////
-//                Base & Remote Proxy  Implementation. 
-//
-
-_TAO_Contained_Proxy_Impl::_TAO_Contained_Proxy_Impl (void)
-{}
-
-_TAO_Contained_Remote_Proxy_Impl::_TAO_Contained_Remote_Proxy_Impl (void)
-{}
-
-// Remote Implementation of the IDL interface methods
-
-char * _TAO_Contained_Remote_Proxy_Impl::id (
-    CORBA_Object *_collocated_tao_target_,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  
-  CORBA::String_var _tao_safe_retval;
-  
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-
-  
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_get_id",
-      7,
-      0,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_Contained::TAO_ClientRequestInfo_IR_Contained_id_get ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              char * _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-void _TAO_Contained_Remote_Proxy_Impl::id (
-    CORBA_Object *_collocated_tao_target_,
-    const char * id,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW (CORBA::INTERNAL ());
-
-  
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_set_id",
-      7,
-      1,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_Contained::TAO_ClientRequestInfo_IR_Contained_id_set ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        id,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK;
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK;
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK;
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK;
-          
-          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-          if (!(
-                            (_tao_out << id)
-            ))
-            TAO_INTERCEPTOR_THROW (
-              CORBA::MARSHAL ()
-            );
-            
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK;
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)
-              );
-              
-            }
-          
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK;
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK;
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  
-}
-
-char * _TAO_Contained_Remote_Proxy_Impl::name (
-    CORBA_Object *_collocated_tao_target_,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{  
-  CORBA::String_var _tao_safe_retval;
-    
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-
-  
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_get_name",
-      9,
-      0,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_Contained::TAO_ClientRequestInfo_IR_Contained_name_get ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              char * _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-void _TAO_Contained_Remote_Proxy_Impl::name (
-    CORBA_Object *_collocated_tao_target_,
-    const char * name,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW (CORBA::INTERNAL ());
-
-  
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_set_name",
-      9,
-      1,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_Contained::TAO_ClientRequestInfo_IR_Contained_name_set ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        name,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK;
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK;
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK;
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK;
-          
-          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-          if (!(
-                            (_tao_out << name)
-            ))
-            TAO_INTERCEPTOR_THROW (
-              CORBA::MARSHAL ()
-            );
-            
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK;
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)
-              );
-              
-            }
-          
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK;
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK;
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  
-}
-
-char * _TAO_Contained_Remote_Proxy_Impl::version (
-    CORBA_Object *_collocated_tao_target_,
-   CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  
-  CORBA::String_var _tao_safe_retval;
-  
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-
-  
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_get_version",
-      12,
-      0,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_Contained::TAO_ClientRequestInfo_IR_Contained_version_get ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              char * _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-void _TAO_Contained_Remote_Proxy_Impl::version (
-    CORBA_Object *_collocated_tao_target_,
-    const char * version,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{ 
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW (CORBA::INTERNAL ());
-  
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_set_version",
-      12,
-      1,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_Contained::TAO_ClientRequestInfo_IR_Contained_version_set ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        version,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK;
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK;
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK;
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK;
-          
-          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-          if (!(
-                            (_tao_out << version)
-            ))
-            TAO_INTERCEPTOR_THROW (
-              CORBA::MARSHAL ()
-            );
-            
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK;
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)
-              );
-              
-            }
-          
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK;
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK;
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  
-}
-
-IR_Container_ptr _TAO_Contained_Remote_Proxy_Impl::defined_in (
-    CORBA_Object *_collocated_tao_target_,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{  
-  IR_Container_ptr _tao_retval = IR_Container::_nil ();
-  IR_Container_var _tao_safe_retval (_tao_retval);
-  
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-  
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_get_defined_in",
-      15,
-      0,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_Contained::TAO_ClientRequestInfo_IR_Contained_defined_in_get ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              IR_Container_ptr _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-char * _TAO_Contained_Remote_Proxy_Impl::absolute_name (
-    CORBA_Object *_collocated_tao_target_,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{  
-  CORBA::String_var _tao_safe_retval;
-    
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-  
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_get_absolute_name",
-      18,
-      0,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_Contained::TAO_ClientRequestInfo_IR_Contained_absolute_name_get ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              char * _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-IR_Repository_ptr _TAO_Contained_Remote_Proxy_Impl::containing_repository (
-    CORBA_Object *_collocated_tao_target_,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{ 
-  IR_Repository_ptr _tao_retval = IR_Repository::_nil ();
-  IR_Repository_var _tao_safe_retval (_tao_retval);
-    
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-  
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_get_containing_repository",
-      26,
-      0,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_Contained::TAO_ClientRequestInfo_IR_Contained_containing_repository_get ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              IR_Repository_ptr _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-IR_Contained::Description * _TAO_Contained_Remote_Proxy_Impl::describe (
-    CORBA_Object *_collocated_tao_target_,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{  
-  IR_Contained::Description *_tao_retval = 0;
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-  
-  ACE_NEW_RETURN (_tao_retval, IR_Contained::Description, _tao_retval);
-  IR_Contained::Description_var _tao_safe_retval (_tao_retval);
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "describe",
-      8,
-      0,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_Contained::TAO_ClientRequestInfo_IR_Contained_describe ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              IR_Contained::Description * _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-void _TAO_Contained_Remote_Proxy_Impl::move (
-    CORBA_Object *_collocated_tao_target_,
-    IR_Container_ptr new_container,
-    const char * new_name,
-    const char * new_version,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW (CORBA::INTERNAL ());
- 
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "move",
-      4,
-      1,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_Contained::TAO_ClientRequestInfo_IR_Contained_move ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        new_container,
-        new_name,
-        new_version,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK;
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK;
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK;
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK;
-          
-          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-          if (!(
-                            (_tao_out << new_container) &&
-              (_tao_out << new_name) &&
-              (_tao_out << new_version)
-            ))
-            TAO_INTERCEPTOR_THROW (
-              CORBA::MARSHAL ()
-            );
-            
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK;
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)
-              );
-              
-            }
-          
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK;
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK;
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  
-}
-
-
-//
-//            End  Base & Remote  Proxy Implemeentation. 
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//           Remote & Base  Proxy Broker Implementation
-//
-
-_TAO_Contained_Proxy_Broker::_TAO_Contained_Proxy_Broker (void)
-{
-}
-
-_TAO_Contained_Proxy_Broker::~_TAO_Contained_Proxy_Broker (void)
-{
-}
-
-_TAO_Contained_Proxy_Broker * (*_TAO_Contained_Proxy_Broker_Factory_function_pointer) (
-    CORBA::Object_ptr obj
-  ) = 0;
-
-// Factory Member function Implementation.
-_TAO_Contained_Remote_Proxy_Broker *
-_TAO_Contained_Remote_Proxy_Broker::the_TAO_Contained_Remote_Proxy_Broker (void)
-{
-  static ::_TAO_Contained_Remote_Proxy_Broker remote_proxy_broker;
-  return &remote_proxy_broker;
-}
-
-_TAO_Contained_Remote_Proxy_Broker::_TAO_Contained_Remote_Proxy_Broker (void)
-{
-}
-
-_TAO_Contained_Remote_Proxy_Broker::~_TAO_Contained_Remote_Proxy_Broker (void)
-{
-}
-
-_TAO_Contained_Proxy_Impl&
-_TAO_Contained_Remote_Proxy_Broker::select_proxy (
-  IR_Contained *object,
-  CORBA::Environment &ACE_TRY_ENV
-)
-{
-  ACE_UNUSED_ARG (object);
-  ACE_UNUSED_ARG (ACE_TRY_ENV);
-  return remote_proxy_impl_;
-}
-
-
-//
-//           End Remote & Base Proxy Broker Implementation
-///////////////////////////////////////////////////////////////////////
-
-
-// default constructor
-IR_Contained::IR_Contained (int collocated)
-{
-  this->IR_Contained_setup_collocation (collocated);
-}
-
-// destructor
-IR_Contained::~IR_Contained (void)
-{}
-
-void
-IR_Contained::IR_Contained_setup_collocation (int collocated)
-{
-  if (collocated)
-    this->the_TAO_Contained_Proxy_Broker_ =
-      _TAO_Contained_Proxy_Broker_Factory_function_pointer (this);
-  else
-    this->the_TAO_Contained_Proxy_Broker_ =
-      _TAO_Contained_Remote_Proxy_Broker::the_TAO_Contained_Remote_Proxy_Broker ();
-  
-  this->CORBA_IRObject_setup_collocation (collocated);
-}
-
-void IR_Contained::_tao_any_destructor (void *x)
-{
-  IR_Contained *tmp = ACE_static_cast (IR_Contained*,x);
-  CORBA::release (tmp);
-}
-
-IR_Contained_ptr IR_Contained::_narrow (
-    CORBA::Object_ptr obj,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  if (CORBA::is_nil (obj))
-    return IR_Contained::_nil ();
-  if (! obj->_is_local ())
-    {
-      CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/IR/Contained:1.0", ACE_TRY_ENV);
-      ACE_CHECK_RETURN (IR_Contained::_nil ());
-      if (is_a == 0)
-        return IR_Contained::_nil ();
-    }
-  return IR_Contained::_unchecked_narrow (obj, ACE_TRY_ENV);
-}
-
-IR_Contained_ptr IR_Contained::_unchecked_narrow (
-    CORBA::Object_ptr obj,
-    CORBA::Environment &
-  )
-{
-  if (CORBA::is_nil (obj))
-    return IR_Contained::_nil ();
-  if (! obj->_is_local ())
-    {
-      TAO_Stub* stub = obj->_stubobj ();
-      if (stub)
-        stub->_incr_refcnt ();
-      IR_Contained_ptr default_proxy = IR_Contained::_nil ();
-
-      if (
-          !CORBA::is_nil (stub->servant_orb_var ().ptr ()) &&
-          stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects () &&
-          obj->_is_collocated () &&_TAO_Contained_Proxy_Broker_Factory_function_pointer != 0
-        )
-      {
-        ACE_NEW_RETURN (
-          default_proxy,
-          IR_Contained (
-            stub,
-            1,
-            obj->_servant ()),
-            
-          IR_Contained::_nil ());
-        }
-      if (CORBA::is_nil (default_proxy))
-        ACE_NEW_RETURN (default_proxy, IR_Contained (stub, 0, obj->_servant ()), IR_Contained::_nil ());
-        return default_proxy;
-      }
-    else 
-      return
-        ACE_reinterpret_cast
-          (
-            IR_Contained_ptr,
-              obj->_tao_QueryInterface
-                (
-                  ACE_reinterpret_cast
-                    (
-                      ptr_arith_t,
-                      &IR_Contained::_narrow
-                    )
-                )
-          );
-}
-
-IR_Contained_ptr
-IR_Contained::_duplicate (IR_Contained_ptr obj)
-{
-  if (!CORBA::is_nil (obj))
-    obj->_add_ref ();
-  return obj;
-}
-
-CORBA::Boolean IR_Contained::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
-{
-  if (
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/Contained:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
-  return 1; // success using local knowledge
-  else
-    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
-}
-
-void *IR_Contained::_tao_QueryInterface (ptr_arith_t type)
-{
-  void *retv = 0;
-  if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_Contained::_narrow))
-    retv = ACE_reinterpret_cast (void*, this);
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &CORBA_IRObject::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            CORBA_IRObject_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
-    retv = ACE_reinterpret_cast (void *,
-      ACE_static_cast (CORBA::Object_ptr, this));
-    
-  if (retv)
-    this->_add_ref ();
-  return retv;
-}
-
-const char* IR_Contained::_interface_repository_id (void) const
-{
-  return "IDL:omg.org/IR/Contained:1.0";
-}
-
-char * IR_Contained::id (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{  
-  _TAO_Contained_Proxy_Impl &proxy = 
-    this->the_TAO_Contained_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.id (
-      this,
-      ACE_TRY_ENV
-    );
-}
-
-void IR_Contained::id (
-    const char * id,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{  
-  _TAO_Contained_Proxy_Impl &proxy = 
-    this->the_TAO_Contained_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK;
-  
-  proxy.id (
-      this,
-      id,
-      ACE_TRY_ENV
-    );
-}
-
-char * IR_Contained::name (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_Contained_Proxy_Impl &proxy = 
-    this->the_TAO_Contained_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.name (
-      this,
-      ACE_TRY_ENV
-    );
-}
-
-void IR_Contained::name (
-    const char * name,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{  
-  _TAO_Contained_Proxy_Impl &proxy = 
-    this->the_TAO_Contained_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK;
-  
-  proxy.name (
-      this,
-      name,
-      ACE_TRY_ENV
-    );
-}
-
-char * IR_Contained::version (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{  
-  _TAO_Contained_Proxy_Impl &proxy = 
-    this->the_TAO_Contained_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.version (
-      this,
-      ACE_TRY_ENV
-    );
-}
-
-void IR_Contained::version (
-    const char * version,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{  
-  _TAO_Contained_Proxy_Impl &proxy = 
-    this->the_TAO_Contained_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK;
-  
-  proxy.version (
-      this,
-      version,
-      ACE_TRY_ENV
-    );
-}
-
-IR_Container_ptr IR_Contained::defined_in (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{  
-  _TAO_Contained_Proxy_Impl &proxy = 
-    this->the_TAO_Contained_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.defined_in (
-      this,
-      ACE_TRY_ENV
-    );
-}
-
-char * IR_Contained::absolute_name (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{  
-  _TAO_Contained_Proxy_Impl &proxy = 
-    this->the_TAO_Contained_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.absolute_name (
-      this,
-      ACE_TRY_ENV
-    );
-}
-
-IR_Repository_ptr IR_Contained::containing_repository (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{  
-  _TAO_Contained_Proxy_Impl &proxy = 
-    this->the_TAO_Contained_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.containing_repository (
-      this,
-      ACE_TRY_ENV
-    );
-}
-
-static const CORBA::Long _oc_IR_Contained_Description[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  41, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f43), ACE_NTOHL (0x6f6e7461), ACE_NTOHL (0x696e6564), ACE_NTOHL (0x2f446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/Contained/Description:1.0
-  12, ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e00),  // name = Description
-  2, // member count
-  5, ACE_NTOHL (0x6b696e64), ACE_NTOHL (0x0),  // name = kind
-  CORBA::tk_enum, // typecode kind
-  632, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    34, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f44), ACE_NTOHL (0x6566696e), ACE_NTOHL (0x6974696f), ACE_NTOHL (0x6e4b696e), ACE_NTOHL (0x643a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/DefinitionKind:1.0
-    15, ACE_NTOHL (0x44656669), ACE_NTOHL (0x6e697469), ACE_NTOHL (0x6f6e4b69), ACE_NTOHL (0x6e640000),  // name = DefinitionKind
-    34, // member count
-    8, ACE_NTOHL (0x646b5f6e), ACE_NTOHL (0x6f6e6500),  // name = dk_none
-    7, ACE_NTOHL (0x646b5f61), ACE_NTOHL (0x6c6c0000),  // name = dk_all
-    13, ACE_NTOHL (0x646b5f41), ACE_NTOHL (0x74747269), ACE_NTOHL (0x62757465), ACE_NTOHL (0x0),  // name = dk_Attribute
-    12, ACE_NTOHL (0x646b5f43), ACE_NTOHL (0x6f6e7374), ACE_NTOHL (0x616e7400),  // name = dk_Constant
-    13, ACE_NTOHL (0x646b5f45), ACE_NTOHL (0x78636570), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = dk_Exception
-    13, ACE_NTOHL (0x646b5f49), ACE_NTOHL (0x6e746572), ACE_NTOHL (0x66616365), ACE_NTOHL (0x0),  // name = dk_Interface
-    10, ACE_NTOHL (0x646b5f4d), ACE_NTOHL (0x6f64756c), ACE_NTOHL (0x65000000),  // name = dk_Module
-    13, ACE_NTOHL (0x646b5f4f), ACE_NTOHL (0x70657261), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = dk_Operation
-    11, ACE_NTOHL (0x646b5f54), ACE_NTOHL (0x79706564), ACE_NTOHL (0x65660000),  // name = dk_Typedef
-    9, ACE_NTOHL (0x646b5f41), ACE_NTOHL (0x6c696173), ACE_NTOHL (0x0),  // name = dk_Alias
-    10, ACE_NTOHL (0x646b5f53), ACE_NTOHL (0x74727563), ACE_NTOHL (0x74000000),  // name = dk_Struct
-    9, ACE_NTOHL (0x646b5f55), ACE_NTOHL (0x6e696f6e), ACE_NTOHL (0x0),  // name = dk_Union
-    8, ACE_NTOHL (0x646b5f45), ACE_NTOHL (0x6e756d00),  // name = dk_Enum
-    13, ACE_NTOHL (0x646b5f50), ACE_NTOHL (0x72696d69), ACE_NTOHL (0x74697665), ACE_NTOHL (0x0),  // name = dk_Primitive
-    10, ACE_NTOHL (0x646b5f53), ACE_NTOHL (0x7472696e), ACE_NTOHL (0x67000000),  // name = dk_String
-    12, ACE_NTOHL (0x646b5f53), ACE_NTOHL (0x65717565), ACE_NTOHL (0x6e636500),  // name = dk_Sequence
-    9, ACE_NTOHL (0x646b5f41), ACE_NTOHL (0x72726179), ACE_NTOHL (0x0),  // name = dk_Array
-    14, ACE_NTOHL (0x646b5f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x79000000),  // name = dk_Repository
-    11, ACE_NTOHL (0x646b5f57), ACE_NTOHL (0x73747269), ACE_NTOHL (0x6e670000),  // name = dk_Wstring
-    9, ACE_NTOHL (0x646b5f46), ACE_NTOHL (0x69786564), ACE_NTOHL (0x0),  // name = dk_Fixed
-    9, ACE_NTOHL (0x646b5f56), ACE_NTOHL (0x616c7565), ACE_NTOHL (0x0),  // name = dk_Value
-    12, ACE_NTOHL (0x646b5f56), ACE_NTOHL (0x616c7565), ACE_NTOHL (0x426f7800),  // name = dk_ValueBox
-    15, ACE_NTOHL (0x646b5f56), ACE_NTOHL (0x616c7565), ACE_NTOHL (0x4d656d62), ACE_NTOHL (0x65720000),  // name = dk_ValueMember
-    10, ACE_NTOHL (0x646b5f4e), ACE_NTOHL (0x61746976), ACE_NTOHL (0x65000000),  // name = dk_Native
-    13, ACE_NTOHL (0x646b5f43), ACE_NTOHL (0x6f6d706f), ACE_NTOHL (0x6e656e74), ACE_NTOHL (0x0),  // name = dk_Component
-    8, ACE_NTOHL (0x646b5f48), ACE_NTOHL (0x6f6d6500),  // name = dk_Home
-    11, ACE_NTOHL (0x646b5f46), ACE_NTOHL (0x6163746f), ACE_NTOHL (0x72790000),  // name = dk_Factory
-    10, ACE_NTOHL (0x646b5f46), ACE_NTOHL (0x696e6465), ACE_NTOHL (0x72000000),  // name = dk_Finder
-    14, ACE_NTOHL (0x646b5f50), ACE_NTOHL (0x72696d61), ACE_NTOHL (0x72794b65), ACE_NTOHL (0x79000000),  // name = dk_PrimaryKey
-    9, ACE_NTOHL (0x646b5f45), ACE_NTOHL (0x6d697473), ACE_NTOHL (0x0),  // name = dk_Emits
-    13, ACE_NTOHL (0x646b5f50), ACE_NTOHL (0x75626c69), ACE_NTOHL (0x73686573), ACE_NTOHL (0x0),  // name = dk_Publishes
-    12, ACE_NTOHL (0x646b5f43), ACE_NTOHL (0x6f6e7375), ACE_NTOHL (0x6d657300),  // name = dk_Consumes
-    12, ACE_NTOHL (0x646b5f50), ACE_NTOHL (0x726f7669), ACE_NTOHL (0x64657300),  // name = dk_Provides
-    8, ACE_NTOHL (0x646b5f55), ACE_NTOHL (0x73657300),  // name = dk_Uses
-
-  6, ACE_NTOHL (0x76616c75), ACE_NTOHL (0x65000000),  // name = value
-  CORBA::tk_any,
-
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_Contained_Description (CORBA::tk_struct, sizeof (_oc_IR_Contained_Description), (char *) &_oc_IR_Contained_Description, 0, sizeof (IR_Contained::Description));
-CORBA::TypeCode_ptr IR_Contained::_tc_Description = &_tc_TAO_tc_IR_Contained_Description;
-
-void IR_Contained::Description::_tao_any_destructor (void *x)
-{
-  Description *tmp = ACE_static_cast (Description*,x);
-  delete tmp;
-}
-
-IR_Contained::Description * IR_Contained::describe (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{  
-  _TAO_Contained_Proxy_Impl &proxy = 
-    this->the_TAO_Contained_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.describe (
-      this,
-      ACE_TRY_ENV
-    );
-}
-
-void IR_Contained::move (
-    IR_Container_ptr new_container,
-    const char * new_name,
-    const char * new_version,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{  
-  _TAO_Contained_Proxy_Impl &proxy = 
-    this->the_TAO_Contained_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK;
-  
-  proxy.move (
-      this,
-      new_container,
-      new_name,
-      new_version,
-      ACE_TRY_ENV
-    );
-}
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-IR_Contained::TAO_ClientRequestInfo_IR_Contained_id_get::TAO_ClientRequestInfo_IR_Contained_id_get (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
-{}
-
-Dynamic::ParameterList *
-IR_Contained::TAO_ClientRequestInfo_IR_Contained_id_get::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return parameter_list;
-}
-
-Dynamic::ExceptionList *
-IR_Contained::TAO_ClientRequestInfo_IR_Contained_id_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_Contained::TAO_ClientRequestInfo_IR_Contained_id_get::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_Contained::TAO_ClientRequestInfo_IR_Contained_id_get::result (char * result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_Contained::TAO_ClientRequestInfo_IR_Contained_id_set::TAO_ClientRequestInfo_IR_Contained_id_set (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    const char * id,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
-    id_ (id)
-{}
-
-Dynamic::ParameterList *
-IR_Contained::TAO_ClientRequestInfo_IR_Contained_id_set::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
-    
-  CORBA::ULong length_id = parameter_list->length ();
-  parameter_list->length (length_id + 1);
-  (*parameter_list)[length_id].argument <<= id_;
-  (*parameter_list)[length_id].mode = Dynamic::PARAM_IN;
-  
-  return safe_parameter_list._retn ();
-}
-
-Dynamic::ExceptionList *
-IR_Contained::TAO_ClientRequestInfo_IR_Contained_id_set::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_Contained::TAO_ClientRequestInfo_IR_Contained_id_set::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 1;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return result_any;
-}
-
-IR_Contained::TAO_ClientRequestInfo_IR_Contained_name_get::TAO_ClientRequestInfo_IR_Contained_name_get (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
-{}
-
-Dynamic::ParameterList *
-IR_Contained::TAO_ClientRequestInfo_IR_Contained_name_get::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return parameter_list;
-}
-
-Dynamic::ExceptionList *
-IR_Contained::TAO_ClientRequestInfo_IR_Contained_name_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_Contained::TAO_ClientRequestInfo_IR_Contained_name_get::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_Contained::TAO_ClientRequestInfo_IR_Contained_name_get::result (char * result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_Contained::TAO_ClientRequestInfo_IR_Contained_name_set::TAO_ClientRequestInfo_IR_Contained_name_set (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    const char * name,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
-    name_ (name)
-{}
-
-Dynamic::ParameterList *
-IR_Contained::TAO_ClientRequestInfo_IR_Contained_name_set::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
-    
-  CORBA::ULong length_name = parameter_list->length ();
-  parameter_list->length (length_name + 1);
-  (*parameter_list)[length_name].argument <<= name_;
-  (*parameter_list)[length_name].mode = Dynamic::PARAM_IN;
-  
-  return safe_parameter_list._retn ();
-}
-
-Dynamic::ExceptionList *
-IR_Contained::TAO_ClientRequestInfo_IR_Contained_name_set::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_Contained::TAO_ClientRequestInfo_IR_Contained_name_set::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 1;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return result_any;
-}
-
-IR_Contained::TAO_ClientRequestInfo_IR_Contained_version_get::TAO_ClientRequestInfo_IR_Contained_version_get (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
-{}
-
-Dynamic::ParameterList *
-IR_Contained::TAO_ClientRequestInfo_IR_Contained_version_get::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return parameter_list;
-}
-
-Dynamic::ExceptionList *
-IR_Contained::TAO_ClientRequestInfo_IR_Contained_version_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_Contained::TAO_ClientRequestInfo_IR_Contained_version_get::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_Contained::TAO_ClientRequestInfo_IR_Contained_version_get::result (char * result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_Contained::TAO_ClientRequestInfo_IR_Contained_version_set::TAO_ClientRequestInfo_IR_Contained_version_set (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    const char * version,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
-    version_ (version)
-{}
-
-Dynamic::ParameterList *
-IR_Contained::TAO_ClientRequestInfo_IR_Contained_version_set::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
-    
-  CORBA::ULong length_version = parameter_list->length ();
-  parameter_list->length (length_version + 1);
-  (*parameter_list)[length_version].argument <<= version_;
-  (*parameter_list)[length_version].mode = Dynamic::PARAM_IN;
-  
-  return safe_parameter_list._retn ();
-}
-
-Dynamic::ExceptionList *
-IR_Contained::TAO_ClientRequestInfo_IR_Contained_version_set::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_Contained::TAO_ClientRequestInfo_IR_Contained_version_set::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 1;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return result_any;
-}
-
-IR_Contained::TAO_ClientRequestInfo_IR_Contained_defined_in_get::TAO_ClientRequestInfo_IR_Contained_defined_in_get (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
-{}
-
-Dynamic::ParameterList *
-IR_Contained::TAO_ClientRequestInfo_IR_Contained_defined_in_get::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return parameter_list;
-}
-
-Dynamic::ExceptionList *
-IR_Contained::TAO_ClientRequestInfo_IR_Contained_defined_in_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_Contained::TAO_ClientRequestInfo_IR_Contained_defined_in_get::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_Contained::TAO_ClientRequestInfo_IR_Contained_defined_in_get::result (IR_Container_ptr result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_Contained::TAO_ClientRequestInfo_IR_Contained_absolute_name_get::TAO_ClientRequestInfo_IR_Contained_absolute_name_get (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
-{}
-
-Dynamic::ParameterList *
-IR_Contained::TAO_ClientRequestInfo_IR_Contained_absolute_name_get::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return parameter_list;
-}
-
-Dynamic::ExceptionList *
-IR_Contained::TAO_ClientRequestInfo_IR_Contained_absolute_name_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_Contained::TAO_ClientRequestInfo_IR_Contained_absolute_name_get::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_Contained::TAO_ClientRequestInfo_IR_Contained_absolute_name_get::result (char * result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_Contained::TAO_ClientRequestInfo_IR_Contained_containing_repository_get::TAO_ClientRequestInfo_IR_Contained_containing_repository_get (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
-{}
-
-Dynamic::ParameterList *
-IR_Contained::TAO_ClientRequestInfo_IR_Contained_containing_repository_get::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return parameter_list;
-}
-
-Dynamic::ExceptionList *
-IR_Contained::TAO_ClientRequestInfo_IR_Contained_containing_repository_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_Contained::TAO_ClientRequestInfo_IR_Contained_containing_repository_get::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_Contained::TAO_ClientRequestInfo_IR_Contained_containing_repository_get::result (IR_Repository_ptr result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_Contained::TAO_ClientRequestInfo_IR_Contained_describe::TAO_ClientRequestInfo_IR_Contained_describe (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
-{}
-
-Dynamic::ParameterList *
-IR_Contained::TAO_ClientRequestInfo_IR_Contained_describe::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return parameter_list;
-}
-
-Dynamic::ExceptionList *
-IR_Contained::TAO_ClientRequestInfo_IR_Contained_describe::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_Contained::TAO_ClientRequestInfo_IR_Contained_describe::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_Contained::TAO_ClientRequestInfo_IR_Contained_describe::result (ACE_NESTED_CLASS (IR_Contained,Description) * result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_Contained::TAO_ClientRequestInfo_IR_Contained_move::TAO_ClientRequestInfo_IR_Contained_move (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    IR_Container_ptr new_container,
-    const char * new_name,
-    const char * new_version,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
-    new_container_ (new_container),
-    new_name_ (new_name),
-    new_version_ (new_version)
-{}
-
-Dynamic::ParameterList *
-IR_Contained::TAO_ClientRequestInfo_IR_Contained_move::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
-    
-  CORBA::ULong length_new_container = parameter_list->length ();
-  parameter_list->length (length_new_container + 1);
-  (*parameter_list)[length_new_container].argument <<=  this->new_container_;
-  
-  (*parameter_list)[length_new_container].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_new_name = parameter_list->length ();
-  parameter_list->length (length_new_name + 1);
-  (*parameter_list)[length_new_name].argument <<= new_name_;
-  (*parameter_list)[length_new_name].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_new_version = parameter_list->length ();
-  parameter_list->length (length_new_version + 1);
-  (*parameter_list)[length_new_version].argument <<= new_version_;
-  (*parameter_list)[length_new_version].mode = Dynamic::PARAM_IN;
-  
-  return safe_parameter_list._retn ();
-}
-
-Dynamic::ExceptionList *
-IR_Contained::TAO_ClientRequestInfo_IR_Contained_move::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_Contained::TAO_ClientRequestInfo_IR_Contained_move::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 1;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return result_any;
-}
-
-#endif /* TAO_HAS_INTERCEPTORS */
-
-static const CORBA::Long _oc_IR_Contained[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  29, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f43), ACE_NTOHL (0x6f6e7461), ACE_NTOHL (0x696e6564), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/Contained:1.0
-  10, ACE_NTOHL (0x436f6e74), ACE_NTOHL (0x61696e65), ACE_NTOHL (0x64000000),  // name = IR_Contained
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_Contained (CORBA::tk_objref, sizeof (_oc_IR_Contained), (char *) &_oc_IR_Contained, 0, sizeof (IR_Contained));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_Contained, &_tc_TAO_tc_IR_Contained)
-TAO_NAMESPACE_END
-
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  
-  // The Base_Sequence functions, please see tao/Sequence.h
-  void
-  _TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq::_allocate_buffer (CORBA::ULong length)
-  {
-    IR_InterfaceDef **tmp = 0;
-    tmp = _TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq::allocbuf (length);
-    
-    if (this->buffer_ != 0)
-    {
-      IR_InterfaceDef **old = ACE_reinterpret_cast (IR_InterfaceDef**, this->buffer_);
-      for (CORBA::ULong i = 0; i < this->length_; ++i)
-        if (!this->release_)
-          tmp[i] = IR_InterfaceDef::_duplicate (old[i]);
-        else
-          tmp[i] = old[i];
-        
-      if (this->release_)
-        delete[] old;
-      
-    }
-    this->buffer_ = tmp;
-  }
-  
-  void
-  _TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq::_deallocate_buffer (void)
-  {
-    if (this->buffer_ == 0 || this->release_ == 0)
-      return;
-    IR_InterfaceDef **tmp = ACE_reinterpret_cast (IR_InterfaceDef**, this->buffer_);
-    for (CORBA::ULong i = 0; i < this->length_; ++i)
-    {
-      CORBA::release (tmp[i]);
-      tmp[i] = IR_InterfaceDef::_nil ();
-    }
-    _TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq::freebuf (tmp);
-    this->buffer_ = 0;
-  }
-  
-  _TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq::~_TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq (void)
-  {
-    this->_deallocate_buffer ();
-  }
-  
-  void
-  _TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq::_shrink_buffer (CORBA::ULong nl, CORBA::ULong ol)
-  {
-    IR_InterfaceDef **tmp = ACE_reinterpret_cast (IR_InterfaceDef**, this->buffer_);
-    
-    for (CORBA::ULong i = nl; i < ol; ++i)
-    {
-      CORBA::release (tmp[i]);
-      tmp[i] = IR_InterfaceDef::_nil ();
-    }
-  }
-  void 
-  _TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq::_downcast (
-      void* target,
-      CORBA_Object *src,
-      CORBA_Environment &ACE_TRY_ENV
-    )
-  {
-    IR_InterfaceDef **tmp = ACE_static_cast (IR_InterfaceDef**, target);
-    *tmp = IR_InterfaceDef::_narrow (src, ACE_TRY_ENV);
-  }
-
-  CORBA_Object*
-  _TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq::_upcast (void *src) const
-  {
-    IR_InterfaceDef **tmp = ACE_static_cast (IR_InterfaceDef**, src);
-    return *tmp;
-  }
-  
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
-
-// *************************************************************
-// IR_InterfaceDefSeq
-// *************************************************************
-
-IR_InterfaceDefSeq::IR_InterfaceDefSeq (void)
-{}
-IR_InterfaceDefSeq::IR_InterfaceDefSeq (CORBA::ULong max) // uses max size
-  : 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Object_Sequence<IR_InterfaceDef,IR_InterfaceDef_var>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
- (max)
-{}
-IR_InterfaceDefSeq::IR_InterfaceDefSeq (CORBA::ULong max, CORBA::ULong length, IR_InterfaceDef_ptr *buffer, CORBA::Boolean release)
-  : 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Object_Sequence<IR_InterfaceDef,IR_InterfaceDef_var>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
- (max, length, buffer, release)
-{}
-IR_InterfaceDefSeq::IR_InterfaceDefSeq (const IR_InterfaceDefSeq &seq) // copy ctor
-  : 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Object_Sequence<IR_InterfaceDef,IR_InterfaceDef_var>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
- (seq)
-{}
-IR_InterfaceDefSeq::~IR_InterfaceDefSeq (void) // dtor
-{}
-void IR_InterfaceDefSeq::_tao_any_destructor (void *x)
-{
-  IR_InterfaceDefSeq *tmp = ACE_static_cast (IR_InterfaceDefSeq*,x);
-  delete tmp;
-}
-
-static const CORBA::Long _oc_IR_InterfaceDefSeq[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x6e746572), ACE_NTOHL (0x66616365), ACE_NTOHL (0x44656653), ACE_NTOHL (0x65713a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/InterfaceDefSeq:1.0
-  16, ACE_NTOHL (0x496e7465), ACE_NTOHL (0x72666163), ACE_NTOHL (0x65446566), ACE_NTOHL (0x53657100),  // name = IR_InterfaceDefSeq
-  CORBA::tk_sequence, // typecode kind
-  76, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    CORBA::tk_objref, // typecode kind
-    60, // encapsulation length
-      TAO_ENCAP_BYTE_ORDER, // byte order
-      32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x6e746572), ACE_NTOHL (0x66616365), ACE_NTOHL (0x4465663a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/InterfaceDef:1.0
-      13, ACE_NTOHL (0x496e7465), ACE_NTOHL (0x72666163), ACE_NTOHL (0x65446566), ACE_NTOHL (0x0),  // name = IR_InterfaceDef
-
-    0U,
-
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_InterfaceDefSeq (CORBA::tk_alias, sizeof (_oc_IR_InterfaceDefSeq), (char *) &_oc_IR_InterfaceDefSeq, 0, sizeof (IR_InterfaceDefSeq));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_InterfaceDefSeq, &_tc_TAO_tc_IR_InterfaceDefSeq)
-TAO_NAMESPACE_END
-
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  
-  // The Base_Sequence functions, please see tao/Sequence.h
-  void
-  _TAO_Unbounded_Object_Sequence_IR_ValueDefSeq::_allocate_buffer (CORBA::ULong length)
-  {
-    IR_ValueDef **tmp = 0;
-    tmp = _TAO_Unbounded_Object_Sequence_IR_ValueDefSeq::allocbuf (length);
-    
-    if (this->buffer_ != 0)
-    {
-      IR_ValueDef **old = ACE_reinterpret_cast (IR_ValueDef**, this->buffer_);
-      for (CORBA::ULong i = 0; i < this->length_; ++i)
-        if (!this->release_)
-          tmp[i] = IR_ValueDef::_duplicate (old[i]);
-        else
-          tmp[i] = old[i];
-        
-      if (this->release_)
-        delete[] old;
-      
-    }
-    this->buffer_ = tmp;
-  }
-  
-  void
-  _TAO_Unbounded_Object_Sequence_IR_ValueDefSeq::_deallocate_buffer (void)
-  {
-    if (this->buffer_ == 0 || this->release_ == 0)
-      return;
-    IR_ValueDef **tmp = ACE_reinterpret_cast (IR_ValueDef**, this->buffer_);
-    for (CORBA::ULong i = 0; i < this->length_; ++i)
-    {
-      CORBA::release (tmp[i]);
-      tmp[i] = IR_ValueDef::_nil ();
-    }
-    _TAO_Unbounded_Object_Sequence_IR_ValueDefSeq::freebuf (tmp);
-    this->buffer_ = 0;
-  }
-  
-  _TAO_Unbounded_Object_Sequence_IR_ValueDefSeq::~_TAO_Unbounded_Object_Sequence_IR_ValueDefSeq (void)
-  {
-    this->_deallocate_buffer ();
-  }
-  
-  void
-  _TAO_Unbounded_Object_Sequence_IR_ValueDefSeq::_shrink_buffer (CORBA::ULong nl, CORBA::ULong ol)
-  {
-    IR_ValueDef **tmp = ACE_reinterpret_cast (IR_ValueDef**, this->buffer_);
-    
-    for (CORBA::ULong i = nl; i < ol; ++i)
-    {
-      CORBA::release (tmp[i]);
-      tmp[i] = IR_ValueDef::_nil ();
-    }
-  }
-  void 
-  _TAO_Unbounded_Object_Sequence_IR_ValueDefSeq::_downcast (
-      void* target,
-      CORBA_Object *src,
-      CORBA_Environment &ACE_TRY_ENV
-    )
-  {
-    IR_ValueDef **tmp = ACE_static_cast (IR_ValueDef**, target);
-    *tmp = IR_ValueDef::_narrow (src, ACE_TRY_ENV);
-  }
-
-  CORBA_Object*
-  _TAO_Unbounded_Object_Sequence_IR_ValueDefSeq::_upcast (void *src) const
-  {
-    IR_ValueDef **tmp = ACE_static_cast (IR_ValueDef**, src);
-    return *tmp;
-  }
-  
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
-
-// *************************************************************
-// IR_ValueDefSeq
-// *************************************************************
-
-IR_ValueDefSeq::IR_ValueDefSeq (void)
-{}
-IR_ValueDefSeq::IR_ValueDefSeq (CORBA::ULong max) // uses max size
-  : 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Object_Sequence_IR_ValueDefSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Object_Sequence<IR_ValueDef,IR_ValueDef_var>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
- (max)
-{}
-IR_ValueDefSeq::IR_ValueDefSeq (CORBA::ULong max, CORBA::ULong length, IR_ValueDef_ptr *buffer, CORBA::Boolean release)
-  : 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Object_Sequence_IR_ValueDefSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Object_Sequence<IR_ValueDef,IR_ValueDef_var>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
- (max, length, buffer, release)
-{}
-IR_ValueDefSeq::IR_ValueDefSeq (const IR_ValueDefSeq &seq) // copy ctor
-  : 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Object_Sequence_IR_ValueDefSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Object_Sequence<IR_ValueDef,IR_ValueDef_var>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
- (seq)
-{}
-IR_ValueDefSeq::~IR_ValueDefSeq (void) // dtor
-{}
-void IR_ValueDefSeq::_tao_any_destructor (void *x)
-{
-  IR_ValueDefSeq *tmp = ACE_static_cast (IR_ValueDefSeq*,x);
-  delete tmp;
-}
-
-static const CORBA::Long _oc_IR_ValueDefSeq[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x616c7565), ACE_NTOHL (0x44656653), ACE_NTOHL (0x65713a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/ValueDefSeq:1.0
-  12, ACE_NTOHL (0x56616c75), ACE_NTOHL (0x65446566), ACE_NTOHL (0x53657100),  // name = IR_ValueDefSeq
-  CORBA::tk_sequence, // typecode kind
-  68, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    CORBA::tk_objref, // typecode kind
-    52, // encapsulation length
-      TAO_ENCAP_BYTE_ORDER, // byte order
-      28, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x616c7565), ACE_NTOHL (0x4465663a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ValueDef:1.0
-      9, ACE_NTOHL (0x56616c75), ACE_NTOHL (0x65446566), ACE_NTOHL (0x0),  // name = IR_ValueDef
-
-    0U,
-
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_ValueDefSeq (CORBA::tk_alias, sizeof (_oc_IR_ValueDefSeq), (char *) &_oc_IR_ValueDefSeq, 0, sizeof (IR_ValueDefSeq));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ValueDefSeq, &_tc_TAO_tc_IR_ValueDefSeq)
-TAO_NAMESPACE_END
-
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  
-  // The Base_Sequence functions, please see tao/Sequence.h
-  void
-  _TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq::_allocate_buffer (CORBA::ULong length)
-  {
-    IR_ComponentDef **tmp = 0;
-    tmp = _TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq::allocbuf (length);
-    
-    if (this->buffer_ != 0)
-    {
-      IR_ComponentDef **old = ACE_reinterpret_cast (IR_ComponentDef**, this->buffer_);
-      for (CORBA::ULong i = 0; i < this->length_; ++i)
-        if (!this->release_)
-          tmp[i] = IR_ComponentDef::_duplicate (old[i]);
-        else
-          tmp[i] = old[i];
-        
-      if (this->release_)
-        delete[] old;
-      
-    }
-    this->buffer_ = tmp;
-  }
-  
-  void
-  _TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq::_deallocate_buffer (void)
-  {
-    if (this->buffer_ == 0 || this->release_ == 0)
-      return;
-    IR_ComponentDef **tmp = ACE_reinterpret_cast (IR_ComponentDef**, this->buffer_);
-    for (CORBA::ULong i = 0; i < this->length_; ++i)
-    {
-      CORBA::release (tmp[i]);
-      tmp[i] = IR_ComponentDef::_nil ();
-    }
-    _TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq::freebuf (tmp);
-    this->buffer_ = 0;
-  }
-  
-  _TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq::~_TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq (void)
-  {
-    this->_deallocate_buffer ();
-  }
-  
-  void
-  _TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq::_shrink_buffer (CORBA::ULong nl, CORBA::ULong ol)
-  {
-    IR_ComponentDef **tmp = ACE_reinterpret_cast (IR_ComponentDef**, this->buffer_);
-    
-    for (CORBA::ULong i = nl; i < ol; ++i)
-    {
-      CORBA::release (tmp[i]);
-      tmp[i] = IR_ComponentDef::_nil ();
-    }
-  }
-  void 
-  _TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq::_downcast (
-      void* target,
-      CORBA_Object *src,
-      CORBA_Environment &ACE_TRY_ENV
-    )
-  {
-    IR_ComponentDef **tmp = ACE_static_cast (IR_ComponentDef**, target);
-    *tmp = IR_ComponentDef::_narrow (src, ACE_TRY_ENV);
-  }
-
-  CORBA_Object*
-  _TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq::_upcast (void *src) const
-  {
-    IR_ComponentDef **tmp = ACE_static_cast (IR_ComponentDef**, src);
-    return *tmp;
-  }
-  
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
-
-// *************************************************************
-// IR_ComponentDefSeq
-// *************************************************************
-
-IR_ComponentDefSeq::IR_ComponentDefSeq (void)
-{}
-IR_ComponentDefSeq::IR_ComponentDefSeq (CORBA::ULong max) // uses max size
-  : 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Object_Sequence<IR_ComponentDef,IR_ComponentDef_var>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
- (max)
-{}
-IR_ComponentDefSeq::IR_ComponentDefSeq (CORBA::ULong max, CORBA::ULong length, IR_ComponentDef_ptr *buffer, CORBA::Boolean release)
-  : 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Object_Sequence<IR_ComponentDef,IR_ComponentDef_var>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
- (max, length, buffer, release)
-{}
-IR_ComponentDefSeq::IR_ComponentDefSeq (const IR_ComponentDefSeq &seq) // copy ctor
-  : 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Object_Sequence<IR_ComponentDef,IR_ComponentDef_var>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
- (seq)
-{}
-IR_ComponentDefSeq::~IR_ComponentDefSeq (void) // dtor
-{}
-void IR_ComponentDefSeq::_tao_any_destructor (void *x)
-{
-  IR_ComponentDefSeq *tmp = ACE_static_cast (IR_ComponentDefSeq*,x);
-  delete tmp;
-}
-
-static const CORBA::Long _oc_IR_ComponentDefSeq[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f43), ACE_NTOHL (0x6f6d706f), ACE_NTOHL (0x6e656e74), ACE_NTOHL (0x44656653), ACE_NTOHL (0x65713a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/ComponentDefSeq:1.0
-  16, ACE_NTOHL (0x436f6d70), ACE_NTOHL (0x6f6e656e), ACE_NTOHL (0x74446566), ACE_NTOHL (0x53657100),  // name = IR_ComponentDefSeq
-  CORBA::tk_sequence, // typecode kind
-  76, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    CORBA::tk_objref, // typecode kind
-    60, // encapsulation length
-      TAO_ENCAP_BYTE_ORDER, // byte order
-      32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f43), ACE_NTOHL (0x6f6d706f), ACE_NTOHL (0x6e656e74), ACE_NTOHL (0x4465663a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ComponentDef:1.0
-      13, ACE_NTOHL (0x436f6d70), ACE_NTOHL (0x6f6e656e), ACE_NTOHL (0x74446566), ACE_NTOHL (0x0),  // name = IR_ComponentDef
-
-    0U,
-
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_ComponentDefSeq (CORBA::tk_alias, sizeof (_oc_IR_ComponentDefSeq), (char *) &_oc_IR_ComponentDefSeq, 0, sizeof (IR_ComponentDefSeq));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ComponentDefSeq, &_tc_TAO_tc_IR_ComponentDefSeq)
-TAO_NAMESPACE_END
-
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  
-  // The Base_Sequence functions, please see tao/Sequence.h
-  void
-  _TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq::_allocate_buffer (CORBA::ULong length)
-  {
-    IR_ProvidesDef **tmp = 0;
-    tmp = _TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq::allocbuf (length);
-    
-    if (this->buffer_ != 0)
-    {
-      IR_ProvidesDef **old = ACE_reinterpret_cast (IR_ProvidesDef**, this->buffer_);
-      for (CORBA::ULong i = 0; i < this->length_; ++i)
-        if (!this->release_)
-          tmp[i] = IR_ProvidesDef::_duplicate (old[i]);
-        else
-          tmp[i] = old[i];
-        
-      if (this->release_)
-        delete[] old;
-      
-    }
-    this->buffer_ = tmp;
-  }
-  
-  void
-  _TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq::_deallocate_buffer (void)
-  {
-    if (this->buffer_ == 0 || this->release_ == 0)
-      return;
-    IR_ProvidesDef **tmp = ACE_reinterpret_cast (IR_ProvidesDef**, this->buffer_);
-    for (CORBA::ULong i = 0; i < this->length_; ++i)
-    {
-      CORBA::release (tmp[i]);
-      tmp[i] = IR_ProvidesDef::_nil ();
-    }
-    _TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq::freebuf (tmp);
-    this->buffer_ = 0;
-  }
-  
-  _TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq::~_TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq (void)
-  {
-    this->_deallocate_buffer ();
-  }
-  
-  void
-  _TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq::_shrink_buffer (CORBA::ULong nl, CORBA::ULong ol)
-  {
-    IR_ProvidesDef **tmp = ACE_reinterpret_cast (IR_ProvidesDef**, this->buffer_);
-    
-    for (CORBA::ULong i = nl; i < ol; ++i)
-    {
-      CORBA::release (tmp[i]);
-      tmp[i] = IR_ProvidesDef::_nil ();
-    }
-  }
-  void 
-  _TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq::_downcast (
-      void* target,
-      CORBA_Object *src,
-      CORBA_Environment &ACE_TRY_ENV
-    )
-  {
-    IR_ProvidesDef **tmp = ACE_static_cast (IR_ProvidesDef**, target);
-    *tmp = IR_ProvidesDef::_narrow (src, ACE_TRY_ENV);
-  }
-
-  CORBA_Object*
-  _TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq::_upcast (void *src) const
-  {
-    IR_ProvidesDef **tmp = ACE_static_cast (IR_ProvidesDef**, src);
-    return *tmp;
-  }
-  
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
-
-// *************************************************************
-// IR_ProvidesDefSeq
-// *************************************************************
-
-IR_ProvidesDefSeq::IR_ProvidesDefSeq (void)
-{}
-IR_ProvidesDefSeq::IR_ProvidesDefSeq (CORBA::ULong max) // uses max size
-  : 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Object_Sequence<IR_ProvidesDef,IR_ProvidesDef_var>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
- (max)
-{}
-IR_ProvidesDefSeq::IR_ProvidesDefSeq (CORBA::ULong max, CORBA::ULong length, IR_ProvidesDef_ptr *buffer, CORBA::Boolean release)
-  : 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Object_Sequence<IR_ProvidesDef,IR_ProvidesDef_var>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
- (max, length, buffer, release)
-{}
-IR_ProvidesDefSeq::IR_ProvidesDefSeq (const IR_ProvidesDefSeq &seq) // copy ctor
-  : 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Object_Sequence<IR_ProvidesDef,IR_ProvidesDef_var>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
- (seq)
-{}
-IR_ProvidesDefSeq::~IR_ProvidesDefSeq (void) // dtor
-{}
-void IR_ProvidesDefSeq::_tao_any_destructor (void *x)
-{
-  IR_ProvidesDefSeq *tmp = ACE_static_cast (IR_ProvidesDefSeq*,x);
-  delete tmp;
-}
-
-static const CORBA::Long _oc_IR_ProvidesDefSeq[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  34, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f50), ACE_NTOHL (0x726f7669), ACE_NTOHL (0x64657344), ACE_NTOHL (0x65665365), ACE_NTOHL (0x713a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/ProvidesDefSeq:1.0
-  15, ACE_NTOHL (0x50726f76), ACE_NTOHL (0x69646573), ACE_NTOHL (0x44656653), ACE_NTOHL (0x65710000),  // name = IR_ProvidesDefSeq
-  CORBA::tk_sequence, // typecode kind
-  72, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    CORBA::tk_objref, // typecode kind
-    56, // encapsulation length
-      TAO_ENCAP_BYTE_ORDER, // byte order
-      31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f50), ACE_NTOHL (0x726f7669), ACE_NTOHL (0x64657344), ACE_NTOHL (0x65663a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/ProvidesDef:1.0
-      12, ACE_NTOHL (0x50726f76), ACE_NTOHL (0x69646573), ACE_NTOHL (0x44656600),  // name = IR_ProvidesDef
-
-    0U,
-
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_ProvidesDefSeq (CORBA::tk_alias, sizeof (_oc_IR_ProvidesDefSeq), (char *) &_oc_IR_ProvidesDefSeq, 0, sizeof (IR_ProvidesDefSeq));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ProvidesDefSeq, &_tc_TAO_tc_IR_ProvidesDefSeq)
-TAO_NAMESPACE_END
-
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  
-  // The Base_Sequence functions, please see tao/Sequence.h
-  void
-  _TAO_Unbounded_Object_Sequence_IR_UsesDefSeq::_allocate_buffer (CORBA::ULong length)
-  {
-    IR_UsesDef **tmp = 0;
-    tmp = _TAO_Unbounded_Object_Sequence_IR_UsesDefSeq::allocbuf (length);
-    
-    if (this->buffer_ != 0)
-    {
-      IR_UsesDef **old = ACE_reinterpret_cast (IR_UsesDef**, this->buffer_);
-      for (CORBA::ULong i = 0; i < this->length_; ++i)
-        if (!this->release_)
-          tmp[i] = IR_UsesDef::_duplicate (old[i]);
-        else
-          tmp[i] = old[i];
-        
-      if (this->release_)
-        delete[] old;
-      
-    }
-    this->buffer_ = tmp;
-  }
-  
-  void
-  _TAO_Unbounded_Object_Sequence_IR_UsesDefSeq::_deallocate_buffer (void)
-  {
-    if (this->buffer_ == 0 || this->release_ == 0)
-      return;
-    IR_UsesDef **tmp = ACE_reinterpret_cast (IR_UsesDef**, this->buffer_);
-    for (CORBA::ULong i = 0; i < this->length_; ++i)
-    {
-      CORBA::release (tmp[i]);
-      tmp[i] = IR_UsesDef::_nil ();
-    }
-    _TAO_Unbounded_Object_Sequence_IR_UsesDefSeq::freebuf (tmp);
-    this->buffer_ = 0;
-  }
-  
-  _TAO_Unbounded_Object_Sequence_IR_UsesDefSeq::~_TAO_Unbounded_Object_Sequence_IR_UsesDefSeq (void)
-  {
-    this->_deallocate_buffer ();
-  }
-  
-  void
-  _TAO_Unbounded_Object_Sequence_IR_UsesDefSeq::_shrink_buffer (CORBA::ULong nl, CORBA::ULong ol)
-  {
-    IR_UsesDef **tmp = ACE_reinterpret_cast (IR_UsesDef**, this->buffer_);
-    
-    for (CORBA::ULong i = nl; i < ol; ++i)
-    {
-      CORBA::release (tmp[i]);
-      tmp[i] = IR_UsesDef::_nil ();
-    }
-  }
-  void 
-  _TAO_Unbounded_Object_Sequence_IR_UsesDefSeq::_downcast (
-      void* target,
-      CORBA_Object *src,
-      CORBA_Environment &ACE_TRY_ENV
-    )
-  {
-    IR_UsesDef **tmp = ACE_static_cast (IR_UsesDef**, target);
-    *tmp = IR_UsesDef::_narrow (src, ACE_TRY_ENV);
-  }
-
-  CORBA_Object*
-  _TAO_Unbounded_Object_Sequence_IR_UsesDefSeq::_upcast (void *src) const
-  {
-    IR_UsesDef **tmp = ACE_static_cast (IR_UsesDef**, src);
-    return *tmp;
-  }
-  
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
-
-// *************************************************************
-// IR_UsesDefSeq
-// *************************************************************
-
-IR_UsesDefSeq::IR_UsesDefSeq (void)
-{}
-IR_UsesDefSeq::IR_UsesDefSeq (CORBA::ULong max) // uses max size
-  : 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Object_Sequence_IR_UsesDefSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Object_Sequence<IR_UsesDef,IR_UsesDef_var>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
- (max)
-{}
-IR_UsesDefSeq::IR_UsesDefSeq (CORBA::ULong max, CORBA::ULong length, IR_UsesDef_ptr *buffer, CORBA::Boolean release)
-  : 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Object_Sequence_IR_UsesDefSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Object_Sequence<IR_UsesDef,IR_UsesDef_var>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
- (max, length, buffer, release)
-{}
-IR_UsesDefSeq::IR_UsesDefSeq (const IR_UsesDefSeq &seq) // copy ctor
-  : 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Object_Sequence_IR_UsesDefSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Object_Sequence<IR_UsesDef,IR_UsesDef_var>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
- (seq)
-{}
-IR_UsesDefSeq::~IR_UsesDefSeq (void) // dtor
-{}
-void IR_UsesDefSeq::_tao_any_destructor (void *x)
-{
-  IR_UsesDefSeq *tmp = ACE_static_cast (IR_UsesDefSeq*,x);
-  delete tmp;
-}
-
-static const CORBA::Long _oc_IR_UsesDefSeq[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f55), ACE_NTOHL (0x73657344), ACE_NTOHL (0x65665365), ACE_NTOHL (0x713a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/UsesDefSeq:1.0
-  11, ACE_NTOHL (0x55736573), ACE_NTOHL (0x44656653), ACE_NTOHL (0x65710000),  // name = IR_UsesDefSeq
-  CORBA::tk_sequence, // typecode kind
-  64, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    CORBA::tk_objref, // typecode kind
-    48, // encapsulation length
-      TAO_ENCAP_BYTE_ORDER, // byte order
-      27, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f55), ACE_NTOHL (0x73657344), ACE_NTOHL (0x65663a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/UsesDef:1.0
-      8, ACE_NTOHL (0x55736573), ACE_NTOHL (0x44656600),  // name = IR_UsesDef
-
-    0U,
-
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_UsesDefSeq (CORBA::tk_alias, sizeof (_oc_IR_UsesDefSeq), (char *) &_oc_IR_UsesDefSeq, 0, sizeof (IR_UsesDefSeq));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_UsesDefSeq, &_tc_TAO_tc_IR_UsesDefSeq)
-TAO_NAMESPACE_END
-
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  
-  // The Base_Sequence functions, please see tao/Sequence.h
-  void
-  _TAO_Unbounded_Object_Sequence_IR_HomeDefSeq::_allocate_buffer (CORBA::ULong length)
-  {
-    IR_HomeDef **tmp = 0;
-    tmp = _TAO_Unbounded_Object_Sequence_IR_HomeDefSeq::allocbuf (length);
-    
-    if (this->buffer_ != 0)
-    {
-      IR_HomeDef **old = ACE_reinterpret_cast (IR_HomeDef**, this->buffer_);
-      for (CORBA::ULong i = 0; i < this->length_; ++i)
-        if (!this->release_)
-          tmp[i] = IR_HomeDef::_duplicate (old[i]);
-        else
-          tmp[i] = old[i];
-        
-      if (this->release_)
-        delete[] old;
-      
-    }
-    this->buffer_ = tmp;
-  }
-  
-  void
-  _TAO_Unbounded_Object_Sequence_IR_HomeDefSeq::_deallocate_buffer (void)
-  {
-    if (this->buffer_ == 0 || this->release_ == 0)
-      return;
-    IR_HomeDef **tmp = ACE_reinterpret_cast (IR_HomeDef**, this->buffer_);
-    for (CORBA::ULong i = 0; i < this->length_; ++i)
-    {
-      CORBA::release (tmp[i]);
-      tmp[i] = IR_HomeDef::_nil ();
-    }
-    _TAO_Unbounded_Object_Sequence_IR_HomeDefSeq::freebuf (tmp);
-    this->buffer_ = 0;
-  }
-  
-  _TAO_Unbounded_Object_Sequence_IR_HomeDefSeq::~_TAO_Unbounded_Object_Sequence_IR_HomeDefSeq (void)
-  {
-    this->_deallocate_buffer ();
-  }
-  
-  void
-  _TAO_Unbounded_Object_Sequence_IR_HomeDefSeq::_shrink_buffer (CORBA::ULong nl, CORBA::ULong ol)
-  {
-    IR_HomeDef **tmp = ACE_reinterpret_cast (IR_HomeDef**, this->buffer_);
-    
-    for (CORBA::ULong i = nl; i < ol; ++i)
-    {
-      CORBA::release (tmp[i]);
-      tmp[i] = IR_HomeDef::_nil ();
-    }
-  }
-  void 
-  _TAO_Unbounded_Object_Sequence_IR_HomeDefSeq::_downcast (
-      void* target,
-      CORBA_Object *src,
-      CORBA_Environment &ACE_TRY_ENV
-    )
-  {
-    IR_HomeDef **tmp = ACE_static_cast (IR_HomeDef**, target);
-    *tmp = IR_HomeDef::_narrow (src, ACE_TRY_ENV);
-  }
-
-  CORBA_Object*
-  _TAO_Unbounded_Object_Sequence_IR_HomeDefSeq::_upcast (void *src) const
-  {
-    IR_HomeDef **tmp = ACE_static_cast (IR_HomeDef**, src);
-    return *tmp;
-  }
-  
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
-
-// *************************************************************
-// IR_HomeDefSeq
-// *************************************************************
-
-IR_HomeDefSeq::IR_HomeDefSeq (void)
-{}
-IR_HomeDefSeq::IR_HomeDefSeq (CORBA::ULong max) // uses max size
-  : 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Object_Sequence_IR_HomeDefSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Object_Sequence<IR_HomeDef,IR_HomeDef_var>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
- (max)
-{}
-IR_HomeDefSeq::IR_HomeDefSeq (CORBA::ULong max, CORBA::ULong length, IR_HomeDef_ptr *buffer, CORBA::Boolean release)
-  : 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Object_Sequence_IR_HomeDefSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Object_Sequence<IR_HomeDef,IR_HomeDef_var>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
- (max, length, buffer, release)
-{}
-IR_HomeDefSeq::IR_HomeDefSeq (const IR_HomeDefSeq &seq) // copy ctor
-  : 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Object_Sequence_IR_HomeDefSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Object_Sequence<IR_HomeDef,IR_HomeDef_var>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
- (seq)
-{}
-IR_HomeDefSeq::~IR_HomeDefSeq (void) // dtor
-{}
-void IR_HomeDefSeq::_tao_any_destructor (void *x)
-{
-  IR_HomeDefSeq *tmp = ACE_static_cast (IR_HomeDefSeq*,x);
-  delete tmp;
-}
-
-static const CORBA::Long _oc_IR_HomeDefSeq[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f48), ACE_NTOHL (0x6f6d6544), ACE_NTOHL (0x65665365), ACE_NTOHL (0x713a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/HomeDefSeq:1.0
-  11, ACE_NTOHL (0x486f6d65), ACE_NTOHL (0x44656653), ACE_NTOHL (0x65710000),  // name = IR_HomeDefSeq
-  CORBA::tk_sequence, // typecode kind
-  64, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    CORBA::tk_objref, // typecode kind
-    48, // encapsulation length
-      TAO_ENCAP_BYTE_ORDER, // byte order
-      27, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f48), ACE_NTOHL (0x6f6d6544), ACE_NTOHL (0x65663a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/HomeDef:1.0
-      8, ACE_NTOHL (0x486f6d65), ACE_NTOHL (0x44656600),  // name = IR_HomeDef
-
-    0U,
-
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_HomeDefSeq (CORBA::tk_alias, sizeof (_oc_IR_HomeDefSeq), (char *) &_oc_IR_HomeDefSeq, 0, sizeof (IR_HomeDefSeq));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_HomeDefSeq, &_tc_TAO_tc_IR_HomeDefSeq)
-TAO_NAMESPACE_END
-
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  
-  // The Base_Sequence functions, please see tao/Sequence.h
-  void
-  _TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq::_allocate_buffer (CORBA::ULong length)
-  {
-    IR_EmitsDef **tmp = 0;
-    tmp = _TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq::allocbuf (length);
-    
-    if (this->buffer_ != 0)
-    {
-      IR_EmitsDef **old = ACE_reinterpret_cast (IR_EmitsDef**, this->buffer_);
-      for (CORBA::ULong i = 0; i < this->length_; ++i)
-        if (!this->release_)
-          tmp[i] = IR_EmitsDef::_duplicate (old[i]);
-        else
-          tmp[i] = old[i];
-        
-      if (this->release_)
-        delete[] old;
-      
-    }
-    this->buffer_ = tmp;
-  }
-  
-  void
-  _TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq::_deallocate_buffer (void)
-  {
-    if (this->buffer_ == 0 || this->release_ == 0)
-      return;
-    IR_EmitsDef **tmp = ACE_reinterpret_cast (IR_EmitsDef**, this->buffer_);
-    for (CORBA::ULong i = 0; i < this->length_; ++i)
-    {
-      CORBA::release (tmp[i]);
-      tmp[i] = IR_EmitsDef::_nil ();
-    }
-    _TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq::freebuf (tmp);
-    this->buffer_ = 0;
-  }
-  
-  _TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq::~_TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq (void)
-  {
-    this->_deallocate_buffer ();
-  }
-  
-  void
-  _TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq::_shrink_buffer (CORBA::ULong nl, CORBA::ULong ol)
-  {
-    IR_EmitsDef **tmp = ACE_reinterpret_cast (IR_EmitsDef**, this->buffer_);
-    
-    for (CORBA::ULong i = nl; i < ol; ++i)
-    {
-      CORBA::release (tmp[i]);
-      tmp[i] = IR_EmitsDef::_nil ();
-    }
-  }
-  void 
-  _TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq::_downcast (
-      void* target,
-      CORBA_Object *src,
-      CORBA_Environment &ACE_TRY_ENV
-    )
-  {
-    IR_EmitsDef **tmp = ACE_static_cast (IR_EmitsDef**, target);
-    *tmp = IR_EmitsDef::_narrow (src, ACE_TRY_ENV);
-  }
-
-  CORBA_Object*
-  _TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq::_upcast (void *src) const
-  {
-    IR_EmitsDef **tmp = ACE_static_cast (IR_EmitsDef**, src);
-    return *tmp;
-  }
-  
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
-
-// *************************************************************
-// IR_EmitsDefSeq
-// *************************************************************
-
-IR_EmitsDefSeq::IR_EmitsDefSeq (void)
-{}
-IR_EmitsDefSeq::IR_EmitsDefSeq (CORBA::ULong max) // uses max size
-  : 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Object_Sequence<IR_EmitsDef,IR_EmitsDef_var>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
- (max)
-{}
-IR_EmitsDefSeq::IR_EmitsDefSeq (CORBA::ULong max, CORBA::ULong length, IR_EmitsDef_ptr *buffer, CORBA::Boolean release)
-  : 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Object_Sequence<IR_EmitsDef,IR_EmitsDef_var>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
- (max, length, buffer, release)
-{}
-IR_EmitsDefSeq::IR_EmitsDefSeq (const IR_EmitsDefSeq &seq) // copy ctor
-  : 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Object_Sequence<IR_EmitsDef,IR_EmitsDef_var>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
- (seq)
-{}
-IR_EmitsDefSeq::~IR_EmitsDefSeq (void) // dtor
-{}
-void IR_EmitsDefSeq::_tao_any_destructor (void *x)
-{
-  IR_EmitsDefSeq *tmp = ACE_static_cast (IR_EmitsDefSeq*,x);
-  delete tmp;
-}
-
-static const CORBA::Long _oc_IR_EmitsDefSeq[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x6d697473), ACE_NTOHL (0x44656653), ACE_NTOHL (0x65713a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/EmitsDefSeq:1.0
-  12, ACE_NTOHL (0x456d6974), ACE_NTOHL (0x73446566), ACE_NTOHL (0x53657100),  // name = IR_EmitsDefSeq
-  CORBA::tk_sequence, // typecode kind
-  68, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    CORBA::tk_objref, // typecode kind
-    52, // encapsulation length
-      TAO_ENCAP_BYTE_ORDER, // byte order
-      28, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x6d697473), ACE_NTOHL (0x4465663a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/EmitsDef:1.0
-      9, ACE_NTOHL (0x456d6974), ACE_NTOHL (0x73446566), ACE_NTOHL (0x0),  // name = IR_EmitsDef
-
-    0U,
-
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_EmitsDefSeq (CORBA::tk_alias, sizeof (_oc_IR_EmitsDefSeq), (char *) &_oc_IR_EmitsDefSeq, 0, sizeof (IR_EmitsDefSeq));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_EmitsDefSeq, &_tc_TAO_tc_IR_EmitsDefSeq)
-TAO_NAMESPACE_END
-
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  
-  // The Base_Sequence functions, please see tao/Sequence.h
-  void
-  _TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq::_allocate_buffer (CORBA::ULong length)
-  {
-    IR_PublishesDef **tmp = 0;
-    tmp = _TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq::allocbuf (length);
-    
-    if (this->buffer_ != 0)
-    {
-      IR_PublishesDef **old = ACE_reinterpret_cast (IR_PublishesDef**, this->buffer_);
-      for (CORBA::ULong i = 0; i < this->length_; ++i)
-        if (!this->release_)
-          tmp[i] = IR_PublishesDef::_duplicate (old[i]);
-        else
-          tmp[i] = old[i];
-        
-      if (this->release_)
-        delete[] old;
-      
-    }
-    this->buffer_ = tmp;
-  }
-  
-  void
-  _TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq::_deallocate_buffer (void)
-  {
-    if (this->buffer_ == 0 || this->release_ == 0)
-      return;
-    IR_PublishesDef **tmp = ACE_reinterpret_cast (IR_PublishesDef**, this->buffer_);
-    for (CORBA::ULong i = 0; i < this->length_; ++i)
-    {
-      CORBA::release (tmp[i]);
-      tmp[i] = IR_PublishesDef::_nil ();
-    }
-    _TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq::freebuf (tmp);
-    this->buffer_ = 0;
-  }
-  
-  _TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq::~_TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq (void)
-  {
-    this->_deallocate_buffer ();
-  }
-  
-  void
-  _TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq::_shrink_buffer (CORBA::ULong nl, CORBA::ULong ol)
-  {
-    IR_PublishesDef **tmp = ACE_reinterpret_cast (IR_PublishesDef**, this->buffer_);
-    
-    for (CORBA::ULong i = nl; i < ol; ++i)
-    {
-      CORBA::release (tmp[i]);
-      tmp[i] = IR_PublishesDef::_nil ();
-    }
-  }
-  void 
-  _TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq::_downcast (
-      void* target,
-      CORBA_Object *src,
-      CORBA_Environment &ACE_TRY_ENV
-    )
-  {
-    IR_PublishesDef **tmp = ACE_static_cast (IR_PublishesDef**, target);
-    *tmp = IR_PublishesDef::_narrow (src, ACE_TRY_ENV);
-  }
-
-  CORBA_Object*
-  _TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq::_upcast (void *src) const
-  {
-    IR_PublishesDef **tmp = ACE_static_cast (IR_PublishesDef**, src);
-    return *tmp;
-  }
-  
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
-
-// *************************************************************
-// IR_PublishesDefSeq
-// *************************************************************
-
-IR_PublishesDefSeq::IR_PublishesDefSeq (void)
-{}
-IR_PublishesDefSeq::IR_PublishesDefSeq (CORBA::ULong max) // uses max size
-  : 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Object_Sequence<IR_PublishesDef,IR_PublishesDef_var>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
- (max)
-{}
-IR_PublishesDefSeq::IR_PublishesDefSeq (CORBA::ULong max, CORBA::ULong length, IR_PublishesDef_ptr *buffer, CORBA::Boolean release)
-  : 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Object_Sequence<IR_PublishesDef,IR_PublishesDef_var>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
- (max, length, buffer, release)
-{}
-IR_PublishesDefSeq::IR_PublishesDefSeq (const IR_PublishesDefSeq &seq) // copy ctor
-  : 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Object_Sequence<IR_PublishesDef,IR_PublishesDef_var>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
- (seq)
-{}
-IR_PublishesDefSeq::~IR_PublishesDefSeq (void) // dtor
-{}
-void IR_PublishesDefSeq::_tao_any_destructor (void *x)
-{
-  IR_PublishesDefSeq *tmp = ACE_static_cast (IR_PublishesDefSeq*,x);
-  delete tmp;
-}
-
-static const CORBA::Long _oc_IR_PublishesDefSeq[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f50), ACE_NTOHL (0x75626c69), ACE_NTOHL (0x73686573), ACE_NTOHL (0x44656653), ACE_NTOHL (0x65713a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/PublishesDefSeq:1.0
-  16, ACE_NTOHL (0x5075626c), ACE_NTOHL (0x69736865), ACE_NTOHL (0x73446566), ACE_NTOHL (0x53657100),  // name = IR_PublishesDefSeq
-  CORBA::tk_sequence, // typecode kind
-  76, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    CORBA::tk_objref, // typecode kind
-    60, // encapsulation length
-      TAO_ENCAP_BYTE_ORDER, // byte order
-      32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f50), ACE_NTOHL (0x75626c69), ACE_NTOHL (0x73686573), ACE_NTOHL (0x4465663a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/PublishesDef:1.0
-      13, ACE_NTOHL (0x5075626c), ACE_NTOHL (0x69736865), ACE_NTOHL (0x73446566), ACE_NTOHL (0x0),  // name = IR_PublishesDef
-
-    0U,
-
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_PublishesDefSeq (CORBA::tk_alias, sizeof (_oc_IR_PublishesDefSeq), (char *) &_oc_IR_PublishesDefSeq, 0, sizeof (IR_PublishesDefSeq));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_PublishesDefSeq, &_tc_TAO_tc_IR_PublishesDefSeq)
-TAO_NAMESPACE_END
-
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  
-  // The Base_Sequence functions, please see tao/Sequence.h
-  void
-  _TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq::_allocate_buffer (CORBA::ULong length)
-  {
-    IR_ConsumesDef **tmp = 0;
-    tmp = _TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq::allocbuf (length);
-    
-    if (this->buffer_ != 0)
-    {
-      IR_ConsumesDef **old = ACE_reinterpret_cast (IR_ConsumesDef**, this->buffer_);
-      for (CORBA::ULong i = 0; i < this->length_; ++i)
-        if (!this->release_)
-          tmp[i] = IR_ConsumesDef::_duplicate (old[i]);
-        else
-          tmp[i] = old[i];
-        
-      if (this->release_)
-        delete[] old;
-      
-    }
-    this->buffer_ = tmp;
-  }
-  
-  void
-  _TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq::_deallocate_buffer (void)
-  {
-    if (this->buffer_ == 0 || this->release_ == 0)
-      return;
-    IR_ConsumesDef **tmp = ACE_reinterpret_cast (IR_ConsumesDef**, this->buffer_);
-    for (CORBA::ULong i = 0; i < this->length_; ++i)
-    {
-      CORBA::release (tmp[i]);
-      tmp[i] = IR_ConsumesDef::_nil ();
-    }
-    _TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq::freebuf (tmp);
-    this->buffer_ = 0;
-  }
-  
-  _TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq::~_TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq (void)
-  {
-    this->_deallocate_buffer ();
-  }
-  
-  void
-  _TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq::_shrink_buffer (CORBA::ULong nl, CORBA::ULong ol)
-  {
-    IR_ConsumesDef **tmp = ACE_reinterpret_cast (IR_ConsumesDef**, this->buffer_);
-    
-    for (CORBA::ULong i = nl; i < ol; ++i)
-    {
-      CORBA::release (tmp[i]);
-      tmp[i] = IR_ConsumesDef::_nil ();
-    }
-  }
-  void 
-  _TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq::_downcast (
-      void* target,
-      CORBA_Object *src,
-      CORBA_Environment &ACE_TRY_ENV
-    )
-  {
-    IR_ConsumesDef **tmp = ACE_static_cast (IR_ConsumesDef**, target);
-    *tmp = IR_ConsumesDef::_narrow (src, ACE_TRY_ENV);
-  }
-
-  CORBA_Object*
-  _TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq::_upcast (void *src) const
-  {
-    IR_ConsumesDef **tmp = ACE_static_cast (IR_ConsumesDef**, src);
-    return *tmp;
-  }
-  
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
-
-// *************************************************************
-// IR_ConsumesDefSeq
-// *************************************************************
-
-IR_ConsumesDefSeq::IR_ConsumesDefSeq (void)
-{}
-IR_ConsumesDefSeq::IR_ConsumesDefSeq (CORBA::ULong max) // uses max size
-  : 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Object_Sequence<IR_ConsumesDef,IR_ConsumesDef_var>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
- (max)
-{}
-IR_ConsumesDefSeq::IR_ConsumesDefSeq (CORBA::ULong max, CORBA::ULong length, IR_ConsumesDef_ptr *buffer, CORBA::Boolean release)
-  : 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Object_Sequence<IR_ConsumesDef,IR_ConsumesDef_var>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
- (max, length, buffer, release)
-{}
-IR_ConsumesDefSeq::IR_ConsumesDefSeq (const IR_ConsumesDefSeq &seq) // copy ctor
-  : 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Object_Sequence<IR_ConsumesDef,IR_ConsumesDef_var>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
- (seq)
-{}
-IR_ConsumesDefSeq::~IR_ConsumesDefSeq (void) // dtor
-{}
-void IR_ConsumesDefSeq::_tao_any_destructor (void *x)
-{
-  IR_ConsumesDefSeq *tmp = ACE_static_cast (IR_ConsumesDefSeq*,x);
-  delete tmp;
-}
-
-static const CORBA::Long _oc_IR_ConsumesDefSeq[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  34, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f43), ACE_NTOHL (0x6f6e7375), ACE_NTOHL (0x6d657344), ACE_NTOHL (0x65665365), ACE_NTOHL (0x713a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/ConsumesDefSeq:1.0
-  15, ACE_NTOHL (0x436f6e73), ACE_NTOHL (0x756d6573), ACE_NTOHL (0x44656653), ACE_NTOHL (0x65710000),  // name = IR_ConsumesDefSeq
-  CORBA::tk_sequence, // typecode kind
-  72, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    CORBA::tk_objref, // typecode kind
-    56, // encapsulation length
-      TAO_ENCAP_BYTE_ORDER, // byte order
-      31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f43), ACE_NTOHL (0x6f6e7375), ACE_NTOHL (0x6d657344), ACE_NTOHL (0x65663a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/ConsumesDef:1.0
-      12, ACE_NTOHL (0x436f6e73), ACE_NTOHL (0x756d6573), ACE_NTOHL (0x44656600),  // name = IR_ConsumesDef
-
-    0U,
-
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_ConsumesDefSeq (CORBA::tk_alias, sizeof (_oc_IR_ConsumesDefSeq), (char *) &_oc_IR_ConsumesDefSeq, 0, sizeof (IR_ConsumesDefSeq));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ConsumesDefSeq, &_tc_TAO_tc_IR_ConsumesDefSeq)
-TAO_NAMESPACE_END
-
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  
-  // The Base_Sequence functions, please see tao/Sequence.h
-  void
-  _TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq::_allocate_buffer (CORBA::ULong length)
-  {
-    IR_FactoryDef **tmp = 0;
-    tmp = _TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq::allocbuf (length);
-    
-    if (this->buffer_ != 0)
-    {
-      IR_FactoryDef **old = ACE_reinterpret_cast (IR_FactoryDef**, this->buffer_);
-      for (CORBA::ULong i = 0; i < this->length_; ++i)
-        if (!this->release_)
-          tmp[i] = IR_FactoryDef::_duplicate (old[i]);
-        else
-          tmp[i] = old[i];
-        
-      if (this->release_)
-        delete[] old;
-      
-    }
-    this->buffer_ = tmp;
-  }
-  
-  void
-  _TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq::_deallocate_buffer (void)
-  {
-    if (this->buffer_ == 0 || this->release_ == 0)
-      return;
-    IR_FactoryDef **tmp = ACE_reinterpret_cast (IR_FactoryDef**, this->buffer_);
-    for (CORBA::ULong i = 0; i < this->length_; ++i)
-    {
-      CORBA::release (tmp[i]);
-      tmp[i] = IR_FactoryDef::_nil ();
-    }
-    _TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq::freebuf (tmp);
-    this->buffer_ = 0;
-  }
-  
-  _TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq::~_TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq (void)
-  {
-    this->_deallocate_buffer ();
-  }
-  
-  void
-  _TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq::_shrink_buffer (CORBA::ULong nl, CORBA::ULong ol)
-  {
-    IR_FactoryDef **tmp = ACE_reinterpret_cast (IR_FactoryDef**, this->buffer_);
-    
-    for (CORBA::ULong i = nl; i < ol; ++i)
-    {
-      CORBA::release (tmp[i]);
-      tmp[i] = IR_FactoryDef::_nil ();
-    }
-  }
-  void 
-  _TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq::_downcast (
-      void* target,
-      CORBA_Object *src,
-      CORBA_Environment &ACE_TRY_ENV
-    )
-  {
-    IR_FactoryDef **tmp = ACE_static_cast (IR_FactoryDef**, target);
-    *tmp = IR_FactoryDef::_narrow (src, ACE_TRY_ENV);
-  }
-
-  CORBA_Object*
-  _TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq::_upcast (void *src) const
-  {
-    IR_FactoryDef **tmp = ACE_static_cast (IR_FactoryDef**, src);
-    return *tmp;
-  }
-  
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
-
-// *************************************************************
-// IR_FactoryDefSeq
-// *************************************************************
-
-IR_FactoryDefSeq::IR_FactoryDefSeq (void)
-{}
-IR_FactoryDefSeq::IR_FactoryDefSeq (CORBA::ULong max) // uses max size
-  : 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Object_Sequence<IR_FactoryDef,IR_FactoryDef_var>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
- (max)
-{}
-IR_FactoryDefSeq::IR_FactoryDefSeq (CORBA::ULong max, CORBA::ULong length, IR_FactoryDef_ptr *buffer, CORBA::Boolean release)
-  : 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Object_Sequence<IR_FactoryDef,IR_FactoryDef_var>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
- (max, length, buffer, release)
-{}
-IR_FactoryDefSeq::IR_FactoryDefSeq (const IR_FactoryDefSeq &seq) // copy ctor
-  : 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Object_Sequence<IR_FactoryDef,IR_FactoryDef_var>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
- (seq)
-{}
-IR_FactoryDefSeq::~IR_FactoryDefSeq (void) // dtor
-{}
-void IR_FactoryDefSeq::_tao_any_destructor (void *x)
-{
-  IR_FactoryDefSeq *tmp = ACE_static_cast (IR_FactoryDefSeq*,x);
-  delete tmp;
-}
-
-static const CORBA::Long _oc_IR_FactoryDefSeq[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f46), ACE_NTOHL (0x6163746f), ACE_NTOHL (0x72794465), ACE_NTOHL (0x66536571), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/FactoryDefSeq:1.0
-  14, ACE_NTOHL (0x46616374), ACE_NTOHL (0x6f727944), ACE_NTOHL (0x65665365), ACE_NTOHL (0x71000000),  // name = IR_FactoryDefSeq
-  CORBA::tk_sequence, // typecode kind
-  72, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    CORBA::tk_objref, // typecode kind
-    56, // encapsulation length
-      TAO_ENCAP_BYTE_ORDER, // byte order
-      30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f46), ACE_NTOHL (0x6163746f), ACE_NTOHL (0x72794465), ACE_NTOHL (0x663a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/FactoryDef:1.0
-      11, ACE_NTOHL (0x46616374), ACE_NTOHL (0x6f727944), ACE_NTOHL (0x65660000),  // name = IR_FactoryDef
-
-    0U,
-
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_FactoryDefSeq (CORBA::tk_alias, sizeof (_oc_IR_FactoryDefSeq), (char *) &_oc_IR_FactoryDefSeq, 0, sizeof (IR_FactoryDefSeq));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_FactoryDefSeq, &_tc_TAO_tc_IR_FactoryDefSeq)
-TAO_NAMESPACE_END
-
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  
-  // The Base_Sequence functions, please see tao/Sequence.h
-  void
-  _TAO_Unbounded_Object_Sequence_IR_FinderDefSeq::_allocate_buffer (CORBA::ULong length)
-  {
-    IR_FinderDef **tmp = 0;
-    tmp = _TAO_Unbounded_Object_Sequence_IR_FinderDefSeq::allocbuf (length);
-    
-    if (this->buffer_ != 0)
-    {
-      IR_FinderDef **old = ACE_reinterpret_cast (IR_FinderDef**, this->buffer_);
-      for (CORBA::ULong i = 0; i < this->length_; ++i)
-        if (!this->release_)
-          tmp[i] = IR_FinderDef::_duplicate (old[i]);
-        else
-          tmp[i] = old[i];
-        
-      if (this->release_)
-        delete[] old;
-      
-    }
-    this->buffer_ = tmp;
-  }
-  
-  void
-  _TAO_Unbounded_Object_Sequence_IR_FinderDefSeq::_deallocate_buffer (void)
-  {
-    if (this->buffer_ == 0 || this->release_ == 0)
-      return;
-    IR_FinderDef **tmp = ACE_reinterpret_cast (IR_FinderDef**, this->buffer_);
-    for (CORBA::ULong i = 0; i < this->length_; ++i)
-    {
-      CORBA::release (tmp[i]);
-      tmp[i] = IR_FinderDef::_nil ();
-    }
-    _TAO_Unbounded_Object_Sequence_IR_FinderDefSeq::freebuf (tmp);
-    this->buffer_ = 0;
-  }
-  
-  _TAO_Unbounded_Object_Sequence_IR_FinderDefSeq::~_TAO_Unbounded_Object_Sequence_IR_FinderDefSeq (void)
-  {
-    this->_deallocate_buffer ();
-  }
-  
-  void
-  _TAO_Unbounded_Object_Sequence_IR_FinderDefSeq::_shrink_buffer (CORBA::ULong nl, CORBA::ULong ol)
-  {
-    IR_FinderDef **tmp = ACE_reinterpret_cast (IR_FinderDef**, this->buffer_);
-    
-    for (CORBA::ULong i = nl; i < ol; ++i)
-    {
-      CORBA::release (tmp[i]);
-      tmp[i] = IR_FinderDef::_nil ();
-    }
-  }
-  void 
-  _TAO_Unbounded_Object_Sequence_IR_FinderDefSeq::_downcast (
-      void* target,
-      CORBA_Object *src,
-      CORBA_Environment &ACE_TRY_ENV
-    )
-  {
-    IR_FinderDef **tmp = ACE_static_cast (IR_FinderDef**, target);
-    *tmp = IR_FinderDef::_narrow (src, ACE_TRY_ENV);
-  }
-
-  CORBA_Object*
-  _TAO_Unbounded_Object_Sequence_IR_FinderDefSeq::_upcast (void *src) const
-  {
-    IR_FinderDef **tmp = ACE_static_cast (IR_FinderDef**, src);
-    return *tmp;
-  }
-  
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
-
-// *************************************************************
-// IR_FinderDefSeq
-// *************************************************************
-
-IR_FinderDefSeq::IR_FinderDefSeq (void)
-{}
-IR_FinderDefSeq::IR_FinderDefSeq (CORBA::ULong max) // uses max size
-  : 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Object_Sequence_IR_FinderDefSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Object_Sequence<IR_FinderDef,IR_FinderDef_var>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
- (max)
-{}
-IR_FinderDefSeq::IR_FinderDefSeq (CORBA::ULong max, CORBA::ULong length, IR_FinderDef_ptr *buffer, CORBA::Boolean release)
-  : 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Object_Sequence_IR_FinderDefSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Object_Sequence<IR_FinderDef,IR_FinderDef_var>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
- (max, length, buffer, release)
-{}
-IR_FinderDefSeq::IR_FinderDefSeq (const IR_FinderDefSeq &seq) // copy ctor
-  : 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Object_Sequence_IR_FinderDefSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Object_Sequence<IR_FinderDef,IR_FinderDef_var>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
- (seq)
-{}
-IR_FinderDefSeq::~IR_FinderDefSeq (void) // dtor
-{}
-void IR_FinderDefSeq::_tao_any_destructor (void *x)
-{
-  IR_FinderDefSeq *tmp = ACE_static_cast (IR_FinderDefSeq*,x);
-  delete tmp;
-}
-
-static const CORBA::Long _oc_IR_FinderDefSeq[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f46), ACE_NTOHL (0x696e6465), ACE_NTOHL (0x72446566), ACE_NTOHL (0x5365713a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/FinderDefSeq:1.0
-  13, ACE_NTOHL (0x46696e64), ACE_NTOHL (0x65724465), ACE_NTOHL (0x66536571), ACE_NTOHL (0x0),  // name = IR_FinderDefSeq
-  CORBA::tk_sequence, // typecode kind
-  72, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    CORBA::tk_objref, // typecode kind
-    56, // encapsulation length
-      TAO_ENCAP_BYTE_ORDER, // byte order
-      29, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f46), ACE_NTOHL (0x696e6465), ACE_NTOHL (0x72446566), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/FinderDef:1.0
-      10, ACE_NTOHL (0x46696e64), ACE_NTOHL (0x65724465), ACE_NTOHL (0x66000000),  // name = IR_FinderDef
-
-    0U,
-
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_FinderDefSeq (CORBA::tk_alias, sizeof (_oc_IR_FinderDefSeq), (char *) &_oc_IR_FinderDefSeq, 0, sizeof (IR_FinderDefSeq));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_FinderDefSeq, &_tc_TAO_tc_IR_FinderDefSeq)
-TAO_NAMESPACE_END
-
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  
-  // The Base_Sequence functions, please see tao/Sequence.h
-  void
-  _TAO_Unbounded_Object_Sequence_IR_ContainedSeq::_allocate_buffer (CORBA::ULong length)
-  {
-    IR_Contained **tmp = 0;
-    tmp = _TAO_Unbounded_Object_Sequence_IR_ContainedSeq::allocbuf (length);
-    
-    if (this->buffer_ != 0)
-    {
-      IR_Contained **old = ACE_reinterpret_cast (IR_Contained**, this->buffer_);
-      for (CORBA::ULong i = 0; i < this->length_; ++i)
-        if (!this->release_)
-          tmp[i] = IR_Contained::_duplicate (old[i]);
-        else
-          tmp[i] = old[i];
-        
-      if (this->release_)
-        delete[] old;
-      
-    }
-    this->buffer_ = tmp;
-  }
-  
-  void
-  _TAO_Unbounded_Object_Sequence_IR_ContainedSeq::_deallocate_buffer (void)
-  {
-    if (this->buffer_ == 0 || this->release_ == 0)
-      return;
-    IR_Contained **tmp = ACE_reinterpret_cast (IR_Contained**, this->buffer_);
-    for (CORBA::ULong i = 0; i < this->length_; ++i)
-    {
-      CORBA::release (tmp[i]);
-      tmp[i] = IR_Contained::_nil ();
-    }
-    _TAO_Unbounded_Object_Sequence_IR_ContainedSeq::freebuf (tmp);
-    this->buffer_ = 0;
-  }
-  
-  _TAO_Unbounded_Object_Sequence_IR_ContainedSeq::~_TAO_Unbounded_Object_Sequence_IR_ContainedSeq (void)
-  {
-    this->_deallocate_buffer ();
-  }
-  
-  void
-  _TAO_Unbounded_Object_Sequence_IR_ContainedSeq::_shrink_buffer (CORBA::ULong nl, CORBA::ULong ol)
-  {
-    IR_Contained **tmp = ACE_reinterpret_cast (IR_Contained**, this->buffer_);
-    
-    for (CORBA::ULong i = nl; i < ol; ++i)
-    {
-      CORBA::release (tmp[i]);
-      tmp[i] = IR_Contained::_nil ();
-    }
-  }
-  void 
-  _TAO_Unbounded_Object_Sequence_IR_ContainedSeq::_downcast (
-      void* target,
-      CORBA_Object *src,
-      CORBA_Environment &ACE_TRY_ENV
-    )
-  {
-    IR_Contained **tmp = ACE_static_cast (IR_Contained**, target);
-    *tmp = IR_Contained::_narrow (src, ACE_TRY_ENV);
-  }
-
-  CORBA_Object*
-  _TAO_Unbounded_Object_Sequence_IR_ContainedSeq::_upcast (void *src) const
-  {
-    IR_Contained **tmp = ACE_static_cast (IR_Contained**, src);
-    return *tmp;
-  }
-  
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
-
-// *************************************************************
-// IR_ContainedSeq
-// *************************************************************
-
-IR_ContainedSeq::IR_ContainedSeq (void)
-{}
-IR_ContainedSeq::IR_ContainedSeq (CORBA::ULong max) // uses max size
-  : 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Object_Sequence_IR_ContainedSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Object_Sequence<IR_Contained,IR_Contained_var>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
- (max)
-{}
-IR_ContainedSeq::IR_ContainedSeq (CORBA::ULong max, CORBA::ULong length, IR_Contained_ptr *buffer, CORBA::Boolean release)
-  : 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Object_Sequence_IR_ContainedSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Object_Sequence<IR_Contained,IR_Contained_var>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
- (max, length, buffer, release)
-{}
-IR_ContainedSeq::IR_ContainedSeq (const IR_ContainedSeq &seq) // copy ctor
-  : 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Object_Sequence_IR_ContainedSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Object_Sequence<IR_Contained,IR_Contained_var>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
- (seq)
-{}
-IR_ContainedSeq::~IR_ContainedSeq (void) // dtor
-{}
-void IR_ContainedSeq::_tao_any_destructor (void *x)
-{
-  IR_ContainedSeq *tmp = ACE_static_cast (IR_ContainedSeq*,x);
-  delete tmp;
-}
-
-static const CORBA::Long _oc_IR_ContainedSeq[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f43), ACE_NTOHL (0x6f6e7461), ACE_NTOHL (0x696e6564), ACE_NTOHL (0x5365713a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ContainedSeq:1.0
-  13, ACE_NTOHL (0x436f6e74), ACE_NTOHL (0x61696e65), ACE_NTOHL (0x64536571), ACE_NTOHL (0x0),  // name = IR_ContainedSeq
-  CORBA::tk_sequence, // typecode kind
-  72, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    CORBA::tk_objref, // typecode kind
-    56, // encapsulation length
-      TAO_ENCAP_BYTE_ORDER, // byte order
-      29, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f43), ACE_NTOHL (0x6f6e7461), ACE_NTOHL (0x696e6564), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/Contained:1.0
-      10, ACE_NTOHL (0x436f6e74), ACE_NTOHL (0x61696e65), ACE_NTOHL (0x64000000),  // name = IR_Contained
-
-    0U,
-
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_ContainedSeq (CORBA::tk_alias, sizeof (_oc_IR_ContainedSeq), (char *) &_oc_IR_ContainedSeq, 0, sizeof (IR_ContainedSeq));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ContainedSeq, &_tc_TAO_tc_IR_ContainedSeq)
-TAO_NAMESPACE_END
-
-static const CORBA::Long _oc_IR_StructMember[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f53), ACE_NTOHL (0x74727563), ACE_NTOHL (0x744d656d), ACE_NTOHL (0x6265723a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/StructMember:1.0
-  13, ACE_NTOHL (0x53747275), ACE_NTOHL (0x63744d65), ACE_NTOHL (0x6d626572), ACE_NTOHL (0x0),  // name = IR_StructMember
-  3, // member count
-  5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
-  CORBA::tk_alias, // typecode kind for typedefs
-  64, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
-    11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-    CORBA::tk_string, 
-    0U, // string length
-
-  5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
-  CORBA::tk_TypeCode,
-
-  9, ACE_NTOHL (0x74797065), ACE_NTOHL (0x5f646566), ACE_NTOHL (0x0),  // name = type_def
-  CORBA::tk_objref, // typecode kind
-  48, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    27, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x444c5479), ACE_NTOHL (0x70653a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/IDLType:1.0
-    8, ACE_NTOHL (0x49444c54), ACE_NTOHL (0x79706500),  // name = IR_IDLType
-
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_StructMember (CORBA::tk_struct, sizeof (_oc_IR_StructMember), (char *) &_oc_IR_StructMember, 0, sizeof (IR_StructMember));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_StructMember, &_tc_TAO_tc_IR_StructMember)
-TAO_NAMESPACE_END
-
-void IR_StructMember::_tao_any_destructor (void *x)
-{
-  IR_StructMember *tmp = ACE_static_cast (IR_StructMember*,x);
-  delete tmp;
-}
-
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  
-  void
-  _TAO_Unbounded_Sequence_IR_StructMemberSeq::_allocate_buffer (CORBA::ULong length)
-  {
-    IR_StructMember* tmp = 0;
-    tmp = _TAO_Unbounded_Sequence_IR_StructMemberSeq::allocbuf (length);
-    
-    if (this->buffer_ != 0)
-    {
-      IR_StructMember *old = ACE_reinterpret_cast (IR_StructMember *,this->buffer_);
-      
-      for (CORBA::ULong i = 0; i < this->length_; ++i)
-        tmp[i] = old[i];
-      
-      if (this->release_)
-        _TAO_Unbounded_Sequence_IR_StructMemberSeq::freebuf (old);
-      
-    }
-    this->buffer_ = tmp;
-  }
-  
-  void
-  _TAO_Unbounded_Sequence_IR_StructMemberSeq::_deallocate_buffer (void)
-  {
-    if (this->buffer_ == 0 || this->release_ == 0)
-      return;
-    
-    IR_StructMember *tmp = ACE_reinterpret_cast (IR_StructMember *,this->buffer_);
-    
-    _TAO_Unbounded_Sequence_IR_StructMemberSeq::freebuf (tmp);
-    this->buffer_ = 0;
-  } 
-  
-  _TAO_Unbounded_Sequence_IR_StructMemberSeq::~_TAO_Unbounded_Sequence_IR_StructMemberSeq (void) // Dtor.
-  {
-    this->_deallocate_buffer ();
-  }
-  
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
-
-// *************************************************************
-// IR_StructMemberSeq
-// *************************************************************
-
-IR_StructMemberSeq::IR_StructMemberSeq (void)
-{}
-IR_StructMemberSeq::IR_StructMemberSeq (CORBA::ULong max) // uses max size
-  : 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Sequence_IR_StructMemberSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Sequence<IR_StructMember>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
- (max)
-{}
-IR_StructMemberSeq::IR_StructMemberSeq (CORBA::ULong max, CORBA::ULong length, IR_StructMember *buffer, CORBA::Boolean release)
-  : 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Sequence_IR_StructMemberSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Sequence<IR_StructMember>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
- (max, length, buffer, release)
-{}
-IR_StructMemberSeq::IR_StructMemberSeq (const IR_StructMemberSeq &seq) // copy ctor
-  : 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Sequence_IR_StructMemberSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Sequence<IR_StructMember>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
- (seq)
-{}
-IR_StructMemberSeq::~IR_StructMemberSeq (void) // dtor
-{}
-void IR_StructMemberSeq::_tao_any_destructor (void *x)
-{
-  IR_StructMemberSeq *tmp = ACE_static_cast (IR_StructMemberSeq*,x);
-  delete tmp;
-}
-
-static const CORBA::Long _oc_IR_StructMemberSeq[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f53), ACE_NTOHL (0x74727563), ACE_NTOHL (0x744d656d), ACE_NTOHL (0x62657253), ACE_NTOHL (0x65713a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/StructMemberSeq:1.0
-  16, ACE_NTOHL (0x53747275), ACE_NTOHL (0x63744d65), ACE_NTOHL (0x6d626572), ACE_NTOHL (0x53657100),  // name = IR_StructMemberSeq
-  CORBA::tk_sequence, // typecode kind
-  252, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    CORBA::tk_struct, // typecode kind
-    236, // encapsulation length
-      TAO_ENCAP_BYTE_ORDER, // byte order
-      32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f53), ACE_NTOHL (0x74727563), ACE_NTOHL (0x744d656d), ACE_NTOHL (0x6265723a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/StructMember:1.0
-      13, ACE_NTOHL (0x53747275), ACE_NTOHL (0x63744d65), ACE_NTOHL (0x6d626572), ACE_NTOHL (0x0),  // name = IR_StructMember
-      3, // member count
-      5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
-      CORBA::tk_alias, // typecode kind for typedefs
-      64, // encapsulation length
-        TAO_ENCAP_BYTE_ORDER, // byte order
-        30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
-        11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-        CORBA::tk_string, 
-        0U, // string length
-
-      5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
-      CORBA::tk_TypeCode,
-
-      9, ACE_NTOHL (0x74797065), ACE_NTOHL (0x5f646566), ACE_NTOHL (0x0),  // name = type_def
-      CORBA::tk_objref, // typecode kind
-      48, // encapsulation length
-        TAO_ENCAP_BYTE_ORDER, // byte order
-        27, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x444c5479), ACE_NTOHL (0x70653a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/IDLType:1.0
-        8, ACE_NTOHL (0x49444c54), ACE_NTOHL (0x79706500),  // name = IR_IDLType
-
-
-    0U,
-
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_StructMemberSeq (CORBA::tk_alias, sizeof (_oc_IR_StructMemberSeq), (char *) &_oc_IR_StructMemberSeq, 0, sizeof (IR_StructMemberSeq));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_StructMemberSeq, &_tc_TAO_tc_IR_StructMemberSeq)
-TAO_NAMESPACE_END
-
-static const CORBA::Long _oc_IR_Initializer[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x6e697469), ACE_NTOHL (0x616c697a), ACE_NTOHL (0x65723a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/Initializer:1.0
-  12, ACE_NTOHL (0x496e6974), ACE_NTOHL (0x69616c69), ACE_NTOHL (0x7a657200),  // name = IR_Initializer
-  2, // member count
-  8, ACE_NTOHL (0x6d656d62), ACE_NTOHL (0x65727300),  // name = members
-  CORBA::tk_alias, // typecode kind for typedefs
-  324, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f53), ACE_NTOHL (0x74727563), ACE_NTOHL (0x744d656d), ACE_NTOHL (0x62657253), ACE_NTOHL (0x65713a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/StructMemberSeq:1.0
-    16, ACE_NTOHL (0x53747275), ACE_NTOHL (0x63744d65), ACE_NTOHL (0x6d626572), ACE_NTOHL (0x53657100),  // name = IR_StructMemberSeq
-    CORBA::tk_sequence, // typecode kind
-    252, // encapsulation length
-      TAO_ENCAP_BYTE_ORDER, // byte order
-      CORBA::tk_struct, // typecode kind
-      236, // encapsulation length
-        TAO_ENCAP_BYTE_ORDER, // byte order
-        32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f53), ACE_NTOHL (0x74727563), ACE_NTOHL (0x744d656d), ACE_NTOHL (0x6265723a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/StructMember:1.0
-        13, ACE_NTOHL (0x53747275), ACE_NTOHL (0x63744d65), ACE_NTOHL (0x6d626572), ACE_NTOHL (0x0),  // name = IR_StructMember
-        3, // member count
-        5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
-        CORBA::tk_alias, // typecode kind for typedefs
-        64, // encapsulation length
-          TAO_ENCAP_BYTE_ORDER, // byte order
-          30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
-          11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-          CORBA::tk_string, 
-          0U, // string length
-
-        5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
-        CORBA::tk_TypeCode,
-
-        9, ACE_NTOHL (0x74797065), ACE_NTOHL (0x5f646566), ACE_NTOHL (0x0),  // name = type_def
-        CORBA::tk_objref, // typecode kind
-        48, // encapsulation length
-          TAO_ENCAP_BYTE_ORDER, // byte order
-          27, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x444c5479), ACE_NTOHL (0x70653a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/IDLType:1.0
-          8, ACE_NTOHL (0x49444c54), ACE_NTOHL (0x79706500),  // name = IR_IDLType
-
-
-      0U,
-
-
-  5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
-  CORBA::tk_alias, // typecode kind for typedefs
-  64, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
-    11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-    CORBA::tk_string, 
-    0U, // string length
-
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_Initializer (CORBA::tk_struct, sizeof (_oc_IR_Initializer), (char *) &_oc_IR_Initializer, 0, sizeof (IR_Initializer));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_Initializer, &_tc_TAO_tc_IR_Initializer)
-TAO_NAMESPACE_END
-
-void IR_Initializer::_tao_any_destructor (void *x)
-{
-  IR_Initializer *tmp = ACE_static_cast (IR_Initializer*,x);
-  delete tmp;
-}
-
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  
-  void
-  _TAO_Unbounded_Sequence_IR_InitializerSeq::_allocate_buffer (CORBA::ULong length)
-  {
-    IR_Initializer* tmp = 0;
-    tmp = _TAO_Unbounded_Sequence_IR_InitializerSeq::allocbuf (length);
-    
-    if (this->buffer_ != 0)
-    {
-      IR_Initializer *old = ACE_reinterpret_cast (IR_Initializer *,this->buffer_);
-      
-      for (CORBA::ULong i = 0; i < this->length_; ++i)
-        tmp[i] = old[i];
-      
-      if (this->release_)
-        _TAO_Unbounded_Sequence_IR_InitializerSeq::freebuf (old);
-      
-    }
-    this->buffer_ = tmp;
-  }
-  
-  void
-  _TAO_Unbounded_Sequence_IR_InitializerSeq::_deallocate_buffer (void)
-  {
-    if (this->buffer_ == 0 || this->release_ == 0)
-      return;
-    
-    IR_Initializer *tmp = ACE_reinterpret_cast (IR_Initializer *,this->buffer_);
-    
-    _TAO_Unbounded_Sequence_IR_InitializerSeq::freebuf (tmp);
-    this->buffer_ = 0;
-  } 
-  
-  _TAO_Unbounded_Sequence_IR_InitializerSeq::~_TAO_Unbounded_Sequence_IR_InitializerSeq (void) // Dtor.
-  {
-    this->_deallocate_buffer ();
-  }
-  
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
-
-// *************************************************************
-// IR_InitializerSeq
-// *************************************************************
-
-IR_InitializerSeq::IR_InitializerSeq (void)
-{}
-IR_InitializerSeq::IR_InitializerSeq (CORBA::ULong max) // uses max size
-  : 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Sequence_IR_InitializerSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Sequence<IR_Initializer>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
- (max)
-{}
-IR_InitializerSeq::IR_InitializerSeq (CORBA::ULong max, CORBA::ULong length, IR_Initializer *buffer, CORBA::Boolean release)
-  : 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Sequence_IR_InitializerSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Sequence<IR_Initializer>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
- (max, length, buffer, release)
-{}
-IR_InitializerSeq::IR_InitializerSeq (const IR_InitializerSeq &seq) // copy ctor
-  : 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Sequence_IR_InitializerSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Sequence<IR_Initializer>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
- (seq)
-{}
-IR_InitializerSeq::~IR_InitializerSeq (void) // dtor
-{}
-void IR_InitializerSeq::_tao_any_destructor (void *x)
-{
-  IR_InitializerSeq *tmp = ACE_static_cast (IR_InitializerSeq*,x);
-  delete tmp;
-}
-
-static const CORBA::Long _oc_IR_InitializerSeq[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  34, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x6e697469), ACE_NTOHL (0x616c697a), ACE_NTOHL (0x65725365), ACE_NTOHL (0x713a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/InitializerSeq:1.0
-  15, ACE_NTOHL (0x496e6974), ACE_NTOHL (0x69616c69), ACE_NTOHL (0x7a657253), ACE_NTOHL (0x65710000),  // name = IR_InitializerSeq
-  CORBA::tk_sequence, // typecode kind
-  504, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    CORBA::tk_struct, // typecode kind
-    488, // encapsulation length
-      TAO_ENCAP_BYTE_ORDER, // byte order
-      31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x6e697469), ACE_NTOHL (0x616c697a), ACE_NTOHL (0x65723a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/Initializer:1.0
-      12, ACE_NTOHL (0x496e6974), ACE_NTOHL (0x69616c69), ACE_NTOHL (0x7a657200),  // name = IR_Initializer
-      2, // member count
-      8, ACE_NTOHL (0x6d656d62), ACE_NTOHL (0x65727300),  // name = members
-      CORBA::tk_alias, // typecode kind for typedefs
-      324, // encapsulation length
-        TAO_ENCAP_BYTE_ORDER, // byte order
-        35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f53), ACE_NTOHL (0x74727563), ACE_NTOHL (0x744d656d), ACE_NTOHL (0x62657253), ACE_NTOHL (0x65713a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/StructMemberSeq:1.0
-        16, ACE_NTOHL (0x53747275), ACE_NTOHL (0x63744d65), ACE_NTOHL (0x6d626572), ACE_NTOHL (0x53657100),  // name = IR_StructMemberSeq
-        CORBA::tk_sequence, // typecode kind
-        252, // encapsulation length
-          TAO_ENCAP_BYTE_ORDER, // byte order
-          CORBA::tk_struct, // typecode kind
-          236, // encapsulation length
-            TAO_ENCAP_BYTE_ORDER, // byte order
-            32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f53), ACE_NTOHL (0x74727563), ACE_NTOHL (0x744d656d), ACE_NTOHL (0x6265723a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/StructMember:1.0
-            13, ACE_NTOHL (0x53747275), ACE_NTOHL (0x63744d65), ACE_NTOHL (0x6d626572), ACE_NTOHL (0x0),  // name = IR_StructMember
-            3, // member count
-            5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
-            CORBA::tk_alias, // typecode kind for typedefs
-            64, // encapsulation length
-              TAO_ENCAP_BYTE_ORDER, // byte order
-              30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
-              11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-              CORBA::tk_string, 
-              0U, // string length
-
-            5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
-            CORBA::tk_TypeCode,
-
-            9, ACE_NTOHL (0x74797065), ACE_NTOHL (0x5f646566), ACE_NTOHL (0x0),  // name = type_def
-            CORBA::tk_objref, // typecode kind
-            48, // encapsulation length
-              TAO_ENCAP_BYTE_ORDER, // byte order
-              27, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x444c5479), ACE_NTOHL (0x70653a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/IDLType:1.0
-              8, ACE_NTOHL (0x49444c54), ACE_NTOHL (0x79706500),  // name = IR_IDLType
-
-
-          0U,
-
-
-      5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
-      CORBA::tk_alias, // typecode kind for typedefs
-      64, // encapsulation length
-        TAO_ENCAP_BYTE_ORDER, // byte order
-        30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
-        11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-        CORBA::tk_string, 
-        0U, // string length
-
-
-    0U,
-
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_InitializerSeq (CORBA::tk_alias, sizeof (_oc_IR_InitializerSeq), (char *) &_oc_IR_InitializerSeq, 0, sizeof (IR_InitializerSeq));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_InitializerSeq, &_tc_TAO_tc_IR_InitializerSeq)
-TAO_NAMESPACE_END
-
-static const CORBA::Long _oc_IR_UnionMember[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f55), ACE_NTOHL (0x6e696f6e), ACE_NTOHL (0x4d656d62), ACE_NTOHL (0x65723a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/UnionMember:1.0
-  12, ACE_NTOHL (0x556e696f), ACE_NTOHL (0x6e4d656d), ACE_NTOHL (0x62657200),  // name = IR_UnionMember
-  4, // member count
-  5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
-  CORBA::tk_alias, // typecode kind for typedefs
-  64, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
-    11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-    CORBA::tk_string, 
-    0U, // string length
-
-  6, ACE_NTOHL (0x6c616265), ACE_NTOHL (0x6c000000),  // name = label
-  CORBA::tk_any,
-
-  5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
-  CORBA::tk_TypeCode,
-
-  9, ACE_NTOHL (0x74797065), ACE_NTOHL (0x5f646566), ACE_NTOHL (0x0),  // name = type_def
-  CORBA::tk_objref, // typecode kind
-  48, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    27, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x444c5479), ACE_NTOHL (0x70653a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/IDLType:1.0
-    8, ACE_NTOHL (0x49444c54), ACE_NTOHL (0x79706500),  // name = IR_IDLType
-
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_UnionMember (CORBA::tk_struct, sizeof (_oc_IR_UnionMember), (char *) &_oc_IR_UnionMember, 0, sizeof (IR_UnionMember));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_UnionMember, &_tc_TAO_tc_IR_UnionMember)
-TAO_NAMESPACE_END
-
-void IR_UnionMember::_tao_any_destructor (void *x)
-{
-  IR_UnionMember *tmp = ACE_static_cast (IR_UnionMember*,x);
-  delete tmp;
-}
-
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  
-  void
-  _TAO_Unbounded_Sequence_IR_UnionMemberSeq::_allocate_buffer (CORBA::ULong length)
-  {
-    IR_UnionMember* tmp = 0;
-    tmp = _TAO_Unbounded_Sequence_IR_UnionMemberSeq::allocbuf (length);
-    
-    if (this->buffer_ != 0)
-    {
-      IR_UnionMember *old = ACE_reinterpret_cast (IR_UnionMember *,this->buffer_);
-      
-      for (CORBA::ULong i = 0; i < this->length_; ++i)
-        tmp[i] = old[i];
-      
-      if (this->release_)
-        _TAO_Unbounded_Sequence_IR_UnionMemberSeq::freebuf (old);
-      
-    }
-    this->buffer_ = tmp;
-  }
-  
-  void
-  _TAO_Unbounded_Sequence_IR_UnionMemberSeq::_deallocate_buffer (void)
-  {
-    if (this->buffer_ == 0 || this->release_ == 0)
-      return;
-    
-    IR_UnionMember *tmp = ACE_reinterpret_cast (IR_UnionMember *,this->buffer_);
-    
-    _TAO_Unbounded_Sequence_IR_UnionMemberSeq::freebuf (tmp);
-    this->buffer_ = 0;
-  } 
-  
-  _TAO_Unbounded_Sequence_IR_UnionMemberSeq::~_TAO_Unbounded_Sequence_IR_UnionMemberSeq (void) // Dtor.
-  {
-    this->_deallocate_buffer ();
-  }
-  
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
-
-// *************************************************************
-// IR_UnionMemberSeq
-// *************************************************************
-
-IR_UnionMemberSeq::IR_UnionMemberSeq (void)
-{}
-IR_UnionMemberSeq::IR_UnionMemberSeq (CORBA::ULong max) // uses max size
-  : 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Sequence_IR_UnionMemberSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Sequence<IR_UnionMember>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
- (max)
-{}
-IR_UnionMemberSeq::IR_UnionMemberSeq (CORBA::ULong max, CORBA::ULong length, IR_UnionMember *buffer, CORBA::Boolean release)
-  : 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Sequence_IR_UnionMemberSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Sequence<IR_UnionMember>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
- (max, length, buffer, release)
-{}
-IR_UnionMemberSeq::IR_UnionMemberSeq (const IR_UnionMemberSeq &seq) // copy ctor
-  : 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Sequence_IR_UnionMemberSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Sequence<IR_UnionMember>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
- (seq)
-{}
-IR_UnionMemberSeq::~IR_UnionMemberSeq (void) // dtor
-{}
-void IR_UnionMemberSeq::_tao_any_destructor (void *x)
-{
-  IR_UnionMemberSeq *tmp = ACE_static_cast (IR_UnionMemberSeq*,x);
-  delete tmp;
-}
-
-static const CORBA::Long _oc_IR_UnionMemberSeq[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  34, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f55), ACE_NTOHL (0x6e696f6e), ACE_NTOHL (0x4d656d62), ACE_NTOHL (0x65725365), ACE_NTOHL (0x713a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/UnionMemberSeq:1.0
-  15, ACE_NTOHL (0x556e696f), ACE_NTOHL (0x6e4d656d), ACE_NTOHL (0x62657253), ACE_NTOHL (0x65710000),  // name = IR_UnionMemberSeq
-  CORBA::tk_sequence, // typecode kind
-  264, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    CORBA::tk_struct, // typecode kind
-    248, // encapsulation length
-      TAO_ENCAP_BYTE_ORDER, // byte order
-      31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f55), ACE_NTOHL (0x6e696f6e), ACE_NTOHL (0x4d656d62), ACE_NTOHL (0x65723a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/UnionMember:1.0
-      12, ACE_NTOHL (0x556e696f), ACE_NTOHL (0x6e4d656d), ACE_NTOHL (0x62657200),  // name = IR_UnionMember
-      4, // member count
-      5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
-      CORBA::tk_alias, // typecode kind for typedefs
-      64, // encapsulation length
-        TAO_ENCAP_BYTE_ORDER, // byte order
-        30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
-        11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-        CORBA::tk_string, 
-        0U, // string length
-
-      6, ACE_NTOHL (0x6c616265), ACE_NTOHL (0x6c000000),  // name = label
-      CORBA::tk_any,
-
-      5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
-      CORBA::tk_TypeCode,
-
-      9, ACE_NTOHL (0x74797065), ACE_NTOHL (0x5f646566), ACE_NTOHL (0x0),  // name = type_def
-      CORBA::tk_objref, // typecode kind
-      48, // encapsulation length
-        TAO_ENCAP_BYTE_ORDER, // byte order
-        27, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x444c5479), ACE_NTOHL (0x70653a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/IDLType:1.0
-        8, ACE_NTOHL (0x49444c54), ACE_NTOHL (0x79706500),  // name = IR_IDLType
-
-
-    0U,
-
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_UnionMemberSeq (CORBA::tk_alias, sizeof (_oc_IR_UnionMemberSeq), (char *) &_oc_IR_UnionMemberSeq, 0, sizeof (IR_UnionMemberSeq));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_UnionMemberSeq, &_tc_TAO_tc_IR_UnionMemberSeq)
-TAO_NAMESPACE_END
-
-// *************************************************************
-// IR_EnumMemberSeq
-// *************************************************************
-
-IR_EnumMemberSeq::IR_EnumMemberSeq (void)
-{}
-IR_EnumMemberSeq::IR_EnumMemberSeq (CORBA::ULong max) // uses max size
-  : 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  TAO_Unbounded_String_Sequence
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_String_Sequence
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
- (max)
-{}
-IR_EnumMemberSeq::IR_EnumMemberSeq (CORBA::ULong max, CORBA::ULong length, char * *buffer, CORBA::Boolean release)
-  : 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  TAO_Unbounded_String_Sequence
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_String_Sequence
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
- (max, length, buffer, release)
-{}
-IR_EnumMemberSeq::IR_EnumMemberSeq (const IR_EnumMemberSeq &seq) // copy ctor
-  : 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  TAO_Unbounded_String_Sequence
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_String_Sequence
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
- (seq)
-{}
-IR_EnumMemberSeq::~IR_EnumMemberSeq (void) // dtor
-{}
-void IR_EnumMemberSeq::_tao_any_destructor (void *x)
-{
-  IR_EnumMemberSeq *tmp = ACE_static_cast (IR_EnumMemberSeq*,x);
-  delete tmp;
-}
-
-static const CORBA::Long _oc_IR_EnumMemberSeq[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x6e756d4d), ACE_NTOHL (0x656d6265), ACE_NTOHL (0x72536571), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/EnumMemberSeq:1.0
-  14, ACE_NTOHL (0x456e756d), ACE_NTOHL (0x4d656d62), ACE_NTOHL (0x65725365), ACE_NTOHL (0x71000000),  // name = IR_EnumMemberSeq
-  CORBA::tk_sequence, // typecode kind
-  80, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    CORBA::tk_alias, // typecode kind for typedefs
-    64, // encapsulation length
-      TAO_ENCAP_BYTE_ORDER, // byte order
-      30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
-      11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-      CORBA::tk_string, 
-      0U, // string length
-
-    0U,
-
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_EnumMemberSeq (CORBA::tk_alias, sizeof (_oc_IR_EnumMemberSeq), (char *) &_oc_IR_EnumMemberSeq, 0, sizeof (IR_EnumMemberSeq));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_EnumMemberSeq, &_tc_TAO_tc_IR_EnumMemberSeq)
-TAO_NAMESPACE_END
-
-///////////////////////////////////////////////////////////////////////
-//                Base & Remote Proxy  Implementation. 
-//
-
-_TAO_Container_Proxy_Impl::_TAO_Container_Proxy_Impl (void)
-{}
-
-_TAO_Container_Remote_Proxy_Impl::_TAO_Container_Remote_Proxy_Impl (void)
-{}
-
-// Remote Implementation of the IDL interface methods
-
-IR_Contained_ptr _TAO_Container_Remote_Proxy_Impl::lookup (
-    CORBA_Object *_collocated_tao_target_,
-    const char * search_name,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{ 
-  IR_Contained_ptr _tao_retval = IR_Contained::_nil ();
-  IR_Contained_var _tao_safe_retval (_tao_retval);
-  
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-
-  
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "lookup",
-      6,
-      1,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_Container::TAO_ClientRequestInfo_IR_Container_lookup ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        search_name,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-          if (!(
-                            (_tao_out << search_name)
-            ))
-            TAO_INTERCEPTOR_THROW_RETURN (
-              CORBA::MARSHAL (),
-              0
-            );
-            
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              IR_Contained_ptr _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-IR_ContainedSeq * _TAO_Container_Remote_Proxy_Impl::contents (
-    CORBA_Object *_collocated_tao_target_,
-    IR_DefinitionKind limit_type,
-    CORBA::Boolean exclude_inherited,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{ 
-  IR_ContainedSeq *_tao_retval = 0;
-   
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-  
-  ACE_NEW_RETURN (_tao_retval, IR_ContainedSeq, _tao_retval);
-  IR_ContainedSeq_var _tao_safe_retval (_tao_retval);
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "contents",
-      8,
-      1,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_Container::TAO_ClientRequestInfo_IR_Container_contents ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        limit_type,
-        exclude_inherited,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-          if (!(
-                            (_tao_out << limit_type) &&
-              (_tao_out << CORBA::Any::from_boolean (exclude_inherited))
-            ))
-            TAO_INTERCEPTOR_THROW_RETURN (
-              CORBA::MARSHAL (),
-              0
-            );
-            
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              IR_ContainedSeq * _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-IR_ContainedSeq * _TAO_Container_Remote_Proxy_Impl::lookup_name (
-    CORBA_Object *_collocated_tao_target_,
-    const char * search_name,
-    CORBA::Long levels_to_search,
-    IR_DefinitionKind limit_type,
-    CORBA::Boolean exclude_inherited,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{ 
-  IR_ContainedSeq *_tao_retval = 0;
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-
-  ACE_NEW_RETURN (_tao_retval, IR_ContainedSeq, _tao_retval);
-  IR_ContainedSeq_var _tao_safe_retval (_tao_retval);
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "lookup_name",
-      11,
-      1,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_Container::TAO_ClientRequestInfo_IR_Container_lookup_name ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        search_name,
-        levels_to_search,
-        limit_type,
-        exclude_inherited,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-          if (!(
-                            (_tao_out << search_name) &&
-              (_tao_out << levels_to_search) &&
-              (_tao_out << limit_type) &&
-              (_tao_out << CORBA::Any::from_boolean (exclude_inherited))
-            ))
-            TAO_INTERCEPTOR_THROW_RETURN (
-              CORBA::MARSHAL (),
-              0
-            );
-            
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              IR_ContainedSeq * _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-IR_Container::DescriptionSeq * _TAO_Container_Remote_Proxy_Impl::describe_contents (
-    CORBA_Object *_collocated_tao_target_,
-    IR_DefinitionKind limit_type,
-    CORBA::Boolean exclude_inherited,
-    CORBA::Long max_returned_objs,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  IR_Container::DescriptionSeq *_tao_retval = 0;
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-  
-  ACE_NEW_RETURN (_tao_retval, IR_Container::DescriptionSeq, _tao_retval);
-  IR_Container::DescriptionSeq_var _tao_safe_retval (_tao_retval);
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "describe_contents",
-      17,
-      1,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_Container::TAO_ClientRequestInfo_IR_Container_describe_contents ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        limit_type,
-        exclude_inherited,
-        max_returned_objs,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-          if (!(
-                            (_tao_out << limit_type) &&
-              (_tao_out << CORBA::Any::from_boolean (exclude_inherited)) &&
-              (_tao_out << max_returned_objs)
-            ))
-            TAO_INTERCEPTOR_THROW_RETURN (
-              CORBA::MARSHAL (),
-              0
-            );
-            
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              IR_Container::DescriptionSeq * _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-IR_ModuleDef_ptr _TAO_Container_Remote_Proxy_Impl::create_module (
-    CORBA_Object *_collocated_tao_target_,
-    const char * id,
-    const char * name,
-    const char * version,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  IR_ModuleDef_ptr _tao_retval = IR_ModuleDef::_nil ();
-  IR_ModuleDef_var _tao_safe_retval (_tao_retval);
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "create_module",
-      13,
-      1,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_Container::TAO_ClientRequestInfo_IR_Container_create_module ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        id,
-        name,
-        version,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-          if (!(
-                            (_tao_out << id) &&
-              (_tao_out << name) &&
-              (_tao_out << version)
-            ))
-            TAO_INTERCEPTOR_THROW_RETURN (
-              CORBA::MARSHAL (),
-              0
-            );
-            
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              IR_ModuleDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-IR_ConstantDef_ptr _TAO_Container_Remote_Proxy_Impl::create_constant (
-    CORBA_Object *_collocated_tao_target_,
-    const char * id,
-    const char * name,
-    const char * version,
-    IR_IDLType_ptr type,
-    const CORBA::Any & value,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  IR_ConstantDef_ptr _tao_retval = IR_ConstantDef::_nil ();
-  IR_ConstantDef_var _tao_safe_retval (_tao_retval);
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-  
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "create_constant",
-      15,
-      1,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_Container::TAO_ClientRequestInfo_IR_Container_create_constant ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        id,
-        name,
-        version,
-        type,
-        value,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-          if (!(
-                            (_tao_out << id) &&
-              (_tao_out << name) &&
-              (_tao_out << version) &&
-              (_tao_out << type) &&
-              (_tao_out << value)
-            ))
-            TAO_INTERCEPTOR_THROW_RETURN (
-              CORBA::MARSHAL (),
-              0
-            );
-            
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              IR_ConstantDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-IR_StructDef_ptr _TAO_Container_Remote_Proxy_Impl::create_struct (
-    CORBA_Object *_collocated_tao_target_,
-    const char * id,
-    const char * name,
-    const char * version,
-    const IR_StructMemberSeq & members,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  IR_StructDef_ptr _tao_retval = IR_StructDef::_nil ();
-  IR_StructDef_var _tao_safe_retval (_tao_retval);
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "create_struct",
-      13,
-      1,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_Container::TAO_ClientRequestInfo_IR_Container_create_struct ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        id,
-        name,
-        version,
-        members,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-          if (!(
-                            (_tao_out << id) &&
-              (_tao_out << name) &&
-              (_tao_out << version) &&
-              (_tao_out << members)
-            ))
-            TAO_INTERCEPTOR_THROW_RETURN (
-              CORBA::MARSHAL (),
-              0
-            );
-            
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              IR_StructDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-IR_UnionDef_ptr _TAO_Container_Remote_Proxy_Impl::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,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  IR_UnionDef_ptr _tao_retval = IR_UnionDef::_nil ();
-  IR_UnionDef_var _tao_safe_retval (_tao_retval);
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "create_union",
-      12,
-      1,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_Container::TAO_ClientRequestInfo_IR_Container_create_union ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        id,
-        name,
-        version,
-        discriminator_type,
-        members,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-          if (!(
-                            (_tao_out << id) &&
-              (_tao_out << name) &&
-              (_tao_out << version) &&
-              (_tao_out << discriminator_type) &&
-              (_tao_out << members)
-            ))
-            TAO_INTERCEPTOR_THROW_RETURN (
-              CORBA::MARSHAL (),
-              0
-            );
-            
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              IR_UnionDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-IR_EnumDef_ptr _TAO_Container_Remote_Proxy_Impl::create_enum (
-    CORBA_Object *_collocated_tao_target_,
-    const char * id,
-    const char * name,
-    const char * version,
-    const IR_EnumMemberSeq & members,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  IR_EnumDef_ptr _tao_retval = IR_EnumDef::_nil ();
-  IR_EnumDef_var _tao_safe_retval (_tao_retval);
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "create_enum",
-      11,
-      1,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_Container::TAO_ClientRequestInfo_IR_Container_create_enum ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        id,
-        name,
-        version,
-        members,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-          if (!(
-                            (_tao_out << id) &&
-              (_tao_out << name) &&
-              (_tao_out << version) &&
-              (_tao_out << members)
-            ))
-            TAO_INTERCEPTOR_THROW_RETURN (
-              CORBA::MARSHAL (),
-              0
-            );
-            
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              IR_EnumDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-IR_AliasDef_ptr _TAO_Container_Remote_Proxy_Impl::create_alias (
-    CORBA_Object *_collocated_tao_target_,
-    const char * id,
-    const char * name,
-    const char * version,
-    IR_IDLType_ptr original_type,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  IR_AliasDef_ptr _tao_retval = IR_AliasDef::_nil ();
-  IR_AliasDef_var _tao_safe_retval (_tao_retval);
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "create_alias",
-      12,
-      1,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_Container::TAO_ClientRequestInfo_IR_Container_create_alias ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        id,
-        name,
-        version,
-        original_type,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-          if (!(
-                            (_tao_out << id) &&
-              (_tao_out << name) &&
-              (_tao_out << version) &&
-              (_tao_out << original_type)
-            ))
-            TAO_INTERCEPTOR_THROW_RETURN (
-              CORBA::MARSHAL (),
-              0
-            );
-            
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              IR_AliasDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-IR_InterfaceDef_ptr _TAO_Container_Remote_Proxy_Impl::create_interface (
-    CORBA_Object *_collocated_tao_target_,
-    const char * id,
-    const char * name,
-    const char * version,
-    const IR_InterfaceDefSeq & base_interfaces,
-    CORBA::Boolean is_abstract,
-    CORBA::Boolean is_local,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  IR_InterfaceDef_ptr _tao_retval = IR_InterfaceDef::_nil ();
-  IR_InterfaceDef_var _tao_safe_retval (_tao_retval);
-  
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "create_interface",
-      16,
-      1,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_Container::TAO_ClientRequestInfo_IR_Container_create_interface ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        id,
-        name,
-        version,
-        base_interfaces,
-        is_abstract,
-        is_local,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-          if (!(
-                            (_tao_out << id) &&
-              (_tao_out << name) &&
-              (_tao_out << version) &&
-              (_tao_out << base_interfaces) &&
-              (_tao_out << CORBA::Any::from_boolean (is_abstract)) &&
-              (_tao_out << CORBA::Any::from_boolean (is_local))
-            ))
-            TAO_INTERCEPTOR_THROW_RETURN (
-              CORBA::MARSHAL (),
-              0
-            );
-            
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              IR_InterfaceDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-IR_ValueDef_ptr _TAO_Container_Remote_Proxy_Impl::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,
-    CORBA::Boolean is_truncatable,
-    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
-  ))
-{
-  IR_ValueDef_ptr _tao_retval = IR_ValueDef::_nil ();
-  IR_ValueDef_var _tao_safe_retval (_tao_retval);
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "create_value",
-      12,
-      1,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_Container::TAO_ClientRequestInfo_IR_Container_create_value ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        id,
-        name,
-        version,
-        is_custom,
-        is_abstract,
-        base_value,
-        is_truncatable,
-        abstract_base_values,
-        supported_interfaces,
-        initializers,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-          if (!(
-                            (_tao_out << id) &&
-              (_tao_out << name) &&
-              (_tao_out << version) &&
-              (_tao_out << CORBA::Any::from_boolean (is_custom)) &&
-              (_tao_out << CORBA::Any::from_boolean (is_abstract)) &&
-              (_tao_out << base_value) &&
-              (_tao_out << CORBA::Any::from_boolean (is_truncatable)) &&
-              (_tao_out << abstract_base_values) &&
-              (_tao_out << supported_interfaces) &&
-              (_tao_out << initializers)
-            ))
-            TAO_INTERCEPTOR_THROW_RETURN (
-              CORBA::MARSHAL (),
-              0
-            );
-            
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              IR_ValueDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-IR_ValueBoxDef_ptr _TAO_Container_Remote_Proxy_Impl::create_value_box (
-    CORBA_Object *_collocated_tao_target_,
-    const char * id,
-    const char * name,
-    const char * version,
-    IR_IDLType_ptr original_type_def,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  IR_ValueBoxDef_ptr _tao_retval = IR_ValueBoxDef::_nil ();
-  IR_ValueBoxDef_var _tao_safe_retval (_tao_retval);
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "create_value_box",
-      16,
-      1,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_Container::TAO_ClientRequestInfo_IR_Container_create_value_box ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        id,
-        name,
-        version,
-        original_type_def,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-          if (!(
-                            (_tao_out << id) &&
-              (_tao_out << name) &&
-              (_tao_out << version) &&
-              (_tao_out << original_type_def)
-            ))
-            TAO_INTERCEPTOR_THROW_RETURN (
-              CORBA::MARSHAL (),
-              0
-            );
-            
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              IR_ValueBoxDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-IR_ExceptionDef_ptr _TAO_Container_Remote_Proxy_Impl::create_exception (
-    CORBA_Object *_collocated_tao_target_,
-    const char * id,
-    const char * name,
-    const char * version,
-    const IR_StructMemberSeq & members,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  IR_ExceptionDef_ptr _tao_retval = IR_ExceptionDef::_nil ();
-  IR_ExceptionDef_var _tao_safe_retval (_tao_retval);
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "create_exception",
-      16,
-      1,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_Container::TAO_ClientRequestInfo_IR_Container_create_exception ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        id,
-        name,
-        version,
-        members,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-          if (!(
-                            (_tao_out << id) &&
-              (_tao_out << name) &&
-              (_tao_out << version) &&
-              (_tao_out << members)
-            ))
-            TAO_INTERCEPTOR_THROW_RETURN (
-              CORBA::MARSHAL (),
-              0
-            );
-            
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              IR_ExceptionDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-IR_NativeDef_ptr _TAO_Container_Remote_Proxy_Impl::create_native (
-    CORBA_Object *_collocated_tao_target_,
-    const char * id,
-    const char * name,
-    const char * version,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  IR_NativeDef_ptr _tao_retval = IR_NativeDef::_nil ();
-  IR_NativeDef_var _tao_safe_retval (_tao_retval);
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "create_native",
-      13,
-      1,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_Container::TAO_ClientRequestInfo_IR_Container_create_native ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        id,
-        name,
-        version,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-          if (!(
-                            (_tao_out << id) &&
-              (_tao_out << name) &&
-              (_tao_out << version)
-            ))
-            TAO_INTERCEPTOR_THROW_RETURN (
-              CORBA::MARSHAL (),
-              0
-            );
-            
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              IR_NativeDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-
-//
-//            End  Base & Remote  Proxy Implemeentation. 
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//           Remote & Base  Proxy Broker Implementation
-//
-
-_TAO_Container_Proxy_Broker::_TAO_Container_Proxy_Broker (void)
-{
-}
-
-_TAO_Container_Proxy_Broker::~_TAO_Container_Proxy_Broker (void)
-{
-}
-
-_TAO_Container_Proxy_Broker * (*_TAO_Container_Proxy_Broker_Factory_function_pointer) (
-    CORBA::Object_ptr obj
-  ) = 0;
-
-// Factory Member function Implementation.
-_TAO_Container_Remote_Proxy_Broker *
-_TAO_Container_Remote_Proxy_Broker::the_TAO_Container_Remote_Proxy_Broker (void)
-{
-  static ::_TAO_Container_Remote_Proxy_Broker remote_proxy_broker;
-  return &remote_proxy_broker;
-}
-
-_TAO_Container_Remote_Proxy_Broker::_TAO_Container_Remote_Proxy_Broker (void)
-{
-}
-
-_TAO_Container_Remote_Proxy_Broker::~_TAO_Container_Remote_Proxy_Broker (void)
-{
-}
-
-_TAO_Container_Proxy_Impl&
-_TAO_Container_Remote_Proxy_Broker::select_proxy (
-  ::IR_Container *object,
-  CORBA::Environment &ACE_TRY_ENV
-)
-{
-  ACE_UNUSED_ARG (object);
-  ACE_UNUSED_ARG (ACE_TRY_ENV);
-  return remote_proxy_impl_;
-}
-
-
-//
-//           End Remote & Base Proxy Broker Implementation
-///////////////////////////////////////////////////////////////////////
-
-
-// default constructor
-IR_Container::IR_Container (int collocated)
-{
-  this->IR_Container_setup_collocation (collocated);
-}
-
-// destructor
-IR_Container::~IR_Container (void)
-{}
-
-void
-IR_Container::IR_Container_setup_collocation (int collocated)
-{
-  if (collocated)
-    this->the_TAO_Container_Proxy_Broker_ =
-      _TAO_Container_Proxy_Broker_Factory_function_pointer (this);
-  else
-    this->the_TAO_Container_Proxy_Broker_ =
-      _TAO_Container_Remote_Proxy_Broker::the_TAO_Container_Remote_Proxy_Broker ();
-  
-  this->CORBA_IRObject_setup_collocation (collocated);  
-}
-
-void IR_Container::_tao_any_destructor (void *x)
-{
-  IR_Container *tmp = ACE_static_cast (IR_Container*,x);
-  CORBA::release (tmp);
-}
-
-IR_Container_ptr IR_Container::_narrow (
-    CORBA::Object_ptr obj,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  if (CORBA::is_nil (obj))
-    return IR_Container::_nil ();
-  if (! obj->_is_local ())
-    {
-      CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/IR/Container:1.0", ACE_TRY_ENV);
-      ACE_CHECK_RETURN (IR_Container::_nil ());
-      if (is_a == 0)
-        return IR_Container::_nil ();
-    }
-  return IR_Container::_unchecked_narrow (obj, ACE_TRY_ENV);
-}
-
-IR_Container_ptr IR_Container::_unchecked_narrow (
-    CORBA::Object_ptr obj,
-    CORBA::Environment &
-  )
-{
-  if (CORBA::is_nil (obj))
-    return IR_Container::_nil ();
-  if (! obj->_is_local ())
-    {
-      TAO_Stub* stub = obj->_stubobj ();
-      if (stub)
-        stub->_incr_refcnt ();
-      IR_Container_ptr default_proxy = IR_Container::_nil ();
-
-      if (
-          !CORBA::is_nil (stub->servant_orb_var ().ptr ()) &&
-          stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects () &&
-          obj->_is_collocated () &&_TAO_Container_Proxy_Broker_Factory_function_pointer != 0
-        )
-      {
-        ACE_NEW_RETURN (
-          default_proxy,
-          ::IR_Container (
-            stub,
-            1,
-            obj->_servant ()),
-            
-          IR_Container::_nil ());
-        }
-      if (CORBA::is_nil (default_proxy))
-        ACE_NEW_RETURN (default_proxy, ::IR_Container (stub, 0, obj->_servant ()), IR_Container::_nil ());
-        return default_proxy;
-      }
-    else 
-      return
-        ACE_reinterpret_cast
-          (
-            IR_Container_ptr,
-              obj->_tao_QueryInterface
-                (
-                  ACE_reinterpret_cast
-                    (
-                      ptr_arith_t,
-                      &IR_Container::_narrow
-                    )
-                )
-          );
-}
-
-IR_Container_ptr
-IR_Container::_duplicate (IR_Container_ptr obj)
-{
-  if (!CORBA::is_nil (obj))
-    obj->_add_ref ();
-  return obj;
-}
-
-CORBA::Boolean IR_Container::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
-{
-  if (
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/Container:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
-  return 1; // success using local knowledge
-  else
-    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
-}
-
-void *IR_Container::_tao_QueryInterface (ptr_arith_t type)
-{
-  void *retv = 0;
-  if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_Container::_narrow))
-    retv = ACE_reinterpret_cast (void*, this);
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &CORBA_IRObject::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            CORBA_IRObject_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
-    retv = ACE_reinterpret_cast (void *,
-      ACE_static_cast (CORBA::Object_ptr, this));
-    
-  if (retv)
-    this->_add_ref ();
-  return retv;
-}
-
-const char* IR_Container::_interface_repository_id (void) const
-{
-  return "IDL:omg.org/IR/Container:1.0";
-}
-
-IR_Contained_ptr IR_Container::lookup (
-    const char * search_name,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{ 
-  _TAO_Container_Proxy_Impl &proxy = 
-    this->the_TAO_Container_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.lookup (
-      this,
-      search_name,
-      ACE_TRY_ENV
-    );
-}
-
-IR_ContainedSeq * IR_Container::contents (
-    IR_DefinitionKind limit_type,
-    CORBA::Boolean exclude_inherited,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_Container_Proxy_Impl &proxy = 
-    this->the_TAO_Container_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.contents (
-      this,
-      limit_type,
-      exclude_inherited,
-      ACE_TRY_ENV
-    );
-}
-
-IR_ContainedSeq * IR_Container::lookup_name (
-    const char * search_name,
-    CORBA::Long levels_to_search,
-    IR_DefinitionKind limit_type,
-    CORBA::Boolean exclude_inherited,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_Container_Proxy_Impl &proxy = 
-    this->the_TAO_Container_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.lookup_name (
-      this,
-      search_name,
-      levels_to_search,
-      limit_type,
-      exclude_inherited,
-      ACE_TRY_ENV
-    );
-}
-
-static const CORBA::Long _oc_IR_Container_Description[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  41, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f43), ACE_NTOHL (0x6f6e7461), ACE_NTOHL (0x696e6572), ACE_NTOHL (0x2f446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/Container/Description:1.0
-  12, ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e00),  // name = Description
-  3, // member count
-  17, ACE_NTOHL (0x636f6e74), ACE_NTOHL (0x61696e65), ACE_NTOHL (0x645f6f62), ACE_NTOHL (0x6a656374), ACE_NTOHL (0x0),  // name = contained_object
-  CORBA::tk_objref, // typecode kind
-  56, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    29, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f43), ACE_NTOHL (0x6f6e7461), ACE_NTOHL (0x696e6564), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/Contained:1.0
-    10, ACE_NTOHL (0x436f6e74), ACE_NTOHL (0x61696e65), ACE_NTOHL (0x64000000),  // name = IR_Contained
-
-  5, ACE_NTOHL (0x6b696e64), ACE_NTOHL (0x0),  // name = kind
-  CORBA::tk_enum, // typecode kind
-  632, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    34, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f44), ACE_NTOHL (0x6566696e), ACE_NTOHL (0x6974696f), ACE_NTOHL (0x6e4b696e), ACE_NTOHL (0x643a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/DefinitionKind:1.0
-    15, ACE_NTOHL (0x44656669), ACE_NTOHL (0x6e697469), ACE_NTOHL (0x6f6e4b69), ACE_NTOHL (0x6e640000),  // name = DefinitionKind
-    34, // member count
-    8, ACE_NTOHL (0x646b5f6e), ACE_NTOHL (0x6f6e6500),  // name = dk_none
-    7, ACE_NTOHL (0x646b5f61), ACE_NTOHL (0x6c6c0000),  // name = dk_all
-    13, ACE_NTOHL (0x646b5f41), ACE_NTOHL (0x74747269), ACE_NTOHL (0x62757465), ACE_NTOHL (0x0),  // name = dk_Attribute
-    12, ACE_NTOHL (0x646b5f43), ACE_NTOHL (0x6f6e7374), ACE_NTOHL (0x616e7400),  // name = dk_Constant
-    13, ACE_NTOHL (0x646b5f45), ACE_NTOHL (0x78636570), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = dk_Exception
-    13, ACE_NTOHL (0x646b5f49), ACE_NTOHL (0x6e746572), ACE_NTOHL (0x66616365), ACE_NTOHL (0x0),  // name = dk_Interface
-    10, ACE_NTOHL (0x646b5f4d), ACE_NTOHL (0x6f64756c), ACE_NTOHL (0x65000000),  // name = dk_Module
-    13, ACE_NTOHL (0x646b5f4f), ACE_NTOHL (0x70657261), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = dk_Operation
-    11, ACE_NTOHL (0x646b5f54), ACE_NTOHL (0x79706564), ACE_NTOHL (0x65660000),  // name = dk_Typedef
-    9, ACE_NTOHL (0x646b5f41), ACE_NTOHL (0x6c696173), ACE_NTOHL (0x0),  // name = dk_Alias
-    10, ACE_NTOHL (0x646b5f53), ACE_NTOHL (0x74727563), ACE_NTOHL (0x74000000),  // name = dk_Struct
-    9, ACE_NTOHL (0x646b5f55), ACE_NTOHL (0x6e696f6e), ACE_NTOHL (0x0),  // name = dk_Union
-    8, ACE_NTOHL (0x646b5f45), ACE_NTOHL (0x6e756d00),  // name = dk_Enum
-    13, ACE_NTOHL (0x646b5f50), ACE_NTOHL (0x72696d69), ACE_NTOHL (0x74697665), ACE_NTOHL (0x0),  // name = dk_Primitive
-    10, ACE_NTOHL (0x646b5f53), ACE_NTOHL (0x7472696e), ACE_NTOHL (0x67000000),  // name = dk_String
-    12, ACE_NTOHL (0x646b5f53), ACE_NTOHL (0x65717565), ACE_NTOHL (0x6e636500),  // name = dk_Sequence
-    9, ACE_NTOHL (0x646b5f41), ACE_NTOHL (0x72726179), ACE_NTOHL (0x0),  // name = dk_Array
-    14, ACE_NTOHL (0x646b5f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x79000000),  // name = dk_Repository
-    11, ACE_NTOHL (0x646b5f57), ACE_NTOHL (0x73747269), ACE_NTOHL (0x6e670000),  // name = dk_Wstring
-    9, ACE_NTOHL (0x646b5f46), ACE_NTOHL (0x69786564), ACE_NTOHL (0x0),  // name = dk_Fixed
-    9, ACE_NTOHL (0x646b5f56), ACE_NTOHL (0x616c7565), ACE_NTOHL (0x0),  // name = dk_Value
-    12, ACE_NTOHL (0x646b5f56), ACE_NTOHL (0x616c7565), ACE_NTOHL (0x426f7800),  // name = dk_ValueBox
-    15, ACE_NTOHL (0x646b5f56), ACE_NTOHL (0x616c7565), ACE_NTOHL (0x4d656d62), ACE_NTOHL (0x65720000),  // name = dk_ValueMember
-    10, ACE_NTOHL (0x646b5f4e), ACE_NTOHL (0x61746976), ACE_NTOHL (0x65000000),  // name = dk_Native
-    13, ACE_NTOHL (0x646b5f43), ACE_NTOHL (0x6f6d706f), ACE_NTOHL (0x6e656e74), ACE_NTOHL (0x0),  // name = dk_Component
-    8, ACE_NTOHL (0x646b5f48), ACE_NTOHL (0x6f6d6500),  // name = dk_Home
-    11, ACE_NTOHL (0x646b5f46), ACE_NTOHL (0x6163746f), ACE_NTOHL (0x72790000),  // name = dk_Factory
-    10, ACE_NTOHL (0x646b5f46), ACE_NTOHL (0x696e6465), ACE_NTOHL (0x72000000),  // name = dk_Finder
-    14, ACE_NTOHL (0x646b5f50), ACE_NTOHL (0x72696d61), ACE_NTOHL (0x72794b65), ACE_NTOHL (0x79000000),  // name = dk_PrimaryKey
-    9, ACE_NTOHL (0x646b5f45), ACE_NTOHL (0x6d697473), ACE_NTOHL (0x0),  // name = dk_Emits
-    13, ACE_NTOHL (0x646b5f50), ACE_NTOHL (0x75626c69), ACE_NTOHL (0x73686573), ACE_NTOHL (0x0),  // name = dk_Publishes
-    12, ACE_NTOHL (0x646b5f43), ACE_NTOHL (0x6f6e7375), ACE_NTOHL (0x6d657300),  // name = dk_Consumes
-    12, ACE_NTOHL (0x646b5f50), ACE_NTOHL (0x726f7669), ACE_NTOHL (0x64657300),  // name = dk_Provides
-    8, ACE_NTOHL (0x646b5f55), ACE_NTOHL (0x73657300),  // name = dk_Uses
-
-  6, ACE_NTOHL (0x76616c75), ACE_NTOHL (0x65000000),  // name = value
-  CORBA::tk_any,
-
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_Container_Description (CORBA::tk_struct, sizeof (_oc_IR_Container_Description), (char *) &_oc_IR_Container_Description, 0, sizeof (IR_Container::Description));
-CORBA::TypeCode_ptr IR_Container::_tc_Description = &_tc_TAO_tc_IR_Container_Description;
-
-void IR_Container::Description::_tao_any_destructor (void *x)
-{
-  Description *tmp = ACE_static_cast (Description*,x);
-  delete tmp;
-}
-
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  
-  void
-  IR_Container::_TAO_Unbounded_Sequence_IR_Container_DescriptionSeq::_allocate_buffer (CORBA::ULong length)
-  {
-    IR_Container::Description* tmp = 0;
-    tmp = _TAO_Unbounded_Sequence_IR_Container_DescriptionSeq::allocbuf (length);
-    
-    if (this->buffer_ != 0)
-    {
-      IR_Container::Description *old = ACE_reinterpret_cast (IR_Container::Description *,this->buffer_);
-      
-      for (CORBA::ULong i = 0; i < this->length_; ++i)
-        tmp[i] = old[i];
-      
-      if (this->release_)
-        _TAO_Unbounded_Sequence_IR_Container_DescriptionSeq::freebuf (old);
-      
-    }
-    this->buffer_ = tmp;
-  }
-  
-  void
-  IR_Container::_TAO_Unbounded_Sequence_IR_Container_DescriptionSeq::_deallocate_buffer (void)
-  {
-    if (this->buffer_ == 0 || this->release_ == 0)
-      return;
-    
-    IR_Container::Description *tmp = ACE_reinterpret_cast (IR_Container::Description *,this->buffer_);
-    
-    _TAO_Unbounded_Sequence_IR_Container_DescriptionSeq::freebuf (tmp);
-    this->buffer_ = 0;
-  } 
-  
-  IR_Container::_TAO_Unbounded_Sequence_IR_Container_DescriptionSeq::~_TAO_Unbounded_Sequence_IR_Container_DescriptionSeq (void) // Dtor.
-  {
-    this->_deallocate_buffer ();
-  }
-  
-  
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
-
-// *************************************************************
-// IR_Container::DescriptionSeq
-// *************************************************************
-
-IR_Container::DescriptionSeq::DescriptionSeq (void)
-{}
-IR_Container::DescriptionSeq::DescriptionSeq (CORBA::ULong max) // uses max size
-  : 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Sequence_IR_Container_DescriptionSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Sequence<IR_Container::Description>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
- (max)
-{}
-IR_Container::DescriptionSeq::DescriptionSeq (CORBA::ULong max, CORBA::ULong length, IR_Container::Description *buffer, CORBA::Boolean release)
-  : 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Sequence_IR_Container_DescriptionSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Sequence<IR_Container::Description>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
- (max, length, buffer, release)
-{}
-IR_Container::DescriptionSeq::DescriptionSeq (const DescriptionSeq &seq) // copy ctor
-  : 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Sequence_IR_Container_DescriptionSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Sequence<IR_Container::Description>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
- (seq)
-{}
-IR_Container::DescriptionSeq::~DescriptionSeq (void) // dtor
-{}
-void IR_Container::DescriptionSeq::_tao_any_destructor (void *x)
-{
-  DescriptionSeq *tmp = ACE_static_cast (DescriptionSeq*,x);
-  delete tmp;
-}
-
-static const CORBA::Long _oc_IR_Container_DescriptionSeq[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  44, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f43), ACE_NTOHL (0x6f6e7461), ACE_NTOHL (0x696e6572), ACE_NTOHL (0x2f446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x5365713a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/Container/DescriptionSeq:1.0
-  15, ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x65710000),  // name = DescriptionSeq
-  CORBA::tk_sequence, // typecode kind
-  844, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    CORBA::tk_struct, // typecode kind
-    828, // encapsulation length
-      TAO_ENCAP_BYTE_ORDER, // byte order
-      41, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f43), ACE_NTOHL (0x6f6e7461), ACE_NTOHL (0x696e6572), ACE_NTOHL (0x2f446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/Container/Description:1.0
-      12, ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e00),  // name = Description
-      3, // member count
-      17, ACE_NTOHL (0x636f6e74), ACE_NTOHL (0x61696e65), ACE_NTOHL (0x645f6f62), ACE_NTOHL (0x6a656374), ACE_NTOHL (0x0),  // name = contained_object
-      CORBA::tk_objref, // typecode kind
-      56, // encapsulation length
-        TAO_ENCAP_BYTE_ORDER, // byte order
-        29, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f43), ACE_NTOHL (0x6f6e7461), ACE_NTOHL (0x696e6564), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/Contained:1.0
-        10, ACE_NTOHL (0x436f6e74), ACE_NTOHL (0x61696e65), ACE_NTOHL (0x64000000),  // name = IR_Contained
-
-      5, ACE_NTOHL (0x6b696e64), ACE_NTOHL (0x0),  // name = kind
-      CORBA::tk_enum, // typecode kind
-      632, // encapsulation length
-        TAO_ENCAP_BYTE_ORDER, // byte order
-        34, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f44), ACE_NTOHL (0x6566696e), ACE_NTOHL (0x6974696f), ACE_NTOHL (0x6e4b696e), ACE_NTOHL (0x643a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/DefinitionKind:1.0
-        15, ACE_NTOHL (0x44656669), ACE_NTOHL (0x6e697469), ACE_NTOHL (0x6f6e4b69), ACE_NTOHL (0x6e640000),  // name = DefinitionKind
-        34, // member count
-        8, ACE_NTOHL (0x646b5f6e), ACE_NTOHL (0x6f6e6500),  // name = dk_none
-        7, ACE_NTOHL (0x646b5f61), ACE_NTOHL (0x6c6c0000),  // name = dk_all
-        13, ACE_NTOHL (0x646b5f41), ACE_NTOHL (0x74747269), ACE_NTOHL (0x62757465), ACE_NTOHL (0x0),  // name = dk_Attribute
-        12, ACE_NTOHL (0x646b5f43), ACE_NTOHL (0x6f6e7374), ACE_NTOHL (0x616e7400),  // name = dk_Constant
-        13, ACE_NTOHL (0x646b5f45), ACE_NTOHL (0x78636570), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = dk_Exception
-        13, ACE_NTOHL (0x646b5f49), ACE_NTOHL (0x6e746572), ACE_NTOHL (0x66616365), ACE_NTOHL (0x0),  // name = dk_Interface
-        10, ACE_NTOHL (0x646b5f4d), ACE_NTOHL (0x6f64756c), ACE_NTOHL (0x65000000),  // name = dk_Module
-        13, ACE_NTOHL (0x646b5f4f), ACE_NTOHL (0x70657261), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = dk_Operation
-        11, ACE_NTOHL (0x646b5f54), ACE_NTOHL (0x79706564), ACE_NTOHL (0x65660000),  // name = dk_Typedef
-        9, ACE_NTOHL (0x646b5f41), ACE_NTOHL (0x6c696173), ACE_NTOHL (0x0),  // name = dk_Alias
-        10, ACE_NTOHL (0x646b5f53), ACE_NTOHL (0x74727563), ACE_NTOHL (0x74000000),  // name = dk_Struct
-        9, ACE_NTOHL (0x646b5f55), ACE_NTOHL (0x6e696f6e), ACE_NTOHL (0x0),  // name = dk_Union
-        8, ACE_NTOHL (0x646b5f45), ACE_NTOHL (0x6e756d00),  // name = dk_Enum
-        13, ACE_NTOHL (0x646b5f50), ACE_NTOHL (0x72696d69), ACE_NTOHL (0x74697665), ACE_NTOHL (0x0),  // name = dk_Primitive
-        10, ACE_NTOHL (0x646b5f53), ACE_NTOHL (0x7472696e), ACE_NTOHL (0x67000000),  // name = dk_String
-        12, ACE_NTOHL (0x646b5f53), ACE_NTOHL (0x65717565), ACE_NTOHL (0x6e636500),  // name = dk_Sequence
-        9, ACE_NTOHL (0x646b5f41), ACE_NTOHL (0x72726179), ACE_NTOHL (0x0),  // name = dk_Array
-        14, ACE_NTOHL (0x646b5f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x79000000),  // name = dk_Repository
-        11, ACE_NTOHL (0x646b5f57), ACE_NTOHL (0x73747269), ACE_NTOHL (0x6e670000),  // name = dk_Wstring
-        9, ACE_NTOHL (0x646b5f46), ACE_NTOHL (0x69786564), ACE_NTOHL (0x0),  // name = dk_Fixed
-        9, ACE_NTOHL (0x646b5f56), ACE_NTOHL (0x616c7565), ACE_NTOHL (0x0),  // name = dk_Value
-        12, ACE_NTOHL (0x646b5f56), ACE_NTOHL (0x616c7565), ACE_NTOHL (0x426f7800),  // name = dk_ValueBox
-        15, ACE_NTOHL (0x646b5f56), ACE_NTOHL (0x616c7565), ACE_NTOHL (0x4d656d62), ACE_NTOHL (0x65720000),  // name = dk_ValueMember
-        10, ACE_NTOHL (0x646b5f4e), ACE_NTOHL (0x61746976), ACE_NTOHL (0x65000000),  // name = dk_Native
-        13, ACE_NTOHL (0x646b5f43), ACE_NTOHL (0x6f6d706f), ACE_NTOHL (0x6e656e74), ACE_NTOHL (0x0),  // name = dk_Component
-        8, ACE_NTOHL (0x646b5f48), ACE_NTOHL (0x6f6d6500),  // name = dk_Home
-        11, ACE_NTOHL (0x646b5f46), ACE_NTOHL (0x6163746f), ACE_NTOHL (0x72790000),  // name = dk_Factory
-        10, ACE_NTOHL (0x646b5f46), ACE_NTOHL (0x696e6465), ACE_NTOHL (0x72000000),  // name = dk_Finder
-        14, ACE_NTOHL (0x646b5f50), ACE_NTOHL (0x72696d61), ACE_NTOHL (0x72794b65), ACE_NTOHL (0x79000000),  // name = dk_PrimaryKey
-        9, ACE_NTOHL (0x646b5f45), ACE_NTOHL (0x6d697473), ACE_NTOHL (0x0),  // name = dk_Emits
-        13, ACE_NTOHL (0x646b5f50), ACE_NTOHL (0x75626c69), ACE_NTOHL (0x73686573), ACE_NTOHL (0x0),  // name = dk_Publishes
-        12, ACE_NTOHL (0x646b5f43), ACE_NTOHL (0x6f6e7375), ACE_NTOHL (0x6d657300),  // name = dk_Consumes
-        12, ACE_NTOHL (0x646b5f50), ACE_NTOHL (0x726f7669), ACE_NTOHL (0x64657300),  // name = dk_Provides
-        8, ACE_NTOHL (0x646b5f55), ACE_NTOHL (0x73657300),  // name = dk_Uses
-
-      6, ACE_NTOHL (0x76616c75), ACE_NTOHL (0x65000000),  // name = value
-      CORBA::tk_any,
-
-
-    0U,
-
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_Container_DescriptionSeq (CORBA::tk_alias, sizeof (_oc_IR_Container_DescriptionSeq), (char *) &_oc_IR_Container_DescriptionSeq, 0, sizeof (IR_Container::DescriptionSeq));
-CORBA::TypeCode_ptr IR_Container::_tc_DescriptionSeq = &_tc_TAO_tc_IR_Container_DescriptionSeq;
-
-IR_Container::DescriptionSeq * IR_Container::describe_contents (
-    IR_DefinitionKind limit_type,
-    CORBA::Boolean exclude_inherited,
-    CORBA::Long max_returned_objs,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_Container_Proxy_Impl &proxy = 
-    this->the_TAO_Container_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.describe_contents (
-      this,
-      limit_type,
-      exclude_inherited,
-      max_returned_objs,
-      ACE_TRY_ENV
-    );
-}
-
-IR_ModuleDef_ptr IR_Container::create_module (
-    const char * id,
-    const char * name,
-    const char * version,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_Container_Proxy_Impl &proxy = 
-    this->the_TAO_Container_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.create_module (
-      this,
-      id,
-      name,
-      version,
-      ACE_TRY_ENV
-    );
-}
-
-IR_ConstantDef_ptr IR_Container::create_constant (
-    const char * id,
-    const char * name,
-    const char * version,
-    IR_IDLType_ptr type,
-    const CORBA::Any & value,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_Container_Proxy_Impl &proxy = 
-    this->the_TAO_Container_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.create_constant (
-      this,
-      id,
-      name,
-      version,
-      type,
-      value,
-      ACE_TRY_ENV
-    );
-}
-
-IR_StructDef_ptr IR_Container::create_struct (
-    const char * id,
-    const char * name,
-    const char * version,
-    const IR_StructMemberSeq & members,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_Container_Proxy_Impl &proxy = 
-    this->the_TAO_Container_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.create_struct (
-      this,
-      id,
-      name,
-      version,
-      members,
-      ACE_TRY_ENV
-    );
-}
-
-IR_UnionDef_ptr IR_Container::create_union (
-    const char * id,
-    const char * name,
-    const char * version,
-    IR_IDLType_ptr discriminator_type,
-    const IR_UnionMemberSeq & members,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_Container_Proxy_Impl &proxy = 
-    this->the_TAO_Container_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.create_union (
-      this,
-      id,
-      name,
-      version,
-      discriminator_type,
-      members,
-      ACE_TRY_ENV
-    );
-}
-
-IR_EnumDef_ptr IR_Container::create_enum (
-    const char * id,
-    const char * name,
-    const char * version,
-    const IR_EnumMemberSeq & members,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_Container_Proxy_Impl &proxy = 
-    this->the_TAO_Container_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.create_enum (
-      this,
-      id,
-      name,
-      version,
-      members,
-      ACE_TRY_ENV
-    );
-}
-
-IR_AliasDef_ptr IR_Container::create_alias (
-    const char * id,
-    const char * name,
-    const char * version,
-    IR_IDLType_ptr original_type,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_Container_Proxy_Impl &proxy = 
-    this->the_TAO_Container_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.create_alias (
-      this,
-      id,
-      name,
-      version,
-      original_type,
-      ACE_TRY_ENV
-    );
-}
-
-IR_InterfaceDef_ptr IR_Container::create_interface (
-    const char * id,
-    const char * name,
-    const char * version,
-    const IR_InterfaceDefSeq & base_interfaces,
-    CORBA::Boolean is_abstract,
-    CORBA::Boolean is_local,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_Container_Proxy_Impl &proxy = 
-    this->the_TAO_Container_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.create_interface (
-      this,
-      id,
-      name,
-      version,
-      base_interfaces,
-      is_abstract,
-      is_local,
-      ACE_TRY_ENV
-    );
-}
-
-IR_ValueDef_ptr IR_Container::create_value (
-    const char * id,
-    const char * name,
-    const char * version,
-    CORBA::Boolean is_custom,
-    CORBA::Boolean is_abstract,
-    IR_ValueDef_ptr base_value,
-    CORBA::Boolean is_truncatable,
-    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
-  ))
-{
-  _TAO_Container_Proxy_Impl &proxy = 
-    this->the_TAO_Container_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.create_value (
-      this,
-      id,
-      name,
-      version,
-      is_custom,
-      is_abstract,
-      base_value,
-      is_truncatable,
-      abstract_base_values,
-      supported_interfaces,
-      initializers,
-      ACE_TRY_ENV
-    );
-}
-
-IR_ValueBoxDef_ptr IR_Container::create_value_box (
-    const char * id,
-    const char * name,
-    const char * version,
-    IR_IDLType_ptr original_type_def,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_Container_Proxy_Impl &proxy = 
-    this->the_TAO_Container_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.create_value_box (
-      this,
-      id,
-      name,
-      version,
-      original_type_def,
-      ACE_TRY_ENV
-    );
-}
-
-IR_ExceptionDef_ptr IR_Container::create_exception (
-    const char * id,
-    const char * name,
-    const char * version,
-    const IR_StructMemberSeq & members,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_Container_Proxy_Impl &proxy = 
-    this->the_TAO_Container_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.create_exception (
-      this,
-      id,
-      name,
-      version,
-      members,
-      ACE_TRY_ENV
-    );
-}
-
-IR_NativeDef_ptr IR_Container::create_native (
-    const char * id,
-    const char * name,
-    const char * version,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_Container_Proxy_Impl &proxy = 
-    this->the_TAO_Container_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.create_native (
-      this,
-      id,
-      name,
-      version,
-      ACE_TRY_ENV
-    );
-}
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-IR_Container::TAO_ClientRequestInfo_IR_Container_lookup::TAO_ClientRequestInfo_IR_Container_lookup (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    const char * search_name,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
-    search_name_ (search_name)
-{}
-
-Dynamic::ParameterList *
-IR_Container::TAO_ClientRequestInfo_IR_Container_lookup::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
-    
-  CORBA::ULong length_search_name = parameter_list->length ();
-  parameter_list->length (length_search_name + 1);
-  (*parameter_list)[length_search_name].argument <<= search_name_;
-  (*parameter_list)[length_search_name].mode = Dynamic::PARAM_IN;
-  
-  return safe_parameter_list._retn ();
-}
-
-Dynamic::ExceptionList *
-IR_Container::TAO_ClientRequestInfo_IR_Container_lookup::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_Container::TAO_ClientRequestInfo_IR_Container_lookup::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_Container::TAO_ClientRequestInfo_IR_Container_lookup::result (IR_Contained_ptr result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_Container::TAO_ClientRequestInfo_IR_Container_contents::TAO_ClientRequestInfo_IR_Container_contents (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    IR_DefinitionKind & limit_type,
-    const CORBA::Boolean & exclude_inherited,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
-    limit_type_ (limit_type),
-    exclude_inherited_ (exclude_inherited)
-{}
-
-Dynamic::ParameterList *
-IR_Container::TAO_ClientRequestInfo_IR_Container_contents::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
-    
-  CORBA::ULong length_limit_type = parameter_list->length ();
-  parameter_list->length (length_limit_type + 1);
-  (*parameter_list)[length_limit_type].argument <<=  this->limit_type_;
-  
-  (*parameter_list)[length_limit_type].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_exclude_inherited = parameter_list->length ();
-  parameter_list->length (length_exclude_inherited + 1);
-  (*parameter_list)[length_exclude_inherited].argument <<= CORBA::Any::from_boolean (this->exclude_inherited_);
-  (*parameter_list)[length_exclude_inherited].mode = Dynamic::PARAM_IN;
-  
-  return safe_parameter_list._retn ();
-}
-
-Dynamic::ExceptionList *
-IR_Container::TAO_ClientRequestInfo_IR_Container_contents::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_Container::TAO_ClientRequestInfo_IR_Container_contents::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_Container::TAO_ClientRequestInfo_IR_Container_contents::result (IR_ContainedSeq * result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_Container::TAO_ClientRequestInfo_IR_Container_lookup_name::TAO_ClientRequestInfo_IR_Container_lookup_name (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    const char * search_name,
-    const CORBA::Long & levels_to_search,
-    IR_DefinitionKind & limit_type,
-    const CORBA::Boolean & exclude_inherited,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
-    search_name_ (search_name),
-    levels_to_search_ (levels_to_search),
-    limit_type_ (limit_type),
-    exclude_inherited_ (exclude_inherited)
-{}
-
-Dynamic::ParameterList *
-IR_Container::TAO_ClientRequestInfo_IR_Container_lookup_name::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
-    
-  CORBA::ULong length_search_name = parameter_list->length ();
-  parameter_list->length (length_search_name + 1);
-  (*parameter_list)[length_search_name].argument <<= search_name_;
-  (*parameter_list)[length_search_name].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_levels_to_search = parameter_list->length ();
-  parameter_list->length (length_levels_to_search + 1);
-  (*parameter_list)[length_levels_to_search].argument <<= levels_to_search_;
-  (*parameter_list)[length_levels_to_search].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_limit_type = parameter_list->length ();
-  parameter_list->length (length_limit_type + 1);
-  (*parameter_list)[length_limit_type].argument <<=  this->limit_type_;
-  
-  (*parameter_list)[length_limit_type].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_exclude_inherited = parameter_list->length ();
-  parameter_list->length (length_exclude_inherited + 1);
-  (*parameter_list)[length_exclude_inherited].argument <<= CORBA::Any::from_boolean (this->exclude_inherited_);
-  (*parameter_list)[length_exclude_inherited].mode = Dynamic::PARAM_IN;
-  
-  return safe_parameter_list._retn ();
-}
-
-Dynamic::ExceptionList *
-IR_Container::TAO_ClientRequestInfo_IR_Container_lookup_name::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_Container::TAO_ClientRequestInfo_IR_Container_lookup_name::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_Container::TAO_ClientRequestInfo_IR_Container_lookup_name::result (IR_ContainedSeq * result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_Container::TAO_ClientRequestInfo_IR_Container_describe_contents::TAO_ClientRequestInfo_IR_Container_describe_contents (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    IR_DefinitionKind & limit_type,
-    const CORBA::Boolean & exclude_inherited,
-    const CORBA::Long & max_returned_objs,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
-    limit_type_ (limit_type),
-    exclude_inherited_ (exclude_inherited),
-    max_returned_objs_ (max_returned_objs)
-{}
-
-Dynamic::ParameterList *
-IR_Container::TAO_ClientRequestInfo_IR_Container_describe_contents::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
-    
-  CORBA::ULong length_limit_type = parameter_list->length ();
-  parameter_list->length (length_limit_type + 1);
-  (*parameter_list)[length_limit_type].argument <<=  this->limit_type_;
-  
-  (*parameter_list)[length_limit_type].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_exclude_inherited = parameter_list->length ();
-  parameter_list->length (length_exclude_inherited + 1);
-  (*parameter_list)[length_exclude_inherited].argument <<= CORBA::Any::from_boolean (this->exclude_inherited_);
-  (*parameter_list)[length_exclude_inherited].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_max_returned_objs = parameter_list->length ();
-  parameter_list->length (length_max_returned_objs + 1);
-  (*parameter_list)[length_max_returned_objs].argument <<= max_returned_objs_;
-  (*parameter_list)[length_max_returned_objs].mode = Dynamic::PARAM_IN;
-  
-  return safe_parameter_list._retn ();
-}
-
-Dynamic::ExceptionList *
-IR_Container::TAO_ClientRequestInfo_IR_Container_describe_contents::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_Container::TAO_ClientRequestInfo_IR_Container_describe_contents::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_Container::TAO_ClientRequestInfo_IR_Container_describe_contents::result (ACE_NESTED_CLASS (IR_Container,DescriptionSeq) * result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_Container::TAO_ClientRequestInfo_IR_Container_create_module::TAO_ClientRequestInfo_IR_Container_create_module (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    const char * id,
-    const char * name,
-    const char * version,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
-    id_ (id),
-    name_ (name),
-    version_ (version)
-{}
-
-Dynamic::ParameterList *
-IR_Container::TAO_ClientRequestInfo_IR_Container_create_module::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
-    
-  CORBA::ULong length_id = parameter_list->length ();
-  parameter_list->length (length_id + 1);
-  (*parameter_list)[length_id].argument <<= id_;
-  (*parameter_list)[length_id].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_name = parameter_list->length ();
-  parameter_list->length (length_name + 1);
-  (*parameter_list)[length_name].argument <<= name_;
-  (*parameter_list)[length_name].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_version = parameter_list->length ();
-  parameter_list->length (length_version + 1);
-  (*parameter_list)[length_version].argument <<= version_;
-  (*parameter_list)[length_version].mode = Dynamic::PARAM_IN;
-  
-  return safe_parameter_list._retn ();
-}
-
-Dynamic::ExceptionList *
-IR_Container::TAO_ClientRequestInfo_IR_Container_create_module::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_Container::TAO_ClientRequestInfo_IR_Container_create_module::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_Container::TAO_ClientRequestInfo_IR_Container_create_module::result (IR_ModuleDef_ptr result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_Container::TAO_ClientRequestInfo_IR_Container_create_constant::TAO_ClientRequestInfo_IR_Container_create_constant (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    const char * id,
-    const char * name,
-    const char * version,
-    IR_IDLType_ptr type,
-    const CORBA::Any & value,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
-    id_ (id),
-    name_ (name),
-    version_ (version),
-    type_ (type),
-    value_ (value)
-{}
-
-Dynamic::ParameterList *
-IR_Container::TAO_ClientRequestInfo_IR_Container_create_constant::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
-    
-  CORBA::ULong length_id = parameter_list->length ();
-  parameter_list->length (length_id + 1);
-  (*parameter_list)[length_id].argument <<= id_;
-  (*parameter_list)[length_id].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_name = parameter_list->length ();
-  parameter_list->length (length_name + 1);
-  (*parameter_list)[length_name].argument <<= name_;
-  (*parameter_list)[length_name].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_version = parameter_list->length ();
-  parameter_list->length (length_version + 1);
-  (*parameter_list)[length_version].argument <<= version_;
-  (*parameter_list)[length_version].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_type = parameter_list->length ();
-  parameter_list->length (length_type + 1);
-  (*parameter_list)[length_type].argument <<=  this->type_;
-  
-  (*parameter_list)[length_type].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_value = parameter_list->length ();
-  parameter_list->length (length_value + 1);
-  (*parameter_list)[length_value].argument <<= value_;
-  (*parameter_list)[length_value].mode = Dynamic::PARAM_IN;
-  
-  return safe_parameter_list._retn ();
-}
-
-Dynamic::ExceptionList *
-IR_Container::TAO_ClientRequestInfo_IR_Container_create_constant::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_Container::TAO_ClientRequestInfo_IR_Container_create_constant::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_Container::TAO_ClientRequestInfo_IR_Container_create_constant::result (IR_ConstantDef_ptr result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_Container::TAO_ClientRequestInfo_IR_Container_create_struct::TAO_ClientRequestInfo_IR_Container_create_struct (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    const char * id,
-    const char * name,
-    const char * version,
-    const IR_StructMemberSeq & members,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
-    id_ (id),
-    name_ (name),
-    version_ (version),
-    members_ (members)
-{}
-
-Dynamic::ParameterList *
-IR_Container::TAO_ClientRequestInfo_IR_Container_create_struct::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
-    
-  CORBA::ULong length_id = parameter_list->length ();
-  parameter_list->length (length_id + 1);
-  (*parameter_list)[length_id].argument <<= id_;
-  (*parameter_list)[length_id].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_name = parameter_list->length ();
-  parameter_list->length (length_name + 1);
-  (*parameter_list)[length_name].argument <<= name_;
-  (*parameter_list)[length_name].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_version = parameter_list->length ();
-  parameter_list->length (length_version + 1);
-  (*parameter_list)[length_version].argument <<= version_;
-  (*parameter_list)[length_version].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_members = parameter_list->length ();
-  parameter_list->length (length_members + 1);
-  (*parameter_list)[length_members].argument <<=  this->members_;
-  
-  (*parameter_list)[length_members].mode = Dynamic::PARAM_IN;
-  
-  return safe_parameter_list._retn ();
-}
-
-Dynamic::ExceptionList *
-IR_Container::TAO_ClientRequestInfo_IR_Container_create_struct::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_Container::TAO_ClientRequestInfo_IR_Container_create_struct::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_Container::TAO_ClientRequestInfo_IR_Container_create_struct::result (IR_StructDef_ptr result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_Container::TAO_ClientRequestInfo_IR_Container_create_union::TAO_ClientRequestInfo_IR_Container_create_union (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    const char * id,
-    const char * name,
-    const char * version,
-    IR_IDLType_ptr discriminator_type,
-    const IR_UnionMemberSeq & members,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
-    id_ (id),
-    name_ (name),
-    version_ (version),
-    discriminator_type_ (discriminator_type),
-    members_ (members)
-{}
-
-Dynamic::ParameterList *
-IR_Container::TAO_ClientRequestInfo_IR_Container_create_union::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
-    
-  CORBA::ULong length_id = parameter_list->length ();
-  parameter_list->length (length_id + 1);
-  (*parameter_list)[length_id].argument <<= id_;
-  (*parameter_list)[length_id].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_name = parameter_list->length ();
-  parameter_list->length (length_name + 1);
-  (*parameter_list)[length_name].argument <<= name_;
-  (*parameter_list)[length_name].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_version = parameter_list->length ();
-  parameter_list->length (length_version + 1);
-  (*parameter_list)[length_version].argument <<= version_;
-  (*parameter_list)[length_version].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_discriminator_type = parameter_list->length ();
-  parameter_list->length (length_discriminator_type + 1);
-  (*parameter_list)[length_discriminator_type].argument <<=  this->discriminator_type_;
-  
-  (*parameter_list)[length_discriminator_type].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_members = parameter_list->length ();
-  parameter_list->length (length_members + 1);
-  (*parameter_list)[length_members].argument <<=  this->members_;
-  
-  (*parameter_list)[length_members].mode = Dynamic::PARAM_IN;
-  
-  return safe_parameter_list._retn ();
-}
-
-Dynamic::ExceptionList *
-IR_Container::TAO_ClientRequestInfo_IR_Container_create_union::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_Container::TAO_ClientRequestInfo_IR_Container_create_union::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_Container::TAO_ClientRequestInfo_IR_Container_create_union::result (IR_UnionDef_ptr result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_Container::TAO_ClientRequestInfo_IR_Container_create_enum::TAO_ClientRequestInfo_IR_Container_create_enum (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    const char * id,
-    const char * name,
-    const char * version,
-    const IR_EnumMemberSeq & members,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
-    id_ (id),
-    name_ (name),
-    version_ (version),
-    members_ (members)
-{}
-
-Dynamic::ParameterList *
-IR_Container::TAO_ClientRequestInfo_IR_Container_create_enum::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
-    
-  CORBA::ULong length_id = parameter_list->length ();
-  parameter_list->length (length_id + 1);
-  (*parameter_list)[length_id].argument <<= id_;
-  (*parameter_list)[length_id].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_name = parameter_list->length ();
-  parameter_list->length (length_name + 1);
-  (*parameter_list)[length_name].argument <<= name_;
-  (*parameter_list)[length_name].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_version = parameter_list->length ();
-  parameter_list->length (length_version + 1);
-  (*parameter_list)[length_version].argument <<= version_;
-  (*parameter_list)[length_version].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_members = parameter_list->length ();
-  parameter_list->length (length_members + 1);
-  (*parameter_list)[length_members].argument <<=  this->members_;
-  
-  (*parameter_list)[length_members].mode = Dynamic::PARAM_IN;
-  
-  return safe_parameter_list._retn ();
-}
-
-Dynamic::ExceptionList *
-IR_Container::TAO_ClientRequestInfo_IR_Container_create_enum::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_Container::TAO_ClientRequestInfo_IR_Container_create_enum::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_Container::TAO_ClientRequestInfo_IR_Container_create_enum::result (IR_EnumDef_ptr result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_Container::TAO_ClientRequestInfo_IR_Container_create_alias::TAO_ClientRequestInfo_IR_Container_create_alias (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    const char * id,
-    const char * name,
-    const char * version,
-    IR_IDLType_ptr original_type,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
-    id_ (id),
-    name_ (name),
-    version_ (version),
-    original_type_ (original_type)
-{}
-
-Dynamic::ParameterList *
-IR_Container::TAO_ClientRequestInfo_IR_Container_create_alias::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
-    
-  CORBA::ULong length_id = parameter_list->length ();
-  parameter_list->length (length_id + 1);
-  (*parameter_list)[length_id].argument <<= id_;
-  (*parameter_list)[length_id].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_name = parameter_list->length ();
-  parameter_list->length (length_name + 1);
-  (*parameter_list)[length_name].argument <<= name_;
-  (*parameter_list)[length_name].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_version = parameter_list->length ();
-  parameter_list->length (length_version + 1);
-  (*parameter_list)[length_version].argument <<= version_;
-  (*parameter_list)[length_version].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_original_type = parameter_list->length ();
-  parameter_list->length (length_original_type + 1);
-  (*parameter_list)[length_original_type].argument <<=  this->original_type_;
-  
-  (*parameter_list)[length_original_type].mode = Dynamic::PARAM_IN;
-  
-  return safe_parameter_list._retn ();
-}
-
-Dynamic::ExceptionList *
-IR_Container::TAO_ClientRequestInfo_IR_Container_create_alias::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_Container::TAO_ClientRequestInfo_IR_Container_create_alias::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_Container::TAO_ClientRequestInfo_IR_Container_create_alias::result (IR_AliasDef_ptr result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_Container::TAO_ClientRequestInfo_IR_Container_create_interface::TAO_ClientRequestInfo_IR_Container_create_interface (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _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 &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
-    id_ (id),
-    name_ (name),
-    version_ (version),
-    base_interfaces_ (base_interfaces),
-    is_abstract_ (is_abstract),
-    is_local_ (is_local)
-{}
-
-Dynamic::ParameterList *
-IR_Container::TAO_ClientRequestInfo_IR_Container_create_interface::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
-    
-  CORBA::ULong length_id = parameter_list->length ();
-  parameter_list->length (length_id + 1);
-  (*parameter_list)[length_id].argument <<= id_;
-  (*parameter_list)[length_id].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_name = parameter_list->length ();
-  parameter_list->length (length_name + 1);
-  (*parameter_list)[length_name].argument <<= name_;
-  (*parameter_list)[length_name].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_version = parameter_list->length ();
-  parameter_list->length (length_version + 1);
-  (*parameter_list)[length_version].argument <<= version_;
-  (*parameter_list)[length_version].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_base_interfaces = parameter_list->length ();
-  parameter_list->length (length_base_interfaces + 1);
-  (*parameter_list)[length_base_interfaces].argument <<=  this->base_interfaces_;
-  
-  (*parameter_list)[length_base_interfaces].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_is_abstract = parameter_list->length ();
-  parameter_list->length (length_is_abstract + 1);
-  (*parameter_list)[length_is_abstract].argument <<= CORBA::Any::from_boolean (this->is_abstract_);
-  (*parameter_list)[length_is_abstract].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_is_local = parameter_list->length ();
-  parameter_list->length (length_is_local + 1);
-  (*parameter_list)[length_is_local].argument <<= CORBA::Any::from_boolean (this->is_local_);
-  (*parameter_list)[length_is_local].mode = Dynamic::PARAM_IN;
-  
-  return safe_parameter_list._retn ();
-}
-
-Dynamic::ExceptionList *
-IR_Container::TAO_ClientRequestInfo_IR_Container_create_interface::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_Container::TAO_ClientRequestInfo_IR_Container_create_interface::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_Container::TAO_ClientRequestInfo_IR_Container_create_interface::result (IR_InterfaceDef_ptr result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_Container::TAO_ClientRequestInfo_IR_Container_create_value::TAO_ClientRequestInfo_IR_Container_create_value (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _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 &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
-    id_ (id),
-    name_ (name),
-    version_ (version),
-    is_custom_ (is_custom),
-    is_abstract_ (is_abstract),
-    base_value_ (base_value),
-    is_truncatable_ (is_truncatable),
-    abstract_base_values_ (abstract_base_values),
-    supported_interfaces_ (supported_interfaces),
-    initializers_ (initializers)
-{}
-
-Dynamic::ParameterList *
-IR_Container::TAO_ClientRequestInfo_IR_Container_create_value::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
-    
-  CORBA::ULong length_id = parameter_list->length ();
-  parameter_list->length (length_id + 1);
-  (*parameter_list)[length_id].argument <<= id_;
-  (*parameter_list)[length_id].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_name = parameter_list->length ();
-  parameter_list->length (length_name + 1);
-  (*parameter_list)[length_name].argument <<= name_;
-  (*parameter_list)[length_name].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_version = parameter_list->length ();
-  parameter_list->length (length_version + 1);
-  (*parameter_list)[length_version].argument <<= version_;
-  (*parameter_list)[length_version].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_is_custom = parameter_list->length ();
-  parameter_list->length (length_is_custom + 1);
-  (*parameter_list)[length_is_custom].argument <<= CORBA::Any::from_boolean (this->is_custom_);
-  (*parameter_list)[length_is_custom].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_is_abstract = parameter_list->length ();
-  parameter_list->length (length_is_abstract + 1);
-  (*parameter_list)[length_is_abstract].argument <<= CORBA::Any::from_boolean (this->is_abstract_);
-  (*parameter_list)[length_is_abstract].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_base_value = parameter_list->length ();
-  parameter_list->length (length_base_value + 1);
-  (*parameter_list)[length_base_value].argument <<=  this->base_value_;
-  
-  (*parameter_list)[length_base_value].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_is_truncatable = parameter_list->length ();
-  parameter_list->length (length_is_truncatable + 1);
-  (*parameter_list)[length_is_truncatable].argument <<= CORBA::Any::from_boolean (this->is_truncatable_);
-  (*parameter_list)[length_is_truncatable].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_abstract_base_values = parameter_list->length ();
-  parameter_list->length (length_abstract_base_values + 1);
-  (*parameter_list)[length_abstract_base_values].argument <<=  this->abstract_base_values_;
-  
-  (*parameter_list)[length_abstract_base_values].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_supported_interfaces = parameter_list->length ();
-  parameter_list->length (length_supported_interfaces + 1);
-  (*parameter_list)[length_supported_interfaces].argument <<=  this->supported_interfaces_;
-  
-  (*parameter_list)[length_supported_interfaces].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_initializers = parameter_list->length ();
-  parameter_list->length (length_initializers + 1);
-  (*parameter_list)[length_initializers].argument <<=  this->initializers_;
-  
-  (*parameter_list)[length_initializers].mode = Dynamic::PARAM_IN;
-  
-  return safe_parameter_list._retn ();
-}
-
-Dynamic::ExceptionList *
-IR_Container::TAO_ClientRequestInfo_IR_Container_create_value::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_Container::TAO_ClientRequestInfo_IR_Container_create_value::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_Container::TAO_ClientRequestInfo_IR_Container_create_value::result (IR_ValueDef_ptr result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_Container::TAO_ClientRequestInfo_IR_Container_create_value_box::TAO_ClientRequestInfo_IR_Container_create_value_box (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    const char * id,
-    const char * name,
-    const char * version,
-    IR_IDLType_ptr original_type_def,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
-    id_ (id),
-    name_ (name),
-    version_ (version),
-    original_type_def_ (original_type_def)
-{}
-
-Dynamic::ParameterList *
-IR_Container::TAO_ClientRequestInfo_IR_Container_create_value_box::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
-    
-  CORBA::ULong length_id = parameter_list->length ();
-  parameter_list->length (length_id + 1);
-  (*parameter_list)[length_id].argument <<= id_;
-  (*parameter_list)[length_id].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_name = parameter_list->length ();
-  parameter_list->length (length_name + 1);
-  (*parameter_list)[length_name].argument <<= name_;
-  (*parameter_list)[length_name].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_version = parameter_list->length ();
-  parameter_list->length (length_version + 1);
-  (*parameter_list)[length_version].argument <<= version_;
-  (*parameter_list)[length_version].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_original_type_def = parameter_list->length ();
-  parameter_list->length (length_original_type_def + 1);
-  (*parameter_list)[length_original_type_def].argument <<=  this->original_type_def_;
-  
-  (*parameter_list)[length_original_type_def].mode = Dynamic::PARAM_IN;
-  
-  return safe_parameter_list._retn ();
-}
-
-Dynamic::ExceptionList *
-IR_Container::TAO_ClientRequestInfo_IR_Container_create_value_box::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_Container::TAO_ClientRequestInfo_IR_Container_create_value_box::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_Container::TAO_ClientRequestInfo_IR_Container_create_value_box::result (IR_ValueBoxDef_ptr result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_Container::TAO_ClientRequestInfo_IR_Container_create_exception::TAO_ClientRequestInfo_IR_Container_create_exception (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    const char * id,
-    const char * name,
-    const char * version,
-    const IR_StructMemberSeq & members,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
-    id_ (id),
-    name_ (name),
-    version_ (version),
-    members_ (members)
-{}
-
-Dynamic::ParameterList *
-IR_Container::TAO_ClientRequestInfo_IR_Container_create_exception::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
-    
-  CORBA::ULong length_id = parameter_list->length ();
-  parameter_list->length (length_id + 1);
-  (*parameter_list)[length_id].argument <<= id_;
-  (*parameter_list)[length_id].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_name = parameter_list->length ();
-  parameter_list->length (length_name + 1);
-  (*parameter_list)[length_name].argument <<= name_;
-  (*parameter_list)[length_name].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_version = parameter_list->length ();
-  parameter_list->length (length_version + 1);
-  (*parameter_list)[length_version].argument <<= version_;
-  (*parameter_list)[length_version].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_members = parameter_list->length ();
-  parameter_list->length (length_members + 1);
-  (*parameter_list)[length_members].argument <<=  this->members_;
-  
-  (*parameter_list)[length_members].mode = Dynamic::PARAM_IN;
-  
-  return safe_parameter_list._retn ();
-}
-
-Dynamic::ExceptionList *
-IR_Container::TAO_ClientRequestInfo_IR_Container_create_exception::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_Container::TAO_ClientRequestInfo_IR_Container_create_exception::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_Container::TAO_ClientRequestInfo_IR_Container_create_exception::result (IR_ExceptionDef_ptr result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_Container::TAO_ClientRequestInfo_IR_Container_create_native::TAO_ClientRequestInfo_IR_Container_create_native (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    const char * id,
-    const char * name,
-    const char * version,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
-    id_ (id),
-    name_ (name),
-    version_ (version)
-{}
-
-Dynamic::ParameterList *
-IR_Container::TAO_ClientRequestInfo_IR_Container_create_native::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
-    
-  CORBA::ULong length_id = parameter_list->length ();
-  parameter_list->length (length_id + 1);
-  (*parameter_list)[length_id].argument <<= id_;
-  (*parameter_list)[length_id].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_name = parameter_list->length ();
-  parameter_list->length (length_name + 1);
-  (*parameter_list)[length_name].argument <<= name_;
-  (*parameter_list)[length_name].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_version = parameter_list->length ();
-  parameter_list->length (length_version + 1);
-  (*parameter_list)[length_version].argument <<= version_;
-  (*parameter_list)[length_version].mode = Dynamic::PARAM_IN;
-  
-  return safe_parameter_list._retn ();
-}
-
-Dynamic::ExceptionList *
-IR_Container::TAO_ClientRequestInfo_IR_Container_create_native::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_Container::TAO_ClientRequestInfo_IR_Container_create_native::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_Container::TAO_ClientRequestInfo_IR_Container_create_native::result (IR_NativeDef_ptr result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-#endif /* TAO_HAS_INTERCEPTORS */
-
-static const CORBA::Long _oc_IR_Container[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  29, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f43), ACE_NTOHL (0x6f6e7461), ACE_NTOHL (0x696e6572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/Container:1.0
-  10, ACE_NTOHL (0x436f6e74), ACE_NTOHL (0x61696e65), ACE_NTOHL (0x72000000),  // name = IR_Container
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_Container (CORBA::tk_objref, sizeof (_oc_IR_Container), (char *) &_oc_IR_Container, 0, sizeof (IR_Container));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_Container, &_tc_TAO_tc_IR_Container)
-TAO_NAMESPACE_END
-
-///////////////////////////////////////////////////////////////////////
-//                Base & Remote Proxy  Implementation. 
-//
-
-_TAO_IDLType_Proxy_Impl::_TAO_IDLType_Proxy_Impl (void)
-{}
-
-_TAO_IDLType_Remote_Proxy_Impl::_TAO_IDLType_Remote_Proxy_Impl (void)
-{}
-
-// Remote Implementation of the IDL interface methods
-
-CORBA::TypeCode_ptr _TAO_IDLType_Remote_Proxy_Impl::type (
-    CORBA_Object *_collocated_tao_target_,
-        CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{  
-  CORBA::TypeCode_ptr _tao_retval = CORBA::TypeCode::_nil ();
-  CORBA::TypeCode_var _tao_safe_retval (_tao_retval);
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_get_type",
-      9,
-      0,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_IDLType::TAO_ClientRequestInfo_IR_IDLType_type_get ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              CORBA::TypeCode_ptr _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-
-//
-//            End  Base & Remote  Proxy Implemeentation. 
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//           Remote & Base  Proxy Broker Implementation
-//
-
-_TAO_IDLType_Proxy_Broker::_TAO_IDLType_Proxy_Broker (void)
-{
-}
-
-_TAO_IDLType_Proxy_Broker::~_TAO_IDLType_Proxy_Broker (void)
-{
-}
-
-_TAO_IDLType_Proxy_Broker * (*_TAO_IDLType_Proxy_Broker_Factory_function_pointer) (
-    CORBA::Object_ptr obj
-  ) = 0;
-
-// Factory Member function Implementation.
-_TAO_IDLType_Remote_Proxy_Broker *
-_TAO_IDLType_Remote_Proxy_Broker::the_TAO_IDLType_Remote_Proxy_Broker (void)
-{
-  static ::_TAO_IDLType_Remote_Proxy_Broker remote_proxy_broker;
-  return &remote_proxy_broker;
-}
-
-_TAO_IDLType_Remote_Proxy_Broker::_TAO_IDLType_Remote_Proxy_Broker (void)
-{
-}
-
-_TAO_IDLType_Remote_Proxy_Broker::~_TAO_IDLType_Remote_Proxy_Broker (void)
-{
-}
-
-_TAO_IDLType_Proxy_Impl&
-_TAO_IDLType_Remote_Proxy_Broker::select_proxy (
-  ::IR_IDLType *object,
-  CORBA::Environment &ACE_TRY_ENV
-)
-{
-  ACE_UNUSED_ARG (object);
-  ACE_UNUSED_ARG (ACE_TRY_ENV);
-  return remote_proxy_impl_;
-}
-
-
-//
-//           End Remote & Base Proxy Broker Implementation
-///////////////////////////////////////////////////////////////////////
-
-
-// default constructor
-IR_IDLType::IR_IDLType (int collocated)
-{
-  this->IR_IDLType_setup_collocation (collocated);
-}
-
-// destructor
-IR_IDLType::~IR_IDLType (void)
-{}
-
-void
-IR_IDLType::IR_IDLType_setup_collocation (int collocated)
-{
-  if (collocated)
-    this->the_TAO_IDLType_Proxy_Broker_ =
-      _TAO_IDLType_Proxy_Broker_Factory_function_pointer (this);
-  else
-    this->the_TAO_IDLType_Proxy_Broker_ =
-      ::_TAO_IDLType_Remote_Proxy_Broker::the_TAO_IDLType_Remote_Proxy_Broker ();
-  
-  this->CORBA_IRObject_setup_collocation (collocated);  
-}
-
-void IR_IDLType::_tao_any_destructor (void *x)
-{
-  IR_IDLType *tmp = ACE_static_cast (IR_IDLType*,x);
-  CORBA::release (tmp);
-}
-
-IR_IDLType_ptr IR_IDLType::_narrow (
-    CORBA::Object_ptr obj,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  if (CORBA::is_nil (obj))
-    return IR_IDLType::_nil ();
-  if (! obj->_is_local ())
-    {
-      CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/IR/IDLType:1.0", ACE_TRY_ENV);
-      ACE_CHECK_RETURN (IR_IDLType::_nil ());
-      if (is_a == 0)
-        return IR_IDLType::_nil ();
-    }
-  return IR_IDLType::_unchecked_narrow (obj, ACE_TRY_ENV);
-}
-
-IR_IDLType_ptr IR_IDLType::_unchecked_narrow (
-    CORBA::Object_ptr obj,
-    CORBA::Environment &
-  )
-{
-  if (CORBA::is_nil (obj))
-    return IR_IDLType::_nil ();
-  if (! obj->_is_local ())
-    {
-      TAO_Stub* stub = obj->_stubobj ();
-      if (stub)
-        stub->_incr_refcnt ();
-      IR_IDLType_ptr default_proxy = IR_IDLType::_nil ();
-
-      if (
-          !CORBA::is_nil (stub->servant_orb_var ().ptr ()) &&
-          stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects () &&
-          obj->_is_collocated () &&_TAO_IDLType_Proxy_Broker_Factory_function_pointer != 0
-        )
-      {
-        ACE_NEW_RETURN (
-          default_proxy,
-          ::IR_IDLType (
-            stub,
-            1,
-            obj->_servant ()),
-            
-          IR_IDLType::_nil ());
-        }
-      if (CORBA::is_nil (default_proxy))
-        ACE_NEW_RETURN (default_proxy, ::IR_IDLType (stub, 0, obj->_servant ()), IR_IDLType::_nil ());
-        return default_proxy;
-      }
-    else 
-      return
-        ACE_reinterpret_cast
-          (
-            IR_IDLType_ptr,
-              obj->_tao_QueryInterface
-                (
-                  ACE_reinterpret_cast
-                    (
-                      ptr_arith_t,
-                      &IR_IDLType::_narrow
-                    )
-                )
-          );
-}
-
-IR_IDLType_ptr
-IR_IDLType::_duplicate (IR_IDLType_ptr obj)
-{
-  if (!CORBA::is_nil (obj))
-    obj->_add_ref ();
-  return obj;
-}
-
-CORBA::Boolean IR_IDLType::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
-{
-  if (
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/IDLType:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
-  return 1; // success using local knowledge
-  else
-    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
-}
-
-void *IR_IDLType::_tao_QueryInterface (ptr_arith_t type)
-{
-  void *retv = 0;
-  if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_IDLType::_narrow))
-    retv = ACE_reinterpret_cast (void*, this);
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &CORBA_IRObject::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            CORBA_IRObject_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
-    retv = ACE_reinterpret_cast (void *,
-      ACE_static_cast (CORBA::Object_ptr, this));
-    
-  if (retv)
-    this->_add_ref ();
-  return retv;
-}
-
-const char* IR_IDLType::_interface_repository_id (void) const
-{
-  return "IDL:omg.org/IR/IDLType:1.0";
-}
-
-CORBA::TypeCode_ptr IR_IDLType::type (
-            CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_IDLType_Proxy_Impl &proxy = 
-    this->the_TAO_IDLType_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.type (
-      this,
-      ACE_TRY_ENV
-    );
-}
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-IR_IDLType::TAO_ClientRequestInfo_IR_IDLType_type_get::TAO_ClientRequestInfo_IR_IDLType_type_get (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
-{}
-
-Dynamic::ParameterList *
-IR_IDLType::TAO_ClientRequestInfo_IR_IDLType_type_get::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return parameter_list;
-}
-
-Dynamic::ExceptionList *
-IR_IDLType::TAO_ClientRequestInfo_IR_IDLType_type_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_IDLType::TAO_ClientRequestInfo_IR_IDLType_type_get::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_IDLType::TAO_ClientRequestInfo_IR_IDLType_type_get::result (CORBA::TypeCode_ptr result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-#endif /* TAO_HAS_INTERCEPTORS */
-
-static const CORBA::Long _oc_IR_IDLType[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  27, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x444c5479), ACE_NTOHL (0x70653a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/IDLType:1.0
-  8, ACE_NTOHL (0x49444c54), ACE_NTOHL (0x79706500),  // name = IR_IDLType
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_IDLType (CORBA::tk_objref, sizeof (_oc_IR_IDLType), (char *) &_oc_IR_IDLType, 0, sizeof (IR_IDLType));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_IDLType, &_tc_TAO_tc_IR_IDLType)
-TAO_NAMESPACE_END
-static const CORBA::Long _oc_IR_PrimitiveKind[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f50), ACE_NTOHL (0x72696d69), ACE_NTOHL (0x74697665), ACE_NTOHL (0x4b696e64), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/PrimitiveKind:1.0
-  14, ACE_NTOHL (0x5072696d), ACE_NTOHL (0x69746976), ACE_NTOHL (0x654b696e), ACE_NTOHL (0x64000000),  // name = PrimitiveKind
-  22, // member count
-  8, ACE_NTOHL (0x706b5f6e), ACE_NTOHL (0x756c6c00),  // name = pk_null
-  8, ACE_NTOHL (0x706b5f76), ACE_NTOHL (0x6f696400),  // name = pk_void
-  9, ACE_NTOHL (0x706b5f73), ACE_NTOHL (0x686f7274), ACE_NTOHL (0x0),  // name = pk_short
-  8, ACE_NTOHL (0x706b5f6c), ACE_NTOHL (0x6f6e6700),  // name = pk_long
-  10, ACE_NTOHL (0x706b5f75), ACE_NTOHL (0x73686f72), ACE_NTOHL (0x74000000),  // name = pk_ushort
-  9, ACE_NTOHL (0x706b5f75), ACE_NTOHL (0x6c6f6e67), ACE_NTOHL (0x0),  // name = pk_ulong
-  9, ACE_NTOHL (0x706b5f66), ACE_NTOHL (0x6c6f6174), ACE_NTOHL (0x0),  // name = pk_float
-  10, ACE_NTOHL (0x706b5f64), ACE_NTOHL (0x6f75626c), ACE_NTOHL (0x65000000),  // name = pk_double
-  11, ACE_NTOHL (0x706b5f62), ACE_NTOHL (0x6f6f6c65), ACE_NTOHL (0x616e0000),  // name = pk_boolean
-  8, ACE_NTOHL (0x706b5f63), ACE_NTOHL (0x68617200),  // name = pk_char
-  9, ACE_NTOHL (0x706b5f6f), ACE_NTOHL (0x63746574), ACE_NTOHL (0x0),  // name = pk_octet
-  7, ACE_NTOHL (0x706b5f61), ACE_NTOHL (0x6e790000),  // name = pk_any
-  12, ACE_NTOHL (0x706b5f54), ACE_NTOHL (0x79706543), ACE_NTOHL (0x6f646500),  // name = pk_TypeCode
-  13, ACE_NTOHL (0x706b5f50), ACE_NTOHL (0x72696e63), ACE_NTOHL (0x6970616c), ACE_NTOHL (0x0),  // name = pk_Principal
-  10, ACE_NTOHL (0x706b5f73), ACE_NTOHL (0x7472696e), ACE_NTOHL (0x67000000),  // name = pk_string
-  10, ACE_NTOHL (0x706b5f6f), ACE_NTOHL (0x626a7265), ACE_NTOHL (0x66000000),  // name = pk_objref
-  12, ACE_NTOHL (0x706b5f6c), ACE_NTOHL (0x6f6e676c), ACE_NTOHL (0x6f6e6700),  // name = pk_longlong
-  13, ACE_NTOHL (0x706b5f75), ACE_NTOHL (0x6c6f6e67), ACE_NTOHL (0x6c6f6e67), ACE_NTOHL (0x0),  // name = pk_ulonglong
-  14, ACE_NTOHL (0x706b5f6c), ACE_NTOHL (0x6f6e6764), ACE_NTOHL (0x6f75626c), ACE_NTOHL (0x65000000),  // name = pk_longdouble
-  9, ACE_NTOHL (0x706b5f77), ACE_NTOHL (0x63686172), ACE_NTOHL (0x0),  // name = pk_wchar
-  11, ACE_NTOHL (0x706b5f77), ACE_NTOHL (0x73747269), ACE_NTOHL (0x6e670000),  // name = pk_wstring
-  14, ACE_NTOHL (0x706b5f76), ACE_NTOHL (0x616c7565), ACE_NTOHL (0x5f626173), ACE_NTOHL (0x65000000),  // name = pk_value_base
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_PrimitiveKind (CORBA::tk_enum, sizeof (_oc_IR_PrimitiveKind), (char *) &_oc_IR_PrimitiveKind, 0, sizeof (IR_PrimitiveKind));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_PrimitiveKind, &_tc_TAO_tc_IR_PrimitiveKind)
-TAO_NAMESPACE_END
-
-///////////////////////////////////////////////////////////////////////
-//                Base & Remote Proxy  Implementation. 
-//
-
-_TAO_Repository_Proxy_Impl::_TAO_Repository_Proxy_Impl (void)
-{}
-
-_TAO_Repository_Remote_Proxy_Impl::_TAO_Repository_Remote_Proxy_Impl (void)
-{}
-
-// Remote Implementation of the IDL interface methods
-
-IR_Contained_ptr _TAO_Repository_Remote_Proxy_Impl::lookup_id (
-    CORBA_Object *_collocated_tao_target_,
-    const char * search_id,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  IR_Contained_ptr _tao_retval = IR_Contained::_nil ();
-  IR_Contained_var _tao_safe_retval (_tao_retval);
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "lookup_id",
-      9,
-      1,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_Repository::TAO_ClientRequestInfo_IR_Repository_lookup_id ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        search_id,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-          if (!(
-                            (_tao_out << search_id)
-            ))
-            TAO_INTERCEPTOR_THROW_RETURN (
-              CORBA::MARSHAL (),
-              0
-            );
-            
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              IR_Contained_ptr _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-CORBA::TypeCode_ptr _TAO_Repository_Remote_Proxy_Impl::get_canonical_typecode (
-    CORBA_Object *_collocated_tao_target_,
-    CORBA::TypeCode_ptr tc,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  CORBA::TypeCode_ptr _tao_retval = CORBA::TypeCode::_nil ();
-  CORBA::TypeCode_var _tao_safe_retval (_tao_retval);
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "get_canonical_typecode",
-      22,
-      1,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_Repository::TAO_ClientRequestInfo_IR_Repository_get_canonical_typecode ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        tc,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-          if (!(
-                            (_tao_out << tc)
-            ))
-            TAO_INTERCEPTOR_THROW_RETURN (
-              CORBA::MARSHAL (),
-              0
-            );
-            
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              CORBA::TypeCode_ptr _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-IR_PrimitiveDef_ptr _TAO_Repository_Remote_Proxy_Impl::get_primitive (
-    CORBA_Object *_collocated_tao_target_,
-    IR_PrimitiveKind kind,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  IR_PrimitiveDef_ptr _tao_retval = IR_PrimitiveDef::_nil ();
-  IR_PrimitiveDef_var _tao_safe_retval (_tao_retval);
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "get_primitive",
-      13,
-      1,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_Repository::TAO_ClientRequestInfo_IR_Repository_get_primitive ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        kind,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-          if (!(
-                            (_tao_out << kind)
-            ))
-            TAO_INTERCEPTOR_THROW_RETURN (
-              CORBA::MARSHAL (),
-              0
-            );
-            
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              IR_PrimitiveDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-IR_StringDef_ptr _TAO_Repository_Remote_Proxy_Impl::create_string (
-    CORBA_Object *_collocated_tao_target_,
-    CORBA::ULong bound,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  IR_StringDef_ptr _tao_retval = IR_StringDef::_nil ();
-  IR_StringDef_var _tao_safe_retval (_tao_retval);
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-  
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "create_string",
-      13,
-      1,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_Repository::TAO_ClientRequestInfo_IR_Repository_create_string ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        bound,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-          if (!(
-                            (_tao_out << bound)
-            ))
-            TAO_INTERCEPTOR_THROW_RETURN (
-              CORBA::MARSHAL (),
-              0
-            );
-            
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              IR_StringDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-IR_WstringDef_ptr _TAO_Repository_Remote_Proxy_Impl::create_wstring (
-    CORBA_Object *_collocated_tao_target_,
-    CORBA::ULong bound,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  IR_WstringDef_ptr _tao_retval = IR_WstringDef::_nil ();
-  IR_WstringDef_var _tao_safe_retval (_tao_retval);
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "create_wstring",
-      14,
-      1,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_Repository::TAO_ClientRequestInfo_IR_Repository_create_wstring ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        bound,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-          if (!(
-                            (_tao_out << bound)
-            ))
-            TAO_INTERCEPTOR_THROW_RETURN (
-              CORBA::MARSHAL (),
-              0
-            );
-            
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              IR_WstringDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-IR_SequenceDef_ptr _TAO_Repository_Remote_Proxy_Impl::create_sequence (
-    CORBA_Object *_collocated_tao_target_,
-    CORBA::ULong bound,
-    IR_IDLType_ptr element_type,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  IR_SequenceDef_ptr _tao_retval = IR_SequenceDef::_nil ();
-  IR_SequenceDef_var _tao_safe_retval (_tao_retval);
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "create_sequence",
-      15,
-      1,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_Repository::TAO_ClientRequestInfo_IR_Repository_create_sequence ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        bound,
-        element_type,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-          if (!(
-                            (_tao_out << bound) &&
-              (_tao_out << element_type)
-            ))
-            TAO_INTERCEPTOR_THROW_RETURN (
-              CORBA::MARSHAL (),
-              0
-            );
-            
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              IR_SequenceDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-IR_ArrayDef_ptr _TAO_Repository_Remote_Proxy_Impl::create_array (
-    CORBA_Object *_collocated_tao_target_,
-    CORBA::ULong length,
-    IR_IDLType_ptr element_type,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  IR_ArrayDef_ptr _tao_retval = IR_ArrayDef::_nil ();
-  IR_ArrayDef_var _tao_safe_retval (_tao_retval);
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "create_array",
-      12,
-      1,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_Repository::TAO_ClientRequestInfo_IR_Repository_create_array ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        length,
-        element_type,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-          if (!(
-                            (_tao_out << length) &&
-              (_tao_out << element_type)
-            ))
-            TAO_INTERCEPTOR_THROW_RETURN (
-              CORBA::MARSHAL (),
-              0
-            );
-            
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              IR_ArrayDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-IR_FixedDef_ptr _TAO_Repository_Remote_Proxy_Impl::create_fixed (
-    CORBA_Object *_collocated_tao_target_,
-    CORBA::UShort digits,
-    CORBA::Short scale,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  IR_FixedDef_ptr _tao_retval = IR_FixedDef::_nil ();
-  IR_FixedDef_var _tao_safe_retval (_tao_retval);
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "create_fixed",
-      12,
-      1,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_Repository::TAO_ClientRequestInfo_IR_Repository_create_fixed ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        digits,
-        scale,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-          if (!(
-                            (_tao_out << digits) &&
-              (_tao_out << scale)
-            ))
-            TAO_INTERCEPTOR_THROW_RETURN (
-              CORBA::MARSHAL (),
-              0
-            );
-            
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              IR_FixedDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-
-//
-//            End  Base & Remote  Proxy Implemeentation. 
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//           Remote & Base  Proxy Broker Implementation
-//
-
-_TAO_Repository_Proxy_Broker::_TAO_Repository_Proxy_Broker (void)
-{
-}
-
-_TAO_Repository_Proxy_Broker::~_TAO_Repository_Proxy_Broker (void)
-{
-}
-
-_TAO_Repository_Proxy_Broker * (*_TAO_Repository_Proxy_Broker_Factory_function_pointer) (
-    CORBA::Object_ptr obj
-  ) = 0;
-
-// Factory Member function Implementation.
-_TAO_Repository_Remote_Proxy_Broker *
-_TAO_Repository_Remote_Proxy_Broker::the_TAO_Repository_Remote_Proxy_Broker (void)
-{
-  static ::_TAO_Repository_Remote_Proxy_Broker remote_proxy_broker;
-  return &remote_proxy_broker;
-}
-
-_TAO_Repository_Remote_Proxy_Broker::_TAO_Repository_Remote_Proxy_Broker (void)
-{
-}
-
-_TAO_Repository_Remote_Proxy_Broker::~_TAO_Repository_Remote_Proxy_Broker (void)
-{
-}
-
-_TAO_Repository_Proxy_Impl&
-_TAO_Repository_Remote_Proxy_Broker::select_proxy (
-  ::IR_Repository *object,
-  CORBA::Environment &ACE_TRY_ENV
-)
-{
-  ACE_UNUSED_ARG (object);
-  ACE_UNUSED_ARG (ACE_TRY_ENV);
-  return remote_proxy_impl_;
-}
-
-
-//
-//           End Remote & Base Proxy Broker Implementation
-///////////////////////////////////////////////////////////////////////
-
-
-// default constructor
-IR_Repository::IR_Repository (int collocated)
-{
-  this->IR_Repository_setup_collocation (collocated);
-}
-
-// destructor
-IR_Repository::~IR_Repository (void)
-{}
-
-void
-IR_Repository::IR_Repository_setup_collocation (int collocated)
-{
-  if (collocated)
-    this->the_TAO_Repository_Proxy_Broker_ =
-      _TAO_Repository_Proxy_Broker_Factory_function_pointer (this);
-  else
-    this->the_TAO_Repository_Proxy_Broker_ =
-      ::_TAO_Repository_Remote_Proxy_Broker::the_TAO_Repository_Remote_Proxy_Broker ();
-  
-  this->IR_Container_setup_collocation (collocated); 
-}
-
-void IR_Repository::_tao_any_destructor (void *x)
-{
-  IR_Repository *tmp = ACE_static_cast (IR_Repository*,x);
-  CORBA::release (tmp);
-}
-
-IR_Repository_ptr IR_Repository::_narrow (
-    CORBA::Object_ptr obj,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  if (CORBA::is_nil (obj))
-    return IR_Repository::_nil ();
-  if (! obj->_is_local ())
-    {
-      CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/IR/Repository:1.0", ACE_TRY_ENV);
-      ACE_CHECK_RETURN (IR_Repository::_nil ());
-      if (is_a == 0)
-        return IR_Repository::_nil ();
-    }
-  return IR_Repository::_unchecked_narrow (obj, ACE_TRY_ENV);
-}
-
-IR_Repository_ptr IR_Repository::_unchecked_narrow (
-    CORBA::Object_ptr obj,
-    CORBA::Environment &
-  )
-{
-  if (CORBA::is_nil (obj))
-    return IR_Repository::_nil ();
-  if (! obj->_is_local ())
-    {
-      TAO_Stub* stub = obj->_stubobj ();
-      if (stub)
-        stub->_incr_refcnt ();
-      IR_Repository_ptr default_proxy = IR_Repository::_nil ();
-
-      if (
-          !CORBA::is_nil (stub->servant_orb_var ().ptr ()) &&
-          stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects () &&
-          obj->_is_collocated () &&_TAO_Repository_Proxy_Broker_Factory_function_pointer != 0
-        )
-      {
-        ACE_NEW_RETURN (
-          default_proxy,
-          ::IR_Repository (
-            stub,
-            1,
-            obj->_servant ()),
-            
-          IR_Repository::_nil ());
-        }
-      if (CORBA::is_nil (default_proxy))
-        ACE_NEW_RETURN (default_proxy, ::IR_Repository (stub, 0, obj->_servant ()), IR_Repository::_nil ());
-        return default_proxy;
-      }
-    else 
-      return
-        ACE_reinterpret_cast
-          (
-            IR_Repository_ptr,
-              obj->_tao_QueryInterface
-                (
-                  ACE_reinterpret_cast
-                    (
-                      ptr_arith_t,
-                      &IR_Repository::_narrow
-                    )
-                )
-          );
-}
-
-IR_Repository_ptr
-IR_Repository::_duplicate (IR_Repository_ptr obj)
-{
-  if (!CORBA::is_nil (obj))
-    obj->_add_ref ();
-  return obj;
-}
-
-CORBA::Boolean IR_Repository::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
-{
-  if (
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/Repository:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/Container:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
-  return 1; // success using local knowledge
-  else
-    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
-}
-
-void *IR_Repository::_tao_QueryInterface (ptr_arith_t type)
-{
-  void *retv = 0;
-  if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_Repository::_narrow))
-    retv = ACE_reinterpret_cast (void*, this);
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_Container::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            IR_Container_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &CORBA_IRObject::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            CORBA_IRObject_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
-    retv = ACE_reinterpret_cast (void *,
-      ACE_static_cast (CORBA::Object_ptr, this));
-    
-  if (retv)
-    this->_add_ref ();
-  return retv;
-}
-
-const char* IR_Repository::_interface_repository_id (void) const
-{
-  return "IDL:omg.org/IR/Repository:1.0";
-}
-
-IR_Contained_ptr IR_Repository::lookup_id (
-   const char * search_id,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_Repository_Proxy_Impl &proxy = 
-    this->the_TAO_Repository_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.lookup_id (
-      this,
-      search_id,
-      ACE_TRY_ENV
-    );
-}
-
-CORBA::TypeCode_ptr IR_Repository::get_canonical_typecode (
-    CORBA::TypeCode_ptr tc,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_Repository_Proxy_Impl &proxy = 
-    this->the_TAO_Repository_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.get_canonical_typecode (
-      this,
-      tc,
-      ACE_TRY_ENV
-    );
-}
-
-IR_PrimitiveDef_ptr IR_Repository::get_primitive (
-    IR_PrimitiveKind kind,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_Repository_Proxy_Impl &proxy = 
-    this->the_TAO_Repository_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.get_primitive (
-      this,
-      kind,
-      ACE_TRY_ENV
-    );
-}
-
-IR_StringDef_ptr IR_Repository::create_string (
-    CORBA::ULong bound,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_Repository_Proxy_Impl &proxy = 
-    this->the_TAO_Repository_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.create_string (
-      this,
-      bound,
-      ACE_TRY_ENV
-    );
-}
-
-IR_WstringDef_ptr IR_Repository::create_wstring (
-    CORBA::ULong bound,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_Repository_Proxy_Impl &proxy = 
-    this->the_TAO_Repository_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.create_wstring (
-      this,
-      bound,
-      ACE_TRY_ENV
-    );
-}
-
-IR_SequenceDef_ptr IR_Repository::create_sequence (
-    CORBA::ULong bound,
-    IR_IDLType_ptr element_type,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_Repository_Proxy_Impl &proxy = 
-    this->the_TAO_Repository_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.create_sequence (
-      this,
-      bound,
-      element_type,
-      ACE_TRY_ENV
-    );
-}
-
-IR_ArrayDef_ptr IR_Repository::create_array (
-    CORBA::ULong length,
-    IR_IDLType_ptr element_type,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_Repository_Proxy_Impl &proxy = 
-    this->the_TAO_Repository_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.create_array (
-      this,
-      length,
-      element_type,
-      ACE_TRY_ENV
-    );
-}
-
-IR_FixedDef_ptr IR_Repository::create_fixed (
-    CORBA::UShort digits,
-    CORBA::Short scale,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_Repository_Proxy_Impl &proxy = 
-    this->the_TAO_Repository_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.create_fixed (
-      this,
-      digits,
-      scale,
-      ACE_TRY_ENV
-    );
-}
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-IR_Repository::TAO_ClientRequestInfo_IR_Repository_lookup_id::TAO_ClientRequestInfo_IR_Repository_lookup_id (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    const char * search_id,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
-    search_id_ (search_id)
-{}
-
-Dynamic::ParameterList *
-IR_Repository::TAO_ClientRequestInfo_IR_Repository_lookup_id::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
-    
-  CORBA::ULong length_search_id = parameter_list->length ();
-  parameter_list->length (length_search_id + 1);
-  (*parameter_list)[length_search_id].argument <<= search_id_;
-  (*parameter_list)[length_search_id].mode = Dynamic::PARAM_IN;
-  
-  return safe_parameter_list._retn ();
-}
-
-Dynamic::ExceptionList *
-IR_Repository::TAO_ClientRequestInfo_IR_Repository_lookup_id::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_Repository::TAO_ClientRequestInfo_IR_Repository_lookup_id::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_Repository::TAO_ClientRequestInfo_IR_Repository_lookup_id::result (IR_Contained_ptr result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_Repository::TAO_ClientRequestInfo_IR_Repository_get_canonical_typecode::TAO_ClientRequestInfo_IR_Repository_get_canonical_typecode (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    CORBA::TypeCode_ptr tc,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
-    tc_ (tc)
-{}
-
-Dynamic::ParameterList *
-IR_Repository::TAO_ClientRequestInfo_IR_Repository_get_canonical_typecode::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
-    
-  CORBA::ULong length_tc = parameter_list->length ();
-  parameter_list->length (length_tc + 1);
-  (*parameter_list)[length_tc].argument <<= tc_;
-  (*parameter_list)[length_tc].mode = Dynamic::PARAM_IN;
-  
-  return safe_parameter_list._retn ();
-}
-
-Dynamic::ExceptionList *
-IR_Repository::TAO_ClientRequestInfo_IR_Repository_get_canonical_typecode::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_Repository::TAO_ClientRequestInfo_IR_Repository_get_canonical_typecode::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_Repository::TAO_ClientRequestInfo_IR_Repository_get_canonical_typecode::result (CORBA::TypeCode_ptr result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_Repository::TAO_ClientRequestInfo_IR_Repository_get_primitive::TAO_ClientRequestInfo_IR_Repository_get_primitive (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    IR_PrimitiveKind & kind,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
-    kind_ (kind)
-{}
-
-Dynamic::ParameterList *
-IR_Repository::TAO_ClientRequestInfo_IR_Repository_get_primitive::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
-    
-  CORBA::ULong length_kind = parameter_list->length ();
-  parameter_list->length (length_kind + 1);
-  (*parameter_list)[length_kind].argument <<=  this->kind_;
-  
-  (*parameter_list)[length_kind].mode = Dynamic::PARAM_IN;
-  
-  return safe_parameter_list._retn ();
-}
-
-Dynamic::ExceptionList *
-IR_Repository::TAO_ClientRequestInfo_IR_Repository_get_primitive::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_Repository::TAO_ClientRequestInfo_IR_Repository_get_primitive::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_Repository::TAO_ClientRequestInfo_IR_Repository_get_primitive::result (IR_PrimitiveDef_ptr result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_Repository::TAO_ClientRequestInfo_IR_Repository_create_string::TAO_ClientRequestInfo_IR_Repository_create_string (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    const CORBA::ULong & bound,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
-    bound_ (bound)
-{}
-
-Dynamic::ParameterList *
-IR_Repository::TAO_ClientRequestInfo_IR_Repository_create_string::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
-    
-  CORBA::ULong length_bound = parameter_list->length ();
-  parameter_list->length (length_bound + 1);
-  (*parameter_list)[length_bound].argument <<= bound_;
-  (*parameter_list)[length_bound].mode = Dynamic::PARAM_IN;
-  
-  return safe_parameter_list._retn ();
-}
-
-Dynamic::ExceptionList *
-IR_Repository::TAO_ClientRequestInfo_IR_Repository_create_string::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_Repository::TAO_ClientRequestInfo_IR_Repository_create_string::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_Repository::TAO_ClientRequestInfo_IR_Repository_create_string::result (IR_StringDef_ptr result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_Repository::TAO_ClientRequestInfo_IR_Repository_create_wstring::TAO_ClientRequestInfo_IR_Repository_create_wstring (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    const CORBA::ULong & bound,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
-    bound_ (bound)
-{}
-
-Dynamic::ParameterList *
-IR_Repository::TAO_ClientRequestInfo_IR_Repository_create_wstring::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
-    
-  CORBA::ULong length_bound = parameter_list->length ();
-  parameter_list->length (length_bound + 1);
-  (*parameter_list)[length_bound].argument <<= bound_;
-  (*parameter_list)[length_bound].mode = Dynamic::PARAM_IN;
-  
-  return safe_parameter_list._retn ();
-}
-
-Dynamic::ExceptionList *
-IR_Repository::TAO_ClientRequestInfo_IR_Repository_create_wstring::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_Repository::TAO_ClientRequestInfo_IR_Repository_create_wstring::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_Repository::TAO_ClientRequestInfo_IR_Repository_create_wstring::result (IR_WstringDef_ptr result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_Repository::TAO_ClientRequestInfo_IR_Repository_create_sequence::TAO_ClientRequestInfo_IR_Repository_create_sequence (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    const CORBA::ULong & bound,
-    IR_IDLType_ptr element_type,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
-    bound_ (bound),
-    element_type_ (element_type)
-{}
-
-Dynamic::ParameterList *
-IR_Repository::TAO_ClientRequestInfo_IR_Repository_create_sequence::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
-    
-  CORBA::ULong length_bound = parameter_list->length ();
-  parameter_list->length (length_bound + 1);
-  (*parameter_list)[length_bound].argument <<= bound_;
-  (*parameter_list)[length_bound].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_element_type = parameter_list->length ();
-  parameter_list->length (length_element_type + 1);
-  (*parameter_list)[length_element_type].argument <<=  this->element_type_;
-  
-  (*parameter_list)[length_element_type].mode = Dynamic::PARAM_IN;
-  
-  return safe_parameter_list._retn ();
-}
-
-Dynamic::ExceptionList *
-IR_Repository::TAO_ClientRequestInfo_IR_Repository_create_sequence::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_Repository::TAO_ClientRequestInfo_IR_Repository_create_sequence::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_Repository::TAO_ClientRequestInfo_IR_Repository_create_sequence::result (IR_SequenceDef_ptr result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_Repository::TAO_ClientRequestInfo_IR_Repository_create_array::TAO_ClientRequestInfo_IR_Repository_create_array (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    const CORBA::ULong & length,
-    IR_IDLType_ptr element_type,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
-    length_ (length),
-    element_type_ (element_type)
-{}
-
-Dynamic::ParameterList *
-IR_Repository::TAO_ClientRequestInfo_IR_Repository_create_array::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
-    
-  CORBA::ULong length_length = parameter_list->length ();
-  parameter_list->length (length_length + 1);
-  (*parameter_list)[length_length].argument <<= length_;
-  (*parameter_list)[length_length].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_element_type = parameter_list->length ();
-  parameter_list->length (length_element_type + 1);
-  (*parameter_list)[length_element_type].argument <<=  this->element_type_;
-  
-  (*parameter_list)[length_element_type].mode = Dynamic::PARAM_IN;
-  
-  return safe_parameter_list._retn ();
-}
-
-Dynamic::ExceptionList *
-IR_Repository::TAO_ClientRequestInfo_IR_Repository_create_array::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_Repository::TAO_ClientRequestInfo_IR_Repository_create_array::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_Repository::TAO_ClientRequestInfo_IR_Repository_create_array::result (IR_ArrayDef_ptr result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_Repository::TAO_ClientRequestInfo_IR_Repository_create_fixed::TAO_ClientRequestInfo_IR_Repository_create_fixed (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    const CORBA::UShort & digits,
-    const CORBA::Short & scale,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
-    digits_ (digits),
-    scale_ (scale)
-{}
-
-Dynamic::ParameterList *
-IR_Repository::TAO_ClientRequestInfo_IR_Repository_create_fixed::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
-    
-  CORBA::ULong length_digits = parameter_list->length ();
-  parameter_list->length (length_digits + 1);
-  (*parameter_list)[length_digits].argument <<= digits_;
-  (*parameter_list)[length_digits].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_scale = parameter_list->length ();
-  parameter_list->length (length_scale + 1);
-  (*parameter_list)[length_scale].argument <<= scale_;
-  (*parameter_list)[length_scale].mode = Dynamic::PARAM_IN;
-  
-  return safe_parameter_list._retn ();
-}
-
-Dynamic::ExceptionList *
-IR_Repository::TAO_ClientRequestInfo_IR_Repository_create_fixed::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_Repository::TAO_ClientRequestInfo_IR_Repository_create_fixed::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_Repository::TAO_ClientRequestInfo_IR_Repository_create_fixed::result (IR_FixedDef_ptr result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-#endif /* TAO_HAS_INTERCEPTORS */
-
-static const CORBA::Long _oc_IR_Repository[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x793a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Repository:1.0
-  11, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72790000),  // name = IR_Repository
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_Repository (CORBA::tk_objref, sizeof (_oc_IR_Repository), (char *) &_oc_IR_Repository, 0, sizeof (IR_Repository));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_Repository, &_tc_TAO_tc_IR_Repository)
-TAO_NAMESPACE_END
-
-///////////////////////////////////////////////////////////////////////
-//                Base & Remote Proxy  Implementation. 
-//
-
-_TAO_ComponentRepository_Proxy_Impl::_TAO_ComponentRepository_Proxy_Impl (void)
-{}
-
-_TAO_ComponentRepository_Remote_Proxy_Impl::_TAO_ComponentRepository_Remote_Proxy_Impl (void)
-{}
-
-// Remote Implementation of the IDL interface methods
-
-IR_ComponentDef_ptr _TAO_ComponentRepository_Remote_Proxy_Impl::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,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  IR_ComponentDef_ptr _tao_retval = IR_ComponentDef::_nil ();
-  IR_ComponentDef_var _tao_safe_retval (_tao_retval);
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-  
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "create_component",
-      16,
-      1,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_ComponentRepository::TAO_ClientRequestInfo_IR_ComponentRepository_create_component ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        id,
-        name,
-        version,
-        base_component,
-        supports_interfaces,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-          if (!(
-                            (_tao_out << id) &&
-              (_tao_out << name) &&
-              (_tao_out << version) &&
-              (_tao_out << base_component) &&
-              (_tao_out << supports_interfaces)
-            ))
-            TAO_INTERCEPTOR_THROW_RETURN (
-              CORBA::MARSHAL (),
-              0
-            );
-            
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              IR_ComponentDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-IR_HomeDef_ptr _TAO_ComponentRepository_Remote_Proxy_Impl::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,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  IR_HomeDef_ptr _tao_retval = IR_HomeDef::_nil ();
-  IR_HomeDef_var _tao_safe_retval (_tao_retval);
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "create_home",
-      11,
-      1,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_ComponentRepository::TAO_ClientRequestInfo_IR_ComponentRepository_create_home ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        id,
-        name,
-        version,
-        base_home,
-        managed_component,
-        primary_key,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-          if (!(
-                            (_tao_out << id) &&
-              (_tao_out << name) &&
-              (_tao_out << version) &&
-              (_tao_out << base_home) &&
-              (_tao_out << managed_component) &&
-              (_tao_out << primary_key)
-            ))
-            TAO_INTERCEPTOR_THROW_RETURN (
-              CORBA::MARSHAL (),
-              0
-            );
-            
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              IR_HomeDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-
-//
-//            End  Base & Remote  Proxy Implemeentation. 
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//           Remote & Base  Proxy Broker Implementation
-//
-
-_TAO_ComponentRepository_Proxy_Broker::_TAO_ComponentRepository_Proxy_Broker (void)
-{
-}
-
-_TAO_ComponentRepository_Proxy_Broker::~_TAO_ComponentRepository_Proxy_Broker (void)
-{
-}
-
-_TAO_ComponentRepository_Proxy_Broker * (*_TAO_ComponentRepository_Proxy_Broker_Factory_function_pointer) (
-    CORBA::Object_ptr obj
-  ) = 0;
-
-// Factory Member function Implementation.
-_TAO_ComponentRepository_Remote_Proxy_Broker *
-_TAO_ComponentRepository_Remote_Proxy_Broker::the_TAO_ComponentRepository_Remote_Proxy_Broker (void)
-{
-  static ::_TAO_ComponentRepository_Remote_Proxy_Broker remote_proxy_broker;
-  return &remote_proxy_broker;
-}
-
-_TAO_ComponentRepository_Remote_Proxy_Broker::_TAO_ComponentRepository_Remote_Proxy_Broker (void)
-{
-}
-
-_TAO_ComponentRepository_Remote_Proxy_Broker::~_TAO_ComponentRepository_Remote_Proxy_Broker (void)
-{
-}
-
-_TAO_ComponentRepository_Proxy_Impl&
-_TAO_ComponentRepository_Remote_Proxy_Broker::select_proxy (
-  ::IR_ComponentRepository *object,
-  CORBA::Environment &ACE_TRY_ENV
-)
-{
-  ACE_UNUSED_ARG (object);
-  ACE_UNUSED_ARG (ACE_TRY_ENV);
-  return remote_proxy_impl_;
-}
-
-
-//
-//           End Remote & Base Proxy Broker Implementation
-///////////////////////////////////////////////////////////////////////
-
-
-// default constructor
-IR_ComponentRepository::IR_ComponentRepository (int collocated)
-{
-  this->IR_ComponentRepository_setup_collocation (collocated);
-}
-
-// destructor
-IR_ComponentRepository::~IR_ComponentRepository (void)
-{}
-
-void
-IR_ComponentRepository::IR_ComponentRepository_setup_collocation (int collocated)
-{
-  if (collocated)
-    this->the_TAO_ComponentRepository_Proxy_Broker_ =
-      _TAO_ComponentRepository_Proxy_Broker_Factory_function_pointer (this);
-  else
-    this->the_TAO_ComponentRepository_Proxy_Broker_ =
-      _TAO_ComponentRepository_Remote_Proxy_Broker::the_TAO_ComponentRepository_Remote_Proxy_Broker ();
-  
-  this->IR_Repository_setup_collocation (collocated);  
-}
-
-void IR_ComponentRepository::_tao_any_destructor (void *x)
-{
-  IR_ComponentRepository *tmp = ACE_static_cast (IR_ComponentRepository*,x);
-  CORBA::release (tmp);
-}
-
-IR_ComponentRepository_ptr IR_ComponentRepository::_narrow (
-    CORBA::Object_ptr obj,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  if (CORBA::is_nil (obj))
-    return IR_ComponentRepository::_nil ();
-  if (! obj->_is_local ())
-    {
-      CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/IR/ComponentRepository:1.0", ACE_TRY_ENV);
-      ACE_CHECK_RETURN (IR_ComponentRepository::_nil ());
-      if (is_a == 0)
-        return IR_ComponentRepository::_nil ();
-    }
-  return IR_ComponentRepository::_unchecked_narrow (obj, ACE_TRY_ENV);
-}
-
-IR_ComponentRepository_ptr IR_ComponentRepository::_unchecked_narrow (
-    CORBA::Object_ptr obj,
-    CORBA::Environment &
-  )
-{
-  if (CORBA::is_nil (obj))
-    return IR_ComponentRepository::_nil ();
-  if (! obj->_is_local ())
-    {
-      TAO_Stub* stub = obj->_stubobj ();
-      if (stub)
-        stub->_incr_refcnt ();
-      IR_ComponentRepository_ptr default_proxy = IR_ComponentRepository::_nil ();
-
-      if (
-          !CORBA::is_nil (stub->servant_orb_var ().ptr ()) &&
-          stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects () &&
-          obj->_is_collocated () &&_TAO_ComponentRepository_Proxy_Broker_Factory_function_pointer != 0
-        )
-      {
-        ACE_NEW_RETURN (
-          default_proxy,
-          ::IR_ComponentRepository (
-            stub,
-            1,
-            obj->_servant ()),
-            
-          IR_ComponentRepository::_nil ());
-        }
-      if (CORBA::is_nil (default_proxy))
-        ACE_NEW_RETURN (default_proxy, ::IR_ComponentRepository (stub, 0, obj->_servant ()), IR_ComponentRepository::_nil ());
-        return default_proxy;
-      }
-    else 
-      return
-        ACE_reinterpret_cast
-          (
-            IR_ComponentRepository_ptr,
-              obj->_tao_QueryInterface
-                (
-                  ACE_reinterpret_cast
-                    (
-                      ptr_arith_t,
-                      &IR_ComponentRepository::_narrow
-                    )
-                )
-          );
-}
-
-IR_ComponentRepository_ptr
-IR_ComponentRepository::_duplicate (IR_ComponentRepository_ptr obj)
-{
-  if (!CORBA::is_nil (obj))
-    obj->_add_ref ();
-  return obj;
-}
-
-CORBA::Boolean IR_ComponentRepository::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
-{
-  if (
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/ComponentRepository:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/Repository:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/Container:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
-  return 1; // success using local knowledge
-  else
-    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
-}
-
-void *IR_ComponentRepository::_tao_QueryInterface (ptr_arith_t type)
-{
-  void *retv = 0;
-  if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_ComponentRepository::_narrow))
-    retv = ACE_reinterpret_cast (void*, this);
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_Repository::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            IR_Repository_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_Container::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            IR_Container_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &CORBA_IRObject::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            CORBA_IRObject_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
-    retv = ACE_reinterpret_cast (void *,
-      ACE_static_cast (CORBA::Object_ptr, this));
-    
-  if (retv)
-    this->_add_ref ();
-  return retv;
-}
-
-const char* IR_ComponentRepository::_interface_repository_id (void) const
-{
-  return "IDL:omg.org/IR/ComponentRepository:1.0";
-}
-
-IR_ComponentDef_ptr IR_ComponentRepository::create_component (
-    const char * id,
-    const char * name,
-    const char * version,
-    IR_ComponentDef_ptr base_component,
-    const IR_InterfaceDefSeq & supports_interfaces,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_ComponentRepository_Proxy_Impl &proxy = 
-    this->the_TAO_ComponentRepository_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.create_component (
-      this,
-      id,
-      name,
-      version,
-      base_component,
-      supports_interfaces,
-      ACE_TRY_ENV
-    );
-}
-
-IR_HomeDef_ptr 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,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{ 
-  _TAO_ComponentRepository_Proxy_Impl &proxy = 
-    this->the_TAO_ComponentRepository_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.create_home (
-      this,
-      id,
-      name,
-      version,
-      base_home,
-      managed_component,
-      primary_key,
-      ACE_TRY_ENV
-    );
-}
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-IR_ComponentRepository::TAO_ClientRequestInfo_IR_ComponentRepository_create_component::TAO_ClientRequestInfo_IR_ComponentRepository_create_component (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    const char * id,
-    const char * name,
-    const char * version,
-    IR_ComponentDef_ptr base_component,
-    const IR_InterfaceDefSeq & supports_interfaces,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
-    id_ (id),
-    name_ (name),
-    version_ (version),
-    base_component_ (base_component),
-    supports_interfaces_ (supports_interfaces)
-{}
-
-Dynamic::ParameterList *
-IR_ComponentRepository::TAO_ClientRequestInfo_IR_ComponentRepository_create_component::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
-    
-  CORBA::ULong length_id = parameter_list->length ();
-  parameter_list->length (length_id + 1);
-  (*parameter_list)[length_id].argument <<= id_;
-  (*parameter_list)[length_id].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_name = parameter_list->length ();
-  parameter_list->length (length_name + 1);
-  (*parameter_list)[length_name].argument <<= name_;
-  (*parameter_list)[length_name].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_version = parameter_list->length ();
-  parameter_list->length (length_version + 1);
-  (*parameter_list)[length_version].argument <<= version_;
-  (*parameter_list)[length_version].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_base_component = parameter_list->length ();
-  parameter_list->length (length_base_component + 1);
-  (*parameter_list)[length_base_component].argument <<=  this->base_component_;
-  
-  (*parameter_list)[length_base_component].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_supports_interfaces = parameter_list->length ();
-  parameter_list->length (length_supports_interfaces + 1);
-  (*parameter_list)[length_supports_interfaces].argument <<=  this->supports_interfaces_;
-  
-  (*parameter_list)[length_supports_interfaces].mode = Dynamic::PARAM_IN;
-  
-  return safe_parameter_list._retn ();
-}
-
-Dynamic::ExceptionList *
-IR_ComponentRepository::TAO_ClientRequestInfo_IR_ComponentRepository_create_component::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_ComponentRepository::TAO_ClientRequestInfo_IR_ComponentRepository_create_component::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_ComponentRepository::TAO_ClientRequestInfo_IR_ComponentRepository_create_component::result (IR_ComponentDef_ptr result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_ComponentRepository::TAO_ClientRequestInfo_IR_ComponentRepository_create_home::TAO_ClientRequestInfo_IR_ComponentRepository_create_home (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _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 &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
-    id_ (id),
-    name_ (name),
-    version_ (version),
-    base_home_ (base_home),
-    managed_component_ (managed_component),
-    primary_key_ (primary_key)
-{}
-
-Dynamic::ParameterList *
-IR_ComponentRepository::TAO_ClientRequestInfo_IR_ComponentRepository_create_home::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
-    
-  CORBA::ULong length_id = parameter_list->length ();
-  parameter_list->length (length_id + 1);
-  (*parameter_list)[length_id].argument <<= id_;
-  (*parameter_list)[length_id].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_name = parameter_list->length ();
-  parameter_list->length (length_name + 1);
-  (*parameter_list)[length_name].argument <<= name_;
-  (*parameter_list)[length_name].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_version = parameter_list->length ();
-  parameter_list->length (length_version + 1);
-  (*parameter_list)[length_version].argument <<= version_;
-  (*parameter_list)[length_version].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_base_home = parameter_list->length ();
-  parameter_list->length (length_base_home + 1);
-  (*parameter_list)[length_base_home].argument <<=  this->base_home_;
-  
-  (*parameter_list)[length_base_home].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_managed_component = parameter_list->length ();
-  parameter_list->length (length_managed_component + 1);
-  (*parameter_list)[length_managed_component].argument <<=  this->managed_component_;
-  
-  (*parameter_list)[length_managed_component].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_primary_key = parameter_list->length ();
-  parameter_list->length (length_primary_key + 1);
-  (*parameter_list)[length_primary_key].argument <<=  this->primary_key_;
-  
-  (*parameter_list)[length_primary_key].mode = Dynamic::PARAM_IN;
-  
-  return safe_parameter_list._retn ();
-}
-
-Dynamic::ExceptionList *
-IR_ComponentRepository::TAO_ClientRequestInfo_IR_ComponentRepository_create_home::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_ComponentRepository::TAO_ClientRequestInfo_IR_ComponentRepository_create_home::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_ComponentRepository::TAO_ClientRequestInfo_IR_ComponentRepository_create_home::result (IR_HomeDef_ptr result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-#endif /* TAO_HAS_INTERCEPTORS */
-
-static const CORBA::Long _oc_IR_ComponentRepository[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  39, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f43), ACE_NTOHL (0x6f6d706f), ACE_NTOHL (0x6e656e74), ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72793a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/ComponentRepository:1.0
-  20, ACE_NTOHL (0x436f6d70), ACE_NTOHL (0x6f6e656e), ACE_NTOHL (0x74526570), ACE_NTOHL (0x6f736974), ACE_NTOHL (0x6f727900),  // name = IR_ComponentRepository
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_ComponentRepository (CORBA::tk_objref, sizeof (_oc_IR_ComponentRepository), (char *) &_oc_IR_ComponentRepository, 0, sizeof (IR_ComponentRepository));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ComponentRepository, &_tc_TAO_tc_IR_ComponentRepository)
-TAO_NAMESPACE_END
-
-///////////////////////////////////////////////////////////////////////
-//                Base & Remote Proxy  Implementation. 
-//
-
-_TAO_ModuleDef_Proxy_Impl::_TAO_ModuleDef_Proxy_Impl (void)
-{}
-
-_TAO_ModuleDef_Remote_Proxy_Impl::_TAO_ModuleDef_Remote_Proxy_Impl (void)
-{}
-
-// Remote Implementation of the IDL interface methods
-
-
-//
-//            End  Base & Remote  Proxy Implemeentation. 
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//           Remote & Base  Proxy Broker Implementation
-//
-
-_TAO_ModuleDef_Proxy_Broker::_TAO_ModuleDef_Proxy_Broker (void)
-{
-}
-
-_TAO_ModuleDef_Proxy_Broker::~_TAO_ModuleDef_Proxy_Broker (void)
-{
-}
-
-_TAO_ModuleDef_Proxy_Broker * (*_TAO_ModuleDef_Proxy_Broker_Factory_function_pointer) (
-    CORBA::Object_ptr obj
-  ) = 0;
-
-// Factory Member function Implementation.
-_TAO_ModuleDef_Remote_Proxy_Broker *
-_TAO_ModuleDef_Remote_Proxy_Broker::the_TAO_ModuleDef_Remote_Proxy_Broker (void)
-{
-  static ::_TAO_ModuleDef_Remote_Proxy_Broker remote_proxy_broker;
-  return &remote_proxy_broker;
-}
-
-_TAO_ModuleDef_Remote_Proxy_Broker::_TAO_ModuleDef_Remote_Proxy_Broker (void)
-{
-}
-
-_TAO_ModuleDef_Remote_Proxy_Broker::~_TAO_ModuleDef_Remote_Proxy_Broker (void)
-{
-}
-
-_TAO_ModuleDef_Proxy_Impl&
-_TAO_ModuleDef_Remote_Proxy_Broker::select_proxy (
-  ::IR_ModuleDef *object,
-  CORBA::Environment &ACE_TRY_ENV
-)
-{
-  ACE_UNUSED_ARG (object);
-  ACE_UNUSED_ARG (ACE_TRY_ENV);
-  return remote_proxy_impl_;
-}
-
-
-//
-//           End Remote & Base Proxy Broker Implementation
-///////////////////////////////////////////////////////////////////////
-
-
-// default constructor
-IR_ModuleDef::IR_ModuleDef (int collocated)
-{
-  this->IR_ModuleDef_setup_collocation (collocated);
-}
-
-// destructor
-IR_ModuleDef::~IR_ModuleDef (void)
-{}
-
-void
-IR_ModuleDef::IR_ModuleDef_setup_collocation (int collocated)
-{
-  if (collocated)
-    this->the_TAO_ModuleDef_Proxy_Broker_ =
-      _TAO_ModuleDef_Proxy_Broker_Factory_function_pointer (this);
-  else
-    this->the_TAO_ModuleDef_Proxy_Broker_ =
-      _TAO_ModuleDef_Remote_Proxy_Broker::the_TAO_ModuleDef_Remote_Proxy_Broker ();
-  
-  this->IR_Container_setup_collocation (collocated);
-  this->IR_Contained_setup_collocation (collocated); 
-}
-
-void IR_ModuleDef::_tao_any_destructor (void *x)
-{
-  IR_ModuleDef *tmp = ACE_static_cast (IR_ModuleDef*,x);
-  CORBA::release (tmp);
-}
-
-IR_ModuleDef_ptr IR_ModuleDef::_narrow (
-    CORBA::Object_ptr obj,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  if (CORBA::is_nil (obj))
-    return IR_ModuleDef::_nil ();
-  if (! obj->_is_local ())
-    {
-      CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/IR/ModuleDef:1.0", ACE_TRY_ENV);
-      ACE_CHECK_RETURN (IR_ModuleDef::_nil ());
-      if (is_a == 0)
-        return IR_ModuleDef::_nil ();
-    }
-  return IR_ModuleDef::_unchecked_narrow (obj, ACE_TRY_ENV);
-}
-
-IR_ModuleDef_ptr IR_ModuleDef::_unchecked_narrow (
-    CORBA::Object_ptr obj,
-    CORBA::Environment &
-  )
-{
-  if (CORBA::is_nil (obj))
-    return IR_ModuleDef::_nil ();
-  if (! obj->_is_local ())
-    {
-      TAO_Stub* stub = obj->_stubobj ();
-      if (stub)
-        stub->_incr_refcnt ();
-      IR_ModuleDef_ptr default_proxy = IR_ModuleDef::_nil ();
-
-      if (
-          !CORBA::is_nil (stub->servant_orb_var ().ptr ()) &&
-          stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects () &&
-          obj->_is_collocated () &&_TAO_ModuleDef_Proxy_Broker_Factory_function_pointer != 0
-        )
-      {
-        ACE_NEW_RETURN (
-          default_proxy,
-          ::IR_ModuleDef (
-            stub,
-            1,
-            obj->_servant ()),
-            
-          IR_ModuleDef::_nil ());
-        }
-      if (CORBA::is_nil (default_proxy))
-        ACE_NEW_RETURN (default_proxy, ::IR_ModuleDef (stub, 0, obj->_servant ()), IR_ModuleDef::_nil ());
-        return default_proxy;
-      }
-    else 
-      return
-        ACE_reinterpret_cast
-          (
-            IR_ModuleDef_ptr,
-              obj->_tao_QueryInterface
-                (
-                  ACE_reinterpret_cast
-                    (
-                      ptr_arith_t,
-                      &IR_ModuleDef::_narrow
-                    )
-                )
-          );
-}
-
-IR_ModuleDef_ptr
-IR_ModuleDef::_duplicate (IR_ModuleDef_ptr obj)
-{
-  if (!CORBA::is_nil (obj))
-    obj->_add_ref ();
-  return obj;
-}
-
-CORBA::Boolean IR_ModuleDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
-{
-  if (
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/ModuleDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/Container:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/Contained:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
-  return 1; // success using local knowledge
-  else
-    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
-}
-
-void *IR_ModuleDef::_tao_QueryInterface (ptr_arith_t type)
-{
-  void *retv = 0;
-  if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_ModuleDef::_narrow))
-    retv = ACE_reinterpret_cast (void*, this);
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_Container::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            IR_Container_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_Contained::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            IR_Contained_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &CORBA_IRObject::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            CORBA_IRObject_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
-    retv = ACE_reinterpret_cast (void *,
-      ACE_static_cast (CORBA::Object_ptr, this));
-    
-  if (retv)
-    this->_add_ref ();
-  return retv;
-}
-
-const char* IR_ModuleDef::_interface_repository_id (void) const
-{
-  return "IDL:omg.org/IR/ModuleDef:1.0";
-}
-
-static const CORBA::Long _oc_IR_ModuleDef[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  29, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f4d), ACE_NTOHL (0x6f64756c), ACE_NTOHL (0x65446566), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/ModuleDef:1.0
-  10, ACE_NTOHL (0x4d6f6475), ACE_NTOHL (0x6c654465), ACE_NTOHL (0x66000000),  // name = IR_ModuleDef
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_ModuleDef (CORBA::tk_objref, sizeof (_oc_IR_ModuleDef), (char *) &_oc_IR_ModuleDef, 0, sizeof (IR_ModuleDef));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ModuleDef, &_tc_TAO_tc_IR_ModuleDef)
-TAO_NAMESPACE_END
-
-static const CORBA::Long _oc_IR_ModuleDescription[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  37, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f4d), ACE_NTOHL (0x6f64756c), ACE_NTOHL (0x65446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/ModuleDescription:1.0
-  18, ACE_NTOHL (0x4d6f6475), ACE_NTOHL (0x6c654465), ACE_NTOHL (0x73637269), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e000000),  // name = ModuleDescription
-  4, // member count
-  5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
-  CORBA::tk_alias, // typecode kind for typedefs
-  64, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
-    11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-    CORBA::tk_string, 
-    0U, // string length
-
-  3, ACE_NTOHL (0x69640000),  // name = id
-  CORBA::tk_alias, // typecode kind for typedefs
-  68, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-    13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-    CORBA::tk_string, 
-    0U, // string length
-
-  11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
-  CORBA::tk_alias, // typecode kind for typedefs
-  68, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-    13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-    CORBA::tk_string, 
-    0U, // string length
-
-  8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
-  CORBA::tk_alias, // typecode kind for typedefs
-  64, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
-    12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
-    CORBA::tk_string, 
-    0U, // string length
-
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_ModuleDescription (CORBA::tk_struct, sizeof (_oc_IR_ModuleDescription), (char *) &_oc_IR_ModuleDescription, 0, sizeof (IR_ModuleDescription));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ModuleDescription, &_tc_TAO_tc_IR_ModuleDescription)
-TAO_NAMESPACE_END
-
-void IR_ModuleDescription::_tao_any_destructor (void *x)
-{
-  IR_ModuleDescription *tmp = ACE_static_cast (IR_ModuleDescription*,x);
-  delete tmp;
-}
-
-///////////////////////////////////////////////////////////////////////
-//                Base & Remote Proxy  Implementation. 
-//
-
-_TAO_ConstantDef_Proxy_Impl::_TAO_ConstantDef_Proxy_Impl (void)
-{}
-
-_TAO_ConstantDef_Remote_Proxy_Impl::_TAO_ConstantDef_Remote_Proxy_Impl (void)
-{}
-
-// Remote Implementation of the IDL interface methods
-
-CORBA::TypeCode_ptr _TAO_ConstantDef_Remote_Proxy_Impl::type (
-    CORBA_Object *_collocated_tao_target_,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  CORBA::TypeCode_ptr _tao_retval = CORBA::TypeCode::_nil ();
-  CORBA::TypeCode_var _tao_safe_retval (_tao_retval);
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_get_type",
-      9,
-      0,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_ConstantDef::TAO_ClientRequestInfo_IR_ConstantDef_type_get ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              CORBA::TypeCode_ptr _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-IR_IDLType_ptr _TAO_ConstantDef_Remote_Proxy_Impl::type_def (
-    CORBA_Object *_collocated_tao_target_,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  IR_IDLType_ptr _tao_retval = IR_IDLType::_nil ();
-  IR_IDLType_var _tao_safe_retval (_tao_retval);
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_get_type_def",
-      13,
-      0,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_ConstantDef::TAO_ClientRequestInfo_IR_ConstantDef_type_def_get ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              IR_IDLType_ptr _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-void _TAO_ConstantDef_Remote_Proxy_Impl::type_def (
-    CORBA_Object *_collocated_tao_target_,
-    IR_IDLType_ptr type_def,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW (CORBA::INTERNAL ());
-
-  
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_set_type_def",
-      13,
-      1,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_ConstantDef::TAO_ClientRequestInfo_IR_ConstantDef_type_def_set ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        type_def,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK;
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK;
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK;
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK;
-          
-          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-          if (!(
-                            (_tao_out << type_def)
-            ))
-            TAO_INTERCEPTOR_THROW (
-              CORBA::MARSHAL ()
-            );
-            
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK;
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)
-              );
-              
-            }
-          
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK;
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK;
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  
-}
-
-CORBA::Any * _TAO_ConstantDef_Remote_Proxy_Impl::value (
-    CORBA_Object *_collocated_tao_target_,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  CORBA::Any *_tao_retval = 0;
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-
-  ACE_NEW_RETURN (_tao_retval, CORBA::Any, _tao_retval);
-  CORBA::Any_var _tao_safe_retval (_tao_retval);
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_get_value",
-      10,
-      0,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_ConstantDef::TAO_ClientRequestInfo_IR_ConstantDef_value_get ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              CORBA::Any * _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-void _TAO_ConstantDef_Remote_Proxy_Impl::value (
-    CORBA_Object *_collocated_tao_target_,
-    const CORBA::Any & value,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW (CORBA::INTERNAL ());
-
-  
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_set_value",
-      10,
-      1,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_ConstantDef::TAO_ClientRequestInfo_IR_ConstantDef_value_set ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        value,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK;
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK;
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK;
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK;
-          
-          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-          if (!(
-                            (_tao_out << value)
-            ))
-            TAO_INTERCEPTOR_THROW (
-              CORBA::MARSHAL ()
-            );
-            
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK;
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)
-              );
-              
-            }
-          
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK;
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK;
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  
-}
-
-//
-//            End  Base & Remote  Proxy Implemeentation. 
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//           Remote & Base  Proxy Broker Implementation
-//
-
-_TAO_ConstantDef_Proxy_Broker::_TAO_ConstantDef_Proxy_Broker (void)
-{
-}
-
-_TAO_ConstantDef_Proxy_Broker::~_TAO_ConstantDef_Proxy_Broker (void)
-{
-}
-
-_TAO_ConstantDef_Proxy_Broker * (*_TAO_ConstantDef_Proxy_Broker_Factory_function_pointer) (
-    CORBA::Object_ptr obj
-  ) = 0;
-
-// Factory Member function Implementation.
-_TAO_ConstantDef_Remote_Proxy_Broker *
-_TAO_ConstantDef_Remote_Proxy_Broker::the_TAO_ConstantDef_Remote_Proxy_Broker (void)
-{
-  static ::_TAO_ConstantDef_Remote_Proxy_Broker remote_proxy_broker;
-  return &remote_proxy_broker;
-}
-
-_TAO_ConstantDef_Remote_Proxy_Broker::_TAO_ConstantDef_Remote_Proxy_Broker (void)
-{
-}
-
-_TAO_ConstantDef_Remote_Proxy_Broker::~_TAO_ConstantDef_Remote_Proxy_Broker (void)
-{
-}
-
-_TAO_ConstantDef_Proxy_Impl&
-_TAO_ConstantDef_Remote_Proxy_Broker::select_proxy (
-  ::IR_ConstantDef *object,
-  CORBA::Environment &ACE_TRY_ENV
-)
-{
-  ACE_UNUSED_ARG (object);
-  ACE_UNUSED_ARG (ACE_TRY_ENV);
-  return remote_proxy_impl_;
-}
-
-
-//
-//           End Remote & Base Proxy Broker Implementation
-///////////////////////////////////////////////////////////////////////
-
-
-// default constructor
-IR_ConstantDef::IR_ConstantDef (int collocated)
-{
-  this->IR_ConstantDef_setup_collocation (collocated);
-}
-
-// destructor
-IR_ConstantDef::~IR_ConstantDef (void)
-{}
-
-void
-IR_ConstantDef::IR_ConstantDef_setup_collocation (int collocated)
-{
-  if (collocated)
-    this->the_TAO_ConstantDef_Proxy_Broker_ =
-      _TAO_ConstantDef_Proxy_Broker_Factory_function_pointer (this);
-  else
-    this->the_TAO_ConstantDef_Proxy_Broker_ =
-      _TAO_ConstantDef_Remote_Proxy_Broker::the_TAO_ConstantDef_Remote_Proxy_Broker ();
-  
-  this->IR_Contained_setup_collocation (collocated);  
-}
-
-void IR_ConstantDef::_tao_any_destructor (void *x)
-{
-  IR_ConstantDef *tmp = ACE_static_cast (IR_ConstantDef*,x);
-  CORBA::release (tmp);
-}
-
-IR_ConstantDef_ptr IR_ConstantDef::_narrow (
-    CORBA::Object_ptr obj,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  if (CORBA::is_nil (obj))
-    return IR_ConstantDef::_nil ();
-  if (! obj->_is_local ())
-    {
-      CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/IR/ConstantDef:1.0", ACE_TRY_ENV);
-      ACE_CHECK_RETURN (IR_ConstantDef::_nil ());
-      if (is_a == 0)
-        return IR_ConstantDef::_nil ();
-    }
-  return IR_ConstantDef::_unchecked_narrow (obj, ACE_TRY_ENV);
-}
-
-IR_ConstantDef_ptr IR_ConstantDef::_unchecked_narrow (
-    CORBA::Object_ptr obj,
-    CORBA::Environment &
-  )
-{
-  if (CORBA::is_nil (obj))
-    return IR_ConstantDef::_nil ();
-  if (! obj->_is_local ())
-    {
-      TAO_Stub* stub = obj->_stubobj ();
-      if (stub)
-        stub->_incr_refcnt ();
-      IR_ConstantDef_ptr default_proxy = IR_ConstantDef::_nil ();
-
-      if (
-          !CORBA::is_nil (stub->servant_orb_var ().ptr ()) &&
-          stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects () &&
-          obj->_is_collocated () &&_TAO_ConstantDef_Proxy_Broker_Factory_function_pointer != 0
-        )
-      {
-        ACE_NEW_RETURN (
-          default_proxy,
-          ::IR_ConstantDef (
-            stub,
-            1,
-            obj->_servant ()),
-            
-          IR_ConstantDef::_nil ());
-        }
-      if (CORBA::is_nil (default_proxy))
-        ACE_NEW_RETURN (default_proxy, ::IR_ConstantDef (stub, 0, obj->_servant ()), IR_ConstantDef::_nil ());
-        return default_proxy;
-      }
-    else 
-      return
-        ACE_reinterpret_cast
-          (
-            IR_ConstantDef_ptr,
-              obj->_tao_QueryInterface
-                (
-                  ACE_reinterpret_cast
-                    (
-                      ptr_arith_t,
-                      &IR_ConstantDef::_narrow
-                    )
-                )
-          );
-}
-
-IR_ConstantDef_ptr
-IR_ConstantDef::_duplicate (IR_ConstantDef_ptr obj)
-{
-  if (!CORBA::is_nil (obj))
-    obj->_add_ref ();
-  return obj;
-}
-
-CORBA::Boolean IR_ConstantDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
-{
-  if (
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/ConstantDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/Contained:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
-  return 1; // success using local knowledge
-  else
-    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
-}
-
-void *IR_ConstantDef::_tao_QueryInterface (ptr_arith_t type)
-{
-  void *retv = 0;
-  if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_ConstantDef::_narrow))
-    retv = ACE_reinterpret_cast (void*, this);
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_Contained::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            IR_Contained_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &CORBA_IRObject::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            CORBA_IRObject_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
-    retv = ACE_reinterpret_cast (void *,
-      ACE_static_cast (CORBA::Object_ptr, this));
-    
-  if (retv)
-    this->_add_ref ();
-  return retv;
-}
-
-const char* IR_ConstantDef::_interface_repository_id (void) const
-{
-  return "IDL:omg.org/IR/ConstantDef:1.0";
-}
-
-CORBA::TypeCode_ptr IR_ConstantDef::type (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{ 
-  _TAO_ConstantDef_Proxy_Impl &proxy = 
-    this->the_TAO_ConstantDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.type (
-      this,
-      ACE_TRY_ENV
-    );
-}
-
-IR_IDLType_ptr IR_ConstantDef::type_def (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_ConstantDef_Proxy_Impl &proxy = 
-    this->the_TAO_ConstantDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.type_def (
-      this,
-      ACE_TRY_ENV
-    );
-}
-
-void IR_ConstantDef::type_def (
-    IR_IDLType_ptr type_def,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_ConstantDef_Proxy_Impl &proxy = 
-    this->the_TAO_ConstantDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK;
-  
-  proxy.type_def (
-      this,
-      type_def,
-      ACE_TRY_ENV
-    );
-}
-
-CORBA::Any * IR_ConstantDef::value (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_ConstantDef_Proxy_Impl &proxy = 
-    this->the_TAO_ConstantDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.value (
-      this,
-      ACE_TRY_ENV
-    );
-}
-
-void IR_ConstantDef::value (
-    const CORBA::Any & value,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_ConstantDef_Proxy_Impl &proxy = 
-    this->the_TAO_ConstantDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK;
-  
-  proxy.value (
-      this,
-      value,
-      ACE_TRY_ENV
-    );
-}
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-IR_ConstantDef::TAO_ClientRequestInfo_IR_ConstantDef_type_get::TAO_ClientRequestInfo_IR_ConstantDef_type_get (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
-{}
-
-Dynamic::ParameterList *
-IR_ConstantDef::TAO_ClientRequestInfo_IR_ConstantDef_type_get::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return parameter_list;
-}
-
-Dynamic::ExceptionList *
-IR_ConstantDef::TAO_ClientRequestInfo_IR_ConstantDef_type_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_ConstantDef::TAO_ClientRequestInfo_IR_ConstantDef_type_get::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_ConstantDef::TAO_ClientRequestInfo_IR_ConstantDef_type_get::result (CORBA::TypeCode_ptr result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_ConstantDef::TAO_ClientRequestInfo_IR_ConstantDef_type_def_get::TAO_ClientRequestInfo_IR_ConstantDef_type_def_get (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
-{}
-
-Dynamic::ParameterList *
-IR_ConstantDef::TAO_ClientRequestInfo_IR_ConstantDef_type_def_get::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return parameter_list;
-}
-
-Dynamic::ExceptionList *
-IR_ConstantDef::TAO_ClientRequestInfo_IR_ConstantDef_type_def_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_ConstantDef::TAO_ClientRequestInfo_IR_ConstantDef_type_def_get::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_ConstantDef::TAO_ClientRequestInfo_IR_ConstantDef_type_def_get::result (IR_IDLType_ptr result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_ConstantDef::TAO_ClientRequestInfo_IR_ConstantDef_type_def_set::TAO_ClientRequestInfo_IR_ConstantDef_type_def_set (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    IR_IDLType_ptr type_def,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
-    type_def_ (type_def)
-{}
-
-Dynamic::ParameterList *
-IR_ConstantDef::TAO_ClientRequestInfo_IR_ConstantDef_type_def_set::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
-    
-  CORBA::ULong length_type_def = parameter_list->length ();
-  parameter_list->length (length_type_def + 1);
-  (*parameter_list)[length_type_def].argument <<=  this->type_def_;
-  
-  (*parameter_list)[length_type_def].mode = Dynamic::PARAM_IN;
-  
-  return safe_parameter_list._retn ();
-}
-
-Dynamic::ExceptionList *
-IR_ConstantDef::TAO_ClientRequestInfo_IR_ConstantDef_type_def_set::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_ConstantDef::TAO_ClientRequestInfo_IR_ConstantDef_type_def_set::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 1;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return result_any;
-}
-
-IR_ConstantDef::TAO_ClientRequestInfo_IR_ConstantDef_value_get::TAO_ClientRequestInfo_IR_ConstantDef_value_get (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
-{}
-
-Dynamic::ParameterList *
-IR_ConstantDef::TAO_ClientRequestInfo_IR_ConstantDef_value_get::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return parameter_list;
-}
-
-Dynamic::ExceptionList *
-IR_ConstantDef::TAO_ClientRequestInfo_IR_ConstantDef_value_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_ConstantDef::TAO_ClientRequestInfo_IR_ConstantDef_value_get::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_ConstantDef::TAO_ClientRequestInfo_IR_ConstantDef_value_get::result (CORBA::Any * result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_ConstantDef::TAO_ClientRequestInfo_IR_ConstantDef_value_set::TAO_ClientRequestInfo_IR_ConstantDef_value_set (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    const CORBA::Any & value,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
-    value_ (value)
-{}
-
-Dynamic::ParameterList *
-IR_ConstantDef::TAO_ClientRequestInfo_IR_ConstantDef_value_set::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
-    
-  CORBA::ULong length_value = parameter_list->length ();
-  parameter_list->length (length_value + 1);
-  (*parameter_list)[length_value].argument <<= value_;
-  (*parameter_list)[length_value].mode = Dynamic::PARAM_IN;
-  
-  return safe_parameter_list._retn ();
-}
-
-Dynamic::ExceptionList *
-IR_ConstantDef::TAO_ClientRequestInfo_IR_ConstantDef_value_set::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_ConstantDef::TAO_ClientRequestInfo_IR_ConstantDef_value_set::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 1;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return result_any;
-}
-
-#endif /* TAO_HAS_INTERCEPTORS */
-
-static const CORBA::Long _oc_IR_ConstantDef[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f43), ACE_NTOHL (0x6f6e7374), ACE_NTOHL (0x616e7444), ACE_NTOHL (0x65663a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/ConstantDef:1.0
-  12, ACE_NTOHL (0x436f6e73), ACE_NTOHL (0x74616e74), ACE_NTOHL (0x44656600),  // name = IR_ConstantDef
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_ConstantDef (CORBA::tk_objref, sizeof (_oc_IR_ConstantDef), (char *) &_oc_IR_ConstantDef, 0, sizeof (IR_ConstantDef));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ConstantDef, &_tc_TAO_tc_IR_ConstantDef)
-TAO_NAMESPACE_END
-
-static const CORBA::Long _oc_IR_ConstantDescription[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  39, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f43), ACE_NTOHL (0x6f6e7374), ACE_NTOHL (0x616e7444), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e3a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/ConstantDescription:1.0
-  20, ACE_NTOHL (0x436f6e73), ACE_NTOHL (0x74616e74), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e00),  // name = ConstantDescription
-  6, // member count
-  5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
-  CORBA::tk_alias, // typecode kind for typedefs
-  64, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
-    11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-    CORBA::tk_string, 
-    0U, // string length
-
-  3, ACE_NTOHL (0x69640000),  // name = id
-  CORBA::tk_alias, // typecode kind for typedefs
-  68, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-    13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-    CORBA::tk_string, 
-    0U, // string length
-
-  11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
-  CORBA::tk_alias, // typecode kind for typedefs
-  68, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-    13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-    CORBA::tk_string, 
-    0U, // string length
-
-  8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
-  CORBA::tk_alias, // typecode kind for typedefs
-  64, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
-    12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
-    CORBA::tk_string, 
-    0U, // string length
-
-  5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
-  CORBA::tk_TypeCode,
-
-  6, ACE_NTOHL (0x76616c75), ACE_NTOHL (0x65000000),  // name = value
-  CORBA::tk_any,
-
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_ConstantDescription (CORBA::tk_struct, sizeof (_oc_IR_ConstantDescription), (char *) &_oc_IR_ConstantDescription, 0, sizeof (IR_ConstantDescription));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ConstantDescription, &_tc_TAO_tc_IR_ConstantDescription)
-TAO_NAMESPACE_END
-
-void IR_ConstantDescription::_tao_any_destructor (void *x)
-{
-  IR_ConstantDescription *tmp = ACE_static_cast (IR_ConstantDescription*,x);
-  delete tmp;
-}
-
-
-///////////////////////////////////////////////////////////////////////
-//                Base & Remote Proxy  Implementation. 
-//
-
-_TAO_TypedefDef_Proxy_Impl::_TAO_TypedefDef_Proxy_Impl (void)
-{}
-
-_TAO_TypedefDef_Remote_Proxy_Impl::_TAO_TypedefDef_Remote_Proxy_Impl (void)
-{}
-
-// Remote Implementation of the IDL interface methods
-
-
-//
-//            End  Base & Remote  Proxy Implemeentation. 
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//           Remote & Base  Proxy Broker Implementation
-//
-
-_TAO_TypedefDef_Proxy_Broker::_TAO_TypedefDef_Proxy_Broker (void)
-{
-}
-
-_TAO_TypedefDef_Proxy_Broker::~_TAO_TypedefDef_Proxy_Broker (void)
-{
-}
-
-_TAO_TypedefDef_Proxy_Broker * (*_TAO_TypedefDef_Proxy_Broker_Factory_function_pointer) (
-    CORBA::Object_ptr obj
-  ) = 0;
-
-// Factory Member function Implementation.
-_TAO_TypedefDef_Remote_Proxy_Broker *
-_TAO_TypedefDef_Remote_Proxy_Broker::the_TAO_TypedefDef_Remote_Proxy_Broker (void)
-{
-  static ::_TAO_TypedefDef_Remote_Proxy_Broker remote_proxy_broker;
-  return &remote_proxy_broker;
-}
-
-_TAO_TypedefDef_Remote_Proxy_Broker::_TAO_TypedefDef_Remote_Proxy_Broker (void)
-{
-}
-
-_TAO_TypedefDef_Remote_Proxy_Broker::~_TAO_TypedefDef_Remote_Proxy_Broker (void)
-{
-}
-
-_TAO_TypedefDef_Proxy_Impl&
-_TAO_TypedefDef_Remote_Proxy_Broker::select_proxy (
-  ::IR_TypedefDef *object,
-  CORBA::Environment &ACE_TRY_ENV
-)
-{
-  ACE_UNUSED_ARG (object);
-  ACE_UNUSED_ARG (ACE_TRY_ENV);
-  return remote_proxy_impl_;
-}
-
-
-//
-//           End Remote & Base Proxy Broker Implementation
-///////////////////////////////////////////////////////////////////////
-
-
-// default constructor
-IR_TypedefDef::IR_TypedefDef (int collocated)
-{
-  this->IR_TypedefDef_setup_collocation (collocated);
-}
-
-// destructor
-IR_TypedefDef::~IR_TypedefDef (void)
-{}
-
-void
-IR_TypedefDef::IR_TypedefDef_setup_collocation (int collocated)
-{
-  if (collocated)
-    this->the_TAO_TypedefDef_Proxy_Broker_ =
-      _TAO_TypedefDef_Proxy_Broker_Factory_function_pointer (this);
-  else
-    this->the_TAO_TypedefDef_Proxy_Broker_ =
-      _TAO_TypedefDef_Remote_Proxy_Broker::the_TAO_TypedefDef_Remote_Proxy_Broker ();
-  
-  this->IR_Contained_setup_collocation (collocated);
-  this->IR_IDLType_setup_collocation (collocated);  
-}
-
-void IR_TypedefDef::_tao_any_destructor (void *x)
-{
-  IR_TypedefDef *tmp = ACE_static_cast (IR_TypedefDef*,x);
-  CORBA::release (tmp);
-}
-
-IR_TypedefDef_ptr IR_TypedefDef::_narrow (
-    CORBA::Object_ptr obj,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  if (CORBA::is_nil (obj))
-    return IR_TypedefDef::_nil ();
-  if (! obj->_is_local ())
-    {
-      CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/IR/TypedefDef:1.0", ACE_TRY_ENV);
-      ACE_CHECK_RETURN (IR_TypedefDef::_nil ());
-      if (is_a == 0)
-        return IR_TypedefDef::_nil ();
-    }
-  return IR_TypedefDef::_unchecked_narrow (obj, ACE_TRY_ENV);
-}
-
-IR_TypedefDef_ptr IR_TypedefDef::_unchecked_narrow (
-    CORBA::Object_ptr obj,
-    CORBA::Environment &
-  )
-{
-  if (CORBA::is_nil (obj))
-    return IR_TypedefDef::_nil ();
-  if (! obj->_is_local ())
-    {
-      TAO_Stub* stub = obj->_stubobj ();
-      if (stub)
-        stub->_incr_refcnt ();
-      IR_TypedefDef_ptr default_proxy = IR_TypedefDef::_nil ();
-
-      if (
-          !CORBA::is_nil (stub->servant_orb_var ().ptr ()) &&
-          stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects () &&
-          obj->_is_collocated () &&_TAO_TypedefDef_Proxy_Broker_Factory_function_pointer != 0
-        )
-      {
-        ACE_NEW_RETURN (
-          default_proxy,
-          ::IR_TypedefDef (
-            stub,
-            1,
-            obj->_servant ()),
-            
-          IR_TypedefDef::_nil ());
-        }
-      if (CORBA::is_nil (default_proxy))
-        ACE_NEW_RETURN (default_proxy, ::IR_TypedefDef (stub, 0, obj->_servant ()), IR_TypedefDef::_nil ());
-        return default_proxy;
-      }
-    else 
-      return
-        ACE_reinterpret_cast
-          (
-            IR_TypedefDef_ptr,
-              obj->_tao_QueryInterface
-                (
-                  ACE_reinterpret_cast
-                    (
-                      ptr_arith_t,
-                      &IR_TypedefDef::_narrow
-                    )
-                )
-          );
-}
-
-IR_TypedefDef_ptr
-IR_TypedefDef::_duplicate (IR_TypedefDef_ptr obj)
-{
-  if (!CORBA::is_nil (obj))
-    obj->_add_ref ();
-  return obj;
-}
-
-CORBA::Boolean IR_TypedefDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
-{
-  if (
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/TypedefDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/Contained:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/IDLType:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
-  return 1; // success using local knowledge
-  else
-    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
-}
-
-void *IR_TypedefDef::_tao_QueryInterface (ptr_arith_t type)
-{
-  void *retv = 0;
-  if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_TypedefDef::_narrow))
-    retv = ACE_reinterpret_cast (void*, this);
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_Contained::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            IR_Contained_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_IDLType::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            IR_IDLType_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &CORBA_IRObject::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            CORBA_IRObject_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
-    retv = ACE_reinterpret_cast (void *,
-      ACE_static_cast (CORBA::Object_ptr, this));
-    
-  if (retv)
-    this->_add_ref ();
-  return retv;
-}
-
-const char* IR_TypedefDef::_interface_repository_id (void) const
-{
-  return "IDL:omg.org/IR/TypedefDef:1.0";
-}
-
-static const CORBA::Long _oc_IR_TypedefDef[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f54), ACE_NTOHL (0x79706564), ACE_NTOHL (0x65664465), ACE_NTOHL (0x663a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/TypedefDef:1.0
-  11, ACE_NTOHL (0x54797065), ACE_NTOHL (0x64656644), ACE_NTOHL (0x65660000),  // name = IR_TypedefDef
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_TypedefDef (CORBA::tk_objref, sizeof (_oc_IR_TypedefDef), (char *) &_oc_IR_TypedefDef, 0, sizeof (IR_TypedefDef));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_TypedefDef, &_tc_TAO_tc_IR_TypedefDef)
-TAO_NAMESPACE_END
-
-static const CORBA::Long _oc_IR_TypeDescription[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f54), ACE_NTOHL (0x79706544), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e3a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/TypeDescription:1.0
-  16, ACE_NTOHL (0x54797065), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e00),  // name = TypeDescription
-  5, // member count
-  5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
-  CORBA::tk_alias, // typecode kind for typedefs
-  64, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
-    11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-    CORBA::tk_string, 
-    0U, // string length
-
-  3, ACE_NTOHL (0x69640000),  // name = id
-  CORBA::tk_alias, // typecode kind for typedefs
-  68, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-    13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-    CORBA::tk_string, 
-    0U, // string length
-
-  11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
-  CORBA::tk_alias, // typecode kind for typedefs
-  68, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-    13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-    CORBA::tk_string, 
-    0U, // string length
-
-  8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
-  CORBA::tk_alias, // typecode kind for typedefs
-  64, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
-    12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
-    CORBA::tk_string, 
-    0U, // string length
-
-  5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
-  CORBA::tk_TypeCode,
-
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_TypeDescription (CORBA::tk_struct, sizeof (_oc_IR_TypeDescription), (char *) &_oc_IR_TypeDescription, 0, sizeof (IR_TypeDescription));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_TypeDescription, &_tc_TAO_tc_IR_TypeDescription)
-TAO_NAMESPACE_END
-
-void IR_TypeDescription::_tao_any_destructor (void *x)
-{
-  IR_TypeDescription *tmp = ACE_static_cast (IR_TypeDescription*,x);
-  delete tmp;
-}
-
-///////////////////////////////////////////////////////////////////////
-//                Base & Remote Proxy  Implementation. 
-//
-
-_TAO_StructDef_Proxy_Impl::_TAO_StructDef_Proxy_Impl (void)
-{}
-
-_TAO_StructDef_Remote_Proxy_Impl::_TAO_StructDef_Remote_Proxy_Impl (void)
-{}
-
-// Remote Implementation of the IDL interface methods
-
-IR_StructMemberSeq * _TAO_StructDef_Remote_Proxy_Impl::members (
-    CORBA_Object *_collocated_tao_target_,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  IR_StructMemberSeq *_tao_retval = 0;
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-
-  ACE_NEW_RETURN (_tao_retval, IR_StructMemberSeq, _tao_retval);
-  IR_StructMemberSeq_var _tao_safe_retval (_tao_retval);
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_get_members",
-      12,
-      0,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_StructDef::TAO_ClientRequestInfo_IR_StructDef_members_get ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              IR_StructMemberSeq * _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-void _TAO_StructDef_Remote_Proxy_Impl::members (
-    CORBA_Object *_collocated_tao_target_,
-    const IR_StructMemberSeq & members,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW (CORBA::INTERNAL ());
-
-  
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_set_members",
-      12,
-      1,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_StructDef::TAO_ClientRequestInfo_IR_StructDef_members_set ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        members,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK;
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK;
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK;
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK;
-          
-          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-          if (!(
-                            (_tao_out << members)
-            ))
-            TAO_INTERCEPTOR_THROW (
-              CORBA::MARSHAL ()
-            );
-            
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK;
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)
-              );
-              
-            }
-          
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK;
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK;
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  
-}
-
-
-//
-//            End  Base & Remote  Proxy Implemeentation. 
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//           Remote & Base  Proxy Broker Implementation
-//
-
-_TAO_StructDef_Proxy_Broker::_TAO_StructDef_Proxy_Broker (void)
-{
-}
-
-_TAO_StructDef_Proxy_Broker::~_TAO_StructDef_Proxy_Broker (void)
-{
-}
-
-_TAO_StructDef_Proxy_Broker * (*_TAO_StructDef_Proxy_Broker_Factory_function_pointer) (
-    CORBA::Object_ptr obj
-  ) = 0;
-
-// Factory Member function Implementation.
-_TAO_StructDef_Remote_Proxy_Broker *
-_TAO_StructDef_Remote_Proxy_Broker::the_TAO_StructDef_Remote_Proxy_Broker (void)
-{
-  static ::_TAO_StructDef_Remote_Proxy_Broker remote_proxy_broker;
-  return &remote_proxy_broker;
-}
-
-_TAO_StructDef_Remote_Proxy_Broker::_TAO_StructDef_Remote_Proxy_Broker (void)
-{
-}
-
-_TAO_StructDef_Remote_Proxy_Broker::~_TAO_StructDef_Remote_Proxy_Broker (void)
-{
-}
-
-_TAO_StructDef_Proxy_Impl&
-_TAO_StructDef_Remote_Proxy_Broker::select_proxy (
-  ::IR_StructDef *object,
-  CORBA::Environment &ACE_TRY_ENV
-)
-{
-  ACE_UNUSED_ARG (object);
-  ACE_UNUSED_ARG (ACE_TRY_ENV);
-  return remote_proxy_impl_;
-}
-
-
-//
-//           End Remote & Base Proxy Broker Implementation
-///////////////////////////////////////////////////////////////////////
-
-
-// default constructor
-IR_StructDef::IR_StructDef (int collocated)
-{
-  this->IR_StructDef_setup_collocation (collocated);
-}
-
-// destructor
-IR_StructDef::~IR_StructDef (void)
-{}
-
-void
-IR_StructDef::IR_StructDef_setup_collocation (int collocated)
-{
-  if (collocated)
-    this->the_TAO_StructDef_Proxy_Broker_ =
-      _TAO_StructDef_Proxy_Broker_Factory_function_pointer (this);
-  else
-    this->the_TAO_StructDef_Proxy_Broker_ =
-      _TAO_StructDef_Remote_Proxy_Broker::the_TAO_StructDef_Remote_Proxy_Broker ();
-  
-  this->IR_TypedefDef_setup_collocation (collocated);
-  this->IR_Container_setup_collocation (collocated);  
-}
-
-void IR_StructDef::_tao_any_destructor (void *x)
-{
-  IR_StructDef *tmp = ACE_static_cast (IR_StructDef*,x);
-  CORBA::release (tmp);
-}
-
-IR_StructDef_ptr IR_StructDef::_narrow (
-    CORBA::Object_ptr obj,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  if (CORBA::is_nil (obj))
-    return IR_StructDef::_nil ();
-  if (! obj->_is_local ())
-    {
-      CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/IR/StructDef:1.0", ACE_TRY_ENV);
-      ACE_CHECK_RETURN (IR_StructDef::_nil ());
-      if (is_a == 0)
-        return IR_StructDef::_nil ();
-    }
-  return IR_StructDef::_unchecked_narrow (obj, ACE_TRY_ENV);
-}
-
-IR_StructDef_ptr IR_StructDef::_unchecked_narrow (
-    CORBA::Object_ptr obj,
-    CORBA::Environment &
-  )
-{
-  if (CORBA::is_nil (obj))
-    return IR_StructDef::_nil ();
-  if (! obj->_is_local ())
-    {
-      TAO_Stub* stub = obj->_stubobj ();
-      if (stub)
-        stub->_incr_refcnt ();
-      IR_StructDef_ptr default_proxy = IR_StructDef::_nil ();
-
-      if (
-          !CORBA::is_nil (stub->servant_orb_var ().ptr ()) &&
-          stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects () &&
-          obj->_is_collocated () &&_TAO_StructDef_Proxy_Broker_Factory_function_pointer != 0
-        )
-      {
-        ACE_NEW_RETURN (
-          default_proxy,
-          ::IR_StructDef (
-            stub,
-            1,
-            obj->_servant ()),
-            
-          IR_StructDef::_nil ());
-        }
-      if (CORBA::is_nil (default_proxy))
-        ACE_NEW_RETURN (default_proxy, ::IR_StructDef (stub, 0, obj->_servant ()), IR_StructDef::_nil ());
-        return default_proxy;
-      }
-    else 
-      return
-        ACE_reinterpret_cast
-          (
-            IR_StructDef_ptr,
-              obj->_tao_QueryInterface
-                (
-                  ACE_reinterpret_cast
-                    (
-                      ptr_arith_t,
-                      &IR_StructDef::_narrow
-                    )
-                )
-          );
-}
-
-IR_StructDef_ptr
-IR_StructDef::_duplicate (IR_StructDef_ptr obj)
-{
-  if (!CORBA::is_nil (obj))
-    obj->_add_ref ();
-  return obj;
-}
-
-CORBA::Boolean IR_StructDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
-{
-  if (
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/StructDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/TypedefDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/Container:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/Contained:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/IDLType:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
-  return 1; // success using local knowledge
-  else
-    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
-}
-
-void *IR_StructDef::_tao_QueryInterface (ptr_arith_t type)
-{
-  void *retv = 0;
-  if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_StructDef::_narrow))
-    retv = ACE_reinterpret_cast (void*, this);
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_TypedefDef::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            IR_TypedefDef_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_Container::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            IR_Container_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_Contained::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            IR_Contained_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_IDLType::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            IR_IDLType_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &CORBA_IRObject::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            CORBA_IRObject_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
-    retv = ACE_reinterpret_cast (void *,
-      ACE_static_cast (CORBA::Object_ptr, this));
-    
-  if (retv)
-    this->_add_ref ();
-  return retv;
-}
-
-const char* IR_StructDef::_interface_repository_id (void) const
-{
-  return "IDL:omg.org/IR/StructDef:1.0";
-}
-
-IR_StructMemberSeq * IR_StructDef::members (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_StructDef_Proxy_Impl &proxy = 
-    this->the_TAO_StructDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.members (
-      this,
-      ACE_TRY_ENV
-    );
-}
-
-void IR_StructDef::members (
-    const IR_StructMemberSeq & members,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_StructDef_Proxy_Impl &proxy = 
-    this->the_TAO_StructDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK;
-  
-  proxy.members (
-      this,
-      members,
-      ACE_TRY_ENV
-    );
-}
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-IR_StructDef::TAO_ClientRequestInfo_IR_StructDef_members_get::TAO_ClientRequestInfo_IR_StructDef_members_get (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
-{}
-
-Dynamic::ParameterList *
-IR_StructDef::TAO_ClientRequestInfo_IR_StructDef_members_get::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return parameter_list;
-}
-
-Dynamic::ExceptionList *
-IR_StructDef::TAO_ClientRequestInfo_IR_StructDef_members_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_StructDef::TAO_ClientRequestInfo_IR_StructDef_members_get::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_StructDef::TAO_ClientRequestInfo_IR_StructDef_members_get::result (IR_StructMemberSeq * result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_StructDef::TAO_ClientRequestInfo_IR_StructDef_members_set::TAO_ClientRequestInfo_IR_StructDef_members_set (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    const IR_StructMemberSeq & members,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
-    members_ (members)
-{}
-
-Dynamic::ParameterList *
-IR_StructDef::TAO_ClientRequestInfo_IR_StructDef_members_set::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
-    
-  CORBA::ULong length_members = parameter_list->length ();
-  parameter_list->length (length_members + 1);
-  (*parameter_list)[length_members].argument <<=  this->members_;
-  
-  (*parameter_list)[length_members].mode = Dynamic::PARAM_IN;
-  
-  return safe_parameter_list._retn ();
-}
-
-Dynamic::ExceptionList *
-IR_StructDef::TAO_ClientRequestInfo_IR_StructDef_members_set::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_StructDef::TAO_ClientRequestInfo_IR_StructDef_members_set::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 1;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return result_any;
-}
-
-#endif /* TAO_HAS_INTERCEPTORS */
-
-static const CORBA::Long _oc_IR_StructDef[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  29, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f53), ACE_NTOHL (0x74727563), ACE_NTOHL (0x74446566), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/StructDef:1.0
-  10, ACE_NTOHL (0x53747275), ACE_NTOHL (0x63744465), ACE_NTOHL (0x66000000),  // name = IR_StructDef
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_StructDef (CORBA::tk_objref, sizeof (_oc_IR_StructDef), (char *) &_oc_IR_StructDef, 0, sizeof (IR_StructDef));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_StructDef, &_tc_TAO_tc_IR_StructDef)
-TAO_NAMESPACE_END
-
-///////////////////////////////////////////////////////////////////////
-//                Base & Remote Proxy  Implementation. 
-//
-
-_TAO_UnionDef_Proxy_Impl::_TAO_UnionDef_Proxy_Impl (void)
-{}
-
-_TAO_UnionDef_Remote_Proxy_Impl::_TAO_UnionDef_Remote_Proxy_Impl (void)
-{}
-
-// Remote Implementation of the IDL interface methods
-
-CORBA::TypeCode_ptr _TAO_UnionDef_Remote_Proxy_Impl::discriminator_type (
-    CORBA_Object *_collocated_tao_target_,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  CORBA::TypeCode_ptr _tao_retval = CORBA::TypeCode::_nil ();
-  CORBA::TypeCode_var _tao_safe_retval (_tao_retval);
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_get_discriminator_type",
-      23,
-      0,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_UnionDef::TAO_ClientRequestInfo_IR_UnionDef_discriminator_type_get ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              CORBA::TypeCode_ptr _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-IR_IDLType_ptr _TAO_UnionDef_Remote_Proxy_Impl::discriminator_type_def (
-    CORBA_Object *_collocated_tao_target_,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  IR_IDLType_ptr _tao_retval = IR_IDLType::_nil ();
-  IR_IDLType_var _tao_safe_retval (_tao_retval);
- 
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_get_discriminator_type_def",
-      27,
-      0,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_UnionDef::TAO_ClientRequestInfo_IR_UnionDef_discriminator_type_def_get ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              IR_IDLType_ptr _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-void _TAO_UnionDef_Remote_Proxy_Impl::discriminator_type_def (
-    CORBA_Object *_collocated_tao_target_,
-    IR_IDLType_ptr discriminator_type_def,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW (CORBA::INTERNAL ());
-
-  
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_set_discriminator_type_def",
-      27,
-      1,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_UnionDef::TAO_ClientRequestInfo_IR_UnionDef_discriminator_type_def_set ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        discriminator_type_def,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK;
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK;
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK;
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK;
-          
-          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-          if (!(
-                            (_tao_out << discriminator_type_def)
-            ))
-            TAO_INTERCEPTOR_THROW (
-              CORBA::MARSHAL ()
-            );
-            
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK;
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)
-              );
-              
-            }
-          
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK;
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK;
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  
-}
-
-IR_UnionMemberSeq * _TAO_UnionDef_Remote_Proxy_Impl::members (
-    CORBA_Object *_collocated_tao_target_,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  IR_UnionMemberSeq *_tao_retval = 0;
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-
-  ACE_NEW_RETURN (_tao_retval, IR_UnionMemberSeq, _tao_retval);
-  IR_UnionMemberSeq_var _tao_safe_retval (_tao_retval);
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_get_members",
-      12,
-      0,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_UnionDef::TAO_ClientRequestInfo_IR_UnionDef_members_get ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              IR_UnionMemberSeq * _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-void _TAO_UnionDef_Remote_Proxy_Impl::members (
-    CORBA_Object *_collocated_tao_target_,
-    const IR_UnionMemberSeq & members,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW (CORBA::INTERNAL ());
-
-  
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_set_members",
-      12,
-      1,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_UnionDef::TAO_ClientRequestInfo_IR_UnionDef_members_set ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        members,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK;
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK;
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK;
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK;
-          
-          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-          if (!(
-                            (_tao_out << members)
-            ))
-            TAO_INTERCEPTOR_THROW (
-              CORBA::MARSHAL ()
-            );
-            
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK;
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)
-              );
-              
-            }
-          
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK;
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK;
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  
-}
-
-
-//
-//            End  Base & Remote  Proxy Implemeentation. 
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//           Remote & Base  Proxy Broker Implementation
-//
-
-_TAO_UnionDef_Proxy_Broker::_TAO_UnionDef_Proxy_Broker (void)
-{
-}
-
-_TAO_UnionDef_Proxy_Broker::~_TAO_UnionDef_Proxy_Broker (void)
-{
-}
-
-_TAO_UnionDef_Proxy_Broker * (*_TAO_UnionDef_Proxy_Broker_Factory_function_pointer) (
-    CORBA::Object_ptr obj
-  ) = 0;
-
-// Factory Member function Implementation.
-_TAO_UnionDef_Remote_Proxy_Broker *
-_TAO_UnionDef_Remote_Proxy_Broker::the_TAO_UnionDef_Remote_Proxy_Broker (void)
-{
-  static ::_TAO_UnionDef_Remote_Proxy_Broker remote_proxy_broker;
-  return &remote_proxy_broker;
-}
-
-_TAO_UnionDef_Remote_Proxy_Broker::_TAO_UnionDef_Remote_Proxy_Broker (void)
-{
-}
-
-_TAO_UnionDef_Remote_Proxy_Broker::~_TAO_UnionDef_Remote_Proxy_Broker (void)
-{
-}
-
-_TAO_UnionDef_Proxy_Impl&
-_TAO_UnionDef_Remote_Proxy_Broker::select_proxy (
-  ::IR_UnionDef *object,
-  CORBA::Environment &ACE_TRY_ENV
-)
-{
-  ACE_UNUSED_ARG (object);
-  ACE_UNUSED_ARG (ACE_TRY_ENV);
-  return remote_proxy_impl_;
-}
-
-
-//
-//           End Remote & Base Proxy Broker Implementation
-///////////////////////////////////////////////////////////////////////
-
-
-// default constructor
-IR_UnionDef::IR_UnionDef (int collocated)
-{
-  this->IR_UnionDef_setup_collocation (collocated);
-}
-
-// destructor
-IR_UnionDef::~IR_UnionDef (void)
-{}
-
-void
-IR_UnionDef::IR_UnionDef_setup_collocation (int collocated)
-{
-  if (collocated)
-    this->the_TAO_UnionDef_Proxy_Broker_ =
-      _TAO_UnionDef_Proxy_Broker_Factory_function_pointer (this);
-  else
-    this->the_TAO_UnionDef_Proxy_Broker_ =
-      _TAO_UnionDef_Remote_Proxy_Broker::the_TAO_UnionDef_Remote_Proxy_Broker ();
-  
-  this->IR_TypedefDef_setup_collocation (collocated);
-  this->IR_Container_setup_collocation (collocated);
-}
-
-void IR_UnionDef::_tao_any_destructor (void *x)
-{
-  IR_UnionDef *tmp = ACE_static_cast (IR_UnionDef*,x);
-  CORBA::release (tmp);
-}
-
-IR_UnionDef_ptr IR_UnionDef::_narrow (
-    CORBA::Object_ptr obj,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  if (CORBA::is_nil (obj))
-    return IR_UnionDef::_nil ();
-  if (! obj->_is_local ())
-    {
-      CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/IR/UnionDef:1.0", ACE_TRY_ENV);
-      ACE_CHECK_RETURN (IR_UnionDef::_nil ());
-      if (is_a == 0)
-        return IR_UnionDef::_nil ();
-    }
-  return IR_UnionDef::_unchecked_narrow (obj, ACE_TRY_ENV);
-}
-
-IR_UnionDef_ptr IR_UnionDef::_unchecked_narrow (
-    CORBA::Object_ptr obj,
-    CORBA::Environment &
-  )
-{
-  if (CORBA::is_nil (obj))
-    return IR_UnionDef::_nil ();
-  if (! obj->_is_local ())
-    {
-      TAO_Stub* stub = obj->_stubobj ();
-      if (stub)
-        stub->_incr_refcnt ();
-      IR_UnionDef_ptr default_proxy = IR_UnionDef::_nil ();
-
-      if (
-          !CORBA::is_nil (stub->servant_orb_var ().ptr ()) &&
-          stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects () &&
-          obj->_is_collocated () &&_TAO_UnionDef_Proxy_Broker_Factory_function_pointer != 0
-        )
-      {
-        ACE_NEW_RETURN (
-          default_proxy,
-          ::IR_UnionDef (
-            stub,
-            1,
-            obj->_servant ()),
-            
-          IR_UnionDef::_nil ());
-        }
-      if (CORBA::is_nil (default_proxy))
-        ACE_NEW_RETURN (default_proxy, ::IR_UnionDef (stub, 0, obj->_servant ()), IR_UnionDef::_nil ());
-        return default_proxy;
-      }
-    else 
-      return
-        ACE_reinterpret_cast
-          (
-            IR_UnionDef_ptr,
-              obj->_tao_QueryInterface
-                (
-                  ACE_reinterpret_cast
-                    (
-                      ptr_arith_t,
-                      &IR_UnionDef::_narrow
-                    )
-                )
-          );
-}
-
-IR_UnionDef_ptr
-IR_UnionDef::_duplicate (IR_UnionDef_ptr obj)
-{
-  if (!CORBA::is_nil (obj))
-    obj->_add_ref ();
-  return obj;
-}
-
-CORBA::Boolean IR_UnionDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
-{
-  if (
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/UnionDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/TypedefDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/Container:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/Contained:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/IDLType:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
-  return 1; // success using local knowledge
-  else
-    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
-}
-
-void *IR_UnionDef::_tao_QueryInterface (ptr_arith_t type)
-{
-  void *retv = 0;
-  if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_UnionDef::_narrow))
-    retv = ACE_reinterpret_cast (void*, this);
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_TypedefDef::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            IR_TypedefDef_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_Container::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            IR_Container_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_Contained::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            IR_Contained_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_IDLType::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            IR_IDLType_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &CORBA_IRObject::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            CORBA_IRObject_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
-    retv = ACE_reinterpret_cast (void *,
-      ACE_static_cast (CORBA::Object_ptr, this));
-    
-  if (retv)
-    this->_add_ref ();
-  return retv;
-}
-
-const char* IR_UnionDef::_interface_repository_id (void) const
-{
-  return "IDL:omg.org/IR/UnionDef:1.0";
-}
-
-CORBA::TypeCode_ptr IR_UnionDef::discriminator_type (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_UnionDef_Proxy_Impl &proxy = 
-    this->the_TAO_UnionDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.discriminator_type (
-      this,
-      ACE_TRY_ENV
-    );
-}
-
-IR_IDLType_ptr IR_UnionDef::discriminator_type_def (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_UnionDef_Proxy_Impl &proxy = 
-    this->the_TAO_UnionDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.discriminator_type_def (
-      this,
-      ACE_TRY_ENV
-    );
-}
-
-void IR_UnionDef::discriminator_type_def (
-    IR_IDLType_ptr discriminator_type_def,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_UnionDef_Proxy_Impl &proxy = 
-    this->the_TAO_UnionDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK;
-  
-  proxy.discriminator_type_def (
-      this,
-      discriminator_type_def,
-      ACE_TRY_ENV
-    );
-}
-
-IR_UnionMemberSeq * IR_UnionDef::members (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_UnionDef_Proxy_Impl &proxy = 
-    this->the_TAO_UnionDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.members (
-      this,
-      ACE_TRY_ENV
-    );
-}
-
-void IR_UnionDef::members (
-    const IR_UnionMemberSeq & members,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_UnionDef_Proxy_Impl &proxy = 
-    this->the_TAO_UnionDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK;
-  
-  proxy.members (
-      this,
-      members,
-      ACE_TRY_ENV
-    );
-}
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-IR_UnionDef::TAO_ClientRequestInfo_IR_UnionDef_discriminator_type_get::TAO_ClientRequestInfo_IR_UnionDef_discriminator_type_get (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
-{}
-
-Dynamic::ParameterList *
-IR_UnionDef::TAO_ClientRequestInfo_IR_UnionDef_discriminator_type_get::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return parameter_list;
-}
-
-Dynamic::ExceptionList *
-IR_UnionDef::TAO_ClientRequestInfo_IR_UnionDef_discriminator_type_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_UnionDef::TAO_ClientRequestInfo_IR_UnionDef_discriminator_type_get::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_UnionDef::TAO_ClientRequestInfo_IR_UnionDef_discriminator_type_get::result (CORBA::TypeCode_ptr result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_UnionDef::TAO_ClientRequestInfo_IR_UnionDef_discriminator_type_def_get::TAO_ClientRequestInfo_IR_UnionDef_discriminator_type_def_get (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
-{}
-
-Dynamic::ParameterList *
-IR_UnionDef::TAO_ClientRequestInfo_IR_UnionDef_discriminator_type_def_get::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return parameter_list;
-}
-
-Dynamic::ExceptionList *
-IR_UnionDef::TAO_ClientRequestInfo_IR_UnionDef_discriminator_type_def_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_UnionDef::TAO_ClientRequestInfo_IR_UnionDef_discriminator_type_def_get::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_UnionDef::TAO_ClientRequestInfo_IR_UnionDef_discriminator_type_def_get::result (IR_IDLType_ptr result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_UnionDef::TAO_ClientRequestInfo_IR_UnionDef_discriminator_type_def_set::TAO_ClientRequestInfo_IR_UnionDef_discriminator_type_def_set (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    IR_IDLType_ptr discriminator_type_def,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
-    discriminator_type_def_ (discriminator_type_def)
-{}
-
-Dynamic::ParameterList *
-IR_UnionDef::TAO_ClientRequestInfo_IR_UnionDef_discriminator_type_def_set::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
-    
-  CORBA::ULong length_discriminator_type_def = parameter_list->length ();
-  parameter_list->length (length_discriminator_type_def + 1);
-  (*parameter_list)[length_discriminator_type_def].argument <<=  this->discriminator_type_def_;
-  
-  (*parameter_list)[length_discriminator_type_def].mode = Dynamic::PARAM_IN;
-  
-  return safe_parameter_list._retn ();
-}
-
-Dynamic::ExceptionList *
-IR_UnionDef::TAO_ClientRequestInfo_IR_UnionDef_discriminator_type_def_set::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_UnionDef::TAO_ClientRequestInfo_IR_UnionDef_discriminator_type_def_set::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 1;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return result_any;
-}
-
-IR_UnionDef::TAO_ClientRequestInfo_IR_UnionDef_members_get::TAO_ClientRequestInfo_IR_UnionDef_members_get (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
-{}
-
-Dynamic::ParameterList *
-IR_UnionDef::TAO_ClientRequestInfo_IR_UnionDef_members_get::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return parameter_list;
-}
-
-Dynamic::ExceptionList *
-IR_UnionDef::TAO_ClientRequestInfo_IR_UnionDef_members_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_UnionDef::TAO_ClientRequestInfo_IR_UnionDef_members_get::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_UnionDef::TAO_ClientRequestInfo_IR_UnionDef_members_get::result (IR_UnionMemberSeq * result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_UnionDef::TAO_ClientRequestInfo_IR_UnionDef_members_set::TAO_ClientRequestInfo_IR_UnionDef_members_set (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    const IR_UnionMemberSeq & members,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
-    members_ (members)
-{}
-
-Dynamic::ParameterList *
-IR_UnionDef::TAO_ClientRequestInfo_IR_UnionDef_members_set::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
-    
-  CORBA::ULong length_members = parameter_list->length ();
-  parameter_list->length (length_members + 1);
-  (*parameter_list)[length_members].argument <<=  this->members_;
-  
-  (*parameter_list)[length_members].mode = Dynamic::PARAM_IN;
-  
-  return safe_parameter_list._retn ();
-}
-
-Dynamic::ExceptionList *
-IR_UnionDef::TAO_ClientRequestInfo_IR_UnionDef_members_set::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_UnionDef::TAO_ClientRequestInfo_IR_UnionDef_members_set::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 1;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return result_any;
-}
-
-#endif /* TAO_HAS_INTERCEPTORS */
-
-static const CORBA::Long _oc_IR_UnionDef[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  28, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f55), ACE_NTOHL (0x6e696f6e), ACE_NTOHL (0x4465663a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/UnionDef:1.0
-  9, ACE_NTOHL (0x556e696f), ACE_NTOHL (0x6e446566), ACE_NTOHL (0x0),  // name = IR_UnionDef
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_UnionDef (CORBA::tk_objref, sizeof (_oc_IR_UnionDef), (char *) &_oc_IR_UnionDef, 0, sizeof (IR_UnionDef));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_UnionDef, &_tc_TAO_tc_IR_UnionDef)
-TAO_NAMESPACE_END
-
-///////////////////////////////////////////////////////////////////////
-//                Base & Remote Proxy  Implementation. 
-//
-
-_TAO_EnumDef_Proxy_Impl::_TAO_EnumDef_Proxy_Impl (void)
-{}
-
-_TAO_EnumDef_Remote_Proxy_Impl::_TAO_EnumDef_Remote_Proxy_Impl (void)
-{}
-
-// Remote Implementation of the IDL interface methods
-
-IR_EnumMemberSeq * _TAO_EnumDef_Remote_Proxy_Impl::members (
-    CORBA_Object *_collocated_tao_target_,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  IR_EnumMemberSeq *_tao_retval = 0;
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-
-  ACE_NEW_RETURN (_tao_retval, IR_EnumMemberSeq, _tao_retval);
-  IR_EnumMemberSeq_var _tao_safe_retval (_tao_retval);
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_get_members",
-      12,
-      0,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_EnumDef::TAO_ClientRequestInfo_IR_EnumDef_members_get ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              IR_EnumMemberSeq * _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-void _TAO_EnumDef_Remote_Proxy_Impl::members (
-    CORBA_Object *_collocated_tao_target_,
-    const IR_EnumMemberSeq & members,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW (CORBA::INTERNAL ());
-
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_set_members",
-      12,
-      1,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_EnumDef::TAO_ClientRequestInfo_IR_EnumDef_members_set ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        members,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK;
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK;
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK;
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK;
-          
-          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-          if (!(
-                            (_tao_out << members)
-            ))
-            TAO_INTERCEPTOR_THROW (
-              CORBA::MARSHAL ()
-            );
-            
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK;
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)
-              );
-              
-            }
-          
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK;
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK;
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  
-}
-
-
-//
-//            End  Base & Remote  Proxy Implemeentation. 
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//           Remote & Base  Proxy Broker Implementation
-//
-
-_TAO_EnumDef_Proxy_Broker::_TAO_EnumDef_Proxy_Broker (void)
-{
-}
-
-_TAO_EnumDef_Proxy_Broker::~_TAO_EnumDef_Proxy_Broker (void)
-{
-}
-
-_TAO_EnumDef_Proxy_Broker * (*_TAO_EnumDef_Proxy_Broker_Factory_function_pointer) (
-    CORBA::Object_ptr obj
-  ) = 0;
-
-// Factory Member function Implementation.
-_TAO_EnumDef_Remote_Proxy_Broker *
-_TAO_EnumDef_Remote_Proxy_Broker::the_TAO_EnumDef_Remote_Proxy_Broker (void)
-{
-  static ::_TAO_EnumDef_Remote_Proxy_Broker remote_proxy_broker;
-  return &remote_proxy_broker;
-}
-
-_TAO_EnumDef_Remote_Proxy_Broker::_TAO_EnumDef_Remote_Proxy_Broker (void)
-{
-}
-
-_TAO_EnumDef_Remote_Proxy_Broker::~_TAO_EnumDef_Remote_Proxy_Broker (void)
-{
-}
-
-_TAO_EnumDef_Proxy_Impl&
-_TAO_EnumDef_Remote_Proxy_Broker::select_proxy (
-  ::IR_EnumDef *object,
-  CORBA::Environment &ACE_TRY_ENV
-)
-{
-  ACE_UNUSED_ARG (object);
-  ACE_UNUSED_ARG (ACE_TRY_ENV);
-  return remote_proxy_impl_;
-}
-
-
-//
-//           End Remote & Base Proxy Broker Implementation
-///////////////////////////////////////////////////////////////////////
-
-
-// default constructor
-IR_EnumDef::IR_EnumDef (int collocated)
-{
-  this->IR_EnumDef_setup_collocation (collocated);
-}
-
-// destructor
-IR_EnumDef::~IR_EnumDef (void)
-{}
-
-void
-IR_EnumDef::IR_EnumDef_setup_collocation (int collocated)
-{
-  if (collocated)
-    this->the_TAO_EnumDef_Proxy_Broker_ =
-      _TAO_EnumDef_Proxy_Broker_Factory_function_pointer (this);
-  else
-    this->the_TAO_EnumDef_Proxy_Broker_ =
-      _TAO_EnumDef_Remote_Proxy_Broker::the_TAO_EnumDef_Remote_Proxy_Broker ();
-  
-  this->IR_TypedefDef_setup_collocation (collocated); 
-}
-
-void IR_EnumDef::_tao_any_destructor (void *x)
-{
-  IR_EnumDef *tmp = ACE_static_cast (IR_EnumDef*,x);
-  CORBA::release (tmp);
-}
-
-IR_EnumDef_ptr IR_EnumDef::_narrow (
-    CORBA::Object_ptr obj,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  if (CORBA::is_nil (obj))
-    return IR_EnumDef::_nil ();
-  if (! obj->_is_local ())
-    {
-      CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/IR/EnumDef:1.0", ACE_TRY_ENV);
-      ACE_CHECK_RETURN (IR_EnumDef::_nil ());
-      if (is_a == 0)
-        return IR_EnumDef::_nil ();
-    }
-  return IR_EnumDef::_unchecked_narrow (obj, ACE_TRY_ENV);
-}
-
-IR_EnumDef_ptr IR_EnumDef::_unchecked_narrow (
-    CORBA::Object_ptr obj,
-    CORBA::Environment &
-  )
-{
-  if (CORBA::is_nil (obj))
-    return IR_EnumDef::_nil ();
-  if (! obj->_is_local ())
-    {
-      TAO_Stub* stub = obj->_stubobj ();
-      if (stub)
-        stub->_incr_refcnt ();
-      IR_EnumDef_ptr default_proxy = IR_EnumDef::_nil ();
-
-      if (
-          !CORBA::is_nil (stub->servant_orb_var ().ptr ()) &&
-          stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects () &&
-          obj->_is_collocated () &&_TAO_EnumDef_Proxy_Broker_Factory_function_pointer != 0
-        )
-      {
-        ACE_NEW_RETURN (
-          default_proxy,
-          ::IR_EnumDef (
-            stub,
-            1,
-            obj->_servant ()),
-            
-          IR_EnumDef::_nil ());
-        }
-      if (CORBA::is_nil (default_proxy))
-        ACE_NEW_RETURN (default_proxy, ::IR_EnumDef (stub, 0, obj->_servant ()), IR_EnumDef::_nil ());
-        return default_proxy;
-      }
-    else 
-      return
-        ACE_reinterpret_cast
-          (
-            IR_EnumDef_ptr,
-              obj->_tao_QueryInterface
-                (
-                  ACE_reinterpret_cast
-                    (
-                      ptr_arith_t,
-                      &IR_EnumDef::_narrow
-                    )
-                )
-          );
-}
-
-IR_EnumDef_ptr
-IR_EnumDef::_duplicate (IR_EnumDef_ptr obj)
-{
-  if (!CORBA::is_nil (obj))
-    obj->_add_ref ();
-  return obj;
-}
-
-CORBA::Boolean IR_EnumDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
-{
-  if (
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/EnumDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/TypedefDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/Contained:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/IDLType:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
-  return 1; // success using local knowledge
-  else
-    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
-}
-
-void *IR_EnumDef::_tao_QueryInterface (ptr_arith_t type)
-{
-  void *retv = 0;
-  if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_EnumDef::_narrow))
-    retv = ACE_reinterpret_cast (void*, this);
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_TypedefDef::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            IR_TypedefDef_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_Contained::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            IR_Contained_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_IDLType::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            IR_IDLType_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &CORBA_IRObject::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            CORBA_IRObject_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
-    retv = ACE_reinterpret_cast (void *,
-      ACE_static_cast (CORBA::Object_ptr, this));
-    
-  if (retv)
-    this->_add_ref ();
-  return retv;
-}
-
-const char* IR_EnumDef::_interface_repository_id (void) const
-{
-  return "IDL:omg.org/IR/EnumDef:1.0";
-}
-
-IR_EnumMemberSeq * IR_EnumDef::members (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_EnumDef_Proxy_Impl &proxy = 
-    this->the_TAO_EnumDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.members (
-      this,
-      ACE_TRY_ENV
-    );
-}
-
-void IR_EnumDef::members (
-    const IR_EnumMemberSeq & members,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_EnumDef_Proxy_Impl &proxy = 
-    this->the_TAO_EnumDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK;
-  
-  proxy.members (
-      this,
-      members,
-      ACE_TRY_ENV
-    );
-}
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-IR_EnumDef::TAO_ClientRequestInfo_IR_EnumDef_members_get::TAO_ClientRequestInfo_IR_EnumDef_members_get (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
-{}
-
-Dynamic::ParameterList *
-IR_EnumDef::TAO_ClientRequestInfo_IR_EnumDef_members_get::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return parameter_list;
-}
-
-Dynamic::ExceptionList *
-IR_EnumDef::TAO_ClientRequestInfo_IR_EnumDef_members_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_EnumDef::TAO_ClientRequestInfo_IR_EnumDef_members_get::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_EnumDef::TAO_ClientRequestInfo_IR_EnumDef_members_get::result (IR_EnumMemberSeq * result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_EnumDef::TAO_ClientRequestInfo_IR_EnumDef_members_set::TAO_ClientRequestInfo_IR_EnumDef_members_set (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    const IR_EnumMemberSeq & members,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
-    members_ (members)
-{}
-
-Dynamic::ParameterList *
-IR_EnumDef::TAO_ClientRequestInfo_IR_EnumDef_members_set::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
-    
-  CORBA::ULong length_members = parameter_list->length ();
-  parameter_list->length (length_members + 1);
-  (*parameter_list)[length_members].argument <<=  this->members_;
-  
-  (*parameter_list)[length_members].mode = Dynamic::PARAM_IN;
-  
-  return safe_parameter_list._retn ();
-}
-
-Dynamic::ExceptionList *
-IR_EnumDef::TAO_ClientRequestInfo_IR_EnumDef_members_set::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_EnumDef::TAO_ClientRequestInfo_IR_EnumDef_members_set::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 1;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return result_any;
-}
-
-#endif /* TAO_HAS_INTERCEPTORS */
-
-static const CORBA::Long _oc_IR_EnumDef[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  27, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x6e756d44), ACE_NTOHL (0x65663a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/EnumDef:1.0
-  8, ACE_NTOHL (0x456e756d), ACE_NTOHL (0x44656600),  // name = IR_EnumDef
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_EnumDef (CORBA::tk_objref, sizeof (_oc_IR_EnumDef), (char *) &_oc_IR_EnumDef, 0, sizeof (IR_EnumDef));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_EnumDef, &_tc_TAO_tc_IR_EnumDef)
-TAO_NAMESPACE_END
-
-///////////////////////////////////////////////////////////////////////
-//                Base & Remote Proxy  Implementation. 
-//
-
-_TAO_AliasDef_Proxy_Impl::_TAO_AliasDef_Proxy_Impl (void)
-{}
-
-_TAO_AliasDef_Remote_Proxy_Impl::_TAO_AliasDef_Remote_Proxy_Impl (void)
-{}
-
-// Remote Implementation of the IDL interface methods
-
-IR_IDLType_ptr _TAO_AliasDef_Remote_Proxy_Impl::original_type_def (
-    CORBA_Object *_collocated_tao_target_,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  IR_IDLType_ptr _tao_retval = IR_IDLType::_nil ();
-  IR_IDLType_var _tao_safe_retval (_tao_retval);
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_get_original_type_def",
-      22,
-      0,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_AliasDef::TAO_ClientRequestInfo_IR_AliasDef_original_type_def_get ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              IR_IDLType_ptr _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-void _TAO_AliasDef_Remote_Proxy_Impl::original_type_def (
-    CORBA_Object *_collocated_tao_target_,
-    IR_IDLType_ptr original_type_def,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW (CORBA::INTERNAL ());
-
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_set_original_type_def",
-      22,
-      1,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_AliasDef::TAO_ClientRequestInfo_IR_AliasDef_original_type_def_set ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        original_type_def,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK;
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK;
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK;
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK;
-          
-          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-          if (!(
-                            (_tao_out << original_type_def)
-            ))
-            TAO_INTERCEPTOR_THROW (
-              CORBA::MARSHAL ()
-            );
-            
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK;
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)
-              );
-              
-            }
-          
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK;
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK;
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  
-}
-
-
-//
-//            End  Base & Remote  Proxy Implemeentation. 
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//           Remote & Base  Proxy Broker Implementation
-//
-
-_TAO_AliasDef_Proxy_Broker::_TAO_AliasDef_Proxy_Broker (void)
-{
-}
-
-_TAO_AliasDef_Proxy_Broker::~_TAO_AliasDef_Proxy_Broker (void)
-{
-}
-
-_TAO_AliasDef_Proxy_Broker * (*_TAO_AliasDef_Proxy_Broker_Factory_function_pointer) (
-    CORBA::Object_ptr obj
-  ) = 0;
-
-// Factory Member function Implementation.
-_TAO_AliasDef_Remote_Proxy_Broker *
-_TAO_AliasDef_Remote_Proxy_Broker::the_TAO_AliasDef_Remote_Proxy_Broker (void)
-{
-  static ::_TAO_AliasDef_Remote_Proxy_Broker remote_proxy_broker;
-  return &remote_proxy_broker;
-}
-
-_TAO_AliasDef_Remote_Proxy_Broker::_TAO_AliasDef_Remote_Proxy_Broker (void)
-{
-}
-
-_TAO_AliasDef_Remote_Proxy_Broker::~_TAO_AliasDef_Remote_Proxy_Broker (void)
-{
-}
-
-_TAO_AliasDef_Proxy_Impl&
-_TAO_AliasDef_Remote_Proxy_Broker::select_proxy (
-  ::IR_AliasDef *object,
-  CORBA::Environment &ACE_TRY_ENV
-)
-{
-  ACE_UNUSED_ARG (object);
-  ACE_UNUSED_ARG (ACE_TRY_ENV);
-  return remote_proxy_impl_;
-}
-
-
-//
-//           End Remote & Base Proxy Broker Implementation
-///////////////////////////////////////////////////////////////////////
-
-
-// default constructor
-IR_AliasDef::IR_AliasDef (int collocated)
-{
-  this->IR_AliasDef_setup_collocation (collocated);
-}
-
-// destructor
-IR_AliasDef::~IR_AliasDef (void)
-{}
-
-void
-IR_AliasDef::IR_AliasDef_setup_collocation (int collocated)
-{
-  if (collocated)
-    this->the_TAO_AliasDef_Proxy_Broker_ =
-      _TAO_AliasDef_Proxy_Broker_Factory_function_pointer (this);
-  else
-    this->the_TAO_AliasDef_Proxy_Broker_ =
-      _TAO_AliasDef_Remote_Proxy_Broker::the_TAO_AliasDef_Remote_Proxy_Broker ();
-  
-  this->IR_TypedefDef_setup_collocation (collocated); 
-}
-
-void IR_AliasDef::_tao_any_destructor (void *x)
-{
-  IR_AliasDef *tmp = ACE_static_cast (IR_AliasDef*,x);
-  CORBA::release (tmp);
-}
-
-IR_AliasDef_ptr IR_AliasDef::_narrow (
-    CORBA::Object_ptr obj,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  if (CORBA::is_nil (obj))
-    return IR_AliasDef::_nil ();
-  if (! obj->_is_local ())
-    {
-      CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/IR/AliasDef:1.0", ACE_TRY_ENV);
-      ACE_CHECK_RETURN (IR_AliasDef::_nil ());
-      if (is_a == 0)
-        return IR_AliasDef::_nil ();
-    }
-  return IR_AliasDef::_unchecked_narrow (obj, ACE_TRY_ENV);
-}
-
-IR_AliasDef_ptr IR_AliasDef::_unchecked_narrow (
-    CORBA::Object_ptr obj,
-    CORBA::Environment &
-  )
-{
-  if (CORBA::is_nil (obj))
-    return IR_AliasDef::_nil ();
-  if (! obj->_is_local ())
-    {
-      TAO_Stub* stub = obj->_stubobj ();
-      if (stub)
-        stub->_incr_refcnt ();
-      IR_AliasDef_ptr default_proxy = IR_AliasDef::_nil ();
-
-      if (
-          !CORBA::is_nil (stub->servant_orb_var ().ptr ()) &&
-          stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects () &&
-          obj->_is_collocated () &&_TAO_AliasDef_Proxy_Broker_Factory_function_pointer != 0
-        )
-      {
-        ACE_NEW_RETURN (
-          default_proxy,
-          ::IR_AliasDef (
-            stub,
-            1,
-            obj->_servant ()),
-            
-          IR_AliasDef::_nil ());
-        }
-      if (CORBA::is_nil (default_proxy))
-        ACE_NEW_RETURN (default_proxy, ::IR_AliasDef (stub, 0, obj->_servant ()), IR_AliasDef::_nil ());
-        return default_proxy;
-      }
-    else 
-      return
-        ACE_reinterpret_cast
-          (
-            IR_AliasDef_ptr,
-              obj->_tao_QueryInterface
-                (
-                  ACE_reinterpret_cast
-                    (
-                      ptr_arith_t,
-                      &IR_AliasDef::_narrow
-                    )
-                )
-          );
-}
-
-IR_AliasDef_ptr
-IR_AliasDef::_duplicate (IR_AliasDef_ptr obj)
-{
-  if (!CORBA::is_nil (obj))
-    obj->_add_ref ();
-  return obj;
-}
-
-CORBA::Boolean IR_AliasDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
-{
-  if (
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/AliasDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/TypedefDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/Contained:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/IDLType:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
-  return 1; // success using local knowledge
-  else
-    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
-}
-
-void *IR_AliasDef::_tao_QueryInterface (ptr_arith_t type)
-{
-  void *retv = 0;
-  if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_AliasDef::_narrow))
-    retv = ACE_reinterpret_cast (void*, this);
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_TypedefDef::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            IR_TypedefDef_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_Contained::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            IR_Contained_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_IDLType::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            IR_IDLType_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &CORBA_IRObject::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            CORBA_IRObject_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
-    retv = ACE_reinterpret_cast (void *,
-      ACE_static_cast (CORBA::Object_ptr, this));
-    
-  if (retv)
-    this->_add_ref ();
-  return retv;
-}
-
-const char* IR_AliasDef::_interface_repository_id (void) const
-{
-  return "IDL:omg.org/IR/AliasDef:1.0";
-}
-
-IR_IDLType_ptr IR_AliasDef::original_type_def (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_AliasDef_Proxy_Impl &proxy = 
-    this->the_TAO_AliasDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.original_type_def (
-      this,
-      ACE_TRY_ENV
-    );
-}
-
-void IR_AliasDef::original_type_def (
-    IR_IDLType_ptr original_type_def,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_AliasDef_Proxy_Impl &proxy = 
-    this->the_TAO_AliasDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK;
-  
-  proxy.original_type_def (
-      this,
-      original_type_def,
-      ACE_TRY_ENV
-    );
-}
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-IR_AliasDef::TAO_ClientRequestInfo_IR_AliasDef_original_type_def_get::TAO_ClientRequestInfo_IR_AliasDef_original_type_def_get (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
-{}
-
-Dynamic::ParameterList *
-IR_AliasDef::TAO_ClientRequestInfo_IR_AliasDef_original_type_def_get::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return parameter_list;
-}
-
-Dynamic::ExceptionList *
-IR_AliasDef::TAO_ClientRequestInfo_IR_AliasDef_original_type_def_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_AliasDef::TAO_ClientRequestInfo_IR_AliasDef_original_type_def_get::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_AliasDef::TAO_ClientRequestInfo_IR_AliasDef_original_type_def_get::result (IR_IDLType_ptr result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_AliasDef::TAO_ClientRequestInfo_IR_AliasDef_original_type_def_set::TAO_ClientRequestInfo_IR_AliasDef_original_type_def_set (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    IR_IDLType_ptr original_type_def,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
-    original_type_def_ (original_type_def)
-{}
-
-Dynamic::ParameterList *
-IR_AliasDef::TAO_ClientRequestInfo_IR_AliasDef_original_type_def_set::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
-    
-  CORBA::ULong length_original_type_def = parameter_list->length ();
-  parameter_list->length (length_original_type_def + 1);
-  (*parameter_list)[length_original_type_def].argument <<=  this->original_type_def_;
-  
-  (*parameter_list)[length_original_type_def].mode = Dynamic::PARAM_IN;
-  
-  return safe_parameter_list._retn ();
-}
-
-Dynamic::ExceptionList *
-IR_AliasDef::TAO_ClientRequestInfo_IR_AliasDef_original_type_def_set::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_AliasDef::TAO_ClientRequestInfo_IR_AliasDef_original_type_def_set::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 1;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return result_any;
-}
-
-#endif /* TAO_HAS_INTERCEPTORS */
-
-static const CORBA::Long _oc_IR_AliasDef[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  28, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f41), ACE_NTOHL (0x6c696173), ACE_NTOHL (0x4465663a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/AliasDef:1.0
-  9, ACE_NTOHL (0x416c6961), ACE_NTOHL (0x73446566), ACE_NTOHL (0x0),  // name = IR_AliasDef
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_AliasDef (CORBA::tk_objref, sizeof (_oc_IR_AliasDef), (char *) &_oc_IR_AliasDef, 0, sizeof (IR_AliasDef));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_AliasDef, &_tc_TAO_tc_IR_AliasDef)
-TAO_NAMESPACE_END
-
-///////////////////////////////////////////////////////////////////////
-//                Base & Remote Proxy  Implementation. 
-//
-
-_TAO_NativeDef_Proxy_Impl::_TAO_NativeDef_Proxy_Impl (void)
-{}
-
-_TAO_NativeDef_Remote_Proxy_Impl::_TAO_NativeDef_Remote_Proxy_Impl (void)
-{}
-
-// Remote Implementation of the IDL interface methods
-
-
-//
-//            End  Base & Remote  Proxy Implemeentation. 
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//           Remote & Base  Proxy Broker Implementation
-//
-
-_TAO_NativeDef_Proxy_Broker::_TAO_NativeDef_Proxy_Broker (void)
-{
-}
-
-_TAO_NativeDef_Proxy_Broker::~_TAO_NativeDef_Proxy_Broker (void)
-{
-}
-
-_TAO_NativeDef_Proxy_Broker * (*_TAO_NativeDef_Proxy_Broker_Factory_function_pointer) (
-    CORBA::Object_ptr obj
-  ) = 0;
-
-// Factory Member function Implementation.
-_TAO_NativeDef_Remote_Proxy_Broker *
-_TAO_NativeDef_Remote_Proxy_Broker::the_TAO_NativeDef_Remote_Proxy_Broker (void)
-{
-  static ::_TAO_NativeDef_Remote_Proxy_Broker remote_proxy_broker;
-  return &remote_proxy_broker;
-}
-
-_TAO_NativeDef_Remote_Proxy_Broker::_TAO_NativeDef_Remote_Proxy_Broker (void)
-{
-}
-
-_TAO_NativeDef_Remote_Proxy_Broker::~_TAO_NativeDef_Remote_Proxy_Broker (void)
-{
-}
-
-_TAO_NativeDef_Proxy_Impl&
-_TAO_NativeDef_Remote_Proxy_Broker::select_proxy (
-  ::IR_NativeDef *object,
-  CORBA::Environment &ACE_TRY_ENV
-)
-{
-  ACE_UNUSED_ARG (object);
-  ACE_UNUSED_ARG (ACE_TRY_ENV);
-  return remote_proxy_impl_;
-}
-
-
-//
-//           End Remote & Base Proxy Broker Implementation
-///////////////////////////////////////////////////////////////////////
-
-
-// default constructor
-IR_NativeDef::IR_NativeDef (int collocated)
-{
-  this->IR_NativeDef_setup_collocation (collocated);
-}
-
-// destructor
-IR_NativeDef::~IR_NativeDef (void)
-{}
-
-void
-IR_NativeDef::IR_NativeDef_setup_collocation (int collocated)
-{
-  if (collocated)
-    this->the_TAO_NativeDef_Proxy_Broker_ =
-      _TAO_NativeDef_Proxy_Broker_Factory_function_pointer (this);
-  else
-    this->the_TAO_NativeDef_Proxy_Broker_ =
-      _TAO_NativeDef_Remote_Proxy_Broker::the_TAO_NativeDef_Remote_Proxy_Broker ();
-  
-  this->IR_TypedefDef_setup_collocation (collocated);
-}
-  
-void IR_NativeDef::_tao_any_destructor (void *x)
-{
-  IR_NativeDef *tmp = ACE_static_cast (IR_NativeDef*,x);
-  CORBA::release (tmp);
-}
-
-IR_NativeDef_ptr IR_NativeDef::_narrow (
-    CORBA::Object_ptr obj,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  if (CORBA::is_nil (obj))
-    return IR_NativeDef::_nil ();
-  if (! obj->_is_local ())
-    {
-      CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/IR/NativeDef:1.0", ACE_TRY_ENV);
-      ACE_CHECK_RETURN (IR_NativeDef::_nil ());
-      if (is_a == 0)
-        return IR_NativeDef::_nil ();
-    }
-  return IR_NativeDef::_unchecked_narrow (obj, ACE_TRY_ENV);
-}
-
-IR_NativeDef_ptr IR_NativeDef::_unchecked_narrow (
-    CORBA::Object_ptr obj,
-    CORBA::Environment &
-  )
-{
-  if (CORBA::is_nil (obj))
-    return IR_NativeDef::_nil ();
-  if (! obj->_is_local ())
-    {
-      TAO_Stub* stub = obj->_stubobj ();
-      if (stub)
-        stub->_incr_refcnt ();
-      IR_NativeDef_ptr default_proxy = IR_NativeDef::_nil ();
-
-      if (
-          !CORBA::is_nil (stub->servant_orb_var ().ptr ()) &&
-          stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects () &&
-          obj->_is_collocated () &&_TAO_NativeDef_Proxy_Broker_Factory_function_pointer != 0
-        )
-      {
-        ACE_NEW_RETURN (
-          default_proxy,
-          ::IR_NativeDef (
-            stub,
-            1,
-            obj->_servant ()),
-            
-          IR_NativeDef::_nil ());
-        }
-      if (CORBA::is_nil (default_proxy))
-        ACE_NEW_RETURN (default_proxy, ::IR_NativeDef (stub, 0, obj->_servant ()), IR_NativeDef::_nil ());
-        return default_proxy;
-      }
-    else 
-      return
-        ACE_reinterpret_cast
-          (
-            IR_NativeDef_ptr,
-              obj->_tao_QueryInterface
-                (
-                  ACE_reinterpret_cast
-                    (
-                      ptr_arith_t,
-                      &IR_NativeDef::_narrow
-                    )
-                )
-          );
-}
-
-IR_NativeDef_ptr
-IR_NativeDef::_duplicate (IR_NativeDef_ptr obj)
-{
-  if (!CORBA::is_nil (obj))
-    obj->_add_ref ();
-  return obj;
-}
-
-CORBA::Boolean IR_NativeDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
-{
-  if (
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/NativeDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/TypedefDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/Contained:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/IDLType:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
-  return 1; // success using local knowledge
-  else
-    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
-}
-
-void *IR_NativeDef::_tao_QueryInterface (ptr_arith_t type)
-{
-  void *retv = 0;
-  if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_NativeDef::_narrow))
-    retv = ACE_reinterpret_cast (void*, this);
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_TypedefDef::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            IR_TypedefDef_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_Contained::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            IR_Contained_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_IDLType::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            IR_IDLType_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &CORBA_IRObject::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            CORBA_IRObject_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
-    retv = ACE_reinterpret_cast (void *,
-      ACE_static_cast (CORBA::Object_ptr, this));
-    
-  if (retv)
-    this->_add_ref ();
-  return retv;
-}
-
-const char* IR_NativeDef::_interface_repository_id (void) const
-{
-  return "IDL:omg.org/IR/NativeDef:1.0";
-}
-
-static const CORBA::Long _oc_IR_NativeDef[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  29, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f4e), ACE_NTOHL (0x61746976), ACE_NTOHL (0x65446566), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/NativeDef:1.0
-  10, ACE_NTOHL (0x4e617469), ACE_NTOHL (0x76654465), ACE_NTOHL (0x66000000),  // name = IR_NativeDef
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_NativeDef (CORBA::tk_objref, sizeof (_oc_IR_NativeDef), (char *) &_oc_IR_NativeDef, 0, sizeof (IR_NativeDef));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_NativeDef, &_tc_TAO_tc_IR_NativeDef)
-TAO_NAMESPACE_END
-
-///////////////////////////////////////////////////////////////////////
-//                Base & Remote Proxy  Implementation. 
-//
-
-_TAO_PrimitiveDef_Proxy_Impl::_TAO_PrimitiveDef_Proxy_Impl (void)
-{}
-
-_TAO_PrimitiveDef_Remote_Proxy_Impl::_TAO_PrimitiveDef_Remote_Proxy_Impl (void)
-{}
-
-// Remote Implementation of the IDL interface methods
-
-IR_PrimitiveKind _TAO_PrimitiveDef_Remote_Proxy_Impl::kind (
-    CORBA_Object *_collocated_tao_target_,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  IR_PrimitiveKind _tao_retval = (IR_PrimitiveKind)0;
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), _tao_retval);
-
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_get_kind",
-      9,
-      0,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_PrimitiveDef::TAO_ClientRequestInfo_IR_PrimitiveDef_kind_get ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN  (_tao_retval);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                _tao_retval
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_retval)
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                _tao_retval
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              IR_PrimitiveKind  _tao_retval_info = _tao_retval;
-               ri.result (_tao_retval_info);
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN  (_tao_retval);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_retval;
-}
-
-
-//
-//            End  Base & Remote  Proxy Implemeentation. 
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//           Remote & Base  Proxy Broker Implementation
-//
-
-_TAO_PrimitiveDef_Proxy_Broker::_TAO_PrimitiveDef_Proxy_Broker (void)
-{
-}
-
-_TAO_PrimitiveDef_Proxy_Broker::~_TAO_PrimitiveDef_Proxy_Broker (void)
-{
-}
-
-_TAO_PrimitiveDef_Proxy_Broker * (*_TAO_PrimitiveDef_Proxy_Broker_Factory_function_pointer) (
-    CORBA::Object_ptr obj
-  ) = 0;
-
-// Factory Member function Implementation.
-_TAO_PrimitiveDef_Remote_Proxy_Broker *
-_TAO_PrimitiveDef_Remote_Proxy_Broker::the_TAO_PrimitiveDef_Remote_Proxy_Broker (void)
-{
-  static ::_TAO_PrimitiveDef_Remote_Proxy_Broker remote_proxy_broker;
-  return &remote_proxy_broker;
-}
-
-_TAO_PrimitiveDef_Remote_Proxy_Broker::_TAO_PrimitiveDef_Remote_Proxy_Broker (void)
-{
-}
-
-_TAO_PrimitiveDef_Remote_Proxy_Broker::~_TAO_PrimitiveDef_Remote_Proxy_Broker (void)
-{
-}
-
-_TAO_PrimitiveDef_Proxy_Impl&
-_TAO_PrimitiveDef_Remote_Proxy_Broker::select_proxy (
-  ::IR_PrimitiveDef *object,
-  CORBA::Environment &ACE_TRY_ENV
-)
-{
-  ACE_UNUSED_ARG (object);
-  ACE_UNUSED_ARG (ACE_TRY_ENV);
-  return remote_proxy_impl_;
-}
-
-
-//
-//           End Remote & Base Proxy Broker Implementation
-///////////////////////////////////////////////////////////////////////
-
-
-// default constructor
-IR_PrimitiveDef::IR_PrimitiveDef (int collocated)
-{
-  this->IR_PrimitiveDef_setup_collocation (collocated);
-}
-
-// destructor
-IR_PrimitiveDef::~IR_PrimitiveDef (void)
-{}
-
-void
-IR_PrimitiveDef::IR_PrimitiveDef_setup_collocation (int collocated)
-{
-  if (collocated)
-    this->the_TAO_PrimitiveDef_Proxy_Broker_ =
-      _TAO_PrimitiveDef_Proxy_Broker_Factory_function_pointer (this);
-  else
-    this->the_TAO_PrimitiveDef_Proxy_Broker_ =
-      _TAO_PrimitiveDef_Remote_Proxy_Broker::the_TAO_PrimitiveDef_Remote_Proxy_Broker ();
-  
-  this->IR_IDLType_setup_collocation (collocated); 
-}
-
-void IR_PrimitiveDef::_tao_any_destructor (void *x)
-{
-  IR_PrimitiveDef *tmp = ACE_static_cast (IR_PrimitiveDef*,x);
-  CORBA::release (tmp);
-}
-
-IR_PrimitiveDef_ptr IR_PrimitiveDef::_narrow (
-    CORBA::Object_ptr obj,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  if (CORBA::is_nil (obj))
-    return IR_PrimitiveDef::_nil ();
-  if (! obj->_is_local ())
-    {
-      CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/IR/PrimitiveDef:1.0", ACE_TRY_ENV);
-      ACE_CHECK_RETURN (IR_PrimitiveDef::_nil ());
-      if (is_a == 0)
-        return IR_PrimitiveDef::_nil ();
-    }
-  return IR_PrimitiveDef::_unchecked_narrow (obj, ACE_TRY_ENV);
-}
-
-IR_PrimitiveDef_ptr IR_PrimitiveDef::_unchecked_narrow (
-    CORBA::Object_ptr obj,
-    CORBA::Environment &
-  )
-{
-  if (CORBA::is_nil (obj))
-    return IR_PrimitiveDef::_nil ();
-  if (! obj->_is_local ())
-    {
-      TAO_Stub* stub = obj->_stubobj ();
-      if (stub)
-        stub->_incr_refcnt ();
-      IR_PrimitiveDef_ptr default_proxy = IR_PrimitiveDef::_nil ();
-
-      if (
-          !CORBA::is_nil (stub->servant_orb_var ().ptr ()) &&
-          stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects () &&
-          obj->_is_collocated () &&_TAO_PrimitiveDef_Proxy_Broker_Factory_function_pointer != 0
-        )
-      {
-        ACE_NEW_RETURN (
-          default_proxy,
-          ::IR_PrimitiveDef (
-            stub,
-            1,
-            obj->_servant ()),
-            
-          IR_PrimitiveDef::_nil ());
-        }
-      if (CORBA::is_nil (default_proxy))
-        ACE_NEW_RETURN (default_proxy, ::IR_PrimitiveDef (stub, 0, obj->_servant ()), IR_PrimitiveDef::_nil ());
-        return default_proxy;
-      }
-    else 
-      return
-        ACE_reinterpret_cast
-          (
-            IR_PrimitiveDef_ptr,
-              obj->_tao_QueryInterface
-                (
-                  ACE_reinterpret_cast
-                    (
-                      ptr_arith_t,
-                      &IR_PrimitiveDef::_narrow
-                    )
-                )
-          );
-}
-
-IR_PrimitiveDef_ptr
-IR_PrimitiveDef::_duplicate (IR_PrimitiveDef_ptr obj)
-{
-  if (!CORBA::is_nil (obj))
-    obj->_add_ref ();
-  return obj;
-}
-
-CORBA::Boolean IR_PrimitiveDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
-{
-  if (
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/PrimitiveDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/IDLType:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
-  return 1; // success using local knowledge
-  else
-    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
-}
-
-void *IR_PrimitiveDef::_tao_QueryInterface (ptr_arith_t type)
-{
-  void *retv = 0;
-  if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_PrimitiveDef::_narrow))
-    retv = ACE_reinterpret_cast (void*, this);
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_IDLType::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            IR_IDLType_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &CORBA_IRObject::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            CORBA_IRObject_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
-    retv = ACE_reinterpret_cast (void *,
-      ACE_static_cast (CORBA::Object_ptr, this));
-    
-  if (retv)
-    this->_add_ref ();
-  return retv;
-}
-
-const char* IR_PrimitiveDef::_interface_repository_id (void) const
-{
-  return "IDL:omg.org/IR/PrimitiveDef:1.0";
-}
-
-IR_PrimitiveKind IR_PrimitiveDef::kind (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_PrimitiveDef_Proxy_Impl &proxy = 
-    this->the_TAO_PrimitiveDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN ((IR::PrimitiveKind)0);
-  
-  return proxy.kind (
-      this,
-      ACE_TRY_ENV
-    );
-}
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-IR_PrimitiveDef::TAO_ClientRequestInfo_IR_PrimitiveDef_kind_get::TAO_ClientRequestInfo_IR_PrimitiveDef_kind_get (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
-{}
-
-Dynamic::ParameterList *
-IR_PrimitiveDef::TAO_ClientRequestInfo_IR_PrimitiveDef_kind_get::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return parameter_list;
-}
-
-Dynamic::ExceptionList *
-IR_PrimitiveDef::TAO_ClientRequestInfo_IR_PrimitiveDef_kind_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_PrimitiveDef::TAO_ClientRequestInfo_IR_PrimitiveDef_kind_get::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_PrimitiveDef::TAO_ClientRequestInfo_IR_PrimitiveDef_kind_get::result (IR_PrimitiveKind result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-#endif /* TAO_HAS_INTERCEPTORS */
-
-static const CORBA::Long _oc_IR_PrimitiveDef[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f50), ACE_NTOHL (0x72696d69), ACE_NTOHL (0x74697665), ACE_NTOHL (0x4465663a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/PrimitiveDef:1.0
-  13, ACE_NTOHL (0x5072696d), ACE_NTOHL (0x69746976), ACE_NTOHL (0x65446566), ACE_NTOHL (0x0),  // name = IR_PrimitiveDef
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_PrimitiveDef (CORBA::tk_objref, sizeof (_oc_IR_PrimitiveDef), (char *) &_oc_IR_PrimitiveDef, 0, sizeof (IR_PrimitiveDef));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_PrimitiveDef, &_tc_TAO_tc_IR_PrimitiveDef)
-TAO_NAMESPACE_END
-
-///////////////////////////////////////////////////////////////////////
-//                Base & Remote Proxy  Implementation. 
-//
-
-_TAO_StringDef_Proxy_Impl::_TAO_StringDef_Proxy_Impl (void)
-{}
-
-_TAO_StringDef_Remote_Proxy_Impl::_TAO_StringDef_Remote_Proxy_Impl (void)
-{}
-
-// Remote Implementation of the IDL interface methods
-
-CORBA::ULong _TAO_StringDef_Remote_Proxy_Impl::bound (
-    CORBA_Object *_collocated_tao_target_,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  CORBA::ULong _tao_retval = 0;
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), _tao_retval);
-
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_get_bound",
-      10,
-      0,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_StringDef::TAO_ClientRequestInfo_IR_StringDef_bound_get ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN  (_tao_retval);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                _tao_retval
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_retval)
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                _tao_retval
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              CORBA::ULong  _tao_retval_info = _tao_retval;
-               ri.result (_tao_retval_info);
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN  (_tao_retval);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_retval;
-}
-
-void _TAO_StringDef_Remote_Proxy_Impl::bound (
-    CORBA_Object *_collocated_tao_target_,
-    CORBA::ULong bound,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW (CORBA::INTERNAL ());
-
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_set_bound",
-      10,
-      1,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_StringDef::TAO_ClientRequestInfo_IR_StringDef_bound_set ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        bound,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK;
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK;
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK;
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK;
-          
-          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-          if (!(
-                            (_tao_out << bound)
-            ))
-            TAO_INTERCEPTOR_THROW (
-              CORBA::MARSHAL ()
-            );
-            
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK;
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)
-              );
-              
-            }
-          
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK;
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK;
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  
-}
-
-
-//
-//            End  Base & Remote  Proxy Implemeentation. 
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//           Remote & Base  Proxy Broker Implementation
-//
-
-_TAO_StringDef_Proxy_Broker::_TAO_StringDef_Proxy_Broker (void)
-{
-}
-
-_TAO_StringDef_Proxy_Broker::~_TAO_StringDef_Proxy_Broker (void)
-{
-}
-
-_TAO_StringDef_Proxy_Broker * (*_TAO_StringDef_Proxy_Broker_Factory_function_pointer) (
-    CORBA::Object_ptr obj
-  ) = 0;
-
-// Factory Member function Implementation.
-_TAO_StringDef_Remote_Proxy_Broker *
-_TAO_StringDef_Remote_Proxy_Broker::the_TAO_StringDef_Remote_Proxy_Broker (void)
-{
-  static ::_TAO_StringDef_Remote_Proxy_Broker remote_proxy_broker;
-  return &remote_proxy_broker;
-}
-
-_TAO_StringDef_Remote_Proxy_Broker::_TAO_StringDef_Remote_Proxy_Broker (void)
-{
-}
-
-_TAO_StringDef_Remote_Proxy_Broker::~_TAO_StringDef_Remote_Proxy_Broker (void)
-{
-}
-
-_TAO_StringDef_Proxy_Impl&
-_TAO_StringDef_Remote_Proxy_Broker::select_proxy (
-  ::IR_StringDef *object,
-  CORBA::Environment &ACE_TRY_ENV
-)
-{
-  ACE_UNUSED_ARG (object);
-  ACE_UNUSED_ARG (ACE_TRY_ENV);
-  return remote_proxy_impl_;
-}
-
-
-//
-//           End Remote & Base Proxy Broker Implementation
-///////////////////////////////////////////////////////////////////////
-
-
-// default constructor
-IR_StringDef::IR_StringDef (int collocated)
-{
-  this->IR_StringDef_setup_collocation (collocated);
-}
-
-// destructor
-IR_StringDef::~IR_StringDef (void)
-{}
-
-void
-IR_StringDef::IR_StringDef_setup_collocation (int collocated)
-{
-  if (collocated)
-    this->the_TAO_StringDef_Proxy_Broker_ =
-      _TAO_StringDef_Proxy_Broker_Factory_function_pointer (this);
-  else
-    this->the_TAO_StringDef_Proxy_Broker_ =
-      _TAO_StringDef_Remote_Proxy_Broker::the_TAO_StringDef_Remote_Proxy_Broker ();
-  
-  this->IR_IDLType_setup_collocation (collocated);
-}
-
-void IR_StringDef::_tao_any_destructor (void *x)
-{
-  IR_StringDef *tmp = ACE_static_cast (IR_StringDef*,x);
-  CORBA::release (tmp);
-}
-
-IR_StringDef_ptr IR_StringDef::_narrow (
-    CORBA::Object_ptr obj,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  if (CORBA::is_nil (obj))
-    return IR_StringDef::_nil ();
-  if (! obj->_is_local ())
-    {
-      CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/IR/StringDef:1.0", ACE_TRY_ENV);
-      ACE_CHECK_RETURN (IR_StringDef::_nil ());
-      if (is_a == 0)
-        return IR_StringDef::_nil ();
-    }
-  return IR_StringDef::_unchecked_narrow (obj, ACE_TRY_ENV);
-}
-
-IR_StringDef_ptr IR_StringDef::_unchecked_narrow (
-    CORBA::Object_ptr obj,
-    CORBA::Environment &
-  )
-{
-  if (CORBA::is_nil (obj))
-    return IR_StringDef::_nil ();
-  if (! obj->_is_local ())
-    {
-      TAO_Stub* stub = obj->_stubobj ();
-      if (stub)
-        stub->_incr_refcnt ();
-      IR_StringDef_ptr default_proxy = IR_StringDef::_nil ();
-
-      if (
-          !CORBA::is_nil (stub->servant_orb_var ().ptr ()) &&
-          stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects () &&
-          obj->_is_collocated () &&_TAO_StringDef_Proxy_Broker_Factory_function_pointer != 0
-        )
-      {
-        ACE_NEW_RETURN (
-          default_proxy,
-          ::IR_StringDef (
-            stub,
-            1,
-            obj->_servant ()),
-            
-          IR_StringDef::_nil ());
-        }
-      if (CORBA::is_nil (default_proxy))
-        ACE_NEW_RETURN (default_proxy, ::IR_StringDef (stub, 0, obj->_servant ()), IR_StringDef::_nil ());
-        return default_proxy;
-      }
-    else 
-      return
-        ACE_reinterpret_cast
-          (
-            IR_StringDef_ptr,
-              obj->_tao_QueryInterface
-                (
-                  ACE_reinterpret_cast
-                    (
-                      ptr_arith_t,
-                      &IR_StringDef::_narrow
-                    )
-                )
-          );
-}
-
-IR_StringDef_ptr
-IR_StringDef::_duplicate (IR_StringDef_ptr obj)
-{
-  if (!CORBA::is_nil (obj))
-    obj->_add_ref ();
-  return obj;
-}
-
-CORBA::Boolean IR_StringDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
-{
-  if (
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/StringDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/IDLType:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
-  return 1; // success using local knowledge
-  else
-    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
-}
-
-void *IR_StringDef::_tao_QueryInterface (ptr_arith_t type)
-{
-  void *retv = 0;
-  if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_StringDef::_narrow))
-    retv = ACE_reinterpret_cast (void*, this);
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_IDLType::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            IR_IDLType_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &CORBA_IRObject::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            CORBA_IRObject_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
-    retv = ACE_reinterpret_cast (void *,
-      ACE_static_cast (CORBA::Object_ptr, this));
-    
-  if (retv)
-    this->_add_ref ();
-  return retv;
-}
-
-const char* IR_StringDef::_interface_repository_id (void) const
-{
-  return "IDL:omg.org/IR/StringDef:1.0";
-}
-
-CORBA::ULong IR_StringDef::bound (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_StringDef_Proxy_Impl &proxy = 
-    this->the_TAO_StringDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.bound (
-      this,
-      ACE_TRY_ENV
-    );
-}
-
-void IR_StringDef::bound (
-    CORBA::ULong bound,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_StringDef_Proxy_Impl &proxy = 
-    this->the_TAO_StringDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK;
-  
-  proxy.bound (
-      this,
-      bound,
-      ACE_TRY_ENV
-    );
-}
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-IR_StringDef::TAO_ClientRequestInfo_IR_StringDef_bound_get::TAO_ClientRequestInfo_IR_StringDef_bound_get (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
-{}
-
-Dynamic::ParameterList *
-IR_StringDef::TAO_ClientRequestInfo_IR_StringDef_bound_get::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return parameter_list;
-}
-
-Dynamic::ExceptionList *
-IR_StringDef::TAO_ClientRequestInfo_IR_StringDef_bound_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_StringDef::TAO_ClientRequestInfo_IR_StringDef_bound_get::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_StringDef::TAO_ClientRequestInfo_IR_StringDef_bound_get::result (CORBA::ULong result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_StringDef::TAO_ClientRequestInfo_IR_StringDef_bound_set::TAO_ClientRequestInfo_IR_StringDef_bound_set (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    const CORBA::ULong & bound,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
-    bound_ (bound)
-{}
-
-Dynamic::ParameterList *
-IR_StringDef::TAO_ClientRequestInfo_IR_StringDef_bound_set::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
-    
-  CORBA::ULong length_bound = parameter_list->length ();
-  parameter_list->length (length_bound + 1);
-  (*parameter_list)[length_bound].argument <<= bound_;
-  (*parameter_list)[length_bound].mode = Dynamic::PARAM_IN;
-  
-  return safe_parameter_list._retn ();
-}
-
-Dynamic::ExceptionList *
-IR_StringDef::TAO_ClientRequestInfo_IR_StringDef_bound_set::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_StringDef::TAO_ClientRequestInfo_IR_StringDef_bound_set::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 1;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return result_any;
-}
-
-#endif /* TAO_HAS_INTERCEPTORS */
-
-static const CORBA::Long _oc_IR_StringDef[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  29, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f53), ACE_NTOHL (0x7472696e), ACE_NTOHL (0x67446566), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/StringDef:1.0
-  10, ACE_NTOHL (0x53747269), ACE_NTOHL (0x6e674465), ACE_NTOHL (0x66000000),  // name = IR_StringDef
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_StringDef (CORBA::tk_objref, sizeof (_oc_IR_StringDef), (char *) &_oc_IR_StringDef, 0, sizeof (IR_StringDef));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_StringDef, &_tc_TAO_tc_IR_StringDef)
-TAO_NAMESPACE_END
-
-///////////////////////////////////////////////////////////////////////
-//                Base & Remote Proxy  Implementation. 
-//
-
-_TAO_WstringDef_Proxy_Impl::_TAO_WstringDef_Proxy_Impl (void)
-{}
-
-_TAO_WstringDef_Remote_Proxy_Impl::_TAO_WstringDef_Remote_Proxy_Impl (void)
-{}
-
-// Remote Implementation of the IDL interface methods
-
-CORBA::ULong _TAO_WstringDef_Remote_Proxy_Impl::bound (
-    CORBA_Object *_collocated_tao_target_,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  CORBA::ULong _tao_retval = 0;
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), _tao_retval);
-
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_get_bound",
-      10,
-      0,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_WstringDef::TAO_ClientRequestInfo_IR_WstringDef_bound_get ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN  (_tao_retval);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                _tao_retval
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_retval)
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                _tao_retval
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              CORBA::ULong  _tao_retval_info = _tao_retval;
-               ri.result (_tao_retval_info);
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN  (_tao_retval);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_retval;
-}
-
-void _TAO_WstringDef_Remote_Proxy_Impl::bound (
-    CORBA_Object *_collocated_tao_target_,
-    CORBA::ULong bound,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW (CORBA::INTERNAL ());
-
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_set_bound",
-      10,
-      1,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_WstringDef::TAO_ClientRequestInfo_IR_WstringDef_bound_set ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        bound,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK;
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK;
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK;
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK;
-          
-          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-          if (!(
-                            (_tao_out << bound)
-            ))
-            TAO_INTERCEPTOR_THROW (
-              CORBA::MARSHAL ()
-            );
-            
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK;
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)
-              );
-              
-            }
-          
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK;
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK;
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  
-}
-
-
-//
-//            End  Base & Remote  Proxy Implemeentation. 
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//           Remote & Base  Proxy Broker Implementation
-//
-
-_TAO_WstringDef_Proxy_Broker::_TAO_WstringDef_Proxy_Broker (void)
-{
-}
-
-_TAO_WstringDef_Proxy_Broker::~_TAO_WstringDef_Proxy_Broker (void)
-{
-}
-
-_TAO_WstringDef_Proxy_Broker * (*_TAO_WstringDef_Proxy_Broker_Factory_function_pointer) (
-    CORBA::Object_ptr obj
-  ) = 0;
-
-// Factory Member function Implementation.
-_TAO_WstringDef_Remote_Proxy_Broker *
-_TAO_WstringDef_Remote_Proxy_Broker::the_TAO_WstringDef_Remote_Proxy_Broker (void)
-{
-  static ::_TAO_WstringDef_Remote_Proxy_Broker remote_proxy_broker;
-  return &remote_proxy_broker;
-}
-
-_TAO_WstringDef_Remote_Proxy_Broker::_TAO_WstringDef_Remote_Proxy_Broker (void)
-{
-}
-
-_TAO_WstringDef_Remote_Proxy_Broker::~_TAO_WstringDef_Remote_Proxy_Broker (void)
-{
-}
-
-_TAO_WstringDef_Proxy_Impl&
-_TAO_WstringDef_Remote_Proxy_Broker::select_proxy (
-  ::IR_WstringDef *object,
-  CORBA::Environment &ACE_TRY_ENV
-)
-{
-  ACE_UNUSED_ARG (object);
-  ACE_UNUSED_ARG (ACE_TRY_ENV);
-  return remote_proxy_impl_;
-}
-
-
-//
-//           End Remote & Base Proxy Broker Implementation
-///////////////////////////////////////////////////////////////////////
-
-
-// default constructor
-IR_WstringDef::IR_WstringDef (int collocated)
-{
-  this->IR_WstringDef_setup_collocation (collocated);
-}
-
-// destructor
-IR_WstringDef::~IR_WstringDef (void)
-{}
-
-void
-IR_WstringDef::IR_WstringDef_setup_collocation (int collocated)
-{
-  if (collocated)
-    this->the_TAO_WstringDef_Proxy_Broker_ =
-      _TAO_WstringDef_Proxy_Broker_Factory_function_pointer (this);
-  else
-    this->the_TAO_WstringDef_Proxy_Broker_ =
-      _TAO_WstringDef_Remote_Proxy_Broker::the_TAO_WstringDef_Remote_Proxy_Broker ();
-  
-  this->IR_IDLType_setup_collocation (collocated);  
-}
-
-void IR_WstringDef::_tao_any_destructor (void *x)
-{
-  IR_WstringDef *tmp = ACE_static_cast (IR_WstringDef*,x);
-  CORBA::release (tmp);
-}
-
-IR_WstringDef_ptr IR_WstringDef::_narrow (
-    CORBA::Object_ptr obj,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  if (CORBA::is_nil (obj))
-    return IR_WstringDef::_nil ();
-  if (! obj->_is_local ())
-    {
-      CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/IR/WstringDef:1.0", ACE_TRY_ENV);
-      ACE_CHECK_RETURN (IR_WstringDef::_nil ());
-      if (is_a == 0)
-        return IR_WstringDef::_nil ();
-    }
-  return IR_WstringDef::_unchecked_narrow (obj, ACE_TRY_ENV);
-}
-
-IR_WstringDef_ptr IR_WstringDef::_unchecked_narrow (
-    CORBA::Object_ptr obj,
-    CORBA::Environment &
-  )
-{
-  if (CORBA::is_nil (obj))
-    return IR_WstringDef::_nil ();
-  if (! obj->_is_local ())
-    {
-      TAO_Stub* stub = obj->_stubobj ();
-      if (stub)
-        stub->_incr_refcnt ();
-      IR_WstringDef_ptr default_proxy = IR_WstringDef::_nil ();
-
-      if (
-          !CORBA::is_nil (stub->servant_orb_var ().ptr ()) &&
-          stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects () &&
-          obj->_is_collocated () &&_TAO_WstringDef_Proxy_Broker_Factory_function_pointer != 0
-        )
-      {
-        ACE_NEW_RETURN (
-          default_proxy,
-          ::IR_WstringDef (
-            stub,
-            1,
-            obj->_servant ()),
-            
-          IR_WstringDef::_nil ());
-        }
-      if (CORBA::is_nil (default_proxy))
-        ACE_NEW_RETURN (default_proxy, ::IR_WstringDef (stub, 0, obj->_servant ()), IR_WstringDef::_nil ());
-        return default_proxy;
-      }
-    else 
-      return
-        ACE_reinterpret_cast
-          (
-            IR_WstringDef_ptr,
-              obj->_tao_QueryInterface
-                (
-                  ACE_reinterpret_cast
-                    (
-                      ptr_arith_t,
-                      &IR_WstringDef::_narrow
-                    )
-                )
-          );
-}
-
-IR_WstringDef_ptr
-IR_WstringDef::_duplicate (IR_WstringDef_ptr obj)
-{
-  if (!CORBA::is_nil (obj))
-    obj->_add_ref ();
-  return obj;
-}
-
-CORBA::Boolean IR_WstringDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
-{
-  if (
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/WstringDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/IDLType:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
-  return 1; // success using local knowledge
-  else
-    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
-}
-
-void *IR_WstringDef::_tao_QueryInterface (ptr_arith_t type)
-{
-  void *retv = 0;
-  if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_WstringDef::_narrow))
-    retv = ACE_reinterpret_cast (void*, this);
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_IDLType::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            IR_IDLType_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &CORBA_IRObject::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            CORBA_IRObject_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
-    retv = ACE_reinterpret_cast (void *,
-      ACE_static_cast (CORBA::Object_ptr, this));
-    
-  if (retv)
-    this->_add_ref ();
-  return retv;
-}
-
-const char* IR_WstringDef::_interface_repository_id (void) const
-{
-  return "IDL:omg.org/IR/WstringDef:1.0";
-}
-
-CORBA::ULong IR_WstringDef::bound (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_WstringDef_Proxy_Impl &proxy = 
-    this->the_TAO_WstringDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.bound (
-      this,
-      ACE_TRY_ENV
-    );
-}
-
-void IR_WstringDef::bound (
-    CORBA::ULong bound,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_WstringDef_Proxy_Impl &proxy = 
-    this->the_TAO_WstringDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK;
-  
-  proxy.bound (
-      this,
-      bound,
-      ACE_TRY_ENV
-    );
-}
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-IR_WstringDef::TAO_ClientRequestInfo_IR_WstringDef_bound_get::TAO_ClientRequestInfo_IR_WstringDef_bound_get (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
-{}
-
-Dynamic::ParameterList *
-IR_WstringDef::TAO_ClientRequestInfo_IR_WstringDef_bound_get::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return parameter_list;
-}
-
-Dynamic::ExceptionList *
-IR_WstringDef::TAO_ClientRequestInfo_IR_WstringDef_bound_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_WstringDef::TAO_ClientRequestInfo_IR_WstringDef_bound_get::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_WstringDef::TAO_ClientRequestInfo_IR_WstringDef_bound_get::result (CORBA::ULong result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_WstringDef::TAO_ClientRequestInfo_IR_WstringDef_bound_set::TAO_ClientRequestInfo_IR_WstringDef_bound_set (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    const CORBA::ULong & bound,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
-    bound_ (bound)
-{}
-
-Dynamic::ParameterList *
-IR_WstringDef::TAO_ClientRequestInfo_IR_WstringDef_bound_set::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
-    
-  CORBA::ULong length_bound = parameter_list->length ();
-  parameter_list->length (length_bound + 1);
-  (*parameter_list)[length_bound].argument <<= bound_;
-  (*parameter_list)[length_bound].mode = Dynamic::PARAM_IN;
-  
-  return safe_parameter_list._retn ();
-}
-
-Dynamic::ExceptionList *
-IR_WstringDef::TAO_ClientRequestInfo_IR_WstringDef_bound_set::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_WstringDef::TAO_ClientRequestInfo_IR_WstringDef_bound_set::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 1;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return result_any;
-}
-
-#endif /* TAO_HAS_INTERCEPTORS */
-
-static const CORBA::Long _oc_IR_WstringDef[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f57), ACE_NTOHL (0x73747269), ACE_NTOHL (0x6e674465), ACE_NTOHL (0x663a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/WstringDef:1.0
-  11, ACE_NTOHL (0x57737472), ACE_NTOHL (0x696e6744), ACE_NTOHL (0x65660000),  // name = IR_WstringDef
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_WstringDef (CORBA::tk_objref, sizeof (_oc_IR_WstringDef), (char *) &_oc_IR_WstringDef, 0, sizeof (IR_WstringDef));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_WstringDef, &_tc_TAO_tc_IR_WstringDef)
-TAO_NAMESPACE_END
-
-///////////////////////////////////////////////////////////////////////
-//                Base & Remote Proxy  Implementation. 
-//
-
-_TAO_FixedDef_Proxy_Impl::_TAO_FixedDef_Proxy_Impl (void)
-{}
-
-_TAO_FixedDef_Remote_Proxy_Impl::_TAO_FixedDef_Remote_Proxy_Impl (void)
-{}
-
-// Remote Implementation of the IDL interface methods
-
-CORBA::UShort _TAO_FixedDef_Remote_Proxy_Impl::digits (
-    CORBA_Object *_collocated_tao_target_,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  
-  CORBA::UShort _tao_retval = 0;
-  
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), _tao_retval);
-
-  
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_get_digits",
-      11,
-      0,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_FixedDef::TAO_ClientRequestInfo_IR_FixedDef_digits_get ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN  (_tao_retval);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                _tao_retval
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_retval)
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                _tao_retval
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              CORBA::UShort  _tao_retval_info = _tao_retval;
-               ri.result (_tao_retval_info);
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN  (_tao_retval);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_retval;
-}
-
-void _TAO_FixedDef_Remote_Proxy_Impl::digits (
-    CORBA_Object *_collocated_tao_target_,
-    CORBA::UShort digits,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW (CORBA::INTERNAL ());
-
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_set_digits",
-      11,
-      1,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_FixedDef::TAO_ClientRequestInfo_IR_FixedDef_digits_set ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        digits,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK;
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK;
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK;
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK;
-          
-          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-          if (!(
-                            (_tao_out << digits)
-            ))
-            TAO_INTERCEPTOR_THROW (
-              CORBA::MARSHAL ()
-            );
-            
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK;
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)
-              );
-              
-            }
-          
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK;
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK;
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  
-}
-
-CORBA::Short _TAO_FixedDef_Remote_Proxy_Impl::scale (
-    CORBA_Object *_collocated_tao_target_,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  
-  CORBA::Short _tao_retval = 0;
-  
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), _tao_retval);
-
-  
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_get_scale",
-      10,
-      0,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_FixedDef::TAO_ClientRequestInfo_IR_FixedDef_scale_get ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN  (_tao_retval);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                _tao_retval
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_retval)
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                _tao_retval
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              CORBA::Short  _tao_retval_info = _tao_retval;
-               ri.result (_tao_retval_info);
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN  (_tao_retval);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_retval;
-}
-
-void _TAO_FixedDef_Remote_Proxy_Impl::scale (
-    CORBA_Object *_collocated_tao_target_,
-    CORBA::Short scale,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW (CORBA::INTERNAL ());
-
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_set_scale",
-      10,
-      1,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_FixedDef::TAO_ClientRequestInfo_IR_FixedDef_scale_set ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        scale,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK;
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK;
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK;
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK;
-          
-          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-          if (!(
-                            (_tao_out << scale)
-            ))
-            TAO_INTERCEPTOR_THROW (
-              CORBA::MARSHAL ()
-            );
-            
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK;
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)
-              );
-              
-            }
-          
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK;
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK;
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  
-}
-
-
-//
-//            End  Base & Remote  Proxy Implemeentation. 
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//           Remote & Base  Proxy Broker Implementation
-//
-
-_TAO_FixedDef_Proxy_Broker::_TAO_FixedDef_Proxy_Broker (void)
-{
-}
-
-_TAO_FixedDef_Proxy_Broker::~_TAO_FixedDef_Proxy_Broker (void)
-{
-}
-
-_TAO_FixedDef_Proxy_Broker * (*_TAO_FixedDef_Proxy_Broker_Factory_function_pointer) (
-    CORBA::Object_ptr obj
-  ) = 0;
-
-// Factory Member function Implementation.
-_TAO_FixedDef_Remote_Proxy_Broker *
-_TAO_FixedDef_Remote_Proxy_Broker::the_TAO_FixedDef_Remote_Proxy_Broker (void)
-{
-  static ::_TAO_FixedDef_Remote_Proxy_Broker remote_proxy_broker;
-  return &remote_proxy_broker;
-}
-
-_TAO_FixedDef_Remote_Proxy_Broker::_TAO_FixedDef_Remote_Proxy_Broker (void)
-{
-}
-
-_TAO_FixedDef_Remote_Proxy_Broker::~_TAO_FixedDef_Remote_Proxy_Broker (void)
-{
-}
-
-_TAO_FixedDef_Proxy_Impl&
-_TAO_FixedDef_Remote_Proxy_Broker::select_proxy (
-  ::IR_FixedDef *object,
-  CORBA::Environment &ACE_TRY_ENV
-)
-{
-  ACE_UNUSED_ARG (object);
-  ACE_UNUSED_ARG (ACE_TRY_ENV);
-  return remote_proxy_impl_;
-}
-
-
-//
-//           End Remote & Base Proxy Broker Implementation
-///////////////////////////////////////////////////////////////////////
-
-
-// default constructor
-IR_FixedDef::IR_FixedDef (int collocated)
-{
-  this->IR_FixedDef_setup_collocation (collocated);
-}
-
-// destructor
-IR_FixedDef::~IR_FixedDef (void)
-{}
-
-void
-IR_FixedDef::IR_FixedDef_setup_collocation (int collocated)
-{
-  if (collocated)
-    this->the_TAO_FixedDef_Proxy_Broker_ =
-      _TAO_FixedDef_Proxy_Broker_Factory_function_pointer (this);
-  else
-    this->the_TAO_FixedDef_Proxy_Broker_ =
-      _TAO_FixedDef_Remote_Proxy_Broker::the_TAO_FixedDef_Remote_Proxy_Broker ();
-  
-  this->IR_IDLType_setup_collocation (collocated); 
-}
-
-void IR_FixedDef::_tao_any_destructor (void *x)
-{
-  IR_FixedDef *tmp = ACE_static_cast (IR_FixedDef*,x);
-  CORBA::release (tmp);
-}
-
-IR_FixedDef_ptr IR_FixedDef::_narrow (
-    CORBA::Object_ptr obj,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  if (CORBA::is_nil (obj))
-    return IR_FixedDef::_nil ();
-  if (! obj->_is_local ())
-    {
-      CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/IR/FixedDef:1.0", ACE_TRY_ENV);
-      ACE_CHECK_RETURN (IR_FixedDef::_nil ());
-      if (is_a == 0)
-        return IR_FixedDef::_nil ();
-    }
-  return IR_FixedDef::_unchecked_narrow (obj, ACE_TRY_ENV);
-}
-
-IR_FixedDef_ptr IR_FixedDef::_unchecked_narrow (
-    CORBA::Object_ptr obj,
-    CORBA::Environment &
-  )
-{
-  if (CORBA::is_nil (obj))
-    return IR_FixedDef::_nil ();
-  if (! obj->_is_local ())
-    {
-      TAO_Stub* stub = obj->_stubobj ();
-      if (stub)
-        stub->_incr_refcnt ();
-      IR_FixedDef_ptr default_proxy = IR_FixedDef::_nil ();
-
-      if (
-          !CORBA::is_nil (stub->servant_orb_var ().ptr ()) &&
-          stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects () &&
-          obj->_is_collocated () &&_TAO_FixedDef_Proxy_Broker_Factory_function_pointer != 0
-        )
-      {
-        ACE_NEW_RETURN (
-          default_proxy,
-          ::IR_FixedDef (
-            stub,
-            1,
-            obj->_servant ()),
-            
-          IR_FixedDef::_nil ());
-        }
-      if (CORBA::is_nil (default_proxy))
-        ACE_NEW_RETURN (default_proxy, ::IR_FixedDef (stub, 0, obj->_servant ()), IR_FixedDef::_nil ());
-        return default_proxy;
-      }
-    else 
-      return
-        ACE_reinterpret_cast
-          (
-            IR_FixedDef_ptr,
-              obj->_tao_QueryInterface
-                (
-                  ACE_reinterpret_cast
-                    (
-                      ptr_arith_t,
-                      &IR_FixedDef::_narrow
-                    )
-                )
-          );
-}
-
-IR_FixedDef_ptr
-IR_FixedDef::_duplicate (IR_FixedDef_ptr obj)
-{
-  if (!CORBA::is_nil (obj))
-    obj->_add_ref ();
-  return obj;
-}
-
-CORBA::Boolean IR_FixedDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
-{
-  if (
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/FixedDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/IDLType:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
-  return 1; // success using local knowledge
-  else
-    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
-}
-
-void *IR_FixedDef::_tao_QueryInterface (ptr_arith_t type)
-{
-  void *retv = 0;
-  if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_FixedDef::_narrow))
-    retv = ACE_reinterpret_cast (void*, this);
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_IDLType::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            IR_IDLType_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &CORBA_IRObject::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            CORBA_IRObject_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
-    retv = ACE_reinterpret_cast (void *,
-      ACE_static_cast (CORBA::Object_ptr, this));
-    
-  if (retv)
-    this->_add_ref ();
-  return retv;
-}
-
-const char* IR_FixedDef::_interface_repository_id (void) const
-{
-  return "IDL:omg.org/IR/FixedDef:1.0";
-}
-
-CORBA::UShort IR_FixedDef::digits (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_FixedDef_Proxy_Impl &proxy = 
-    this->the_TAO_FixedDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.digits (
-      this,
-      ACE_TRY_ENV
-    );
-}
-
-void IR_FixedDef::digits (
-    CORBA::UShort digits,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_FixedDef_Proxy_Impl &proxy = 
-    this->the_TAO_FixedDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK;
-  
-  proxy.digits (
-      this,
-      digits,
-      ACE_TRY_ENV
-    );
-}
-
-CORBA::Short IR_FixedDef::scale (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_FixedDef_Proxy_Impl &proxy = 
-    this->the_TAO_FixedDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.scale (
-      this,
-      ACE_TRY_ENV
-    );
-}
-
-void IR_FixedDef::scale (
-    CORBA::Short scale,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_FixedDef_Proxy_Impl &proxy = 
-    this->the_TAO_FixedDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK;
-  
-  proxy.scale (
-      this,
-      scale,
-      ACE_TRY_ENV
-    );
-}
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-IR_FixedDef::TAO_ClientRequestInfo_IR_FixedDef_digits_get::TAO_ClientRequestInfo_IR_FixedDef_digits_get (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
-{}
-
-Dynamic::ParameterList *
-IR_FixedDef::TAO_ClientRequestInfo_IR_FixedDef_digits_get::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return parameter_list;
-}
-
-Dynamic::ExceptionList *
-IR_FixedDef::TAO_ClientRequestInfo_IR_FixedDef_digits_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_FixedDef::TAO_ClientRequestInfo_IR_FixedDef_digits_get::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_FixedDef::TAO_ClientRequestInfo_IR_FixedDef_digits_get::result (CORBA::UShort result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_FixedDef::TAO_ClientRequestInfo_IR_FixedDef_digits_set::TAO_ClientRequestInfo_IR_FixedDef_digits_set (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    const CORBA::UShort & digits,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
-    digits_ (digits)
-{}
-
-Dynamic::ParameterList *
-IR_FixedDef::TAO_ClientRequestInfo_IR_FixedDef_digits_set::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
-    
-  CORBA::ULong length_digits = parameter_list->length ();
-  parameter_list->length (length_digits + 1);
-  (*parameter_list)[length_digits].argument <<= digits_;
-  (*parameter_list)[length_digits].mode = Dynamic::PARAM_IN;
-  
-  return safe_parameter_list._retn ();
-}
-
-Dynamic::ExceptionList *
-IR_FixedDef::TAO_ClientRequestInfo_IR_FixedDef_digits_set::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_FixedDef::TAO_ClientRequestInfo_IR_FixedDef_digits_set::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 1;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return result_any;
-}
-
-IR_FixedDef::TAO_ClientRequestInfo_IR_FixedDef_scale_get::TAO_ClientRequestInfo_IR_FixedDef_scale_get (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
-{}
-
-Dynamic::ParameterList *
-IR_FixedDef::TAO_ClientRequestInfo_IR_FixedDef_scale_get::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return parameter_list;
-}
-
-Dynamic::ExceptionList *
-IR_FixedDef::TAO_ClientRequestInfo_IR_FixedDef_scale_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_FixedDef::TAO_ClientRequestInfo_IR_FixedDef_scale_get::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_FixedDef::TAO_ClientRequestInfo_IR_FixedDef_scale_get::result (CORBA::Short result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_FixedDef::TAO_ClientRequestInfo_IR_FixedDef_scale_set::TAO_ClientRequestInfo_IR_FixedDef_scale_set (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    const CORBA::Short & scale,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
-    scale_ (scale)
-{}
-
-Dynamic::ParameterList *
-IR_FixedDef::TAO_ClientRequestInfo_IR_FixedDef_scale_set::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
-    
-  CORBA::ULong length_scale = parameter_list->length ();
-  parameter_list->length (length_scale + 1);
-  (*parameter_list)[length_scale].argument <<= scale_;
-  (*parameter_list)[length_scale].mode = Dynamic::PARAM_IN;
-  
-  return safe_parameter_list._retn ();
-}
-
-Dynamic::ExceptionList *
-IR_FixedDef::TAO_ClientRequestInfo_IR_FixedDef_scale_set::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_FixedDef::TAO_ClientRequestInfo_IR_FixedDef_scale_set::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 1;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return result_any;
-}
-
-#endif /* TAO_HAS_INTERCEPTORS */
-
-static const CORBA::Long _oc_IR_FixedDef[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  28, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f46), ACE_NTOHL (0x69786564), ACE_NTOHL (0x4465663a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/FixedDef:1.0
-  9, ACE_NTOHL (0x46697865), ACE_NTOHL (0x64446566), ACE_NTOHL (0x0),  // name = IR_FixedDef
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_FixedDef (CORBA::tk_objref, sizeof (_oc_IR_FixedDef), (char *) &_oc_IR_FixedDef, 0, sizeof (IR_FixedDef));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_FixedDef, &_tc_TAO_tc_IR_FixedDef)
-TAO_NAMESPACE_END
-
-///////////////////////////////////////////////////////////////////////
-//                Base & Remote Proxy  Implementation. 
-//
-
-_TAO_SequenceDef_Proxy_Impl::_TAO_SequenceDef_Proxy_Impl (void)
-{}
-
-_TAO_SequenceDef_Remote_Proxy_Impl::_TAO_SequenceDef_Remote_Proxy_Impl (void)
-{}
-
-// Remote Implementation of the IDL interface methods
-
-CORBA::ULong _TAO_SequenceDef_Remote_Proxy_Impl::bound (
-    CORBA_Object *_collocated_tao_target_,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  
-  CORBA::ULong _tao_retval = 0;
-  
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), _tao_retval);
-
-  
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_get_bound",
-      10,
-      0,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_SequenceDef::TAO_ClientRequestInfo_IR_SequenceDef_bound_get ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN  (_tao_retval);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                _tao_retval
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_retval)
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                _tao_retval
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              CORBA::ULong  _tao_retval_info = _tao_retval;
-               ri.result (_tao_retval_info);
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN  (_tao_retval);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_retval;
-}
-
-void _TAO_SequenceDef_Remote_Proxy_Impl::bound (
-    CORBA_Object *_collocated_tao_target_,
-    CORBA::ULong bound,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW (CORBA::INTERNAL ());
-
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_set_bound",
-      10,
-      1,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_SequenceDef::TAO_ClientRequestInfo_IR_SequenceDef_bound_set ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        bound,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK;
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK;
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK;
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK;
-          
-          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-          if (!(
-                            (_tao_out << bound)
-            ))
-            TAO_INTERCEPTOR_THROW (
-              CORBA::MARSHAL ()
-            );
-            
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK;
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)
-              );
-              
-            }
-          
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK;
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK;
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  
-}
-
-CORBA::TypeCode_ptr _TAO_SequenceDef_Remote_Proxy_Impl::element_type (
-    CORBA_Object *_collocated_tao_target_,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  
-  CORBA::TypeCode_ptr _tao_retval = CORBA::TypeCode::_nil ();
-  CORBA::TypeCode_var _tao_safe_retval (_tao_retval);
-  
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-
-  
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_get_element_type",
-      17,
-      0,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_SequenceDef::TAO_ClientRequestInfo_IR_SequenceDef_element_type_get ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              CORBA::TypeCode_ptr _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-IR_IDLType_ptr _TAO_SequenceDef_Remote_Proxy_Impl::element_type_def (
-    CORBA_Object *_collocated_tao_target_,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  
-  IR_IDLType_ptr _tao_retval = IR_IDLType::_nil ();
-  IR_IDLType_var _tao_safe_retval (_tao_retval);
-  
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-
-  
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_get_element_type_def",
-      21,
-      0,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_SequenceDef::TAO_ClientRequestInfo_IR_SequenceDef_element_type_def_get ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              IR_IDLType_ptr _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-void _TAO_SequenceDef_Remote_Proxy_Impl::element_type_def (
-    CORBA_Object *_collocated_tao_target_,
-    IR_IDLType_ptr element_type_def,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW (CORBA::INTERNAL ());
-
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_set_element_type_def",
-      21,
-      1,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_SequenceDef::TAO_ClientRequestInfo_IR_SequenceDef_element_type_def_set ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        element_type_def,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK;
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK;
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK;
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK;
-          
-          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-          if (!(
-                            (_tao_out << element_type_def)
-            ))
-            TAO_INTERCEPTOR_THROW (
-              CORBA::MARSHAL ()
-            );
-            
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK;
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)
-              );
-              
-            }
-          
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK;
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK;
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  
-}
-
-
-//
-//            End  Base & Remote  Proxy Implemeentation. 
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//           Remote & Base  Proxy Broker Implementation
-//
-
-_TAO_SequenceDef_Proxy_Broker::_TAO_SequenceDef_Proxy_Broker (void)
-{
-}
-
-_TAO_SequenceDef_Proxy_Broker::~_TAO_SequenceDef_Proxy_Broker (void)
-{
-}
-
-_TAO_SequenceDef_Proxy_Broker * (*_TAO_SequenceDef_Proxy_Broker_Factory_function_pointer) (
-    CORBA::Object_ptr obj
-  ) = 0;
-
-// Factory Member function Implementation.
-_TAO_SequenceDef_Remote_Proxy_Broker *
-_TAO_SequenceDef_Remote_Proxy_Broker::the_TAO_SequenceDef_Remote_Proxy_Broker (void)
-{
-  static ::_TAO_SequenceDef_Remote_Proxy_Broker remote_proxy_broker;
-  return &remote_proxy_broker;
-}
-
-_TAO_SequenceDef_Remote_Proxy_Broker::_TAO_SequenceDef_Remote_Proxy_Broker (void)
-{
-}
-
-_TAO_SequenceDef_Remote_Proxy_Broker::~_TAO_SequenceDef_Remote_Proxy_Broker (void)
-{
-}
-
-_TAO_SequenceDef_Proxy_Impl&
-_TAO_SequenceDef_Remote_Proxy_Broker::select_proxy (
-  ::IR_SequenceDef *object,
-  CORBA::Environment &ACE_TRY_ENV
-)
-{
-  ACE_UNUSED_ARG (object);
-  ACE_UNUSED_ARG (ACE_TRY_ENV);
-  return remote_proxy_impl_;
-}
-
-
-//
-//           End Remote & Base Proxy Broker Implementation
-///////////////////////////////////////////////////////////////////////
-
-
-// default constructor
-IR_SequenceDef::IR_SequenceDef (int collocated)
-{
-  this->IR_SequenceDef_setup_collocation (collocated);
-}
-
-// destructor
-IR_SequenceDef::~IR_SequenceDef (void)
-{}
-
-void
-IR_SequenceDef::IR_SequenceDef_setup_collocation (int collocated)
-{
-  if (collocated)
-    this->the_TAO_SequenceDef_Proxy_Broker_ =
-      _TAO_SequenceDef_Proxy_Broker_Factory_function_pointer (this);
-  else
-    this->the_TAO_SequenceDef_Proxy_Broker_ =
-      _TAO_SequenceDef_Remote_Proxy_Broker::the_TAO_SequenceDef_Remote_Proxy_Broker ();
-  
-  this->IR_IDLType_setup_collocation (collocated);
-}
-
-void IR_SequenceDef::_tao_any_destructor (void *x)
-{
-  IR_SequenceDef *tmp = ACE_static_cast (IR_SequenceDef*,x);
-  CORBA::release (tmp);
-}
-
-IR_SequenceDef_ptr IR_SequenceDef::_narrow (
-    CORBA::Object_ptr obj,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  if (CORBA::is_nil (obj))
-    return IR_SequenceDef::_nil ();
-  if (! obj->_is_local ())
-    {
-      CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/IR/SequenceDef:1.0", ACE_TRY_ENV);
-      ACE_CHECK_RETURN (IR_SequenceDef::_nil ());
-      if (is_a == 0)
-        return IR_SequenceDef::_nil ();
-    }
-  return IR_SequenceDef::_unchecked_narrow (obj, ACE_TRY_ENV);
-}
-
-IR_SequenceDef_ptr IR_SequenceDef::_unchecked_narrow (
-    CORBA::Object_ptr obj,
-    CORBA::Environment &
-  )
-{
-  if (CORBA::is_nil (obj))
-    return IR_SequenceDef::_nil ();
-  if (! obj->_is_local ())
-    {
-      TAO_Stub* stub = obj->_stubobj ();
-      if (stub)
-        stub->_incr_refcnt ();
-      IR_SequenceDef_ptr default_proxy = IR_SequenceDef::_nil ();
-
-      if (
-          !CORBA::is_nil (stub->servant_orb_var ().ptr ()) &&
-          stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects () &&
-          obj->_is_collocated () &&_TAO_SequenceDef_Proxy_Broker_Factory_function_pointer != 0
-        )
-      {
-        ACE_NEW_RETURN (
-          default_proxy,
-          ::IR_SequenceDef (
-            stub,
-            1,
-            obj->_servant ()),
-            
-          IR_SequenceDef::_nil ());
-        }
-      if (CORBA::is_nil (default_proxy))
-        ACE_NEW_RETURN (default_proxy, ::IR_SequenceDef (stub, 0, obj->_servant ()), IR_SequenceDef::_nil ());
-        return default_proxy;
-      }
-    else 
-      return
-        ACE_reinterpret_cast
-          (
-            IR_SequenceDef_ptr,
-              obj->_tao_QueryInterface
-                (
-                  ACE_reinterpret_cast
-                    (
-                      ptr_arith_t,
-                      &IR_SequenceDef::_narrow
-                    )
-                )
-          );
-}
-
-IR_SequenceDef_ptr
-IR_SequenceDef::_duplicate (IR_SequenceDef_ptr obj)
-{
-  if (!CORBA::is_nil (obj))
-    obj->_add_ref ();
-  return obj;
-}
-
-CORBA::Boolean IR_SequenceDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
-{
-  if (
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/SequenceDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/IDLType:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
-  return 1; // success using local knowledge
-  else
-    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
-}
-
-void *IR_SequenceDef::_tao_QueryInterface (ptr_arith_t type)
-{
-  void *retv = 0;
-  if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_SequenceDef::_narrow))
-    retv = ACE_reinterpret_cast (void*, this);
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_IDLType::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            IR_IDLType_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &CORBA_IRObject::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            CORBA_IRObject_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
-    retv = ACE_reinterpret_cast (void *,
-      ACE_static_cast (CORBA::Object_ptr, this));
-    
-  if (retv)
-    this->_add_ref ();
-  return retv;
-}
-
-const char* IR_SequenceDef::_interface_repository_id (void) const
-{
-  return "IDL:omg.org/IR/SequenceDef:1.0";
-}
-
-CORBA::ULong IR_SequenceDef::bound (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_SequenceDef_Proxy_Impl &proxy = 
-    this->the_TAO_SequenceDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.bound (
-      this,
-      ACE_TRY_ENV
-    );
-}
-
-void IR_SequenceDef::bound (
-    CORBA::ULong bound,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_SequenceDef_Proxy_Impl &proxy = 
-    this->the_TAO_SequenceDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK;
-  
-  proxy.bound (
-      this,
-      bound,
-      ACE_TRY_ENV
-    );
-}
-
-CORBA::TypeCode_ptr IR_SequenceDef::element_type (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_SequenceDef_Proxy_Impl &proxy = 
-    this->the_TAO_SequenceDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.element_type (
-      this,
-      ACE_TRY_ENV
-    );
-}
-
-IR_IDLType_ptr IR_SequenceDef::element_type_def (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_SequenceDef_Proxy_Impl &proxy = 
-    this->the_TAO_SequenceDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.element_type_def (
-      this,
-      ACE_TRY_ENV
-    );
-}
-
-void IR_SequenceDef::element_type_def (
-    IR_IDLType_ptr element_type_def,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_SequenceDef_Proxy_Impl &proxy = 
-    this->the_TAO_SequenceDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK;
-  
-  proxy.element_type_def (
-      this,
-      element_type_def,
-      ACE_TRY_ENV
-    );
-}
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-IR_SequenceDef::TAO_ClientRequestInfo_IR_SequenceDef_bound_get::TAO_ClientRequestInfo_IR_SequenceDef_bound_get (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
-{}
-
-Dynamic::ParameterList *
-IR_SequenceDef::TAO_ClientRequestInfo_IR_SequenceDef_bound_get::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return parameter_list;
-}
-
-Dynamic::ExceptionList *
-IR_SequenceDef::TAO_ClientRequestInfo_IR_SequenceDef_bound_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_SequenceDef::TAO_ClientRequestInfo_IR_SequenceDef_bound_get::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_SequenceDef::TAO_ClientRequestInfo_IR_SequenceDef_bound_get::result (CORBA::ULong result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_SequenceDef::TAO_ClientRequestInfo_IR_SequenceDef_bound_set::TAO_ClientRequestInfo_IR_SequenceDef_bound_set (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    const CORBA::ULong & bound,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
-    bound_ (bound)
-{}
-
-Dynamic::ParameterList *
-IR_SequenceDef::TAO_ClientRequestInfo_IR_SequenceDef_bound_set::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
-    
-  CORBA::ULong length_bound = parameter_list->length ();
-  parameter_list->length (length_bound + 1);
-  (*parameter_list)[length_bound].argument <<= bound_;
-  (*parameter_list)[length_bound].mode = Dynamic::PARAM_IN;
-  
-  return safe_parameter_list._retn ();
-}
-
-Dynamic::ExceptionList *
-IR_SequenceDef::TAO_ClientRequestInfo_IR_SequenceDef_bound_set::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_SequenceDef::TAO_ClientRequestInfo_IR_SequenceDef_bound_set::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 1;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return result_any;
-}
-
-IR_SequenceDef::TAO_ClientRequestInfo_IR_SequenceDef_element_type_get::TAO_ClientRequestInfo_IR_SequenceDef_element_type_get (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
-{}
-
-Dynamic::ParameterList *
-IR_SequenceDef::TAO_ClientRequestInfo_IR_SequenceDef_element_type_get::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return parameter_list;
-}
-
-Dynamic::ExceptionList *
-IR_SequenceDef::TAO_ClientRequestInfo_IR_SequenceDef_element_type_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_SequenceDef::TAO_ClientRequestInfo_IR_SequenceDef_element_type_get::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_SequenceDef::TAO_ClientRequestInfo_IR_SequenceDef_element_type_get::result (CORBA::TypeCode_ptr result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_SequenceDef::TAO_ClientRequestInfo_IR_SequenceDef_element_type_def_get::TAO_ClientRequestInfo_IR_SequenceDef_element_type_def_get (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
-{}
-
-Dynamic::ParameterList *
-IR_SequenceDef::TAO_ClientRequestInfo_IR_SequenceDef_element_type_def_get::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return parameter_list;
-}
-
-Dynamic::ExceptionList *
-IR_SequenceDef::TAO_ClientRequestInfo_IR_SequenceDef_element_type_def_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_SequenceDef::TAO_ClientRequestInfo_IR_SequenceDef_element_type_def_get::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_SequenceDef::TAO_ClientRequestInfo_IR_SequenceDef_element_type_def_get::result (IR_IDLType_ptr result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_SequenceDef::TAO_ClientRequestInfo_IR_SequenceDef_element_type_def_set::TAO_ClientRequestInfo_IR_SequenceDef_element_type_def_set (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    IR_IDLType_ptr element_type_def,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
-    element_type_def_ (element_type_def)
-{}
-
-Dynamic::ParameterList *
-IR_SequenceDef::TAO_ClientRequestInfo_IR_SequenceDef_element_type_def_set::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
-    
-  CORBA::ULong length_element_type_def = parameter_list->length ();
-  parameter_list->length (length_element_type_def + 1);
-  (*parameter_list)[length_element_type_def].argument <<=  this->element_type_def_;
-  
-  (*parameter_list)[length_element_type_def].mode = Dynamic::PARAM_IN;
-  
-  return safe_parameter_list._retn ();
-}
-
-Dynamic::ExceptionList *
-IR_SequenceDef::TAO_ClientRequestInfo_IR_SequenceDef_element_type_def_set::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_SequenceDef::TAO_ClientRequestInfo_IR_SequenceDef_element_type_def_set::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 1;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return result_any;
-}
-
-#endif /* TAO_HAS_INTERCEPTORS */
-
-static const CORBA::Long _oc_IR_SequenceDef[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f53), ACE_NTOHL (0x65717565), ACE_NTOHL (0x6e636544), ACE_NTOHL (0x65663a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/SequenceDef:1.0
-  12, ACE_NTOHL (0x53657175), ACE_NTOHL (0x656e6365), ACE_NTOHL (0x44656600),  // name = IR_SequenceDef
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_SequenceDef (CORBA::tk_objref, sizeof (_oc_IR_SequenceDef), (char *) &_oc_IR_SequenceDef, 0, sizeof (IR_SequenceDef));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_SequenceDef, &_tc_TAO_tc_IR_SequenceDef)
-TAO_NAMESPACE_END
-
-///////////////////////////////////////////////////////////////////////
-//                Base & Remote Proxy  Implementation. 
-//
-
-_TAO_ArrayDef_Proxy_Impl::_TAO_ArrayDef_Proxy_Impl (void)
-{}
-
-_TAO_ArrayDef_Remote_Proxy_Impl::_TAO_ArrayDef_Remote_Proxy_Impl (void)
-{}
-
-// Remote Implementation of the IDL interface methods
-
-CORBA::ULong _TAO_ArrayDef_Remote_Proxy_Impl::length (
-    CORBA_Object *_collocated_tao_target_,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  
-  CORBA::ULong _tao_retval = 0;
-  
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), _tao_retval);
-
-  
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_get_length",
-      11,
-      0,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_ArrayDef::TAO_ClientRequestInfo_IR_ArrayDef_length_get ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN  (_tao_retval);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                _tao_retval
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_retval)
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                _tao_retval
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              CORBA::ULong  _tao_retval_info = _tao_retval;
-               ri.result (_tao_retval_info);
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN  (_tao_retval);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_retval;
-}
-
-void _TAO_ArrayDef_Remote_Proxy_Impl::length (
-    CORBA_Object *_collocated_tao_target_,
-    CORBA::ULong length,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW (CORBA::INTERNAL ());
-
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_set_length",
-      11,
-      1,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_ArrayDef::TAO_ClientRequestInfo_IR_ArrayDef_length_set ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        length,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK;
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK;
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK;
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK;
-          
-          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-          if (!(
-                            (_tao_out << length)
-            ))
-            TAO_INTERCEPTOR_THROW (
-              CORBA::MARSHAL ()
-            );
-            
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK;
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)
-              );
-              
-            }
-          
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK;
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK;
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  
-}
-
-CORBA::TypeCode_ptr _TAO_ArrayDef_Remote_Proxy_Impl::element_type (
-    CORBA_Object *_collocated_tao_target_,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  
-  CORBA::TypeCode_ptr _tao_retval = CORBA::TypeCode::_nil ();
-  CORBA::TypeCode_var _tao_safe_retval (_tao_retval);
-  
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-
-  
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_get_element_type",
-      17,
-      0,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_ArrayDef::TAO_ClientRequestInfo_IR_ArrayDef_element_type_get ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              CORBA::TypeCode_ptr _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-IR_IDLType_ptr _TAO_ArrayDef_Remote_Proxy_Impl::element_type_def (
-    CORBA_Object *_collocated_tao_target_,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  
-  IR_IDLType_ptr _tao_retval = IR_IDLType::_nil ();
-  IR_IDLType_var _tao_safe_retval (_tao_retval);
-  
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-
-  
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_get_element_type_def",
-      21,
-      0,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_ArrayDef::TAO_ClientRequestInfo_IR_ArrayDef_element_type_def_get ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              IR_IDLType_ptr _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-void _TAO_ArrayDef_Remote_Proxy_Impl::element_type_def (
-    CORBA_Object *_collocated_tao_target_,
-    IR_IDLType_ptr element_type_def,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW (CORBA::INTERNAL ());
-
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_set_element_type_def",
-      21,
-      1,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_ArrayDef::TAO_ClientRequestInfo_IR_ArrayDef_element_type_def_set ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        element_type_def,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK;
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK;
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK;
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK;
-          
-          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-          if (!(
-                            (_tao_out << element_type_def)
-            ))
-            TAO_INTERCEPTOR_THROW (
-              CORBA::MARSHAL ()
-            );
-            
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK;
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)
-              );
-              
-            }
-          
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK;
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK;
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  
-}
-
-
-//
-//            End  Base & Remote  Proxy Implemeentation. 
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//           Remote & Base  Proxy Broker Implementation
-//
-
-_TAO_ArrayDef_Proxy_Broker::_TAO_ArrayDef_Proxy_Broker (void)
-{
-}
-
-_TAO_ArrayDef_Proxy_Broker::~_TAO_ArrayDef_Proxy_Broker (void)
-{
-}
-
-_TAO_ArrayDef_Proxy_Broker * (*_TAO_ArrayDef_Proxy_Broker_Factory_function_pointer) (
-    CORBA::Object_ptr obj
-  ) = 0;
-
-// Factory Member function Implementation.
-_TAO_ArrayDef_Remote_Proxy_Broker *
-_TAO_ArrayDef_Remote_Proxy_Broker::the_TAO_ArrayDef_Remote_Proxy_Broker (void)
-{
-  static ::_TAO_ArrayDef_Remote_Proxy_Broker remote_proxy_broker;
-  return &remote_proxy_broker;
-}
-
-_TAO_ArrayDef_Remote_Proxy_Broker::_TAO_ArrayDef_Remote_Proxy_Broker (void)
-{
-}
-
-_TAO_ArrayDef_Remote_Proxy_Broker::~_TAO_ArrayDef_Remote_Proxy_Broker (void)
-{
-}
-
-_TAO_ArrayDef_Proxy_Impl&
-_TAO_ArrayDef_Remote_Proxy_Broker::select_proxy (
-  ::IR_ArrayDef *object,
-  CORBA::Environment &ACE_TRY_ENV
-)
-{
-  ACE_UNUSED_ARG (object);
-  ACE_UNUSED_ARG (ACE_TRY_ENV);
-  return remote_proxy_impl_;
-}
-
-
-//
-//           End Remote & Base Proxy Broker Implementation
-///////////////////////////////////////////////////////////////////////
-
-
-// default constructor
-IR_ArrayDef::IR_ArrayDef (int collocated)
-{
-  this->IR_ArrayDef_setup_collocation (collocated);
-}
-
-// destructor
-IR_ArrayDef::~IR_ArrayDef (void)
-{}
-
-void
-IR_ArrayDef::IR_ArrayDef_setup_collocation (int collocated)
-{
-  if (collocated)
-    this->the_TAO_ArrayDef_Proxy_Broker_ =
-      _TAO_ArrayDef_Proxy_Broker_Factory_function_pointer (this);
-  else
-    this->the_TAO_ArrayDef_Proxy_Broker_ =
-      _TAO_ArrayDef_Remote_Proxy_Broker::the_TAO_ArrayDef_Remote_Proxy_Broker ();
-  
-  this->IR_IDLType_setup_collocation (collocated);
-}
-
-void IR_ArrayDef::_tao_any_destructor (void *x)
-{
-  IR_ArrayDef *tmp = ACE_static_cast (IR_ArrayDef*,x);
-  CORBA::release (tmp);
-}
-
-IR_ArrayDef_ptr IR_ArrayDef::_narrow (
-    CORBA::Object_ptr obj,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  if (CORBA::is_nil (obj))
-    return IR_ArrayDef::_nil ();
-  if (! obj->_is_local ())
-    {
-      CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/IR/ArrayDef:1.0", ACE_TRY_ENV);
-      ACE_CHECK_RETURN (IR_ArrayDef::_nil ());
-      if (is_a == 0)
-        return IR_ArrayDef::_nil ();
-    }
-  return IR_ArrayDef::_unchecked_narrow (obj, ACE_TRY_ENV);
-}
-
-IR_ArrayDef_ptr IR_ArrayDef::_unchecked_narrow (
-    CORBA::Object_ptr obj,
-    CORBA::Environment &
-  )
-{
-  if (CORBA::is_nil (obj))
-    return IR_ArrayDef::_nil ();
-  if (! obj->_is_local ())
-    {
-      TAO_Stub* stub = obj->_stubobj ();
-      if (stub)
-        stub->_incr_refcnt ();
-      IR_ArrayDef_ptr default_proxy = IR_ArrayDef::_nil ();
-
-      if (
-          !CORBA::is_nil (stub->servant_orb_var ().ptr ()) &&
-          stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects () &&
-          obj->_is_collocated () &&_TAO_ArrayDef_Proxy_Broker_Factory_function_pointer != 0
-        )
-      {
-        ACE_NEW_RETURN (
-          default_proxy,
-          ::IR_ArrayDef (
-            stub,
-            1,
-            obj->_servant ()),
-            
-          IR_ArrayDef::_nil ());
-        }
-      if (CORBA::is_nil (default_proxy))
-        ACE_NEW_RETURN (default_proxy, ::IR_ArrayDef (stub, 0, obj->_servant ()), IR_ArrayDef::_nil ());
-        return default_proxy;
-      }
-    else 
-      return
-        ACE_reinterpret_cast
-          (
-            IR_ArrayDef_ptr,
-              obj->_tao_QueryInterface
-                (
-                  ACE_reinterpret_cast
-                    (
-                      ptr_arith_t,
-                      &IR_ArrayDef::_narrow
-                    )
-                )
-          );
-}
-
-IR_ArrayDef_ptr
-IR_ArrayDef::_duplicate (IR_ArrayDef_ptr obj)
-{
-  if (!CORBA::is_nil (obj))
-    obj->_add_ref ();
-  return obj;
-}
-
-CORBA::Boolean IR_ArrayDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
-{
-  if (
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/ArrayDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/IDLType:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
-  return 1; // success using local knowledge
-  else
-    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
-}
-
-void *IR_ArrayDef::_tao_QueryInterface (ptr_arith_t type)
-{
-  void *retv = 0;
-  if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_ArrayDef::_narrow))
-    retv = ACE_reinterpret_cast (void*, this);
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_IDLType::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            IR_IDLType_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &CORBA_IRObject::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            CORBA_IRObject_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
-    retv = ACE_reinterpret_cast (void *,
-      ACE_static_cast (CORBA::Object_ptr, this));
-    
-  if (retv)
-    this->_add_ref ();
-  return retv;
-}
-
-const char* IR_ArrayDef::_interface_repository_id (void) const
-{
-  return "IDL:omg.org/IR/ArrayDef:1.0";
-}
-
-CORBA::ULong IR_ArrayDef::length (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_ArrayDef_Proxy_Impl &proxy = 
-    this->the_TAO_ArrayDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.length (
-      this,
-      ACE_TRY_ENV
-    );
-}
-
-void IR_ArrayDef::length (
-    CORBA::ULong length,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_ArrayDef_Proxy_Impl &proxy = 
-    this->the_TAO_ArrayDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK;
-  
-  proxy.length (
-      this,
-      length,
-      ACE_TRY_ENV
-    );
-}
-
-CORBA::TypeCode_ptr IR_ArrayDef::element_type (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_ArrayDef_Proxy_Impl &proxy = 
-    this->the_TAO_ArrayDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.element_type (
-      this,
-      ACE_TRY_ENV
-    );
-}
-
-IR_IDLType_ptr IR_ArrayDef::element_type_def (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_ArrayDef_Proxy_Impl &proxy = 
-    this->the_TAO_ArrayDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.element_type_def (
-      this,
-      ACE_TRY_ENV
-    );
-}
-
-void IR_ArrayDef::element_type_def (
-    IR_IDLType_ptr element_type_def,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_ArrayDef_Proxy_Impl &proxy = 
-    this->the_TAO_ArrayDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK;
-  
-  proxy.element_type_def (
-      this,
-      element_type_def,
-      ACE_TRY_ENV
-    );
-}
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-IR_ArrayDef::TAO_ClientRequestInfo_IR_ArrayDef_length_get::TAO_ClientRequestInfo_IR_ArrayDef_length_get (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
-{}
-
-Dynamic::ParameterList *
-IR_ArrayDef::TAO_ClientRequestInfo_IR_ArrayDef_length_get::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return parameter_list;
-}
-
-Dynamic::ExceptionList *
-IR_ArrayDef::TAO_ClientRequestInfo_IR_ArrayDef_length_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_ArrayDef::TAO_ClientRequestInfo_IR_ArrayDef_length_get::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_ArrayDef::TAO_ClientRequestInfo_IR_ArrayDef_length_get::result (CORBA::ULong result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_ArrayDef::TAO_ClientRequestInfo_IR_ArrayDef_length_set::TAO_ClientRequestInfo_IR_ArrayDef_length_set (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    const CORBA::ULong & length,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
-    length_ (length)
-{}
-
-Dynamic::ParameterList *
-IR_ArrayDef::TAO_ClientRequestInfo_IR_ArrayDef_length_set::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
-    
-  CORBA::ULong length_length = parameter_list->length ();
-  parameter_list->length (length_length + 1);
-  (*parameter_list)[length_length].argument <<= length_;
-  (*parameter_list)[length_length].mode = Dynamic::PARAM_IN;
-  
-  return safe_parameter_list._retn ();
-}
-
-Dynamic::ExceptionList *
-IR_ArrayDef::TAO_ClientRequestInfo_IR_ArrayDef_length_set::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_ArrayDef::TAO_ClientRequestInfo_IR_ArrayDef_length_set::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 1;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return result_any;
-}
-
-IR_ArrayDef::TAO_ClientRequestInfo_IR_ArrayDef_element_type_get::TAO_ClientRequestInfo_IR_ArrayDef_element_type_get (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
-{}
-
-Dynamic::ParameterList *
-IR_ArrayDef::TAO_ClientRequestInfo_IR_ArrayDef_element_type_get::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return parameter_list;
-}
-
-Dynamic::ExceptionList *
-IR_ArrayDef::TAO_ClientRequestInfo_IR_ArrayDef_element_type_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_ArrayDef::TAO_ClientRequestInfo_IR_ArrayDef_element_type_get::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_ArrayDef::TAO_ClientRequestInfo_IR_ArrayDef_element_type_get::result (CORBA::TypeCode_ptr result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_ArrayDef::TAO_ClientRequestInfo_IR_ArrayDef_element_type_def_get::TAO_ClientRequestInfo_IR_ArrayDef_element_type_def_get (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
-{}
-
-Dynamic::ParameterList *
-IR_ArrayDef::TAO_ClientRequestInfo_IR_ArrayDef_element_type_def_get::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return parameter_list;
-}
-
-Dynamic::ExceptionList *
-IR_ArrayDef::TAO_ClientRequestInfo_IR_ArrayDef_element_type_def_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_ArrayDef::TAO_ClientRequestInfo_IR_ArrayDef_element_type_def_get::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_ArrayDef::TAO_ClientRequestInfo_IR_ArrayDef_element_type_def_get::result (IR_IDLType_ptr result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_ArrayDef::TAO_ClientRequestInfo_IR_ArrayDef_element_type_def_set::TAO_ClientRequestInfo_IR_ArrayDef_element_type_def_set (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    IR_IDLType_ptr element_type_def,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
-    element_type_def_ (element_type_def)
-{}
-
-Dynamic::ParameterList *
-IR_ArrayDef::TAO_ClientRequestInfo_IR_ArrayDef_element_type_def_set::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
-    
-  CORBA::ULong length_element_type_def = parameter_list->length ();
-  parameter_list->length (length_element_type_def + 1);
-  (*parameter_list)[length_element_type_def].argument <<=  this->element_type_def_;
-  
-  (*parameter_list)[length_element_type_def].mode = Dynamic::PARAM_IN;
-  
-  return safe_parameter_list._retn ();
-}
-
-Dynamic::ExceptionList *
-IR_ArrayDef::TAO_ClientRequestInfo_IR_ArrayDef_element_type_def_set::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_ArrayDef::TAO_ClientRequestInfo_IR_ArrayDef_element_type_def_set::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 1;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return result_any;
-}
-
-#endif /* TAO_HAS_INTERCEPTORS */
-
-static const CORBA::Long _oc_IR_ArrayDef[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  28, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f41), ACE_NTOHL (0x72726179), ACE_NTOHL (0x4465663a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ArrayDef:1.0
-  9, ACE_NTOHL (0x41727261), ACE_NTOHL (0x79446566), ACE_NTOHL (0x0),  // name = IR_ArrayDef
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_ArrayDef (CORBA::tk_objref, sizeof (_oc_IR_ArrayDef), (char *) &_oc_IR_ArrayDef, 0, sizeof (IR_ArrayDef));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ArrayDef, &_tc_TAO_tc_IR_ArrayDef)
-TAO_NAMESPACE_END
-
-///////////////////////////////////////////////////////////////////////
-//                Base & Remote Proxy  Implementation. 
-//
-
-_TAO_ExceptionDef_Proxy_Impl::_TAO_ExceptionDef_Proxy_Impl (void)
-{}
-
-_TAO_ExceptionDef_Remote_Proxy_Impl::_TAO_ExceptionDef_Remote_Proxy_Impl (void)
-{}
-
-// Remote Implementation of the IDL interface methods
-
-CORBA::TypeCode_ptr _TAO_ExceptionDef_Remote_Proxy_Impl::type (
-    CORBA_Object *_collocated_tao_target_,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  
-  CORBA::TypeCode_ptr _tao_retval = CORBA::TypeCode::_nil ();
-  CORBA::TypeCode_var _tao_safe_retval (_tao_retval);
-  
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-
-  
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_get_type",
-      9,
-      0,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_ExceptionDef::TAO_ClientRequestInfo_IR_ExceptionDef_type_get ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              CORBA::TypeCode_ptr _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-IR_StructMemberSeq * _TAO_ExceptionDef_Remote_Proxy_Impl::members (
-    CORBA_Object *_collocated_tao_target_,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  
-  IR_StructMemberSeq *_tao_retval = 0;
-  
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-
-  
-  ACE_NEW_RETURN (_tao_retval, IR_StructMemberSeq, _tao_retval);
-  IR_StructMemberSeq_var _tao_safe_retval (_tao_retval);
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_get_members",
-      12,
-      0,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_ExceptionDef::TAO_ClientRequestInfo_IR_ExceptionDef_members_get ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              IR_StructMemberSeq * _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-void _TAO_ExceptionDef_Remote_Proxy_Impl::members (
-    CORBA_Object *_collocated_tao_target_,
-    const IR_StructMemberSeq & members,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW (CORBA::INTERNAL ());
-
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_set_members",
-      12,
-      1,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_ExceptionDef::TAO_ClientRequestInfo_IR_ExceptionDef_members_set ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        members,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK;
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK;
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK;
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK;
-          
-          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-          if (!(
-                            (_tao_out << members)
-            ))
-            TAO_INTERCEPTOR_THROW (
-              CORBA::MARSHAL ()
-            );
-            
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK;
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)
-              );
-              
-            }
-          
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK;
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK;
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  
-}
-
-
-//
-//            End  Base & Remote  Proxy Implemeentation. 
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//           Remote & Base  Proxy Broker Implementation
-//
-
-_TAO_ExceptionDef_Proxy_Broker::_TAO_ExceptionDef_Proxy_Broker (void)
-{
-}
-
-_TAO_ExceptionDef_Proxy_Broker::~_TAO_ExceptionDef_Proxy_Broker (void)
-{
-}
-
-_TAO_ExceptionDef_Proxy_Broker * (*_TAO_ExceptionDef_Proxy_Broker_Factory_function_pointer) (
-    CORBA::Object_ptr obj
-  ) = 0;
-
-// Factory Member function Implementation.
-_TAO_ExceptionDef_Remote_Proxy_Broker *
-_TAO_ExceptionDef_Remote_Proxy_Broker::the_TAO_ExceptionDef_Remote_Proxy_Broker (void)
-{
-  static ::_TAO_ExceptionDef_Remote_Proxy_Broker remote_proxy_broker;
-  return &remote_proxy_broker;
-}
-
-_TAO_ExceptionDef_Remote_Proxy_Broker::_TAO_ExceptionDef_Remote_Proxy_Broker (void)
-{
-}
-
-_TAO_ExceptionDef_Remote_Proxy_Broker::~_TAO_ExceptionDef_Remote_Proxy_Broker (void)
-{
-}
-
-_TAO_ExceptionDef_Proxy_Impl&
-_TAO_ExceptionDef_Remote_Proxy_Broker::select_proxy (
-  ::IR_ExceptionDef *object,
-  CORBA::Environment &ACE_TRY_ENV
-)
-{
-  ACE_UNUSED_ARG (object);
-  ACE_UNUSED_ARG (ACE_TRY_ENV);
-  return remote_proxy_impl_;
-}
-
-
-//
-//           End Remote & Base Proxy Broker Implementation
-///////////////////////////////////////////////////////////////////////
-
-
-// default constructor
-IR_ExceptionDef::IR_ExceptionDef (int collocated)
-{
-  this->IR_ExceptionDef_setup_collocation (collocated);
-}
-
-// destructor
-IR_ExceptionDef::~IR_ExceptionDef (void)
-{}
-
-void
-IR_ExceptionDef::IR_ExceptionDef_setup_collocation (int collocated)
-{
-  if (collocated)
-    this->the_TAO_ExceptionDef_Proxy_Broker_ =
-      _TAO_ExceptionDef_Proxy_Broker_Factory_function_pointer (this);
-  else
-    this->the_TAO_ExceptionDef_Proxy_Broker_ =
-      _TAO_ExceptionDef_Remote_Proxy_Broker::the_TAO_ExceptionDef_Remote_Proxy_Broker ();
-  
-  this->IR_Contained_setup_collocation (collocated);
-  this->IR_Container_setup_collocation (collocated);
-}
-
-void IR_ExceptionDef::_tao_any_destructor (void *x)
-{
-  IR_ExceptionDef *tmp = ACE_static_cast (IR_ExceptionDef*,x);
-  CORBA::release (tmp);
-}
-
-IR_ExceptionDef_ptr IR_ExceptionDef::_narrow (
-    CORBA::Object_ptr obj,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  if (CORBA::is_nil (obj))
-    return IR_ExceptionDef::_nil ();
-  if (! obj->_is_local ())
-    {
-      CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/IR/ExceptionDef:1.0", ACE_TRY_ENV);
-      ACE_CHECK_RETURN (IR_ExceptionDef::_nil ());
-      if (is_a == 0)
-        return IR_ExceptionDef::_nil ();
-    }
-  return IR_ExceptionDef::_unchecked_narrow (obj, ACE_TRY_ENV);
-}
-
-IR_ExceptionDef_ptr IR_ExceptionDef::_unchecked_narrow (
-    CORBA::Object_ptr obj,
-    CORBA::Environment &
-  )
-{
-  if (CORBA::is_nil (obj))
-    return IR_ExceptionDef::_nil ();
-  if (! obj->_is_local ())
-    {
-      TAO_Stub* stub = obj->_stubobj ();
-      if (stub)
-        stub->_incr_refcnt ();
-      IR_ExceptionDef_ptr default_proxy = IR_ExceptionDef::_nil ();
-
-      if (
-          !CORBA::is_nil (stub->servant_orb_var ().ptr ()) &&
-          stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects () &&
-          obj->_is_collocated () &&_TAO_ExceptionDef_Proxy_Broker_Factory_function_pointer != 0
-        )
-      {
-        ACE_NEW_RETURN (
-          default_proxy,
-          ::IR_ExceptionDef (
-            stub,
-            1,
-            obj->_servant ()),
-            
-          IR_ExceptionDef::_nil ());
-        }
-      if (CORBA::is_nil (default_proxy))
-        ACE_NEW_RETURN (default_proxy, ::IR_ExceptionDef (stub, 0, obj->_servant ()), IR_ExceptionDef::_nil ());
-        return default_proxy;
-      }
-    else 
-      return
-        ACE_reinterpret_cast
-          (
-            IR_ExceptionDef_ptr,
-              obj->_tao_QueryInterface
-                (
-                  ACE_reinterpret_cast
-                    (
-                      ptr_arith_t,
-                      &IR_ExceptionDef::_narrow
-                    )
-                )
-          );
-}
-
-IR_ExceptionDef_ptr
-IR_ExceptionDef::_duplicate (IR_ExceptionDef_ptr obj)
-{
-  if (!CORBA::is_nil (obj))
-    obj->_add_ref ();
-  return obj;
-}
-
-CORBA::Boolean IR_ExceptionDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
-{
-  if (
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/ExceptionDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/Contained:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/Container:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
-  return 1; // success using local knowledge
-  else
-    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
-}
-
-void *IR_ExceptionDef::_tao_QueryInterface (ptr_arith_t type)
-{
-  void *retv = 0;
-  if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_ExceptionDef::_narrow))
-    retv = ACE_reinterpret_cast (void*, this);
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_Contained::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            IR_Contained_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_Container::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            IR_Container_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &CORBA_IRObject::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            CORBA_IRObject_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
-    retv = ACE_reinterpret_cast (void *,
-      ACE_static_cast (CORBA::Object_ptr, this));
-    
-  if (retv)
-    this->_add_ref ();
-  return retv;
-}
-
-const char* IR_ExceptionDef::_interface_repository_id (void) const
-{
-  return "IDL:omg.org/IR/ExceptionDef:1.0";
-}
-
-CORBA::TypeCode_ptr IR_ExceptionDef::type (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_ExceptionDef_Proxy_Impl &proxy = 
-    this->the_TAO_ExceptionDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.type (
-      this,
-      ACE_TRY_ENV
-    );
-}
-
-IR_StructMemberSeq * IR_ExceptionDef::members (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_ExceptionDef_Proxy_Impl &proxy = 
-    this->the_TAO_ExceptionDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.members (
-      this,
-      ACE_TRY_ENV
-    );
-}
-
-void IR_ExceptionDef::members (
-    const IR_StructMemberSeq & members,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_ExceptionDef_Proxy_Impl &proxy = 
-    this->the_TAO_ExceptionDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK;
-  
-  proxy.members (
-      this,
-      members,
-      ACE_TRY_ENV
-    );
-}
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-IR_ExceptionDef::TAO_ClientRequestInfo_IR_ExceptionDef_type_get::TAO_ClientRequestInfo_IR_ExceptionDef_type_get (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
-{}
-
-Dynamic::ParameterList *
-IR_ExceptionDef::TAO_ClientRequestInfo_IR_ExceptionDef_type_get::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return parameter_list;
-}
-
-Dynamic::ExceptionList *
-IR_ExceptionDef::TAO_ClientRequestInfo_IR_ExceptionDef_type_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_ExceptionDef::TAO_ClientRequestInfo_IR_ExceptionDef_type_get::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_ExceptionDef::TAO_ClientRequestInfo_IR_ExceptionDef_type_get::result (CORBA::TypeCode_ptr result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_ExceptionDef::TAO_ClientRequestInfo_IR_ExceptionDef_members_get::TAO_ClientRequestInfo_IR_ExceptionDef_members_get (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
-{}
-
-Dynamic::ParameterList *
-IR_ExceptionDef::TAO_ClientRequestInfo_IR_ExceptionDef_members_get::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return parameter_list;
-}
-
-Dynamic::ExceptionList *
-IR_ExceptionDef::TAO_ClientRequestInfo_IR_ExceptionDef_members_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_ExceptionDef::TAO_ClientRequestInfo_IR_ExceptionDef_members_get::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_ExceptionDef::TAO_ClientRequestInfo_IR_ExceptionDef_members_get::result (IR_StructMemberSeq * result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_ExceptionDef::TAO_ClientRequestInfo_IR_ExceptionDef_members_set::TAO_ClientRequestInfo_IR_ExceptionDef_members_set (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    const IR_StructMemberSeq & members,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
-    members_ (members)
-{}
-
-Dynamic::ParameterList *
-IR_ExceptionDef::TAO_ClientRequestInfo_IR_ExceptionDef_members_set::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
-    
-  CORBA::ULong length_members = parameter_list->length ();
-  parameter_list->length (length_members + 1);
-  (*parameter_list)[length_members].argument <<=  this->members_;
-  
-  (*parameter_list)[length_members].mode = Dynamic::PARAM_IN;
-  
-  return safe_parameter_list._retn ();
-}
-
-Dynamic::ExceptionList *
-IR_ExceptionDef::TAO_ClientRequestInfo_IR_ExceptionDef_members_set::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_ExceptionDef::TAO_ClientRequestInfo_IR_ExceptionDef_members_set::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 1;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return result_any;
-}
-
-#endif /* TAO_HAS_INTERCEPTORS */
-
-static const CORBA::Long _oc_IR_ExceptionDef[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x78636570), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x4465663a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ExceptionDef:1.0
-  13, ACE_NTOHL (0x45786365), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e446566), ACE_NTOHL (0x0),  // name = IR_ExceptionDef
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_ExceptionDef (CORBA::tk_objref, sizeof (_oc_IR_ExceptionDef), (char *) &_oc_IR_ExceptionDef, 0, sizeof (IR_ExceptionDef));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ExceptionDef, &_tc_TAO_tc_IR_ExceptionDef)
-TAO_NAMESPACE_END
-
-static const CORBA::Long _oc_IR_ExceptionDescription[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x78636570), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ExceptionDescription:1.0
-  21, ACE_NTOHL (0x45786365), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = ExceptionDescription
-  5, // member count
-  5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
-  CORBA::tk_alias, // typecode kind for typedefs
-  64, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
-    11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-    CORBA::tk_string, 
-    0U, // string length
-
-  3, ACE_NTOHL (0x69640000),  // name = id
-  CORBA::tk_alias, // typecode kind for typedefs
-  68, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-    13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-    CORBA::tk_string, 
-    0U, // string length
-
-  11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
-  CORBA::tk_alias, // typecode kind for typedefs
-  68, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-    13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-    CORBA::tk_string, 
-    0U, // string length
-
-  8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
-  CORBA::tk_alias, // typecode kind for typedefs
-  64, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
-    12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
-    CORBA::tk_string, 
-    0U, // string length
-
-  5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
-  CORBA::tk_TypeCode,
-
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_ExceptionDescription (CORBA::tk_struct, sizeof (_oc_IR_ExceptionDescription), (char *) &_oc_IR_ExceptionDescription, 0, sizeof (IR_ExceptionDescription));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ExceptionDescription, &_tc_TAO_tc_IR_ExceptionDescription)
-TAO_NAMESPACE_END
-
-void IR_ExceptionDescription::_tao_any_destructor (void *x)
-{
-  IR_ExceptionDescription *tmp = ACE_static_cast (IR_ExceptionDescription*,x);
-  delete tmp;
-}
-
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  
-  // The Base_Sequence functions, please see tao/Sequence.h
-  void
-  _TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq::_allocate_buffer (CORBA::ULong length)
-  {
-    IR_ExceptionDef **tmp = 0;
-    tmp = _TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq::allocbuf (length);
-    
-    if (this->buffer_ != 0)
-    {
-      IR_ExceptionDef **old = ACE_reinterpret_cast (IR_ExceptionDef**, this->buffer_);
-      for (CORBA::ULong i = 0; i < this->length_; ++i)
-        if (!this->release_)
-          tmp[i] = IR_ExceptionDef::_duplicate (old[i]);
-        else
-          tmp[i] = old[i];
-        
-      if (this->release_)
-        delete[] old;
-      
-    }
-    this->buffer_ = tmp;
-  }
-  
-  void
-  _TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq::_deallocate_buffer (void)
-  {
-    if (this->buffer_ == 0 || this->release_ == 0)
-      return;
-    IR_ExceptionDef **tmp = ACE_reinterpret_cast (IR_ExceptionDef**, this->buffer_);
-    for (CORBA::ULong i = 0; i < this->length_; ++i)
-    {
-      CORBA::release (tmp[i]);
-      tmp[i] = IR_ExceptionDef::_nil ();
-    }
-    _TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq::freebuf (tmp);
-    this->buffer_ = 0;
-  }
-  
-  _TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq::~_TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq (void)
-  {
-    this->_deallocate_buffer ();
-  }
-  
-  void
-  _TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq::_shrink_buffer (CORBA::ULong nl, CORBA::ULong ol)
-  {
-    IR_ExceptionDef **tmp = ACE_reinterpret_cast (IR_ExceptionDef**, this->buffer_);
-    
-    for (CORBA::ULong i = nl; i < ol; ++i)
-    {
-      CORBA::release (tmp[i]);
-      tmp[i] = IR_ExceptionDef::_nil ();
-    }
-  }
-  void 
-  _TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq::_downcast (
-      void* target,
-      CORBA_Object *src,
-      CORBA_Environment &ACE_TRY_ENV
-    )
-  {
-    IR_ExceptionDef **tmp = ACE_static_cast (IR_ExceptionDef**, target);
-    *tmp = IR_ExceptionDef::_narrow (src, ACE_TRY_ENV);
-  }
-
-  CORBA_Object*
-  _TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq::_upcast (void *src) const
-  {
-    IR_ExceptionDef **tmp = ACE_static_cast (IR_ExceptionDef**, src);
-    return *tmp;
-  }
-  
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
-
-// *************************************************************
-// IR_ExceptionDefSeq
-// *************************************************************
-
-IR_ExceptionDefSeq::IR_ExceptionDefSeq (void)
-{}
-IR_ExceptionDefSeq::IR_ExceptionDefSeq (CORBA::ULong max) // uses max size
-  : 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Object_Sequence<IR_ExceptionDef,IR_ExceptionDef_var>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
- (max)
-{}
-IR_ExceptionDefSeq::IR_ExceptionDefSeq (CORBA::ULong max, CORBA::ULong length, IR_ExceptionDef_ptr *buffer, CORBA::Boolean release)
-  : 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Object_Sequence<IR_ExceptionDef,IR_ExceptionDef_var>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
- (max, length, buffer, release)
-{}
-IR_ExceptionDefSeq::IR_ExceptionDefSeq (const IR_ExceptionDefSeq &seq) // copy ctor
-  : 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Object_Sequence<IR_ExceptionDef,IR_ExceptionDef_var>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
- (seq)
-{}
-IR_ExceptionDefSeq::~IR_ExceptionDefSeq (void) // dtor
-{}
-void IR_ExceptionDefSeq::_tao_any_destructor (void *x)
-{
-  IR_ExceptionDefSeq *tmp = ACE_static_cast (IR_ExceptionDefSeq*,x);
-  delete tmp;
-}
-
-static const CORBA::Long _oc_IR_ExceptionDefSeq[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x78636570), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x44656653), ACE_NTOHL (0x65713a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/ExceptionDefSeq:1.0
-  16, ACE_NTOHL (0x45786365), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e446566), ACE_NTOHL (0x53657100),  // name = ExceptionDefSeq
-  CORBA::tk_sequence, // typecode kind
-  76, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    CORBA::tk_objref, // typecode kind
-    60, // encapsulation length
-      TAO_ENCAP_BYTE_ORDER, // byte order
-      32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x78636570), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x4465663a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ExceptionDef:1.0
-      13, ACE_NTOHL (0x45786365), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e446566), ACE_NTOHL (0x0),  // name = IR_ExceptionDef
-
-    0U,
-
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_ExceptionDefSeq (CORBA::tk_alias, sizeof (_oc_IR_ExceptionDefSeq), (char *) &_oc_IR_ExceptionDefSeq, 0, sizeof (IR_ExceptionDefSeq));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ExceptionDefSeq, &_tc_TAO_tc_IR_ExceptionDefSeq)
-TAO_NAMESPACE_END
-
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  
-  void
-  _TAO_Unbounded_Sequence_IR_ExcDescriptionSeq::_allocate_buffer (CORBA::ULong length)
-  {
-    IR_ExceptionDescription* tmp = 0;
-    tmp = _TAO_Unbounded_Sequence_IR_ExcDescriptionSeq::allocbuf (length);
-    
-    if (this->buffer_ != 0)
-    {
-      IR_ExceptionDescription *old = ACE_reinterpret_cast (IR_ExceptionDescription *,this->buffer_);
-      
-      for (CORBA::ULong i = 0; i < this->length_; ++i)
-        tmp[i] = old[i];
-      
-      if (this->release_)
-        _TAO_Unbounded_Sequence_IR_ExcDescriptionSeq::freebuf (old);
-      
-    }
-    this->buffer_ = tmp;
-  }
-  
-  void
-  _TAO_Unbounded_Sequence_IR_ExcDescriptionSeq::_deallocate_buffer (void)
-  {
-    if (this->buffer_ == 0 || this->release_ == 0)
-      return;
-    
-    IR_ExceptionDescription *tmp = ACE_reinterpret_cast (IR_ExceptionDescription *,this->buffer_);
-    
-    _TAO_Unbounded_Sequence_IR_ExcDescriptionSeq::freebuf (tmp);
-    this->buffer_ = 0;
-  } 
-  
-  _TAO_Unbounded_Sequence_IR_ExcDescriptionSeq::~_TAO_Unbounded_Sequence_IR_ExcDescriptionSeq (void) // Dtor.
-  {
-    this->_deallocate_buffer ();
-  }
-  
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
-
-// *************************************************************
-// IR_ExcDescriptionSeq
-// *************************************************************
-
-IR_ExcDescriptionSeq::IR_ExcDescriptionSeq (void)
-{}
-IR_ExcDescriptionSeq::IR_ExcDescriptionSeq (CORBA::ULong max) // uses max size
-  : 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Sequence_IR_ExcDescriptionSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Sequence<IR_ExceptionDescription>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
- (max)
-{}
-IR_ExcDescriptionSeq::IR_ExcDescriptionSeq (CORBA::ULong max, CORBA::ULong length, IR_ExceptionDescription *buffer, CORBA::Boolean release)
-  : 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Sequence_IR_ExcDescriptionSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Sequence<IR_ExceptionDescription>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
- (max, length, buffer, release)
-{}
-IR_ExcDescriptionSeq::IR_ExcDescriptionSeq (const IR_ExcDescriptionSeq &seq) // copy ctor
-  : 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Sequence_IR_ExcDescriptionSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Sequence<IR_ExceptionDescription>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
- (seq)
-{}
-IR_ExcDescriptionSeq::~IR_ExcDescriptionSeq (void) // dtor
-{}
-void IR_ExcDescriptionSeq::_tao_any_destructor (void *x)
-{
-  IR_ExcDescriptionSeq *tmp = ACE_static_cast (IR_ExcDescriptionSeq*,x);
-  delete tmp;
-}
-
-static const CORBA::Long _oc_IR_ExcDescriptionSeq[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  37, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x78634465), ACE_NTOHL (0x73637269), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e536571), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/ExcDescriptionSeq:1.0
-  18, ACE_NTOHL (0x45786344), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e5365), ACE_NTOHL (0x71000000),  // name = ExcDescriptionSeq
-  CORBA::tk_sequence, // typecode kind
-  456, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    CORBA::tk_struct, // typecode kind
-    440, // encapsulation length
-      TAO_ENCAP_BYTE_ORDER, // byte order
-      40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x78636570), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ExceptionDescription:1.0
-      21, ACE_NTOHL (0x45786365), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = ExceptionDescription
-      5, // member count
-      5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
-      CORBA::tk_alias, // typecode kind for typedefs
-      64, // encapsulation length
-        TAO_ENCAP_BYTE_ORDER, // byte order
-        30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
-        11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-        CORBA::tk_string, 
-        0U, // string length
-
-      3, ACE_NTOHL (0x69640000),  // name = id
-      CORBA::tk_alias, // typecode kind for typedefs
-      68, // encapsulation length
-        TAO_ENCAP_BYTE_ORDER, // byte order
-        32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-        13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-        CORBA::tk_string, 
-        0U, // string length
-
-      11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
-      CORBA::tk_alias, // typecode kind for typedefs
-      68, // encapsulation length
-        TAO_ENCAP_BYTE_ORDER, // byte order
-        32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-        13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-        CORBA::tk_string, 
-        0U, // string length
-
-      8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
-      CORBA::tk_alias, // typecode kind for typedefs
-      64, // encapsulation length
-        TAO_ENCAP_BYTE_ORDER, // byte order
-        31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
-        12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
-        CORBA::tk_string, 
-        0U, // string length
-
-      5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
-      CORBA::tk_TypeCode,
-
-
-    0U,
-
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_ExcDescriptionSeq (CORBA::tk_alias, sizeof (_oc_IR_ExcDescriptionSeq), (char *) &_oc_IR_ExcDescriptionSeq, 0, sizeof (IR_ExcDescriptionSeq));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ExcDescriptionSeq, &_tc_TAO_tc_IR_ExcDescriptionSeq)
-TAO_NAMESPACE_END
-
-static const CORBA::Long _oc_IR_AttributeMode[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f41), ACE_NTOHL (0x74747269), ACE_NTOHL (0x62757465), ACE_NTOHL (0x4d6f6465), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/AttributeMode:1.0
-  14, ACE_NTOHL (0x41747472), ACE_NTOHL (0x69627574), ACE_NTOHL (0x654d6f64), ACE_NTOHL (0x65000000),  // name = AttributeMode
-  2, // member count
-  12, ACE_NTOHL (0x41545452), ACE_NTOHL (0x5f4e4f52), ACE_NTOHL (0x4d414c00),  // name = ATTR_NORMAL
-  14, ACE_NTOHL (0x41545452), ACE_NTOHL (0x5f524541), ACE_NTOHL (0x444f4e4c), ACE_NTOHL (0x59000000),  // name = ATTR_READONLY
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_AttributeMode (CORBA::tk_enum, sizeof (_oc_IR_AttributeMode), (char *) &_oc_IR_AttributeMode, 0, sizeof (IR_AttributeMode));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_AttributeMode, &_tc_TAO_tc_IR_AttributeMode)
-TAO_NAMESPACE_END
-
-///////////////////////////////////////////////////////////////////////
-//                Base & Remote Proxy  Implementation. 
-//
-
-_TAO_AttributeDef_Proxy_Impl::_TAO_AttributeDef_Proxy_Impl (void)
-{}
-
-_TAO_AttributeDef_Remote_Proxy_Impl::_TAO_AttributeDef_Remote_Proxy_Impl (void)
-{}
-
-// Remote Implementation of the IDL interface methods
-
-CORBA::TypeCode_ptr _TAO_AttributeDef_Remote_Proxy_Impl::type (
-    CORBA_Object *_collocated_tao_target_,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  
-  CORBA::TypeCode_ptr _tao_retval = CORBA::TypeCode::_nil ();
-  CORBA::TypeCode_var _tao_safe_retval (_tao_retval);
-  
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-
-  
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_get_type",
-      9,
-      0,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_AttributeDef::TAO_ClientRequestInfo_IR_AttributeDef_type_get ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              CORBA::TypeCode_ptr _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-IR_IDLType_ptr _TAO_AttributeDef_Remote_Proxy_Impl::type_def (
-    CORBA_Object *_collocated_tao_target_,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  
-  IR_IDLType_ptr _tao_retval = IR_IDLType::_nil ();
-  IR_IDLType_var _tao_safe_retval (_tao_retval);
-  
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-
-  
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_get_type_def",
-      13,
-      0,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_AttributeDef::TAO_ClientRequestInfo_IR_AttributeDef_type_def_get ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              IR_IDLType_ptr _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-void _TAO_AttributeDef_Remote_Proxy_Impl::type_def (
-    CORBA_Object *_collocated_tao_target_,
-    IR_IDLType_ptr type_def,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW (CORBA::INTERNAL ());
-
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_set_type_def",
-      13,
-      1,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_AttributeDef::TAO_ClientRequestInfo_IR_AttributeDef_type_def_set ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        type_def,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK;
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK;
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK;
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK;
-          
-          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-          if (!(
-                            (_tao_out << type_def)
-            ))
-            TAO_INTERCEPTOR_THROW (
-              CORBA::MARSHAL ()
-            );
-            
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK;
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)
-              );
-              
-            }
-          
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK;
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK;
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  
-}
-
-IR_AttributeMode _TAO_AttributeDef_Remote_Proxy_Impl::mode (
-    CORBA_Object *_collocated_tao_target_,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  
-  IR_AttributeMode _tao_retval = (IR_AttributeMode)0;
-  
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), _tao_retval);
-
-  
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_get_mode",
-      9,
-      0,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_AttributeDef::TAO_ClientRequestInfo_IR_AttributeDef_mode_get ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN  (_tao_retval);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                _tao_retval
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_retval)
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                _tao_retval
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              IR_AttributeMode  _tao_retval_info = _tao_retval;
-               ri.result (_tao_retval_info);
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN  (_tao_retval);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_retval;
-}
-
-void _TAO_AttributeDef_Remote_Proxy_Impl::mode (
-    CORBA_Object *_collocated_tao_target_,
-    IR_AttributeMode mode,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW (CORBA::INTERNAL ());
-
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_set_mode",
-      9,
-      1,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_AttributeDef::TAO_ClientRequestInfo_IR_AttributeDef_mode_set ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        mode,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK;
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK;
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK;
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK;
-          
-          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-          if (!(
-                            (_tao_out << mode)
-            ))
-            TAO_INTERCEPTOR_THROW (
-              CORBA::MARSHAL ()
-            );
-            
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK;
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)
-              );
-              
-            }
-          
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK;
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK;
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  
-}
-
-
-//
-//            End  Base & Remote  Proxy Implemeentation. 
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//           Remote & Base  Proxy Broker Implementation
-//
-
-_TAO_AttributeDef_Proxy_Broker::_TAO_AttributeDef_Proxy_Broker (void)
-{
-}
-
-_TAO_AttributeDef_Proxy_Broker::~_TAO_AttributeDef_Proxy_Broker (void)
-{
-}
-
-_TAO_AttributeDef_Proxy_Broker * (*_TAO_AttributeDef_Proxy_Broker_Factory_function_pointer) (
-    CORBA::Object_ptr obj
-  ) = 0;
-
-// Factory Member function Implementation.
-_TAO_AttributeDef_Remote_Proxy_Broker *
-_TAO_AttributeDef_Remote_Proxy_Broker::the_TAO_AttributeDef_Remote_Proxy_Broker (void)
-{
-  static ::_TAO_AttributeDef_Remote_Proxy_Broker remote_proxy_broker;
-  return &remote_proxy_broker;
-}
-
-_TAO_AttributeDef_Remote_Proxy_Broker::_TAO_AttributeDef_Remote_Proxy_Broker (void)
-{
-}
-
-_TAO_AttributeDef_Remote_Proxy_Broker::~_TAO_AttributeDef_Remote_Proxy_Broker (void)
-{
-}
-
-_TAO_AttributeDef_Proxy_Impl&
-_TAO_AttributeDef_Remote_Proxy_Broker::select_proxy (
-  ::IR_AttributeDef *object,
-  CORBA::Environment &ACE_TRY_ENV
-)
-{
-  ACE_UNUSED_ARG (object);
-  ACE_UNUSED_ARG (ACE_TRY_ENV);
-  return remote_proxy_impl_;
-}
-
-
-//
-//           End Remote & Base Proxy Broker Implementation
-///////////////////////////////////////////////////////////////////////
-
-
-// default constructor
-IR_AttributeDef::IR_AttributeDef (int collocated)
-{
-  this->IR_AttributeDef_setup_collocation (collocated);
-}
-
-// destructor
-IR_AttributeDef::~IR_AttributeDef (void)
-{}
-
-void
-IR_AttributeDef::IR_AttributeDef_setup_collocation (int collocated)
-{
-  if (collocated)
-    this->the_TAO_AttributeDef_Proxy_Broker_ =
-      _TAO_AttributeDef_Proxy_Broker_Factory_function_pointer (this);
-  else
-    this->the_TAO_AttributeDef_Proxy_Broker_ =
-      _TAO_AttributeDef_Remote_Proxy_Broker::the_TAO_AttributeDef_Remote_Proxy_Broker ();
-  
-  this->IR_Contained_setup_collocation (collocated);
-}
-
-void IR_AttributeDef::_tao_any_destructor (void *x)
-{
-  IR_AttributeDef *tmp = ACE_static_cast (IR_AttributeDef*,x);
-  CORBA::release (tmp);
-}
-
-IR_AttributeDef_ptr IR_AttributeDef::_narrow (
-    CORBA::Object_ptr obj,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  if (CORBA::is_nil (obj))
-    return IR_AttributeDef::_nil ();
-  if (! obj->_is_local ())
-    {
-      CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/IR/AttributeDef:1.0", ACE_TRY_ENV);
-      ACE_CHECK_RETURN (IR_AttributeDef::_nil ());
-      if (is_a == 0)
-        return IR_AttributeDef::_nil ();
-    }
-  return IR_AttributeDef::_unchecked_narrow (obj, ACE_TRY_ENV);
-}
-
-IR_AttributeDef_ptr IR_AttributeDef::_unchecked_narrow (
-    CORBA::Object_ptr obj,
-    CORBA::Environment &
-  )
-{
-  if (CORBA::is_nil (obj))
-    return IR_AttributeDef::_nil ();
-  if (! obj->_is_local ())
-    {
-      TAO_Stub* stub = obj->_stubobj ();
-      if (stub)
-        stub->_incr_refcnt ();
-      IR_AttributeDef_ptr default_proxy = IR_AttributeDef::_nil ();
-
-      if (
-          !CORBA::is_nil (stub->servant_orb_var ().ptr ()) &&
-          stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects () &&
-          obj->_is_collocated () &&_TAO_AttributeDef_Proxy_Broker_Factory_function_pointer != 0
-        )
-      {
-        ACE_NEW_RETURN (
-          default_proxy,
-          ::IR_AttributeDef (
-            stub,
-            1,
-            obj->_servant ()),
-            
-          IR_AttributeDef::_nil ());
-        }
-      if (CORBA::is_nil (default_proxy))
-        ACE_NEW_RETURN (default_proxy, ::IR_AttributeDef (stub, 0, obj->_servant ()), IR_AttributeDef::_nil ());
-        return default_proxy;
-      }
-    else 
-      return
-        ACE_reinterpret_cast
-          (
-            IR_AttributeDef_ptr,
-              obj->_tao_QueryInterface
-                (
-                  ACE_reinterpret_cast
-                    (
-                      ptr_arith_t,
-                      &IR_AttributeDef::_narrow
-                    )
-                )
-          );
-}
-
-IR_AttributeDef_ptr
-IR_AttributeDef::_duplicate (IR_AttributeDef_ptr obj)
-{
-  if (!CORBA::is_nil (obj))
-    obj->_add_ref ();
-  return obj;
-}
-
-CORBA::Boolean IR_AttributeDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
-{
-  if (
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/AttributeDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/Contained:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
-  return 1; // success using local knowledge
-  else
-    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
-}
-
-void *IR_AttributeDef::_tao_QueryInterface (ptr_arith_t type)
-{
-  void *retv = 0;
-  if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_AttributeDef::_narrow))
-    retv = ACE_reinterpret_cast (void*, this);
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_Contained::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            IR_Contained_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &CORBA_IRObject::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            CORBA_IRObject_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
-    retv = ACE_reinterpret_cast (void *,
-      ACE_static_cast (CORBA::Object_ptr, this));
-    
-  if (retv)
-    this->_add_ref ();
-  return retv;
-}
-
-const char* IR_AttributeDef::_interface_repository_id (void) const
-{
-  return "IDL:omg.org/IR/AttributeDef:1.0";
-}
-
-CORBA::TypeCode_ptr IR_AttributeDef::type (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_AttributeDef_Proxy_Impl &proxy = 
-    this->the_TAO_AttributeDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.type (
-      this,
-      ACE_TRY_ENV
-    );
-}
-
-IR_IDLType_ptr IR_AttributeDef::type_def (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_AttributeDef_Proxy_Impl &proxy = 
-    this->the_TAO_AttributeDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.type_def (
-      this,
-      ACE_TRY_ENV
-    );
-}
-
-void IR_AttributeDef::type_def (
-    IR_IDLType_ptr type_def,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_AttributeDef_Proxy_Impl &proxy = 
-    this->the_TAO_AttributeDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK;
-  
-  proxy.type_def (
-      this,
-      type_def,
-      ACE_TRY_ENV
-    );
-}
-
-IR_AttributeMode IR_AttributeDef::mode (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_AttributeDef_Proxy_Impl &proxy = 
-    this->the_TAO_AttributeDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN ((IR_AttributeMode)0);
-  
-  return proxy.mode (
-      this,
-      ACE_TRY_ENV
-    );
-}
-
-void IR_AttributeDef::mode (
-    IR_AttributeMode mode,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_AttributeDef_Proxy_Impl &proxy = 
-    this->the_TAO_AttributeDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK;
-  
-  proxy.mode (
-      this,
-      mode,
-      ACE_TRY_ENV
-    );
-}
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-IR_AttributeDef::TAO_ClientRequestInfo_IR_AttributeDef_type_get::TAO_ClientRequestInfo_IR_AttributeDef_type_get (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
-{}
-
-Dynamic::ParameterList *
-IR_AttributeDef::TAO_ClientRequestInfo_IR_AttributeDef_type_get::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return parameter_list;
-}
-
-Dynamic::ExceptionList *
-IR_AttributeDef::TAO_ClientRequestInfo_IR_AttributeDef_type_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_AttributeDef::TAO_ClientRequestInfo_IR_AttributeDef_type_get::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_AttributeDef::TAO_ClientRequestInfo_IR_AttributeDef_type_get::result (CORBA::TypeCode_ptr result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_AttributeDef::TAO_ClientRequestInfo_IR_AttributeDef_type_def_get::TAO_ClientRequestInfo_IR_AttributeDef_type_def_get (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
-{}
-
-Dynamic::ParameterList *
-IR_AttributeDef::TAO_ClientRequestInfo_IR_AttributeDef_type_def_get::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return parameter_list;
-}
-
-Dynamic::ExceptionList *
-IR_AttributeDef::TAO_ClientRequestInfo_IR_AttributeDef_type_def_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_AttributeDef::TAO_ClientRequestInfo_IR_AttributeDef_type_def_get::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_AttributeDef::TAO_ClientRequestInfo_IR_AttributeDef_type_def_get::result (IR_IDLType_ptr result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_AttributeDef::TAO_ClientRequestInfo_IR_AttributeDef_type_def_set::TAO_ClientRequestInfo_IR_AttributeDef_type_def_set (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    IR_IDLType_ptr type_def,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
-    type_def_ (type_def)
-{}
-
-Dynamic::ParameterList *
-IR_AttributeDef::TAO_ClientRequestInfo_IR_AttributeDef_type_def_set::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
-    
-  CORBA::ULong length_type_def = parameter_list->length ();
-  parameter_list->length (length_type_def + 1);
-  (*parameter_list)[length_type_def].argument <<=  this->type_def_;
-  
-  (*parameter_list)[length_type_def].mode = Dynamic::PARAM_IN;
-  
-  return safe_parameter_list._retn ();
-}
-
-Dynamic::ExceptionList *
-IR_AttributeDef::TAO_ClientRequestInfo_IR_AttributeDef_type_def_set::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_AttributeDef::TAO_ClientRequestInfo_IR_AttributeDef_type_def_set::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 1;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return result_any;
-}
-
-IR_AttributeDef::TAO_ClientRequestInfo_IR_AttributeDef_mode_get::TAO_ClientRequestInfo_IR_AttributeDef_mode_get (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
-{}
-
-Dynamic::ParameterList *
-IR_AttributeDef::TAO_ClientRequestInfo_IR_AttributeDef_mode_get::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return parameter_list;
-}
-
-Dynamic::ExceptionList *
-IR_AttributeDef::TAO_ClientRequestInfo_IR_AttributeDef_mode_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_AttributeDef::TAO_ClientRequestInfo_IR_AttributeDef_mode_get::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_AttributeDef::TAO_ClientRequestInfo_IR_AttributeDef_mode_get::result (IR_AttributeMode result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_AttributeDef::TAO_ClientRequestInfo_IR_AttributeDef_mode_set::TAO_ClientRequestInfo_IR_AttributeDef_mode_set (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    IR_AttributeMode & mode,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
-    mode_ (mode)
-{}
-
-Dynamic::ParameterList *
-IR_AttributeDef::TAO_ClientRequestInfo_IR_AttributeDef_mode_set::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
-    
-  CORBA::ULong length_mode = parameter_list->length ();
-  parameter_list->length (length_mode + 1);
-  (*parameter_list)[length_mode].argument <<=  this->mode_;
-  
-  (*parameter_list)[length_mode].mode = Dynamic::PARAM_IN;
-  
-  return safe_parameter_list._retn ();
-}
-
-Dynamic::ExceptionList *
-IR_AttributeDef::TAO_ClientRequestInfo_IR_AttributeDef_mode_set::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_AttributeDef::TAO_ClientRequestInfo_IR_AttributeDef_mode_set::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 1;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return result_any;
-}
-
-#endif /* TAO_HAS_INTERCEPTORS */
-
-static const CORBA::Long _oc_IR_AttributeDef[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f41), ACE_NTOHL (0x74747269), ACE_NTOHL (0x62757465), ACE_NTOHL (0x4465663a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/AttributeDef:1.0
-  13, ACE_NTOHL (0x41747472), ACE_NTOHL (0x69627574), ACE_NTOHL (0x65446566), ACE_NTOHL (0x0),  // name = IR_AttributeDef
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_AttributeDef (CORBA::tk_objref, sizeof (_oc_IR_AttributeDef), (char *) &_oc_IR_AttributeDef, 0, sizeof (IR_AttributeDef));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_AttributeDef, &_tc_TAO_tc_IR_AttributeDef)
-TAO_NAMESPACE_END
-
-static const CORBA::Long _oc_IR_AttributeDescription[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f41), ACE_NTOHL (0x74747269), ACE_NTOHL (0x62757465), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/AttributeDescription:1.0
-  21, ACE_NTOHL (0x41747472), ACE_NTOHL (0x69627574), ACE_NTOHL (0x65446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = AttributeDescription
-  8, // member count
-  5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
-  CORBA::tk_alias, // typecode kind for typedefs
-  64, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
-    11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-    CORBA::tk_string, 
-    0U, // string length
-
-  3, ACE_NTOHL (0x69640000),  // name = id
-  CORBA::tk_alias, // typecode kind for typedefs
-  68, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-    13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-    CORBA::tk_string, 
-    0U, // string length
-
-  11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
-  CORBA::tk_alias, // typecode kind for typedefs
-  68, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-    13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-    CORBA::tk_string, 
-    0U, // string length
-
-  8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
-  CORBA::tk_alias, // typecode kind for typedefs
-  64, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
-    12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
-    CORBA::tk_string, 
-    0U, // string length
-
-  5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
-  CORBA::tk_TypeCode,
-
-  5, ACE_NTOHL (0x6d6f6465), ACE_NTOHL (0x0),  // name = mode
-  CORBA::tk_enum, // typecode kind
-  104, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f41), ACE_NTOHL (0x74747269), ACE_NTOHL (0x62757465), ACE_NTOHL (0x4d6f6465), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/AttributeMode:1.0
-    14, ACE_NTOHL (0x41747472), ACE_NTOHL (0x69627574), ACE_NTOHL (0x654d6f64), ACE_NTOHL (0x65000000),  // name = AttributeMode
-    2, // member count
-    12, ACE_NTOHL (0x41545452), ACE_NTOHL (0x5f4e4f52), ACE_NTOHL (0x4d414c00),  // name = ATTR_NORMAL
-    14, ACE_NTOHL (0x41545452), ACE_NTOHL (0x5f524541), ACE_NTOHL (0x444f4e4c), ACE_NTOHL (0x59000000),  // name = ATTR_READONLY
-
-  15, ACE_NTOHL (0x6765745f), ACE_NTOHL (0x65786365), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e730000),  // name = get_exceptions
-  CORBA::tk_alias, // typecode kind for typedefs
-  536, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    37, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x78634465), ACE_NTOHL (0x73637269), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e536571), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/ExcDescriptionSeq:1.0
-    18, ACE_NTOHL (0x45786344), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e5365), ACE_NTOHL (0x71000000),  // name = ExcDescriptionSeq
-    CORBA::tk_sequence, // typecode kind
-    456, // encapsulation length
-      TAO_ENCAP_BYTE_ORDER, // byte order
-      CORBA::tk_struct, // typecode kind
-      440, // encapsulation length
-        TAO_ENCAP_BYTE_ORDER, // byte order
-        40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x78636570), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ExceptionDescription:1.0
-        21, ACE_NTOHL (0x45786365), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = ExceptionDescription
-        5, // member count
-        5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
-        CORBA::tk_alias, // typecode kind for typedefs
-        64, // encapsulation length
-          TAO_ENCAP_BYTE_ORDER, // byte order
-          30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
-          11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-          CORBA::tk_string, 
-          0U, // string length
-
-        3, ACE_NTOHL (0x69640000),  // name = id
-        CORBA::tk_alias, // typecode kind for typedefs
-        68, // encapsulation length
-          TAO_ENCAP_BYTE_ORDER, // byte order
-          32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-          13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-          CORBA::tk_string, 
-          0U, // string length
-
-        11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
-        CORBA::tk_alias, // typecode kind for typedefs
-        68, // encapsulation length
-          TAO_ENCAP_BYTE_ORDER, // byte order
-          32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-          13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-          CORBA::tk_string, 
-          0U, // string length
-
-        8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
-        CORBA::tk_alias, // typecode kind for typedefs
-        64, // encapsulation length
-          TAO_ENCAP_BYTE_ORDER, // byte order
-          31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
-          12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
-          CORBA::tk_string, 
-          0U, // string length
-
-        5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
-        CORBA::tk_TypeCode,
-
-
-      0U,
-
-
-  15, ACE_NTOHL (0x7075745f), ACE_NTOHL (0x65786365), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e730000),  // name = put_exceptions
-  CORBA::tk_alias, // typecode kind for typedefs
-  536, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    37, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x78634465), ACE_NTOHL (0x73637269), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e536571), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/ExcDescriptionSeq:1.0
-    18, ACE_NTOHL (0x45786344), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e5365), ACE_NTOHL (0x71000000),  // name = ExcDescriptionSeq
-    CORBA::tk_sequence, // typecode kind
-    456, // encapsulation length
-      TAO_ENCAP_BYTE_ORDER, // byte order
-      CORBA::tk_struct, // typecode kind
-      440, // encapsulation length
-        TAO_ENCAP_BYTE_ORDER, // byte order
-        40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x78636570), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ExceptionDescription:1.0
-        21, ACE_NTOHL (0x45786365), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = ExceptionDescription
-        5, // member count
-        5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
-        CORBA::tk_alias, // typecode kind for typedefs
-        64, // encapsulation length
-          TAO_ENCAP_BYTE_ORDER, // byte order
-          30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
-          11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-          CORBA::tk_string, 
-          0U, // string length
-
-        3, ACE_NTOHL (0x69640000),  // name = id
-        CORBA::tk_alias, // typecode kind for typedefs
-        68, // encapsulation length
-          TAO_ENCAP_BYTE_ORDER, // byte order
-          32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-          13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-          CORBA::tk_string, 
-          0U, // string length
-
-        11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
-        CORBA::tk_alias, // typecode kind for typedefs
-        68, // encapsulation length
-          TAO_ENCAP_BYTE_ORDER, // byte order
-          32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-          13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-          CORBA::tk_string, 
-          0U, // string length
-
-        8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
-        CORBA::tk_alias, // typecode kind for typedefs
-        64, // encapsulation length
-          TAO_ENCAP_BYTE_ORDER, // byte order
-          31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
-          12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
-          CORBA::tk_string, 
-          0U, // string length
-
-        5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
-        CORBA::tk_TypeCode,
-
-
-      0U,
-
-
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_AttributeDescription (CORBA::tk_struct, sizeof (_oc_IR_AttributeDescription), (char *) &_oc_IR_AttributeDescription, 0, sizeof (IR_AttributeDescription));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_AttributeDescription, &_tc_TAO_tc_IR_AttributeDescription)
-TAO_NAMESPACE_END
-
-void IR_AttributeDescription::_tao_any_destructor (void *x)
-{
-  IR_AttributeDescription *tmp = ACE_static_cast (IR_AttributeDescription*,x);
-  delete tmp;
-}
-
-static const CORBA::Long _oc_IR_OperationMode[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f4f), ACE_NTOHL (0x70657261), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x4d6f6465), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/OperationMode:1.0
-  14, ACE_NTOHL (0x4f706572), ACE_NTOHL (0x6174696f), ACE_NTOHL (0x6e4d6f64), ACE_NTOHL (0x65000000),  // name = OperationMode
-  2, // member count
-  10, ACE_NTOHL (0x4f505f4e), ACE_NTOHL (0x4f524d41), ACE_NTOHL (0x4c000000),  // name = OP_NORMAL
-  10, ACE_NTOHL (0x4f505f4f), ACE_NTOHL (0x4e455741), ACE_NTOHL (0x59000000),  // name = OP_ONEWAY
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_OperationMode (CORBA::tk_enum, sizeof (_oc_IR_OperationMode), (char *) &_oc_IR_OperationMode, 0, sizeof (IR_OperationMode));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_OperationMode, &_tc_TAO_tc_IR_OperationMode)
-TAO_NAMESPACE_END
-
-static const CORBA::Long _oc_IR_ParameterMode[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f50), ACE_NTOHL (0x6172616d), ACE_NTOHL (0x65746572), ACE_NTOHL (0x4d6f6465), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/ParameterMode:1.0
-  14, ACE_NTOHL (0x50617261), ACE_NTOHL (0x6d657465), ACE_NTOHL (0x724d6f64), ACE_NTOHL (0x65000000),  // name = ParameterMode
-  3, // member count
-  9, ACE_NTOHL (0x50415241), ACE_NTOHL (0x4d5f494e), ACE_NTOHL (0x0),  // name = PARAM_IN
-  10, ACE_NTOHL (0x50415241), ACE_NTOHL (0x4d5f4f55), ACE_NTOHL (0x54000000),  // name = PARAM_OUT
-  12, ACE_NTOHL (0x50415241), ACE_NTOHL (0x4d5f494e), ACE_NTOHL (0x4f555400),  // name = PARAM_INOUT
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_ParameterMode (CORBA::tk_enum, sizeof (_oc_IR_ParameterMode), (char *) &_oc_IR_ParameterMode, 0, sizeof (IR_ParameterMode));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ParameterMode, &_tc_TAO_tc_IR_ParameterMode)
-TAO_NAMESPACE_END
-
-static const CORBA::Long _oc_IR_ParameterDescription[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f50), ACE_NTOHL (0x6172616d), ACE_NTOHL (0x65746572), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ParameterDescription:1.0
-  21, ACE_NTOHL (0x50617261), ACE_NTOHL (0x6d657465), ACE_NTOHL (0x72446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = ParameterDescription
-  4, // member count
-  5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
-  CORBA::tk_alias, // typecode kind for typedefs
-  64, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
-    11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-    CORBA::tk_string, 
-    0U, // string length
-
-  5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
-  CORBA::tk_TypeCode,
-
-  9, ACE_NTOHL (0x74797065), ACE_NTOHL (0x5f646566), ACE_NTOHL (0x0),  // name = type_def
-  CORBA::tk_objref, // typecode kind
-  48, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    27, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x444c5479), ACE_NTOHL (0x70653a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/IDLType:1.0
-    8, ACE_NTOHL (0x49444c54), ACE_NTOHL (0x79706500),  // name = IR_IDLType
-
-  5, ACE_NTOHL (0x6d6f6465), ACE_NTOHL (0x0),  // name = mode
-  CORBA::tk_enum, // typecode kind
-  116, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f50), ACE_NTOHL (0x6172616d), ACE_NTOHL (0x65746572), ACE_NTOHL (0x4d6f6465), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/ParameterMode:1.0
-    14, ACE_NTOHL (0x50617261), ACE_NTOHL (0x6d657465), ACE_NTOHL (0x724d6f64), ACE_NTOHL (0x65000000),  // name = ParameterMode
-    3, // member count
-    9, ACE_NTOHL (0x50415241), ACE_NTOHL (0x4d5f494e), ACE_NTOHL (0x0),  // name = PARAM_IN
-    10, ACE_NTOHL (0x50415241), ACE_NTOHL (0x4d5f4f55), ACE_NTOHL (0x54000000),  // name = PARAM_OUT
-    12, ACE_NTOHL (0x50415241), ACE_NTOHL (0x4d5f494e), ACE_NTOHL (0x4f555400),  // name = PARAM_INOUT
-
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_ParameterDescription (CORBA::tk_struct, sizeof (_oc_IR_ParameterDescription), (char *) &_oc_IR_ParameterDescription, 0, sizeof (IR_ParameterDescription));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ParameterDescription, &_tc_TAO_tc_IR_ParameterDescription)
-TAO_NAMESPACE_END
-
-void IR_ParameterDescription::_tao_any_destructor (void *x)
-{
-  IR_ParameterDescription *tmp = ACE_static_cast (IR_ParameterDescription*,x);
-  delete tmp;
-}
-
-
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  
-  void
-  _TAO_Unbounded_Sequence_IR_ParDescriptionSeq::_allocate_buffer (CORBA::ULong length)
-  {
-    IR_ParameterDescription* tmp = 0;
-    tmp = _TAO_Unbounded_Sequence_IR_ParDescriptionSeq::allocbuf (length);
-    
-    if (this->buffer_ != 0)
-    {
-      IR_ParameterDescription *old = ACE_reinterpret_cast (IR_ParameterDescription *,this->buffer_);
-      
-      for (CORBA::ULong i = 0; i < this->length_; ++i)
-        tmp[i] = old[i];
-      
-      if (this->release_)
-        _TAO_Unbounded_Sequence_IR_ParDescriptionSeq::freebuf (old);
-      
-    }
-    this->buffer_ = tmp;
-  }
-  
-  void
-  _TAO_Unbounded_Sequence_IR_ParDescriptionSeq::_deallocate_buffer (void)
-  {
-    if (this->buffer_ == 0 || this->release_ == 0)
-      return;
-    
-    IR_ParameterDescription *tmp = ACE_reinterpret_cast (IR_ParameterDescription *,this->buffer_);
-    
-    _TAO_Unbounded_Sequence_IR_ParDescriptionSeq::freebuf (tmp);
-    this->buffer_ = 0;
-  } 
-  
-  _TAO_Unbounded_Sequence_IR_ParDescriptionSeq::~_TAO_Unbounded_Sequence_IR_ParDescriptionSeq (void) // Dtor.
-  {
-    this->_deallocate_buffer ();
-  }
-  
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
-
-// *************************************************************
-// IR_ParDescriptionSeq
-// *************************************************************
-
-IR_ParDescriptionSeq::IR_ParDescriptionSeq (void)
-{}
-IR_ParDescriptionSeq::IR_ParDescriptionSeq (CORBA::ULong max) // uses max size
-  : 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Sequence_IR_ParDescriptionSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Sequence<IR_ParameterDescription>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
- (max)
-{}
-IR_ParDescriptionSeq::IR_ParDescriptionSeq (CORBA::ULong max, CORBA::ULong length, IR_ParameterDescription *buffer, CORBA::Boolean release)
-  : 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Sequence_IR_ParDescriptionSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Sequence<IR_ParameterDescription>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
- (max, length, buffer, release)
-{}
-IR_ParDescriptionSeq::IR_ParDescriptionSeq (const IR_ParDescriptionSeq &seq) // copy ctor
-  : 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Sequence_IR_ParDescriptionSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Sequence<IR_ParameterDescription>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
- (seq)
-{}
-IR_ParDescriptionSeq::~IR_ParDescriptionSeq (void) // dtor
-{}
-void IR_ParDescriptionSeq::_tao_any_destructor (void *x)
-{
-  IR_ParDescriptionSeq *tmp = ACE_static_cast (IR_ParDescriptionSeq*,x);
-  delete tmp;
-}
-
-static const CORBA::Long _oc_IR_ParDescriptionSeq[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  37, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f50), ACE_NTOHL (0x61724465), ACE_NTOHL (0x73637269), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e536571), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/ParDescriptionSeq:1.0
-  18, ACE_NTOHL (0x50617244), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e5365), ACE_NTOHL (0x71000000),  // name = ParDescriptionSeq
-  CORBA::tk_sequence, // typecode kind
-  404, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    CORBA::tk_struct, // typecode kind
-    388, // encapsulation length
-      TAO_ENCAP_BYTE_ORDER, // byte order
-      40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f50), ACE_NTOHL (0x6172616d), ACE_NTOHL (0x65746572), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ParameterDescription:1.0
-      21, ACE_NTOHL (0x50617261), ACE_NTOHL (0x6d657465), ACE_NTOHL (0x72446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = ParameterDescription
-      4, // member count
-      5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
-      CORBA::tk_alias, // typecode kind for typedefs
-      64, // encapsulation length
-        TAO_ENCAP_BYTE_ORDER, // byte order
-        30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
-        11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-        CORBA::tk_string, 
-        0U, // string length
-
-      5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
-      CORBA::tk_TypeCode,
-
-      9, ACE_NTOHL (0x74797065), ACE_NTOHL (0x5f646566), ACE_NTOHL (0x0),  // name = type_def
-      CORBA::tk_objref, // typecode kind
-      48, // encapsulation length
-        TAO_ENCAP_BYTE_ORDER, // byte order
-        27, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x444c5479), ACE_NTOHL (0x70653a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/IDLType:1.0
-        8, ACE_NTOHL (0x49444c54), ACE_NTOHL (0x79706500),  // name = IR_IDLType
-
-      5, ACE_NTOHL (0x6d6f6465), ACE_NTOHL (0x0),  // name = mode
-      CORBA::tk_enum, // typecode kind
-      116, // encapsulation length
-        TAO_ENCAP_BYTE_ORDER, // byte order
-        33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f50), ACE_NTOHL (0x6172616d), ACE_NTOHL (0x65746572), ACE_NTOHL (0x4d6f6465), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/ParameterMode:1.0
-        14, ACE_NTOHL (0x50617261), ACE_NTOHL (0x6d657465), ACE_NTOHL (0x724d6f64), ACE_NTOHL (0x65000000),  // name = ParameterMode
-        3, // member count
-        9, ACE_NTOHL (0x50415241), ACE_NTOHL (0x4d5f494e), ACE_NTOHL (0x0),  // name = PARAM_IN
-        10, ACE_NTOHL (0x50415241), ACE_NTOHL (0x4d5f4f55), ACE_NTOHL (0x54000000),  // name = PARAM_OUT
-        12, ACE_NTOHL (0x50415241), ACE_NTOHL (0x4d5f494e), ACE_NTOHL (0x4f555400),  // name = PARAM_INOUT
-
-
-    0U,
-
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_ParDescriptionSeq (CORBA::tk_alias, sizeof (_oc_IR_ParDescriptionSeq), (char *) &_oc_IR_ParDescriptionSeq, 0, sizeof (IR_ParDescriptionSeq));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ParDescriptionSeq, &_tc_TAO_tc_IR_ParDescriptionSeq)
-TAO_NAMESPACE_END
-
-static const CORBA::Long _oc_IR_ContextIdentifier[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  37, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f43), ACE_NTOHL (0x6f6e7465), ACE_NTOHL (0x78744964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/ContextIdentifier:1.0
-  18, ACE_NTOHL (0x436f6e74), ACE_NTOHL (0x65787449), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x72000000),  // name = ContextIdentifier
-  CORBA::tk_alias, // typecode kind for typedefs
-  64, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
-    11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-    CORBA::tk_string, 
-    0U, // string length
-
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_ContextIdentifier (CORBA::tk_alias, sizeof (_oc_IR_ContextIdentifier), (char *) &_oc_IR_ContextIdentifier, 0, sizeof (IR::ContextIdentifier));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ContextIdentifier, &_tc_TAO_tc_IR_ContextIdentifier)
-TAO_NAMESPACE_END
-
-// *************************************************************
-// IR_ContextIdSeq
-// *************************************************************
-
-IR_ContextIdSeq::IR_ContextIdSeq (void)
-{}
-IR_ContextIdSeq::IR_ContextIdSeq (CORBA::ULong max) // uses max size
-  : 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  TAO_Unbounded_String_Sequence
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_String_Sequence
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
- (max)
-{}
-IR_ContextIdSeq::IR_ContextIdSeq (CORBA::ULong max, CORBA::ULong length, char * *buffer, CORBA::Boolean release)
-  : 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  TAO_Unbounded_String_Sequence
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_String_Sequence
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
- (max, length, buffer, release)
-{}
-IR_ContextIdSeq::IR_ContextIdSeq (const IR_ContextIdSeq &seq) // copy ctor
-  : 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  TAO_Unbounded_String_Sequence
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_String_Sequence
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
- (seq)
-{}
-IR_ContextIdSeq::~IR_ContextIdSeq (void) // dtor
-{}
-void IR_ContextIdSeq::_tao_any_destructor (void *x)
-{
-  IR_ContextIdSeq *tmp = ACE_static_cast (IR_ContextIdSeq*,x);
-  delete tmp;
-}
-
-static const CORBA::Long _oc_IR_ContextIdSeq[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f43), ACE_NTOHL (0x6f6e7465), ACE_NTOHL (0x78744964), ACE_NTOHL (0x5365713a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ContextIdSeq:1.0
-  13, ACE_NTOHL (0x436f6e74), ACE_NTOHL (0x65787449), ACE_NTOHL (0x64536571), ACE_NTOHL (0x0),  // name = ContextIdSeq
-  CORBA::tk_sequence, // typecode kind
-  160, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    CORBA::tk_alias, // typecode kind for typedefs
-    144, // encapsulation length
-      TAO_ENCAP_BYTE_ORDER, // byte order
-      37, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f43), ACE_NTOHL (0x6f6e7465), ACE_NTOHL (0x78744964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/ContextIdentifier:1.0
-      18, ACE_NTOHL (0x436f6e74), ACE_NTOHL (0x65787449), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x72000000),  // name = ContextIdentifier
-      CORBA::tk_alias, // typecode kind for typedefs
-      64, // encapsulation length
-        TAO_ENCAP_BYTE_ORDER, // byte order
-        30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
-        11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-        CORBA::tk_string, 
-        0U, // string length
-
-
-    0U,
-
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_ContextIdSeq (CORBA::tk_alias, sizeof (_oc_IR_ContextIdSeq), (char *) &_oc_IR_ContextIdSeq, 0, sizeof (IR_ContextIdSeq));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ContextIdSeq, &_tc_TAO_tc_IR_ContextIdSeq)
-TAO_NAMESPACE_END
-
-///////////////////////////////////////////////////////////////////////
-//                Base & Remote Proxy  Implementation. 
-//
-
-_TAO_OperationDef_Proxy_Impl::_TAO_OperationDef_Proxy_Impl (void)
-{}
-
-_TAO_OperationDef_Remote_Proxy_Impl::_TAO_OperationDef_Remote_Proxy_Impl (void)
-{}
-
-// Remote Implementation of the IDL interface methods
-
-CORBA::TypeCode_ptr _TAO_OperationDef_Remote_Proxy_Impl::result (
-    CORBA_Object *_collocated_tao_target_,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  
-  CORBA::TypeCode_ptr _tao_retval = CORBA::TypeCode::_nil ();
-  CORBA::TypeCode_var _tao_safe_retval (_tao_retval);
-  
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-
-  
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_get_result",
-      11,
-      0,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_OperationDef::TAO_ClientRequestInfo_IR_OperationDef_result_get ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              CORBA::TypeCode_ptr _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-IR_IDLType_ptr _TAO_OperationDef_Remote_Proxy_Impl::result_def (
-    CORBA_Object *_collocated_tao_target_,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  
-  IR_IDLType_ptr _tao_retval = IR_IDLType::_nil ();
-  IR_IDLType_var _tao_safe_retval (_tao_retval);
-  
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-
-  
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_get_result_def",
-      15,
-      0,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_OperationDef::TAO_ClientRequestInfo_IR_OperationDef_result_def_get ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              IR_IDLType_ptr _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-void _TAO_OperationDef_Remote_Proxy_Impl::result_def (
-    CORBA_Object *_collocated_tao_target_,
-    IR_IDLType_ptr result_def,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW (CORBA::INTERNAL ());
-
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_set_result_def",
-      15,
-      1,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_OperationDef::TAO_ClientRequestInfo_IR_OperationDef_result_def_set ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        result_def,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK;
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK;
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK;
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK;
-          
-          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-          if (!(
-                            (_tao_out << result_def)
-            ))
-            TAO_INTERCEPTOR_THROW (
-              CORBA::MARSHAL ()
-            );
-            
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK;
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)
-              );
-              
-            }
-          
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK;
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK;
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  
-}
-
-IR_ParDescriptionSeq * _TAO_OperationDef_Remote_Proxy_Impl::params (
-    CORBA_Object *_collocated_tao_target_,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  
-  IR_ParDescriptionSeq *_tao_retval = 0;
-  
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-
-  
-  ACE_NEW_RETURN (_tao_retval, IR_ParDescriptionSeq, _tao_retval);
-  IR_ParDescriptionSeq_var _tao_safe_retval (_tao_retval);
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_get_params",
-      11,
-      0,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_OperationDef::TAO_ClientRequestInfo_IR_OperationDef_params_get ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              IR_ParDescriptionSeq * _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-void _TAO_OperationDef_Remote_Proxy_Impl::params (
-    CORBA_Object *_collocated_tao_target_,
-    const IR_ParDescriptionSeq & params,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW (CORBA::INTERNAL ());
-
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_set_params",
-      11,
-      1,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_OperationDef::TAO_ClientRequestInfo_IR_OperationDef_params_set ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        params,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK;
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK;
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK;
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK;
-          
-          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-          if (!(
-                            (_tao_out << params)
-            ))
-            TAO_INTERCEPTOR_THROW (
-              CORBA::MARSHAL ()
-            );
-            
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK;
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)
-              );
-              
-            }
-          
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK;
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK;
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  
-}
-
-IR_OperationMode _TAO_OperationDef_Remote_Proxy_Impl::mode (
-    CORBA_Object *_collocated_tao_target_,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  
-  IR_OperationMode _tao_retval = (IR_OperationMode)0;
-  
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), _tao_retval);
-
-  
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_get_mode",
-      9,
-      0,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_OperationDef::TAO_ClientRequestInfo_IR_OperationDef_mode_get ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN  (_tao_retval);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                _tao_retval
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_retval)
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                _tao_retval
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              IR_OperationMode  _tao_retval_info = _tao_retval;
-               ri.result (_tao_retval_info);
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN  (_tao_retval);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_retval;
-}
-
-void _TAO_OperationDef_Remote_Proxy_Impl::mode (
-    CORBA_Object *_collocated_tao_target_,
-    IR_OperationMode mode,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW (CORBA::INTERNAL ());
-
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_set_mode",
-      9,
-      1,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_OperationDef::TAO_ClientRequestInfo_IR_OperationDef_mode_set ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        mode,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK;
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK;
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK;
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK;
-          
-          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-          if (!(
-                            (_tao_out << mode)
-            ))
-            TAO_INTERCEPTOR_THROW (
-              CORBA::MARSHAL ()
-            );
-            
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK;
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)
-              );
-              
-            }
-          
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK;
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK;
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  
-}
-
-IR_ContextIdSeq * _TAO_OperationDef_Remote_Proxy_Impl::contexts (
-    CORBA_Object *_collocated_tao_target_,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  
-  IR_ContextIdSeq *_tao_retval = 0;
-  
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-
-  
-  ACE_NEW_RETURN (_tao_retval, IR_ContextIdSeq, _tao_retval);
-  IR_ContextIdSeq_var _tao_safe_retval (_tao_retval);
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_get_contexts",
-      13,
-      0,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_OperationDef::TAO_ClientRequestInfo_IR_OperationDef_contexts_get ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              IR_ContextIdSeq * _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-void _TAO_OperationDef_Remote_Proxy_Impl::contexts (
-    CORBA_Object *_collocated_tao_target_,
-    const IR_ContextIdSeq & contexts,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW (CORBA::INTERNAL ());
-
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_set_contexts",
-      13,
-      1,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_OperationDef::TAO_ClientRequestInfo_IR_OperationDef_contexts_set ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        contexts,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK;
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK;
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK;
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK;
-          
-          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-          if (!(
-                            (_tao_out << contexts)
-            ))
-            TAO_INTERCEPTOR_THROW (
-              CORBA::MARSHAL ()
-            );
-            
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK;
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)
-              );
-              
-            }
-          
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK;
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK;
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  
-}
-
-IR_ExceptionDefSeq * _TAO_OperationDef_Remote_Proxy_Impl::exceptions (
-    CORBA_Object *_collocated_tao_target_,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  
-  IR_ExceptionDefSeq *_tao_retval = 0;
-  
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-
-  
-  ACE_NEW_RETURN (_tao_retval, IR_ExceptionDefSeq, _tao_retval);
-  IR_ExceptionDefSeq_var _tao_safe_retval (_tao_retval);
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_get_exceptions",
-      15,
-      0,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_OperationDef::TAO_ClientRequestInfo_IR_OperationDef_exceptions_get ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              IR_ExceptionDefSeq * _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-void _TAO_OperationDef_Remote_Proxy_Impl::exceptions (
-    CORBA_Object *_collocated_tao_target_,
-    const IR_ExceptionDefSeq & exceptions,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW (CORBA::INTERNAL ());
-
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_set_exceptions",
-      15,
-      1,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_OperationDef::TAO_ClientRequestInfo_IR_OperationDef_exceptions_set ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        exceptions,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK;
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK;
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK;
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK;
-          
-          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-          if (!(
-                            (_tao_out << exceptions)
-            ))
-            TAO_INTERCEPTOR_THROW (
-              CORBA::MARSHAL ()
-            );
-            
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK;
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)
-              );
-              
-            }
-          
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK;
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK;
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  
-}
-
-
-//
-//            End  Base & Remote  Proxy Implemeentation. 
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//           Remote & Base  Proxy Broker Implementation
-//
-
-_TAO_OperationDef_Proxy_Broker::_TAO_OperationDef_Proxy_Broker (void)
-{
-}
-
-_TAO_OperationDef_Proxy_Broker::~_TAO_OperationDef_Proxy_Broker (void)
-{
-}
-
-_TAO_OperationDef_Proxy_Broker * (*_TAO_OperationDef_Proxy_Broker_Factory_function_pointer) (
-    CORBA::Object_ptr obj
-  ) = 0;
-
-// Factory Member function Implementation.
-_TAO_OperationDef_Remote_Proxy_Broker *
-_TAO_OperationDef_Remote_Proxy_Broker::the_TAO_OperationDef_Remote_Proxy_Broker (void)
-{
-  static ::_TAO_OperationDef_Remote_Proxy_Broker remote_proxy_broker;
-  return &remote_proxy_broker;
-}
-
-_TAO_OperationDef_Remote_Proxy_Broker::_TAO_OperationDef_Remote_Proxy_Broker (void)
-{
-}
-
-_TAO_OperationDef_Remote_Proxy_Broker::~_TAO_OperationDef_Remote_Proxy_Broker (void)
-{
-}
-
-_TAO_OperationDef_Proxy_Impl&
-_TAO_OperationDef_Remote_Proxy_Broker::select_proxy (
-  ::IR_OperationDef *object,
-  CORBA::Environment &ACE_TRY_ENV
-)
-{
-  ACE_UNUSED_ARG (object);
-  ACE_UNUSED_ARG (ACE_TRY_ENV);
-  return remote_proxy_impl_;
-}
-
-
-//
-//           End Remote & Base Proxy Broker Implementation
-///////////////////////////////////////////////////////////////////////
-
-
-// default constructor
-IR_OperationDef::IR_OperationDef (int collocated)
-{
-  this->IR_OperationDef_setup_collocation (collocated);
-}
-
-// destructor
-IR_OperationDef::~IR_OperationDef (void)
-{}
-
-void
-IR_OperationDef::IR_OperationDef_setup_collocation (int collocated)
-{
-  if (collocated)
-    this->the_TAO_OperationDef_Proxy_Broker_ =
-      _TAO_OperationDef_Proxy_Broker_Factory_function_pointer (this);
-  else
-    this->the_TAO_OperationDef_Proxy_Broker_ =
-      _TAO_OperationDef_Remote_Proxy_Broker::the_TAO_OperationDef_Remote_Proxy_Broker ();
-  
-  this->IR_Contained_setup_collocation (collocated);
-}
-
-void IR_OperationDef::_tao_any_destructor (void *x)
-{
-  IR_OperationDef *tmp = ACE_static_cast (IR_OperationDef*,x);
-  CORBA::release (tmp);
-}
-
-IR_OperationDef_ptr IR_OperationDef::_narrow (
-    CORBA::Object_ptr obj,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  if (CORBA::is_nil (obj))
-    return IR_OperationDef::_nil ();
-  if (! obj->_is_local ())
-    {
-      CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/IR/OperationDef:1.0", ACE_TRY_ENV);
-      ACE_CHECK_RETURN (IR_OperationDef::_nil ());
-      if (is_a == 0)
-        return IR_OperationDef::_nil ();
-    }
-  return IR_OperationDef::_unchecked_narrow (obj, ACE_TRY_ENV);
-}
-
-IR_OperationDef_ptr IR_OperationDef::_unchecked_narrow (
-    CORBA::Object_ptr obj,
-    CORBA::Environment &
-  )
-{
-  if (CORBA::is_nil (obj))
-    return IR_OperationDef::_nil ();
-  if (! obj->_is_local ())
-    {
-      TAO_Stub* stub = obj->_stubobj ();
-      if (stub)
-        stub->_incr_refcnt ();
-      IR_OperationDef_ptr default_proxy = IR_OperationDef::_nil ();
-
-      if (
-          !CORBA::is_nil (stub->servant_orb_var ().ptr ()) &&
-          stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects () &&
-          obj->_is_collocated () &&_TAO_OperationDef_Proxy_Broker_Factory_function_pointer != 0
-        )
-      {
-        ACE_NEW_RETURN (
-          default_proxy,
-          ::IR_OperationDef (
-            stub,
-            1,
-            obj->_servant ()),
-            
-          IR_OperationDef::_nil ());
-        }
-      if (CORBA::is_nil (default_proxy))
-        ACE_NEW_RETURN (default_proxy, ::IR_OperationDef (stub, 0, obj->_servant ()), IR_OperationDef::_nil ());
-        return default_proxy;
-      }
-    else 
-      return
-        ACE_reinterpret_cast
-          (
-            IR_OperationDef_ptr,
-              obj->_tao_QueryInterface
-                (
-                  ACE_reinterpret_cast
-                    (
-                      ptr_arith_t,
-                      &IR_OperationDef::_narrow
-                    )
-                )
-          );
-}
-
-IR_OperationDef_ptr
-IR_OperationDef::_duplicate (IR_OperationDef_ptr obj)
-{
-  if (!CORBA::is_nil (obj))
-    obj->_add_ref ();
-  return obj;
-}
-
-CORBA::Boolean IR_OperationDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
-{
-  if (
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/OperationDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/Contained:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
-  return 1; // success using local knowledge
-  else
-    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
-}
-
-void *IR_OperationDef::_tao_QueryInterface (ptr_arith_t type)
-{
-  void *retv = 0;
-  if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_OperationDef::_narrow))
-    retv = ACE_reinterpret_cast (void*, this);
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_Contained::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            IR_Contained_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &CORBA_IRObject::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            CORBA_IRObject_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
-    retv = ACE_reinterpret_cast (void *,
-      ACE_static_cast (CORBA::Object_ptr, this));
-    
-  if (retv)
-    this->_add_ref ();
-  return retv;
-}
-
-const char* IR_OperationDef::_interface_repository_id (void) const
-{
-  return "IDL:omg.org/IR/OperationDef:1.0";
-}
-
-CORBA::TypeCode_ptr IR_OperationDef::result (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_OperationDef_Proxy_Impl &proxy = 
-    this->the_TAO_OperationDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.result (
-      this,
-      ACE_TRY_ENV
-    );
-}
-
-IR_IDLType_ptr IR_OperationDef::result_def (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_OperationDef_Proxy_Impl &proxy = 
-    this->the_TAO_OperationDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.result_def (
-      this,
-      ACE_TRY_ENV
-    );
-}
-
-void IR_OperationDef::result_def (
-    IR_IDLType_ptr result_def,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_OperationDef_Proxy_Impl &proxy = 
-    this->the_TAO_OperationDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK;
-  
-  proxy.result_def (
-      this,
-      result_def,
-      ACE_TRY_ENV
-    );
-}
-
-IR_ParDescriptionSeq * IR_OperationDef::params (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_OperationDef_Proxy_Impl &proxy = 
-    this->the_TAO_OperationDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.params (
-      this,
-      ACE_TRY_ENV
-    );
-}
-
-void IR_OperationDef::params (
-    const IR_ParDescriptionSeq & params,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_OperationDef_Proxy_Impl &proxy = 
-    this->the_TAO_OperationDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK;
-  
-  proxy.params (
-      this,
-      params,
-      ACE_TRY_ENV
-    );
-}
-
-IR_OperationMode IR_OperationDef::mode (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_OperationDef_Proxy_Impl &proxy = 
-    this->the_TAO_OperationDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN ((IR_OperationMode)0);
-  
-  return proxy.mode (
-      this,
-      ACE_TRY_ENV
-    );
-}
-
-void IR_OperationDef::mode (
-    IR_OperationMode mode,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_OperationDef_Proxy_Impl &proxy = 
-    this->the_TAO_OperationDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK;
-  
-  proxy.mode (
-      this,
-      mode,
-      ACE_TRY_ENV
-    );
-}
-
-IR_ContextIdSeq * IR_OperationDef::contexts (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_OperationDef_Proxy_Impl &proxy = 
-    this->the_TAO_OperationDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.contexts (
-      this,
-      ACE_TRY_ENV
-    );
-}
-
-void IR_OperationDef::contexts (
-    const IR_ContextIdSeq & contexts,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_OperationDef_Proxy_Impl &proxy = 
-    this->the_TAO_OperationDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK;
-  
-  proxy.contexts (
-      this,
-      contexts,
-      ACE_TRY_ENV
-    );
-}
-
-IR_ExceptionDefSeq * IR_OperationDef::exceptions (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_OperationDef_Proxy_Impl &proxy = 
-    this->the_TAO_OperationDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.exceptions (
-      this,
-      ACE_TRY_ENV
-    );
-}
-
-void IR_OperationDef::exceptions (
-    const IR_ExceptionDefSeq & exceptions,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_OperationDef_Proxy_Impl &proxy = 
-    this->the_TAO_OperationDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK;
-  
-  proxy.exceptions (
-      this,
-      exceptions,
-      ACE_TRY_ENV
-    );
-}
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-IR_OperationDef::TAO_ClientRequestInfo_IR_OperationDef_result_get::TAO_ClientRequestInfo_IR_OperationDef_result_get (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
-{}
-
-Dynamic::ParameterList *
-IR_OperationDef::TAO_ClientRequestInfo_IR_OperationDef_result_get::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return parameter_list;
-}
-
-Dynamic::ExceptionList *
-IR_OperationDef::TAO_ClientRequestInfo_IR_OperationDef_result_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_OperationDef::TAO_ClientRequestInfo_IR_OperationDef_result_get::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_OperationDef::TAO_ClientRequestInfo_IR_OperationDef_result_get::result (CORBA::TypeCode_ptr result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_OperationDef::TAO_ClientRequestInfo_IR_OperationDef_result_def_get::TAO_ClientRequestInfo_IR_OperationDef_result_def_get (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
-{}
-
-Dynamic::ParameterList *
-IR_OperationDef::TAO_ClientRequestInfo_IR_OperationDef_result_def_get::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return parameter_list;
-}
-
-Dynamic::ExceptionList *
-IR_OperationDef::TAO_ClientRequestInfo_IR_OperationDef_result_def_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_OperationDef::TAO_ClientRequestInfo_IR_OperationDef_result_def_get::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_OperationDef::TAO_ClientRequestInfo_IR_OperationDef_result_def_get::result (IR_IDLType_ptr result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_OperationDef::TAO_ClientRequestInfo_IR_OperationDef_result_def_set::TAO_ClientRequestInfo_IR_OperationDef_result_def_set (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    IR_IDLType_ptr result_def,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
-    result_def_ (result_def)
-{}
-
-Dynamic::ParameterList *
-IR_OperationDef::TAO_ClientRequestInfo_IR_OperationDef_result_def_set::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
-    
-  CORBA::ULong length_result_def = parameter_list->length ();
-  parameter_list->length (length_result_def + 1);
-  (*parameter_list)[length_result_def].argument <<=  this->result_def_;
-  
-  (*parameter_list)[length_result_def].mode = Dynamic::PARAM_IN;
-  
-  return safe_parameter_list._retn ();
-}
-
-Dynamic::ExceptionList *
-IR_OperationDef::TAO_ClientRequestInfo_IR_OperationDef_result_def_set::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_OperationDef::TAO_ClientRequestInfo_IR_OperationDef_result_def_set::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 1;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return result_any;
-}
-
-IR_OperationDef::TAO_ClientRequestInfo_IR_OperationDef_params_get::TAO_ClientRequestInfo_IR_OperationDef_params_get (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
-{}
-
-Dynamic::ParameterList *
-IR_OperationDef::TAO_ClientRequestInfo_IR_OperationDef_params_get::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return parameter_list;
-}
-
-Dynamic::ExceptionList *
-IR_OperationDef::TAO_ClientRequestInfo_IR_OperationDef_params_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_OperationDef::TAO_ClientRequestInfo_IR_OperationDef_params_get::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_OperationDef::TAO_ClientRequestInfo_IR_OperationDef_params_get::result (IR_ParDescriptionSeq * result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_OperationDef::TAO_ClientRequestInfo_IR_OperationDef_params_set::TAO_ClientRequestInfo_IR_OperationDef_params_set (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    const IR_ParDescriptionSeq & params,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
-    params_ (params)
-{}
-
-Dynamic::ParameterList *
-IR_OperationDef::TAO_ClientRequestInfo_IR_OperationDef_params_set::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
-    
-  CORBA::ULong length_params = parameter_list->length ();
-  parameter_list->length (length_params + 1);
-  (*parameter_list)[length_params].argument <<=  this->params_;
-  
-  (*parameter_list)[length_params].mode = Dynamic::PARAM_IN;
-  
-  return safe_parameter_list._retn ();
-}
-
-Dynamic::ExceptionList *
-IR_OperationDef::TAO_ClientRequestInfo_IR_OperationDef_params_set::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_OperationDef::TAO_ClientRequestInfo_IR_OperationDef_params_set::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 1;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return result_any;
-}
-
-IR_OperationDef::TAO_ClientRequestInfo_IR_OperationDef_mode_get::TAO_ClientRequestInfo_IR_OperationDef_mode_get (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
-{}
-
-Dynamic::ParameterList *
-IR_OperationDef::TAO_ClientRequestInfo_IR_OperationDef_mode_get::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return parameter_list;
-}
-
-Dynamic::ExceptionList *
-IR_OperationDef::TAO_ClientRequestInfo_IR_OperationDef_mode_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_OperationDef::TAO_ClientRequestInfo_IR_OperationDef_mode_get::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_OperationDef::TAO_ClientRequestInfo_IR_OperationDef_mode_get::result (IR_OperationMode result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_OperationDef::TAO_ClientRequestInfo_IR_OperationDef_mode_set::TAO_ClientRequestInfo_IR_OperationDef_mode_set (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    IR_OperationMode & mode,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
-    mode_ (mode)
-{}
-
-Dynamic::ParameterList *
-IR_OperationDef::TAO_ClientRequestInfo_IR_OperationDef_mode_set::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
-    
-  CORBA::ULong length_mode = parameter_list->length ();
-  parameter_list->length (length_mode + 1);
-  (*parameter_list)[length_mode].argument <<=  this->mode_;
-  
-  (*parameter_list)[length_mode].mode = Dynamic::PARAM_IN;
-  
-  return safe_parameter_list._retn ();
-}
-
-Dynamic::ExceptionList *
-IR_OperationDef::TAO_ClientRequestInfo_IR_OperationDef_mode_set::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_OperationDef::TAO_ClientRequestInfo_IR_OperationDef_mode_set::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 1;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return result_any;
-}
-
-IR_OperationDef::TAO_ClientRequestInfo_IR_OperationDef_contexts_get::TAO_ClientRequestInfo_IR_OperationDef_contexts_get (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
-{}
-
-Dynamic::ParameterList *
-IR_OperationDef::TAO_ClientRequestInfo_IR_OperationDef_contexts_get::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return parameter_list;
-}
-
-Dynamic::ExceptionList *
-IR_OperationDef::TAO_ClientRequestInfo_IR_OperationDef_contexts_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_OperationDef::TAO_ClientRequestInfo_IR_OperationDef_contexts_get::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_OperationDef::TAO_ClientRequestInfo_IR_OperationDef_contexts_get::result (IR_ContextIdSeq * result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_OperationDef::TAO_ClientRequestInfo_IR_OperationDef_contexts_set::TAO_ClientRequestInfo_IR_OperationDef_contexts_set (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    const IR_ContextIdSeq & contexts,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
-    contexts_ (contexts)
-{}
-
-Dynamic::ParameterList *
-IR_OperationDef::TAO_ClientRequestInfo_IR_OperationDef_contexts_set::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
-    
-  CORBA::ULong length_contexts = parameter_list->length ();
-  parameter_list->length (length_contexts + 1);
-  (*parameter_list)[length_contexts].argument <<=  this->contexts_;
-  
-  (*parameter_list)[length_contexts].mode = Dynamic::PARAM_IN;
-  
-  return safe_parameter_list._retn ();
-}
-
-Dynamic::ExceptionList *
-IR_OperationDef::TAO_ClientRequestInfo_IR_OperationDef_contexts_set::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_OperationDef::TAO_ClientRequestInfo_IR_OperationDef_contexts_set::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 1;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return result_any;
-}
-
-IR_OperationDef::TAO_ClientRequestInfo_IR_OperationDef_exceptions_get::TAO_ClientRequestInfo_IR_OperationDef_exceptions_get (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
-{}
-
-Dynamic::ParameterList *
-IR_OperationDef::TAO_ClientRequestInfo_IR_OperationDef_exceptions_get::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return parameter_list;
-}
-
-Dynamic::ExceptionList *
-IR_OperationDef::TAO_ClientRequestInfo_IR_OperationDef_exceptions_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_OperationDef::TAO_ClientRequestInfo_IR_OperationDef_exceptions_get::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_OperationDef::TAO_ClientRequestInfo_IR_OperationDef_exceptions_get::result (IR_ExceptionDefSeq * result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_OperationDef::TAO_ClientRequestInfo_IR_OperationDef_exceptions_set::TAO_ClientRequestInfo_IR_OperationDef_exceptions_set (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    const IR_ExceptionDefSeq & exceptions,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
-    exceptions_ (exceptions)
-{}
-
-Dynamic::ParameterList *
-IR_OperationDef::TAO_ClientRequestInfo_IR_OperationDef_exceptions_set::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
-    
-  CORBA::ULong length_exceptions = parameter_list->length ();
-  parameter_list->length (length_exceptions + 1);
-  (*parameter_list)[length_exceptions].argument <<=  this->exceptions_;
-  
-  (*parameter_list)[length_exceptions].mode = Dynamic::PARAM_IN;
-  
-  return safe_parameter_list._retn ();
-}
-
-Dynamic::ExceptionList *
-IR_OperationDef::TAO_ClientRequestInfo_IR_OperationDef_exceptions_set::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_OperationDef::TAO_ClientRequestInfo_IR_OperationDef_exceptions_set::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 1;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return result_any;
-}
-
-#endif /* TAO_HAS_INTERCEPTORS */
-
-static const CORBA::Long _oc_IR_OperationDef[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f4f), ACE_NTOHL (0x70657261), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x4465663a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/OperationDef:1.0
-  13, ACE_NTOHL (0x4f706572), ACE_NTOHL (0x6174696f), ACE_NTOHL (0x6e446566), ACE_NTOHL (0x0),  // name = IR_OperationDef
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_OperationDef (CORBA::tk_objref, sizeof (_oc_IR_OperationDef), (char *) &_oc_IR_OperationDef, 0, sizeof (IR_OperationDef));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_OperationDef, &_tc_TAO_tc_IR_OperationDef)
-TAO_NAMESPACE_END
-
-static const CORBA::Long _oc_IR_OperationDescription[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f4f), ACE_NTOHL (0x70657261), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/OperationDescription:1.0
-  21, ACE_NTOHL (0x4f706572), ACE_NTOHL (0x6174696f), ACE_NTOHL (0x6e446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = OperationDescription
-  9, // member count
-  5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
-  CORBA::tk_alias, // typecode kind for typedefs
-  64, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
-    11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-    CORBA::tk_string, 
-    0U, // string length
-
-  3, ACE_NTOHL (0x69640000),  // name = id
-  CORBA::tk_alias, // typecode kind for typedefs
-  68, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-    13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-    CORBA::tk_string, 
-    0U, // string length
-
-  11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
-  CORBA::tk_alias, // typecode kind for typedefs
-  68, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-    13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-    CORBA::tk_string, 
-    0U, // string length
-
-  8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
-  CORBA::tk_alias, // typecode kind for typedefs
-  64, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
-    12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
-    CORBA::tk_string, 
-    0U, // string length
-
-  7, ACE_NTOHL (0x72657375), ACE_NTOHL (0x6c740000),  // name = result
-  CORBA::tk_TypeCode,
-
-  5, ACE_NTOHL (0x6d6f6465), ACE_NTOHL (0x0),  // name = mode
-  CORBA::tk_enum, // typecode kind
-  100, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f4f), ACE_NTOHL (0x70657261), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x4d6f6465), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/OperationMode:1.0
-    14, ACE_NTOHL (0x4f706572), ACE_NTOHL (0x6174696f), ACE_NTOHL (0x6e4d6f64), ACE_NTOHL (0x65000000),  // name = OperationMode
-    2, // member count
-    10, ACE_NTOHL (0x4f505f4e), ACE_NTOHL (0x4f524d41), ACE_NTOHL (0x4c000000),  // name = OP_NORMAL
-    10, ACE_NTOHL (0x4f505f4f), ACE_NTOHL (0x4e455741), ACE_NTOHL (0x59000000),  // name = OP_ONEWAY
-
-  9, ACE_NTOHL (0x636f6e74), ACE_NTOHL (0x65787473), ACE_NTOHL (0x0),  // name = contexts
-  CORBA::tk_alias, // typecode kind for typedefs
-  228, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f43), ACE_NTOHL (0x6f6e7465), ACE_NTOHL (0x78744964), ACE_NTOHL (0x5365713a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ContextIdSeq:1.0
-    13, ACE_NTOHL (0x436f6e74), ACE_NTOHL (0x65787449), ACE_NTOHL (0x64536571), ACE_NTOHL (0x0),  // name = ContextIdSeq
-    CORBA::tk_sequence, // typecode kind
-    160, // encapsulation length
-      TAO_ENCAP_BYTE_ORDER, // byte order
-      CORBA::tk_alias, // typecode kind for typedefs
-      144, // encapsulation length
-        TAO_ENCAP_BYTE_ORDER, // byte order
-        37, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f43), ACE_NTOHL (0x6f6e7465), ACE_NTOHL (0x78744964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/ContextIdentifier:1.0
-        18, ACE_NTOHL (0x436f6e74), ACE_NTOHL (0x65787449), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x72000000),  // name = ContextIdentifier
-        CORBA::tk_alias, // typecode kind for typedefs
-        64, // encapsulation length
-          TAO_ENCAP_BYTE_ORDER, // byte order
-          30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
-          11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-          CORBA::tk_string, 
-          0U, // string length
-
-
-      0U,
-
-
-  11, ACE_NTOHL (0x70617261), ACE_NTOHL (0x6d657465), ACE_NTOHL (0x72730000),  // name = parameters
-  CORBA::tk_alias, // typecode kind for typedefs
-  484, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    37, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f50), ACE_NTOHL (0x61724465), ACE_NTOHL (0x73637269), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e536571), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/ParDescriptionSeq:1.0
-    18, ACE_NTOHL (0x50617244), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e5365), ACE_NTOHL (0x71000000),  // name = ParDescriptionSeq
-    CORBA::tk_sequence, // typecode kind
-    404, // encapsulation length
-      TAO_ENCAP_BYTE_ORDER, // byte order
-      CORBA::tk_struct, // typecode kind
-      388, // encapsulation length
-        TAO_ENCAP_BYTE_ORDER, // byte order
-        40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f50), ACE_NTOHL (0x6172616d), ACE_NTOHL (0x65746572), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ParameterDescription:1.0
-        21, ACE_NTOHL (0x50617261), ACE_NTOHL (0x6d657465), ACE_NTOHL (0x72446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = ParameterDescription
-        4, // member count
-        5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
-        CORBA::tk_alias, // typecode kind for typedefs
-        64, // encapsulation length
-          TAO_ENCAP_BYTE_ORDER, // byte order
-          30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
-          11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-          CORBA::tk_string, 
-          0U, // string length
-
-        5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
-        CORBA::tk_TypeCode,
-
-        9, ACE_NTOHL (0x74797065), ACE_NTOHL (0x5f646566), ACE_NTOHL (0x0),  // name = type_def
-        CORBA::tk_objref, // typecode kind
-        48, // encapsulation length
-          TAO_ENCAP_BYTE_ORDER, // byte order
-          27, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x444c5479), ACE_NTOHL (0x70653a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/IDLType:1.0
-          8, ACE_NTOHL (0x49444c54), ACE_NTOHL (0x79706500),  // name = IR_IDLType
-
-        5, ACE_NTOHL (0x6d6f6465), ACE_NTOHL (0x0),  // name = mode
-        CORBA::tk_enum, // typecode kind
-        116, // encapsulation length
-          TAO_ENCAP_BYTE_ORDER, // byte order
-          33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f50), ACE_NTOHL (0x6172616d), ACE_NTOHL (0x65746572), ACE_NTOHL (0x4d6f6465), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/ParameterMode:1.0
-          14, ACE_NTOHL (0x50617261), ACE_NTOHL (0x6d657465), ACE_NTOHL (0x724d6f64), ACE_NTOHL (0x65000000),  // name = ParameterMode
-          3, // member count
-          9, ACE_NTOHL (0x50415241), ACE_NTOHL (0x4d5f494e), ACE_NTOHL (0x0),  // name = PARAM_IN
-          10, ACE_NTOHL (0x50415241), ACE_NTOHL (0x4d5f4f55), ACE_NTOHL (0x54000000),  // name = PARAM_OUT
-          12, ACE_NTOHL (0x50415241), ACE_NTOHL (0x4d5f494e), ACE_NTOHL (0x4f555400),  // name = PARAM_INOUT
-
-
-      0U,
-
-
-  11, ACE_NTOHL (0x65786365), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e730000),  // name = exceptions
-  CORBA::tk_alias, // typecode kind for typedefs
-  536, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    37, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x78634465), ACE_NTOHL (0x73637269), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e536571), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/ExcDescriptionSeq:1.0
-    18, ACE_NTOHL (0x45786344), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e5365), ACE_NTOHL (0x71000000),  // name = ExcDescriptionSeq
-    CORBA::tk_sequence, // typecode kind
-    456, // encapsulation length
-      TAO_ENCAP_BYTE_ORDER, // byte order
-      CORBA::tk_struct, // typecode kind
-      440, // encapsulation length
-        TAO_ENCAP_BYTE_ORDER, // byte order
-        40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x78636570), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ExceptionDescription:1.0
-        21, ACE_NTOHL (0x45786365), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = ExceptionDescription
-        5, // member count
-        5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
-        CORBA::tk_alias, // typecode kind for typedefs
-        64, // encapsulation length
-          TAO_ENCAP_BYTE_ORDER, // byte order
-          30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
-          11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-          CORBA::tk_string, 
-          0U, // string length
-
-        3, ACE_NTOHL (0x69640000),  // name = id
-        CORBA::tk_alias, // typecode kind for typedefs
-        68, // encapsulation length
-          TAO_ENCAP_BYTE_ORDER, // byte order
-          32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-          13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-          CORBA::tk_string, 
-          0U, // string length
-
-        11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
-        CORBA::tk_alias, // typecode kind for typedefs
-        68, // encapsulation length
-          TAO_ENCAP_BYTE_ORDER, // byte order
-          32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-          13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-          CORBA::tk_string, 
-          0U, // string length
-
-        8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
-        CORBA::tk_alias, // typecode kind for typedefs
-        64, // encapsulation length
-          TAO_ENCAP_BYTE_ORDER, // byte order
-          31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
-          12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
-          CORBA::tk_string, 
-          0U, // string length
-
-        5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
-        CORBA::tk_TypeCode,
-
-
-      0U,
-
-
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_OperationDescription (CORBA::tk_struct, sizeof (_oc_IR_OperationDescription), (char *) &_oc_IR_OperationDescription, 0, sizeof (IR_OperationDescription));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_OperationDescription, &_tc_TAO_tc_IR_OperationDescription)
-TAO_NAMESPACE_END
-
-void IR_OperationDescription::_tao_any_destructor (void *x)
-{
-  IR_OperationDescription *tmp = ACE_static_cast (IR_OperationDescription*,x);
-  delete tmp;
-}
-
-// *************************************************************
-// IR_RepositoryIdSeq
-// *************************************************************
-
-IR_RepositoryIdSeq::IR_RepositoryIdSeq (void)
-{}
-IR_RepositoryIdSeq::IR_RepositoryIdSeq (CORBA::ULong max) // uses max size
-  : 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  TAO_Unbounded_String_Sequence
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_String_Sequence
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
- (max)
-{}
-IR_RepositoryIdSeq::IR_RepositoryIdSeq (CORBA::ULong max, CORBA::ULong length, char * *buffer, CORBA::Boolean release)
-  : 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  TAO_Unbounded_String_Sequence
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_String_Sequence
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
- (max, length, buffer, release)
-{}
-IR_RepositoryIdSeq::IR_RepositoryIdSeq (const IR_RepositoryIdSeq &seq) // copy ctor
-  : 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  TAO_Unbounded_String_Sequence
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_String_Sequence
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
- (seq)
-{}
-IR_RepositoryIdSeq::~IR_RepositoryIdSeq (void) // dtor
-{}
-void IR_RepositoryIdSeq::_tao_any_destructor (void *x)
-{
-  IR_RepositoryIdSeq *tmp = ACE_static_cast (IR_RepositoryIdSeq*,x);
-  delete tmp;
-}
-
-static const CORBA::Long _oc_IR_RepositoryIdSeq[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x79496453), ACE_NTOHL (0x65713a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/RepositoryIdSeq:1.0
-  16, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x53657100),  // name = RepositoryIdSeq
-  CORBA::tk_sequence, // typecode kind
-  84, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    CORBA::tk_alias, // typecode kind for typedefs
-    68, // encapsulation length
-      TAO_ENCAP_BYTE_ORDER, // byte order
-      32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-      13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-      CORBA::tk_string, 
-      0U, // string length
-
-    0U,
-
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_RepositoryIdSeq (CORBA::tk_alias, sizeof (_oc_IR_RepositoryIdSeq), (char *) &_oc_IR_RepositoryIdSeq, 0, sizeof (IR_RepositoryIdSeq));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_RepositoryIdSeq, &_tc_TAO_tc_IR_RepositoryIdSeq)
-TAO_NAMESPACE_END
-
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  
-  void
-  _TAO_Unbounded_Sequence_IR_OpDescriptionSeq::_allocate_buffer (CORBA::ULong length)
-  {
-    IR_OperationDescription* tmp = 0;
-    tmp = _TAO_Unbounded_Sequence_IR_OpDescriptionSeq::allocbuf (length);
-    
-    if (this->buffer_ != 0)
-    {
-      IR_OperationDescription *old = ACE_reinterpret_cast (IR_OperationDescription *,this->buffer_);
-      
-      for (CORBA::ULong i = 0; i < this->length_; ++i)
-        tmp[i] = old[i];
-      
-      if (this->release_)
-        _TAO_Unbounded_Sequence_IR_OpDescriptionSeq::freebuf (old);
-      
-    }
-    this->buffer_ = tmp;
-  }
-  
-  void
-  _TAO_Unbounded_Sequence_IR_OpDescriptionSeq::_deallocate_buffer (void)
-  {
-    if (this->buffer_ == 0 || this->release_ == 0)
-      return;
-    
-    IR_OperationDescription *tmp = ACE_reinterpret_cast (IR_OperationDescription *,this->buffer_);
-    
-    _TAO_Unbounded_Sequence_IR_OpDescriptionSeq::freebuf (tmp);
-    this->buffer_ = 0;
-  } 
-  
-  _TAO_Unbounded_Sequence_IR_OpDescriptionSeq::~_TAO_Unbounded_Sequence_IR_OpDescriptionSeq (void) // Dtor.
-  {
-    this->_deallocate_buffer ();
-  }
-  
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
-
-// *************************************************************
-// IR_OpDescriptionSeq
-// *************************************************************
-
-IR_OpDescriptionSeq::IR_OpDescriptionSeq (void)
-{}
-IR_OpDescriptionSeq::IR_OpDescriptionSeq (CORBA::ULong max) // uses max size
-  : 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Sequence_IR_OpDescriptionSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Sequence<IR_OperationDescription>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
- (max)
-{}
-IR_OpDescriptionSeq::IR_OpDescriptionSeq (CORBA::ULong max, CORBA::ULong length, IR_OperationDescription *buffer, CORBA::Boolean release)
-  : 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Sequence_IR_OpDescriptionSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Sequence<IR_OperationDescription>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
- (max, length, buffer, release)
-{}
-IR_OpDescriptionSeq::IR_OpDescriptionSeq (const IR_OpDescriptionSeq &seq) // copy ctor
-  : 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Sequence_IR_OpDescriptionSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Sequence<IR_OperationDescription>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
- (seq)
-{}
-IR_OpDescriptionSeq::~IR_OpDescriptionSeq (void) // dtor
-{}
-void IR_OpDescriptionSeq::_tao_any_destructor (void *x)
-{
-  IR_OpDescriptionSeq *tmp = ACE_static_cast (IR_OpDescriptionSeq*,x);
-  delete tmp;
-}
-
-static const CORBA::Long _oc_IR_OpDescriptionSeq[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  36, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f4f), ACE_NTOHL (0x70446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x5365713a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/OpDescriptionSeq:1.0
-  17, ACE_NTOHL (0x4f704465), ACE_NTOHL (0x73637269), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e536571), ACE_NTOHL (0x0),  // name = OpDescriptionSeq
-  CORBA::tk_sequence, // typecode kind
-  1896, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    CORBA::tk_struct, // typecode kind
-    1880, // encapsulation length
-      TAO_ENCAP_BYTE_ORDER, // byte order
-      40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f4f), ACE_NTOHL (0x70657261), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/OperationDescription:1.0
-      21, ACE_NTOHL (0x4f706572), ACE_NTOHL (0x6174696f), ACE_NTOHL (0x6e446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = OperationDescription
-      9, // member count
-      5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
-      CORBA::tk_alias, // typecode kind for typedefs
-      64, // encapsulation length
-        TAO_ENCAP_BYTE_ORDER, // byte order
-        30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
-        11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-        CORBA::tk_string, 
-        0U, // string length
-
-      3, ACE_NTOHL (0x69640000),  // name = id
-      CORBA::tk_alias, // typecode kind for typedefs
-      68, // encapsulation length
-        TAO_ENCAP_BYTE_ORDER, // byte order
-        32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-        13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-        CORBA::tk_string, 
-        0U, // string length
-
-      11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
-      CORBA::tk_alias, // typecode kind for typedefs
-      68, // encapsulation length
-        TAO_ENCAP_BYTE_ORDER, // byte order
-        32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-        13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-        CORBA::tk_string, 
-        0U, // string length
-
-      8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
-      CORBA::tk_alias, // typecode kind for typedefs
-      64, // encapsulation length
-        TAO_ENCAP_BYTE_ORDER, // byte order
-        31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
-        12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
-        CORBA::tk_string, 
-        0U, // string length
-
-      7, ACE_NTOHL (0x72657375), ACE_NTOHL (0x6c740000),  // name = result
-      CORBA::tk_TypeCode,
-
-      5, ACE_NTOHL (0x6d6f6465), ACE_NTOHL (0x0),  // name = mode
-      CORBA::tk_enum, // typecode kind
-      100, // encapsulation length
-        TAO_ENCAP_BYTE_ORDER, // byte order
-        33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f4f), ACE_NTOHL (0x70657261), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x4d6f6465), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/OperationMode:1.0
-        14, ACE_NTOHL (0x4f706572), ACE_NTOHL (0x6174696f), ACE_NTOHL (0x6e4d6f64), ACE_NTOHL (0x65000000),  // name = OperationMode
-        2, // member count
-        10, ACE_NTOHL (0x4f505f4e), ACE_NTOHL (0x4f524d41), ACE_NTOHL (0x4c000000),  // name = OP_NORMAL
-        10, ACE_NTOHL (0x4f505f4f), ACE_NTOHL (0x4e455741), ACE_NTOHL (0x59000000),  // name = OP_ONEWAY
-
-      9, ACE_NTOHL (0x636f6e74), ACE_NTOHL (0x65787473), ACE_NTOHL (0x0),  // name = contexts
-      CORBA::tk_alias, // typecode kind for typedefs
-      228, // encapsulation length
-        TAO_ENCAP_BYTE_ORDER, // byte order
-        32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f43), ACE_NTOHL (0x6f6e7465), ACE_NTOHL (0x78744964), ACE_NTOHL (0x5365713a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ContextIdSeq:1.0
-        13, ACE_NTOHL (0x436f6e74), ACE_NTOHL (0x65787449), ACE_NTOHL (0x64536571), ACE_NTOHL (0x0),  // name = ContextIdSeq
-        CORBA::tk_sequence, // typecode kind
-        160, // encapsulation length
-          TAO_ENCAP_BYTE_ORDER, // byte order
-          CORBA::tk_alias, // typecode kind for typedefs
-          144, // encapsulation length
-            TAO_ENCAP_BYTE_ORDER, // byte order
-            37, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f43), ACE_NTOHL (0x6f6e7465), ACE_NTOHL (0x78744964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/ContextIdentifier:1.0
-            18, ACE_NTOHL (0x436f6e74), ACE_NTOHL (0x65787449), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x72000000),  // name = ContextIdentifier
-            CORBA::tk_alias, // typecode kind for typedefs
-            64, // encapsulation length
-              TAO_ENCAP_BYTE_ORDER, // byte order
-              30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
-              11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-              CORBA::tk_string, 
-              0U, // string length
-
-
-          0U,
-
-
-      11, ACE_NTOHL (0x70617261), ACE_NTOHL (0x6d657465), ACE_NTOHL (0x72730000),  // name = parameters
-      CORBA::tk_alias, // typecode kind for typedefs
-      484, // encapsulation length
-        TAO_ENCAP_BYTE_ORDER, // byte order
-        37, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f50), ACE_NTOHL (0x61724465), ACE_NTOHL (0x73637269), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e536571), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/ParDescriptionSeq:1.0
-        18, ACE_NTOHL (0x50617244), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e5365), ACE_NTOHL (0x71000000),  // name = ParDescriptionSeq
-        CORBA::tk_sequence, // typecode kind
-        404, // encapsulation length
-          TAO_ENCAP_BYTE_ORDER, // byte order
-          CORBA::tk_struct, // typecode kind
-          388, // encapsulation length
-            TAO_ENCAP_BYTE_ORDER, // byte order
-            40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f50), ACE_NTOHL (0x6172616d), ACE_NTOHL (0x65746572), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ParameterDescription:1.0
-            21, ACE_NTOHL (0x50617261), ACE_NTOHL (0x6d657465), ACE_NTOHL (0x72446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = ParameterDescription
-            4, // member count
-            5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
-            CORBA::tk_alias, // typecode kind for typedefs
-            64, // encapsulation length
-              TAO_ENCAP_BYTE_ORDER, // byte order
-              30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
-              11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-              CORBA::tk_string, 
-              0U, // string length
-
-            5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
-            CORBA::tk_TypeCode,
-
-            9, ACE_NTOHL (0x74797065), ACE_NTOHL (0x5f646566), ACE_NTOHL (0x0),  // name = type_def
-            CORBA::tk_objref, // typecode kind
-            48, // encapsulation length
-              TAO_ENCAP_BYTE_ORDER, // byte order
-              27, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x444c5479), ACE_NTOHL (0x70653a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/IDLType:1.0
-              8, ACE_NTOHL (0x49444c54), ACE_NTOHL (0x79706500),  // name = IR_IDLType
-
-            5, ACE_NTOHL (0x6d6f6465), ACE_NTOHL (0x0),  // name = mode
-            CORBA::tk_enum, // typecode kind
-            116, // encapsulation length
-              TAO_ENCAP_BYTE_ORDER, // byte order
-              33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f50), ACE_NTOHL (0x6172616d), ACE_NTOHL (0x65746572), ACE_NTOHL (0x4d6f6465), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/ParameterMode:1.0
-              14, ACE_NTOHL (0x50617261), ACE_NTOHL (0x6d657465), ACE_NTOHL (0x724d6f64), ACE_NTOHL (0x65000000),  // name = ParameterMode
-              3, // member count
-              9, ACE_NTOHL (0x50415241), ACE_NTOHL (0x4d5f494e), ACE_NTOHL (0x0),  // name = PARAM_IN
-              10, ACE_NTOHL (0x50415241), ACE_NTOHL (0x4d5f4f55), ACE_NTOHL (0x54000000),  // name = PARAM_OUT
-              12, ACE_NTOHL (0x50415241), ACE_NTOHL (0x4d5f494e), ACE_NTOHL (0x4f555400),  // name = PARAM_INOUT
-
-
-          0U,
-
-
-      11, ACE_NTOHL (0x65786365), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e730000),  // name = exceptions
-      CORBA::tk_alias, // typecode kind for typedefs
-      536, // encapsulation length
-        TAO_ENCAP_BYTE_ORDER, // byte order
-        37, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x78634465), ACE_NTOHL (0x73637269), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e536571), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/ExcDescriptionSeq:1.0
-        18, ACE_NTOHL (0x45786344), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e5365), ACE_NTOHL (0x71000000),  // name = ExcDescriptionSeq
-        CORBA::tk_sequence, // typecode kind
-        456, // encapsulation length
-          TAO_ENCAP_BYTE_ORDER, // byte order
-          CORBA::tk_struct, // typecode kind
-          440, // encapsulation length
-            TAO_ENCAP_BYTE_ORDER, // byte order
-            40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x78636570), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ExceptionDescription:1.0
-            21, ACE_NTOHL (0x45786365), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = ExceptionDescription
-            5, // member count
-            5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
-            CORBA::tk_alias, // typecode kind for typedefs
-            64, // encapsulation length
-              TAO_ENCAP_BYTE_ORDER, // byte order
-              30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
-              11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-              CORBA::tk_string, 
-              0U, // string length
-
-            3, ACE_NTOHL (0x69640000),  // name = id
-            CORBA::tk_alias, // typecode kind for typedefs
-            68, // encapsulation length
-              TAO_ENCAP_BYTE_ORDER, // byte order
-              32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-              13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-              CORBA::tk_string, 
-              0U, // string length
-
-            11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
-            CORBA::tk_alias, // typecode kind for typedefs
-            68, // encapsulation length
-              TAO_ENCAP_BYTE_ORDER, // byte order
-              32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-              13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-              CORBA::tk_string, 
-              0U, // string length
-
-            8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
-            CORBA::tk_alias, // typecode kind for typedefs
-            64, // encapsulation length
-              TAO_ENCAP_BYTE_ORDER, // byte order
-              31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
-              12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
-              CORBA::tk_string, 
-              0U, // string length
-
-            5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
-            CORBA::tk_TypeCode,
-
-
-          0U,
-
-
-
-    0U,
-
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_OpDescriptionSeq (CORBA::tk_alias, sizeof (_oc_IR_OpDescriptionSeq), (char *) &_oc_IR_OpDescriptionSeq, 0, sizeof (IR_OpDescriptionSeq));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_OpDescriptionSeq, &_tc_TAO_tc_IR_OpDescriptionSeq)
-TAO_NAMESPACE_END
-
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  
-  void
-  _TAO_Unbounded_Sequence_IR_AttrDescriptionSeq::_allocate_buffer (CORBA::ULong length)
-  {
-    IR_AttributeDescription* tmp = 0;
-    tmp = _TAO_Unbounded_Sequence_IR_AttrDescriptionSeq::allocbuf (length);
-    
-    if (this->buffer_ != 0)
-    {
-      IR_AttributeDescription *old = ACE_reinterpret_cast (IR_AttributeDescription *,this->buffer_);
-      
-      for (CORBA::ULong i = 0; i < this->length_; ++i)
-        tmp[i] = old[i];
-      
-      if (this->release_)
-        _TAO_Unbounded_Sequence_IR_AttrDescriptionSeq::freebuf (old);
-      
-    }
-    this->buffer_ = tmp;
-  }
-  
-  void
-  _TAO_Unbounded_Sequence_IR_AttrDescriptionSeq::_deallocate_buffer (void)
-  {
-    if (this->buffer_ == 0 || this->release_ == 0)
-      return;
-    
-    IR_AttributeDescription *tmp = ACE_reinterpret_cast (IR_AttributeDescription *,this->buffer_);
-    
-    _TAO_Unbounded_Sequence_IR_AttrDescriptionSeq::freebuf (tmp);
-    this->buffer_ = 0;
-  } 
-  
-  _TAO_Unbounded_Sequence_IR_AttrDescriptionSeq::~_TAO_Unbounded_Sequence_IR_AttrDescriptionSeq (void) // Dtor.
-  {
-    this->_deallocate_buffer ();
-  }
-  
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
-
-// *************************************************************
-// IR_AttrDescriptionSeq
-// *************************************************************
-
-IR_AttrDescriptionSeq::IR_AttrDescriptionSeq (void)
-{}
-IR_AttrDescriptionSeq::IR_AttrDescriptionSeq (CORBA::ULong max) // uses max size
-  : 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Sequence_IR_AttrDescriptionSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Sequence<IR_AttributeDescription>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
- (max)
-{}
-IR_AttrDescriptionSeq::IR_AttrDescriptionSeq (CORBA::ULong max, CORBA::ULong length, IR_AttributeDescription *buffer, CORBA::Boolean release)
-  : 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Sequence_IR_AttrDescriptionSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Sequence<IR_AttributeDescription>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
- (max, length, buffer, release)
-{}
-IR_AttrDescriptionSeq::IR_AttrDescriptionSeq (const IR_AttrDescriptionSeq &seq) // copy ctor
-  : 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Sequence_IR_AttrDescriptionSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Sequence<IR_AttributeDescription>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
- (seq)
-{}
-IR_AttrDescriptionSeq::~IR_AttrDescriptionSeq (void) // dtor
-{}
-void IR_AttrDescriptionSeq::_tao_any_destructor (void *x)
-{
-  IR_AttrDescriptionSeq *tmp = ACE_static_cast (IR_AttrDescriptionSeq*,x);
-  delete tmp;
-}
-
-static const CORBA::Long _oc_IR_AttrDescriptionSeq[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  38, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f41), ACE_NTOHL (0x74747244), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e5365), ACE_NTOHL (0x713a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/AttrDescriptionSeq:1.0
-  19, ACE_NTOHL (0x41747472), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x65710000),  // name = AttrDescriptionSeq
-  CORBA::tk_sequence, // typecode kind
-  1708, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    CORBA::tk_struct, // typecode kind
-    1692, // encapsulation length
-      TAO_ENCAP_BYTE_ORDER, // byte order
-      40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f41), ACE_NTOHL (0x74747269), ACE_NTOHL (0x62757465), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/AttributeDescription:1.0
-      21, ACE_NTOHL (0x41747472), ACE_NTOHL (0x69627574), ACE_NTOHL (0x65446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = AttributeDescription
-      8, // member count
-      5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
-      CORBA::tk_alias, // typecode kind for typedefs
-      64, // encapsulation length
-        TAO_ENCAP_BYTE_ORDER, // byte order
-        30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
-        11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-        CORBA::tk_string, 
-        0U, // string length
-
-      3, ACE_NTOHL (0x69640000),  // name = id
-      CORBA::tk_alias, // typecode kind for typedefs
-      68, // encapsulation length
-        TAO_ENCAP_BYTE_ORDER, // byte order
-        32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-        13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-        CORBA::tk_string, 
-        0U, // string length
-
-      11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
-      CORBA::tk_alias, // typecode kind for typedefs
-      68, // encapsulation length
-        TAO_ENCAP_BYTE_ORDER, // byte order
-        32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-        13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-        CORBA::tk_string, 
-        0U, // string length
-
-      8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
-      CORBA::tk_alias, // typecode kind for typedefs
-      64, // encapsulation length
-        TAO_ENCAP_BYTE_ORDER, // byte order
-        31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
-        12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
-        CORBA::tk_string, 
-        0U, // string length
-
-      5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
-      CORBA::tk_TypeCode,
-
-      5, ACE_NTOHL (0x6d6f6465), ACE_NTOHL (0x0),  // name = mode
-      CORBA::tk_enum, // typecode kind
-      104, // encapsulation length
-        TAO_ENCAP_BYTE_ORDER, // byte order
-        33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f41), ACE_NTOHL (0x74747269), ACE_NTOHL (0x62757465), ACE_NTOHL (0x4d6f6465), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/AttributeMode:1.0
-        14, ACE_NTOHL (0x41747472), ACE_NTOHL (0x69627574), ACE_NTOHL (0x654d6f64), ACE_NTOHL (0x65000000),  // name = AttributeMode
-        2, // member count
-        12, ACE_NTOHL (0x41545452), ACE_NTOHL (0x5f4e4f52), ACE_NTOHL (0x4d414c00),  // name = ATTR_NORMAL
-        14, ACE_NTOHL (0x41545452), ACE_NTOHL (0x5f524541), ACE_NTOHL (0x444f4e4c), ACE_NTOHL (0x59000000),  // name = ATTR_READONLY
-
-      15, ACE_NTOHL (0x6765745f), ACE_NTOHL (0x65786365), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e730000),  // name = get_exceptions
-      CORBA::tk_alias, // typecode kind for typedefs
-      536, // encapsulation length
-        TAO_ENCAP_BYTE_ORDER, // byte order
-        37, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x78634465), ACE_NTOHL (0x73637269), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e536571), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/ExcDescriptionSeq:1.0
-        18, ACE_NTOHL (0x45786344), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e5365), ACE_NTOHL (0x71000000),  // name = ExcDescriptionSeq
-        CORBA::tk_sequence, // typecode kind
-        456, // encapsulation length
-          TAO_ENCAP_BYTE_ORDER, // byte order
-          CORBA::tk_struct, // typecode kind
-          440, // encapsulation length
-            TAO_ENCAP_BYTE_ORDER, // byte order
-            40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x78636570), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ExceptionDescription:1.0
-            21, ACE_NTOHL (0x45786365), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = ExceptionDescription
-            5, // member count
-            5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
-            CORBA::tk_alias, // typecode kind for typedefs
-            64, // encapsulation length
-              TAO_ENCAP_BYTE_ORDER, // byte order
-              30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
-              11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-              CORBA::tk_string, 
-              0U, // string length
-
-            3, ACE_NTOHL (0x69640000),  // name = id
-            CORBA::tk_alias, // typecode kind for typedefs
-            68, // encapsulation length
-              TAO_ENCAP_BYTE_ORDER, // byte order
-              32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-              13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-              CORBA::tk_string, 
-              0U, // string length
-
-            11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
-            CORBA::tk_alias, // typecode kind for typedefs
-            68, // encapsulation length
-              TAO_ENCAP_BYTE_ORDER, // byte order
-              32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-              13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-              CORBA::tk_string, 
-              0U, // string length
-
-            8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
-            CORBA::tk_alias, // typecode kind for typedefs
-            64, // encapsulation length
-              TAO_ENCAP_BYTE_ORDER, // byte order
-              31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
-              12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
-              CORBA::tk_string, 
-              0U, // string length
-
-            5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
-            CORBA::tk_TypeCode,
-
-
-          0U,
-
-
-      15, ACE_NTOHL (0x7075745f), ACE_NTOHL (0x65786365), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e730000),  // name = put_exceptions
-      CORBA::tk_alias, // typecode kind for typedefs
-      536, // encapsulation length
-        TAO_ENCAP_BYTE_ORDER, // byte order
-        37, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x78634465), ACE_NTOHL (0x73637269), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e536571), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/ExcDescriptionSeq:1.0
-        18, ACE_NTOHL (0x45786344), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e5365), ACE_NTOHL (0x71000000),  // name = ExcDescriptionSeq
-        CORBA::tk_sequence, // typecode kind
-        456, // encapsulation length
-          TAO_ENCAP_BYTE_ORDER, // byte order
-          CORBA::tk_struct, // typecode kind
-          440, // encapsulation length
-            TAO_ENCAP_BYTE_ORDER, // byte order
-            40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x78636570), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ExceptionDescription:1.0
-            21, ACE_NTOHL (0x45786365), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = ExceptionDescription
-            5, // member count
-            5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
-            CORBA::tk_alias, // typecode kind for typedefs
-            64, // encapsulation length
-              TAO_ENCAP_BYTE_ORDER, // byte order
-              30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
-              11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-              CORBA::tk_string, 
-              0U, // string length
-
-            3, ACE_NTOHL (0x69640000),  // name = id
-            CORBA::tk_alias, // typecode kind for typedefs
-            68, // encapsulation length
-              TAO_ENCAP_BYTE_ORDER, // byte order
-              32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-              13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-              CORBA::tk_string, 
-              0U, // string length
-
-            11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
-            CORBA::tk_alias, // typecode kind for typedefs
-            68, // encapsulation length
-              TAO_ENCAP_BYTE_ORDER, // byte order
-              32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-              13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-              CORBA::tk_string, 
-              0U, // string length
-
-            8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
-            CORBA::tk_alias, // typecode kind for typedefs
-            64, // encapsulation length
-              TAO_ENCAP_BYTE_ORDER, // byte order
-              31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
-              12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
-              CORBA::tk_string, 
-              0U, // string length
-
-            5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
-            CORBA::tk_TypeCode,
-
-
-          0U,
-
-
-
-    0U,
-
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_AttrDescriptionSeq (CORBA::tk_alias, sizeof (_oc_IR_AttrDescriptionSeq), (char *) &_oc_IR_AttrDescriptionSeq, 0, sizeof (IR_AttrDescriptionSeq));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_AttrDescriptionSeq, &_tc_TAO_tc_IR_AttrDescriptionSeq)
-TAO_NAMESPACE_END
-
-///////////////////////////////////////////////////////////////////////
-//                Base & Remote Proxy  Implementation. 
-//
-
-_TAO_InterfaceDef_Proxy_Impl::_TAO_InterfaceDef_Proxy_Impl (void)
-{}
-
-_TAO_InterfaceDef_Remote_Proxy_Impl::_TAO_InterfaceDef_Remote_Proxy_Impl (void)
-{}
-
-// Remote Implementation of the IDL interface methods
-
-IR_InterfaceDefSeq * _TAO_InterfaceDef_Remote_Proxy_Impl::base_interfaces (
-    CORBA_Object *_collocated_tao_target_,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  
-  IR_InterfaceDefSeq *_tao_retval = 0;
-  
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-
-  
-  ACE_NEW_RETURN (_tao_retval, IR_InterfaceDefSeq, _tao_retval);
-  IR_InterfaceDefSeq_var _tao_safe_retval (_tao_retval);
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_get_base_interfaces",
-      20,
-      0,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_InterfaceDef::TAO_ClientRequestInfo_IR_InterfaceDef_base_interfaces_get ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              IR_InterfaceDefSeq * _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-void _TAO_InterfaceDef_Remote_Proxy_Impl::base_interfaces (
-    CORBA_Object *_collocated_tao_target_,
-    const IR_InterfaceDefSeq & base_interfaces,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW (CORBA::INTERNAL ());
-
-  
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_set_base_interfaces",
-      20,
-      1,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_InterfaceDef::TAO_ClientRequestInfo_IR_InterfaceDef_base_interfaces_set ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        base_interfaces,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK;
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK;
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK;
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK;
-          
-          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-          if (!(
-                            (_tao_out << base_interfaces)
-            ))
-            TAO_INTERCEPTOR_THROW (
-              CORBA::MARSHAL ()
-            );
-            
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK;
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)
-              );
-              
-            }
-          
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK;
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK;
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  
-}
-
-CORBA::Boolean _TAO_InterfaceDef_Remote_Proxy_Impl::is_abstract (
-    CORBA_Object *_collocated_tao_target_,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  
-  CORBA::Boolean _tao_retval = 0;
-  
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), _tao_retval);
-
-  
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_get_is_abstract",
-      16,
-      0,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_InterfaceDef::TAO_ClientRequestInfo_IR_InterfaceDef_is_abstract_get ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN  (_tao_retval);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                _tao_retval
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> CORBA::Any::to_boolean (_tao_retval))
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                _tao_retval
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              CORBA::Boolean  _tao_retval_info = _tao_retval;
-               ri.result (_tao_retval_info);
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN  (_tao_retval);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_retval;
-}
-
-void _TAO_InterfaceDef_Remote_Proxy_Impl::is_abstract (
-    CORBA_Object *_collocated_tao_target_,
-    CORBA::Boolean is_abstract,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW (CORBA::INTERNAL ());
-
-  
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_set_is_abstract",
-      16,
-      1,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_InterfaceDef::TAO_ClientRequestInfo_IR_InterfaceDef_is_abstract_set ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        is_abstract,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK;
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK;
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK;
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK;
-          
-          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-          if (!(
-                            (_tao_out << CORBA::Any::from_boolean (is_abstract))
-            ))
-            TAO_INTERCEPTOR_THROW (
-              CORBA::MARSHAL ()
-            );
-            
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK;
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)
-              );
-              
-            }
-          
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK;
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK;
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  
-}
-
-CORBA::Boolean _TAO_InterfaceDef_Remote_Proxy_Impl::is_local (
-    CORBA_Object *_collocated_tao_target_,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  
-  CORBA::Boolean _tao_retval = 0;
-  
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), _tao_retval);
-
-  
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_get_is_local",
-      13,
-      0,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_InterfaceDef::TAO_ClientRequestInfo_IR_InterfaceDef_is_local_get ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN  (_tao_retval);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                _tao_retval
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> CORBA::Any::to_boolean (_tao_retval))
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                _tao_retval
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              CORBA::Boolean  _tao_retval_info = _tao_retval;
-               ri.result (_tao_retval_info);
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN  (_tao_retval);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_retval;
-}
-
-void _TAO_InterfaceDef_Remote_Proxy_Impl::is_local (
-    CORBA_Object *_collocated_tao_target_,
-    CORBA::Boolean is_local,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW (CORBA::INTERNAL ());
-
-  
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_set_is_local",
-      13,
-      1,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_InterfaceDef::TAO_ClientRequestInfo_IR_InterfaceDef_is_local_set ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        is_local,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK;
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK;
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK;
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK;
-          
-          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-          if (!(
-                            (_tao_out << CORBA::Any::from_boolean (is_local))
-            ))
-            TAO_INTERCEPTOR_THROW (
-              CORBA::MARSHAL ()
-            );
-            
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK;
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)
-              );
-              
-            }
-          
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK;
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK;
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  
-}
-
-CORBA::Boolean _TAO_InterfaceDef_Remote_Proxy_Impl::is_a (
-    CORBA_Object *_collocated_tao_target_,
-    const char * interface_id,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  
-  CORBA::Boolean _tao_retval = 0;
-  
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), _tao_retval);
-
-  
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "is_a",
-      4,
-      1,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_InterfaceDef::TAO_ClientRequestInfo_IR_InterfaceDef_is_a ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        interface_id,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN  (_tao_retval);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-          if (!(
-                            (_tao_out << interface_id)
-            ))
-            TAO_INTERCEPTOR_THROW_RETURN (
-              CORBA::MARSHAL (),
-              _tao_retval
-            );
-            
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                _tao_retval
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> CORBA::Any::to_boolean (_tao_retval))
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                _tao_retval
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              CORBA::Boolean  _tao_retval_info = _tao_retval;
-               ri.result (_tao_retval_info);
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN  (_tao_retval);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_retval;
-}
-
-IR_AttributeDef_ptr _TAO_InterfaceDef_Remote_Proxy_Impl::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,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  
-  IR_AttributeDef_ptr _tao_retval = IR_AttributeDef::_nil ();
-  IR_AttributeDef_var _tao_safe_retval (_tao_retval);
-  
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-
-  
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "create_attribute",
-      16,
-      1,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_InterfaceDef::TAO_ClientRequestInfo_IR_InterfaceDef_create_attribute ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        id,
-        name,
-        version,
-        type,
-        mode,
-        get_exceptions,
-        put_exceptions,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-          if (!(
-                            (_tao_out << id) &&
-              (_tao_out << name) &&
-              (_tao_out << version) &&
-              (_tao_out << type) &&
-              (_tao_out << mode) &&
-              (_tao_out << get_exceptions) &&
-              (_tao_out << put_exceptions)
-            ))
-            TAO_INTERCEPTOR_THROW_RETURN (
-              CORBA::MARSHAL (),
-              0
-            );
-            
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              IR_AttributeDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-IR_OperationDef_ptr _TAO_InterfaceDef_Remote_Proxy_Impl::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,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  
-  IR_OperationDef_ptr _tao_retval = IR_OperationDef::_nil ();
-  IR_OperationDef_var _tao_safe_retval (_tao_retval);
-  
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-
-  
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "create_operation",
-      16,
-      1,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_InterfaceDef::TAO_ClientRequestInfo_IR_InterfaceDef_create_operation ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        id,
-        name,
-        version,
-        result,
-        mode,
-        params,
-        exceptions,
-        contexts,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-          if (!(
-                            (_tao_out << id) &&
-              (_tao_out << name) &&
-              (_tao_out << version) &&
-              (_tao_out << result) &&
-              (_tao_out << mode) &&
-              (_tao_out << params) &&
-              (_tao_out << exceptions) &&
-              (_tao_out << contexts)
-            ))
-            TAO_INTERCEPTOR_THROW_RETURN (
-              CORBA::MARSHAL (),
-              0
-            );
-            
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              IR_OperationDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-
-//
-//            End  Base & Remote  Proxy Implemeentation. 
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//           Remote & Base  Proxy Broker Implementation
-//
-
-_TAO_InterfaceDef_Proxy_Broker::_TAO_InterfaceDef_Proxy_Broker (void)
-{
-}
-
-_TAO_InterfaceDef_Proxy_Broker::~_TAO_InterfaceDef_Proxy_Broker (void)
-{
-}
-
-_TAO_InterfaceDef_Proxy_Broker * (*_TAO_InterfaceDef_Proxy_Broker_Factory_function_pointer) (
-    CORBA::Object_ptr obj
-  ) = 0;
-
-// Factory Member function Implementation.
-_TAO_InterfaceDef_Remote_Proxy_Broker *
-_TAO_InterfaceDef_Remote_Proxy_Broker::the_TAO_InterfaceDef_Remote_Proxy_Broker (void)
-{
-  static ::_TAO_InterfaceDef_Remote_Proxy_Broker remote_proxy_broker;
-  return &remote_proxy_broker;
-}
-
-_TAO_InterfaceDef_Remote_Proxy_Broker::_TAO_InterfaceDef_Remote_Proxy_Broker (void)
-{
-}
-
-_TAO_InterfaceDef_Remote_Proxy_Broker::~_TAO_InterfaceDef_Remote_Proxy_Broker (void)
-{
-}
-
-_TAO_InterfaceDef_Proxy_Impl&
-_TAO_InterfaceDef_Remote_Proxy_Broker::select_proxy (
-  ::IR_InterfaceDef *object,
-  CORBA::Environment &ACE_TRY_ENV
-)
-{
-  ACE_UNUSED_ARG (object);
-  ACE_UNUSED_ARG (ACE_TRY_ENV);
-  return remote_proxy_impl_;
-}
-
-
-//
-//           End Remote & Base Proxy Broker Implementation
-///////////////////////////////////////////////////////////////////////
-
-
-// default constructor
-IR_InterfaceDef::IR_InterfaceDef (int collocated)
-{
-  this->IR_InterfaceDef_setup_collocation (collocated);
-}
-
-// destructor
-IR_InterfaceDef::~IR_InterfaceDef (void)
-{}
-
-void
-IR_InterfaceDef::IR_InterfaceDef_setup_collocation (int collocated)
-{
-  if (collocated)
-    this->the_TAO_InterfaceDef_Proxy_Broker_ =
-      _TAO_InterfaceDef_Proxy_Broker_Factory_function_pointer (this);
-  else
-    this->the_TAO_InterfaceDef_Proxy_Broker_ =
-      _TAO_InterfaceDef_Remote_Proxy_Broker::the_TAO_InterfaceDef_Remote_Proxy_Broker ();
-  
-  this->IR_Container_setup_collocation (collocated);
-  this->IR_Contained_setup_collocation (collocated);
-  this->IR_IDLType_setup_collocation (collocated);
-}
-
-void IR_InterfaceDef::_tao_any_destructor (void *x)
-{
-  IR_InterfaceDef *tmp = ACE_static_cast (IR_InterfaceDef*,x);
-  CORBA::release (tmp);
-}
-
-IR_InterfaceDef_ptr IR_InterfaceDef::_narrow (
-    CORBA::Object_ptr obj,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  if (CORBA::is_nil (obj))
-    return IR_InterfaceDef::_nil ();
-  if (! obj->_is_local ())
-    {
-      CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/IR/InterfaceDef:1.0", ACE_TRY_ENV);
-      ACE_CHECK_RETURN (IR_InterfaceDef::_nil ());
-      if (is_a == 0)
-        return IR_InterfaceDef::_nil ();
-    }
-  return IR_InterfaceDef::_unchecked_narrow (obj, ACE_TRY_ENV);
-}
-
-IR_InterfaceDef_ptr IR_InterfaceDef::_unchecked_narrow (
-    CORBA::Object_ptr obj,
-    CORBA::Environment &
-  )
-{
-  if (CORBA::is_nil (obj))
-    return IR_InterfaceDef::_nil ();
-  if (! obj->_is_local ())
-    {
-      TAO_Stub* stub = obj->_stubobj ();
-      if (stub)
-        stub->_incr_refcnt ();
-      IR_InterfaceDef_ptr default_proxy = IR_InterfaceDef::_nil ();
-
-      if (
-          !CORBA::is_nil (stub->servant_orb_var ().ptr ()) &&
-          stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects () &&
-          obj->_is_collocated () &&_TAO_InterfaceDef_Proxy_Broker_Factory_function_pointer != 0
-        )
-      {
-        ACE_NEW_RETURN (
-          default_proxy,
-          ::IR_InterfaceDef (
-            stub,
-            1,
-            obj->_servant ()),
-            
-          IR_InterfaceDef::_nil ());
-        }
-      if (CORBA::is_nil (default_proxy))
-        ACE_NEW_RETURN (default_proxy, ::IR_InterfaceDef (stub, 0, obj->_servant ()), IR_InterfaceDef::_nil ());
-        return default_proxy;
-      }
-    else 
-      return
-        ACE_reinterpret_cast
-          (
-            IR_InterfaceDef_ptr,
-              obj->_tao_QueryInterface
-                (
-                  ACE_reinterpret_cast
-                    (
-                      ptr_arith_t,
-                      &IR_InterfaceDef::_narrow
-                    )
-                )
-          );
-}
-
-IR_InterfaceDef_ptr
-IR_InterfaceDef::_duplicate (IR_InterfaceDef_ptr obj)
-{
-  if (!CORBA::is_nil (obj))
-    obj->_add_ref ();
-  return obj;
-}
-
-CORBA::Boolean IR_InterfaceDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
-{
-  if (
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/InterfaceDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/Container:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/Contained:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/IDLType:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
-  return 1; // success using local knowledge
-  else
-    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
-}
-
-void *IR_InterfaceDef::_tao_QueryInterface (ptr_arith_t type)
-{
-  void *retv = 0;
-  if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_InterfaceDef::_narrow))
-    retv = ACE_reinterpret_cast (void*, this);
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_Container::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            IR_Container_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_Contained::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            IR_Contained_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_IDLType::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            IR_IDLType_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &CORBA_IRObject::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            CORBA_IRObject_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
-    retv = ACE_reinterpret_cast (void *,
-      ACE_static_cast (CORBA::Object_ptr, this));
-    
-  if (retv)
-    this->_add_ref ();
-  return retv;
-}
-
-const char* IR_InterfaceDef::_interface_repository_id (void) const
-{
-  return "IDL:omg.org/IR/InterfaceDef:1.0";
-}
-
-IR_InterfaceDefSeq * IR_InterfaceDef::base_interfaces (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_InterfaceDef_Proxy_Impl &proxy = 
-    this->the_TAO_InterfaceDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.base_interfaces (
-      this,
-      ACE_TRY_ENV
-    );
-}
-
-void IR_InterfaceDef::base_interfaces (
-    const IR_InterfaceDefSeq & base_interfaces,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_InterfaceDef_Proxy_Impl &proxy = 
-    this->the_TAO_InterfaceDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK;
-  
-  proxy.base_interfaces (
-      this,
-      base_interfaces,
-      ACE_TRY_ENV
-    );
-}
-
-CORBA::Boolean IR_InterfaceDef::is_abstract (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_InterfaceDef_Proxy_Impl &proxy = 
-    this->the_TAO_InterfaceDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.is_abstract (
-      this,
-      ACE_TRY_ENV
-    );
-}
-
-void IR_InterfaceDef::is_abstract (
-    CORBA::Boolean is_abstract,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_InterfaceDef_Proxy_Impl &proxy = 
-    this->the_TAO_InterfaceDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK;
-  
-  proxy.is_abstract (
-      this,
-      is_abstract,
-      ACE_TRY_ENV
-    );
-}
-
-CORBA::Boolean IR_InterfaceDef::is_local (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_InterfaceDef_Proxy_Impl &proxy = 
-    this->the_TAO_InterfaceDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.is_local (
-      this,
-      ACE_TRY_ENV
-    );
-}
-
-void IR_InterfaceDef::is_local (
-    CORBA::Boolean is_local,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_InterfaceDef_Proxy_Impl &proxy = 
-    this->the_TAO_InterfaceDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK;
-  
-  proxy.is_local (
-      this,
-      is_local,
-      ACE_TRY_ENV
-    );
-}
-
-CORBA::Boolean IR_InterfaceDef::is_a (
-    const char * interface_id,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_InterfaceDef_Proxy_Impl &proxy = 
-    this->the_TAO_InterfaceDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.is_a (
-      this,
-      interface_id,
-      ACE_TRY_ENV
-    );
-}
-
-IR_AttributeDef_ptr IR_InterfaceDef::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,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_InterfaceDef_Proxy_Impl &proxy = 
-    this->the_TAO_InterfaceDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.create_attribute (
-      this,
-      id,
-      name,
-      version,
-      type,
-      mode,
-      get_exceptions,
-      put_exceptions,
-      ACE_TRY_ENV
-    );
-}
-
-IR_OperationDef_ptr IR_InterfaceDef::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,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_InterfaceDef_Proxy_Impl &proxy = 
-    this->the_TAO_InterfaceDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.create_operation (
-      this,
-      id,
-      name,
-      version,
-      result,
-      mode,
-      params,
-      exceptions,
-      contexts,
-      ACE_TRY_ENV
-    );
-}
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-IR_InterfaceDef::TAO_ClientRequestInfo_IR_InterfaceDef_base_interfaces_get::TAO_ClientRequestInfo_IR_InterfaceDef_base_interfaces_get (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
-{}
-
-Dynamic::ParameterList *
-IR_InterfaceDef::TAO_ClientRequestInfo_IR_InterfaceDef_base_interfaces_get::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return parameter_list;
-}
-
-Dynamic::ExceptionList *
-IR_InterfaceDef::TAO_ClientRequestInfo_IR_InterfaceDef_base_interfaces_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_InterfaceDef::TAO_ClientRequestInfo_IR_InterfaceDef_base_interfaces_get::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_InterfaceDef::TAO_ClientRequestInfo_IR_InterfaceDef_base_interfaces_get::result (IR_InterfaceDefSeq * result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_InterfaceDef::TAO_ClientRequestInfo_IR_InterfaceDef_base_interfaces_set::TAO_ClientRequestInfo_IR_InterfaceDef_base_interfaces_set (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    const IR_InterfaceDefSeq & base_interfaces,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
-    base_interfaces_ (base_interfaces)
-{}
-
-Dynamic::ParameterList *
-IR_InterfaceDef::TAO_ClientRequestInfo_IR_InterfaceDef_base_interfaces_set::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
-    
-  CORBA::ULong length_base_interfaces = parameter_list->length ();
-  parameter_list->length (length_base_interfaces + 1);
-  (*parameter_list)[length_base_interfaces].argument <<=  this->base_interfaces_;
-  
-  (*parameter_list)[length_base_interfaces].mode = Dynamic::PARAM_IN;
-  
-  return safe_parameter_list._retn ();
-}
-
-Dynamic::ExceptionList *
-IR_InterfaceDef::TAO_ClientRequestInfo_IR_InterfaceDef_base_interfaces_set::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_InterfaceDef::TAO_ClientRequestInfo_IR_InterfaceDef_base_interfaces_set::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 1;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return result_any;
-}
-
-IR_InterfaceDef::TAO_ClientRequestInfo_IR_InterfaceDef_is_abstract_get::TAO_ClientRequestInfo_IR_InterfaceDef_is_abstract_get (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
-{}
-
-Dynamic::ParameterList *
-IR_InterfaceDef::TAO_ClientRequestInfo_IR_InterfaceDef_is_abstract_get::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return parameter_list;
-}
-
-Dynamic::ExceptionList *
-IR_InterfaceDef::TAO_ClientRequestInfo_IR_InterfaceDef_is_abstract_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_InterfaceDef::TAO_ClientRequestInfo_IR_InterfaceDef_is_abstract_get::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= CORBA::Any::from_boolean (this->_result);
-  return safe_result_any._retn ();
-}
-
-void 
-IR_InterfaceDef::TAO_ClientRequestInfo_IR_InterfaceDef_is_abstract_get::result (CORBA::Boolean result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_InterfaceDef::TAO_ClientRequestInfo_IR_InterfaceDef_is_abstract_set::TAO_ClientRequestInfo_IR_InterfaceDef_is_abstract_set (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    const CORBA::Boolean & is_abstract,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
-    is_abstract_ (is_abstract)
-{}
-
-Dynamic::ParameterList *
-IR_InterfaceDef::TAO_ClientRequestInfo_IR_InterfaceDef_is_abstract_set::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
-    
-  CORBA::ULong length_is_abstract = parameter_list->length ();
-  parameter_list->length (length_is_abstract + 1);
-  (*parameter_list)[length_is_abstract].argument <<= CORBA::Any::from_boolean (this->is_abstract_);
-  (*parameter_list)[length_is_abstract].mode = Dynamic::PARAM_IN;
-  
-  return safe_parameter_list._retn ();
-}
-
-Dynamic::ExceptionList *
-IR_InterfaceDef::TAO_ClientRequestInfo_IR_InterfaceDef_is_abstract_set::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_InterfaceDef::TAO_ClientRequestInfo_IR_InterfaceDef_is_abstract_set::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 1;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return result_any;
-}
-
-IR_InterfaceDef::TAO_ClientRequestInfo_IR_InterfaceDef_is_local_get::TAO_ClientRequestInfo_IR_InterfaceDef_is_local_get (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
-{}
-
-Dynamic::ParameterList *
-IR_InterfaceDef::TAO_ClientRequestInfo_IR_InterfaceDef_is_local_get::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return parameter_list;
-}
-
-Dynamic::ExceptionList *
-IR_InterfaceDef::TAO_ClientRequestInfo_IR_InterfaceDef_is_local_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_InterfaceDef::TAO_ClientRequestInfo_IR_InterfaceDef_is_local_get::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= CORBA::Any::from_boolean (this->_result);
-  return safe_result_any._retn ();
-}
-
-void 
-IR_InterfaceDef::TAO_ClientRequestInfo_IR_InterfaceDef_is_local_get::result (CORBA::Boolean result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_InterfaceDef::TAO_ClientRequestInfo_IR_InterfaceDef_is_local_set::TAO_ClientRequestInfo_IR_InterfaceDef_is_local_set (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    const CORBA::Boolean & is_local,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
-    is_local_ (is_local)
-{}
-
-Dynamic::ParameterList *
-IR_InterfaceDef::TAO_ClientRequestInfo_IR_InterfaceDef_is_local_set::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
-    
-  CORBA::ULong length_is_local = parameter_list->length ();
-  parameter_list->length (length_is_local + 1);
-  (*parameter_list)[length_is_local].argument <<= CORBA::Any::from_boolean (this->is_local_);
-  (*parameter_list)[length_is_local].mode = Dynamic::PARAM_IN;
-  
-  return safe_parameter_list._retn ();
-}
-
-Dynamic::ExceptionList *
-IR_InterfaceDef::TAO_ClientRequestInfo_IR_InterfaceDef_is_local_set::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_InterfaceDef::TAO_ClientRequestInfo_IR_InterfaceDef_is_local_set::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 1;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return result_any;
-}
-
-IR_InterfaceDef::TAO_ClientRequestInfo_IR_InterfaceDef_is_a::TAO_ClientRequestInfo_IR_InterfaceDef_is_a (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    const char * interface_id,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
-    interface_id_ (interface_id)
-{}
-
-Dynamic::ParameterList *
-IR_InterfaceDef::TAO_ClientRequestInfo_IR_InterfaceDef_is_a::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
-    
-  CORBA::ULong length_interface_id = parameter_list->length ();
-  parameter_list->length (length_interface_id + 1);
-  (*parameter_list)[length_interface_id].argument <<= interface_id_;
-  (*parameter_list)[length_interface_id].mode = Dynamic::PARAM_IN;
-  
-  return safe_parameter_list._retn ();
-}
-
-Dynamic::ExceptionList *
-IR_InterfaceDef::TAO_ClientRequestInfo_IR_InterfaceDef_is_a::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_InterfaceDef::TAO_ClientRequestInfo_IR_InterfaceDef_is_a::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= CORBA::Any::from_boolean (this->_result);
-  return safe_result_any._retn ();
-}
-
-void 
-IR_InterfaceDef::TAO_ClientRequestInfo_IR_InterfaceDef_is_a::result (CORBA::Boolean result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_InterfaceDef::TAO_ClientRequestInfo_IR_InterfaceDef_create_attribute::TAO_ClientRequestInfo_IR_InterfaceDef_create_attribute (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _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 &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
-    id_ (id),
-    name_ (name),
-    version_ (version),
-    type_ (type),
-    mode_ (mode),
-    get_exceptions_ (get_exceptions),
-    put_exceptions_ (put_exceptions)
-{}
-
-Dynamic::ParameterList *
-IR_InterfaceDef::TAO_ClientRequestInfo_IR_InterfaceDef_create_attribute::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
-    
-  CORBA::ULong length_id = parameter_list->length ();
-  parameter_list->length (length_id + 1);
-  (*parameter_list)[length_id].argument <<= id_;
-  (*parameter_list)[length_id].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_name = parameter_list->length ();
-  parameter_list->length (length_name + 1);
-  (*parameter_list)[length_name].argument <<= name_;
-  (*parameter_list)[length_name].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_version = parameter_list->length ();
-  parameter_list->length (length_version + 1);
-  (*parameter_list)[length_version].argument <<= version_;
-  (*parameter_list)[length_version].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_type = parameter_list->length ();
-  parameter_list->length (length_type + 1);
-  (*parameter_list)[length_type].argument <<=  this->type_;
-  
-  (*parameter_list)[length_type].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_mode = parameter_list->length ();
-  parameter_list->length (length_mode + 1);
-  (*parameter_list)[length_mode].argument <<=  this->mode_;
-  
-  (*parameter_list)[length_mode].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_get_exceptions = parameter_list->length ();
-  parameter_list->length (length_get_exceptions + 1);
-  (*parameter_list)[length_get_exceptions].argument <<=  this->get_exceptions_;
-  
-  (*parameter_list)[length_get_exceptions].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_put_exceptions = parameter_list->length ();
-  parameter_list->length (length_put_exceptions + 1);
-  (*parameter_list)[length_put_exceptions].argument <<=  this->put_exceptions_;
-  
-  (*parameter_list)[length_put_exceptions].mode = Dynamic::PARAM_IN;
-  
-  return safe_parameter_list._retn ();
-}
-
-Dynamic::ExceptionList *
-IR_InterfaceDef::TAO_ClientRequestInfo_IR_InterfaceDef_create_attribute::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_InterfaceDef::TAO_ClientRequestInfo_IR_InterfaceDef_create_attribute::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_InterfaceDef::TAO_ClientRequestInfo_IR_InterfaceDef_create_attribute::result (IR_AttributeDef_ptr result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_InterfaceDef::TAO_ClientRequestInfo_IR_InterfaceDef_create_operation::TAO_ClientRequestInfo_IR_InterfaceDef_create_operation (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _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 &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
-    id_ (id),
-    name_ (name),
-    version_ (version),
-    result_ (result),
-    mode_ (mode),
-    params_ (params),
-    exceptions_ (exceptions),
-    contexts_ (contexts)
-{}
-
-Dynamic::ParameterList *
-IR_InterfaceDef::TAO_ClientRequestInfo_IR_InterfaceDef_create_operation::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
-    
-  CORBA::ULong length_id = parameter_list->length ();
-  parameter_list->length (length_id + 1);
-  (*parameter_list)[length_id].argument <<= id_;
-  (*parameter_list)[length_id].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_name = parameter_list->length ();
-  parameter_list->length (length_name + 1);
-  (*parameter_list)[length_name].argument <<= name_;
-  (*parameter_list)[length_name].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_version = parameter_list->length ();
-  parameter_list->length (length_version + 1);
-  (*parameter_list)[length_version].argument <<= version_;
-  (*parameter_list)[length_version].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_result = parameter_list->length ();
-  parameter_list->length (length_result + 1);
-  (*parameter_list)[length_result].argument <<=  this->result_;
-  
-  (*parameter_list)[length_result].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_mode = parameter_list->length ();
-  parameter_list->length (length_mode + 1);
-  (*parameter_list)[length_mode].argument <<=  this->mode_;
-  
-  (*parameter_list)[length_mode].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_params = parameter_list->length ();
-  parameter_list->length (length_params + 1);
-  (*parameter_list)[length_params].argument <<=  this->params_;
-  
-  (*parameter_list)[length_params].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_exceptions = parameter_list->length ();
-  parameter_list->length (length_exceptions + 1);
-  (*parameter_list)[length_exceptions].argument <<=  this->exceptions_;
-  
-  (*parameter_list)[length_exceptions].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_contexts = parameter_list->length ();
-  parameter_list->length (length_contexts + 1);
-  (*parameter_list)[length_contexts].argument <<=  this->contexts_;
-  
-  (*parameter_list)[length_contexts].mode = Dynamic::PARAM_IN;
-  
-  return safe_parameter_list._retn ();
-}
-
-Dynamic::ExceptionList *
-IR_InterfaceDef::TAO_ClientRequestInfo_IR_InterfaceDef_create_operation::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_InterfaceDef::TAO_ClientRequestInfo_IR_InterfaceDef_create_operation::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_InterfaceDef::TAO_ClientRequestInfo_IR_InterfaceDef_create_operation::result (IR_OperationDef_ptr result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-#endif /* TAO_HAS_INTERCEPTORS */
-
-static const CORBA::Long _oc_IR_InterfaceDef[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x6e746572), ACE_NTOHL (0x66616365), ACE_NTOHL (0x4465663a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/InterfaceDef:1.0
-  13, ACE_NTOHL (0x496e7465), ACE_NTOHL (0x72666163), ACE_NTOHL (0x65446566), ACE_NTOHL (0x0),  // name = IR_InterfaceDef
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_InterfaceDef (CORBA::tk_objref, sizeof (_oc_IR_InterfaceDef), (char *) &_oc_IR_InterfaceDef, 0, sizeof (IR_InterfaceDef));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_InterfaceDef, &_tc_TAO_tc_IR_InterfaceDef)
-TAO_NAMESPACE_END
-
-static const CORBA::Long _oc_IR_InterfaceDescription[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x6e746572), ACE_NTOHL (0x66616365), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/InterfaceDescription:1.0
-  21, ACE_NTOHL (0x496e7465), ACE_NTOHL (0x72666163), ACE_NTOHL (0x65446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = InterfaceDescription
-  10, // member count
-  5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
-  CORBA::tk_alias, // typecode kind for typedefs
-  64, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
-    11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-    CORBA::tk_string, 
-    0U, // string length
-
-  3, ACE_NTOHL (0x69640000),  // name = id
-  CORBA::tk_alias, // typecode kind for typedefs
-  68, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-    13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-    CORBA::tk_string, 
-    0U, // string length
-
-  11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
-  CORBA::tk_alias, // typecode kind for typedefs
-  68, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-    13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-    CORBA::tk_string, 
-    0U, // string length
-
-  8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
-  CORBA::tk_alias, // typecode kind for typedefs
-  64, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
-    12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
-    CORBA::tk_string, 
-    0U, // string length
-
-  11, ACE_NTOHL (0x6f706572), ACE_NTOHL (0x6174696f), ACE_NTOHL (0x6e730000),  // name = operations
-  CORBA::tk_alias, // typecode kind for typedefs
-  1972, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    36, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f4f), ACE_NTOHL (0x70446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x5365713a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/OpDescriptionSeq:1.0
-    17, ACE_NTOHL (0x4f704465), ACE_NTOHL (0x73637269), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e536571), ACE_NTOHL (0x0),  // name = OpDescriptionSeq
-    CORBA::tk_sequence, // typecode kind
-    1896, // encapsulation length
-      TAO_ENCAP_BYTE_ORDER, // byte order
-      CORBA::tk_struct, // typecode kind
-      1880, // encapsulation length
-        TAO_ENCAP_BYTE_ORDER, // byte order
-        40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f4f), ACE_NTOHL (0x70657261), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/OperationDescription:1.0
-        21, ACE_NTOHL (0x4f706572), ACE_NTOHL (0x6174696f), ACE_NTOHL (0x6e446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = OperationDescription
-        9, // member count
-        5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
-        CORBA::tk_alias, // typecode kind for typedefs
-        64, // encapsulation length
-          TAO_ENCAP_BYTE_ORDER, // byte order
-          30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
-          11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-          CORBA::tk_string, 
-          0U, // string length
-
-        3, ACE_NTOHL (0x69640000),  // name = id
-        CORBA::tk_alias, // typecode kind for typedefs
-        68, // encapsulation length
-          TAO_ENCAP_BYTE_ORDER, // byte order
-          32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-          13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-          CORBA::tk_string, 
-          0U, // string length
-
-        11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
-        CORBA::tk_alias, // typecode kind for typedefs
-        68, // encapsulation length
-          TAO_ENCAP_BYTE_ORDER, // byte order
-          32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-          13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-          CORBA::tk_string, 
-          0U, // string length
-
-        8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
-        CORBA::tk_alias, // typecode kind for typedefs
-        64, // encapsulation length
-          TAO_ENCAP_BYTE_ORDER, // byte order
-          31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
-          12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
-          CORBA::tk_string, 
-          0U, // string length
-
-        7, ACE_NTOHL (0x72657375), ACE_NTOHL (0x6c740000),  // name = result
-        CORBA::tk_TypeCode,
-
-        5, ACE_NTOHL (0x6d6f6465), ACE_NTOHL (0x0),  // name = mode
-        CORBA::tk_enum, // typecode kind
-        100, // encapsulation length
-          TAO_ENCAP_BYTE_ORDER, // byte order
-          33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f4f), ACE_NTOHL (0x70657261), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x4d6f6465), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/OperationMode:1.0
-          14, ACE_NTOHL (0x4f706572), ACE_NTOHL (0x6174696f), ACE_NTOHL (0x6e4d6f64), ACE_NTOHL (0x65000000),  // name = OperationMode
-          2, // member count
-          10, ACE_NTOHL (0x4f505f4e), ACE_NTOHL (0x4f524d41), ACE_NTOHL (0x4c000000),  // name = OP_NORMAL
-          10, ACE_NTOHL (0x4f505f4f), ACE_NTOHL (0x4e455741), ACE_NTOHL (0x59000000),  // name = OP_ONEWAY
-
-        9, ACE_NTOHL (0x636f6e74), ACE_NTOHL (0x65787473), ACE_NTOHL (0x0),  // name = contexts
-        CORBA::tk_alias, // typecode kind for typedefs
-        228, // encapsulation length
-          TAO_ENCAP_BYTE_ORDER, // byte order
-          32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f43), ACE_NTOHL (0x6f6e7465), ACE_NTOHL (0x78744964), ACE_NTOHL (0x5365713a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ContextIdSeq:1.0
-          13, ACE_NTOHL (0x436f6e74), ACE_NTOHL (0x65787449), ACE_NTOHL (0x64536571), ACE_NTOHL (0x0),  // name = ContextIdSeq
-          CORBA::tk_sequence, // typecode kind
-          160, // encapsulation length
-            TAO_ENCAP_BYTE_ORDER, // byte order
-            CORBA::tk_alias, // typecode kind for typedefs
-            144, // encapsulation length
-              TAO_ENCAP_BYTE_ORDER, // byte order
-              37, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f43), ACE_NTOHL (0x6f6e7465), ACE_NTOHL (0x78744964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/ContextIdentifier:1.0
-              18, ACE_NTOHL (0x436f6e74), ACE_NTOHL (0x65787449), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x72000000),  // name = ContextIdentifier
-              CORBA::tk_alias, // typecode kind for typedefs
-              64, // encapsulation length
-                TAO_ENCAP_BYTE_ORDER, // byte order
-                30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
-                11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-                CORBA::tk_string, 
-                0U, // string length
-
-
-            0U,
-
-
-        11, ACE_NTOHL (0x70617261), ACE_NTOHL (0x6d657465), ACE_NTOHL (0x72730000),  // name = parameters
-        CORBA::tk_alias, // typecode kind for typedefs
-        484, // encapsulation length
-          TAO_ENCAP_BYTE_ORDER, // byte order
-          37, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f50), ACE_NTOHL (0x61724465), ACE_NTOHL (0x73637269), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e536571), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/ParDescriptionSeq:1.0
-          18, ACE_NTOHL (0x50617244), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e5365), ACE_NTOHL (0x71000000),  // name = ParDescriptionSeq
-          CORBA::tk_sequence, // typecode kind
-          404, // encapsulation length
-            TAO_ENCAP_BYTE_ORDER, // byte order
-            CORBA::tk_struct, // typecode kind
-            388, // encapsulation length
-              TAO_ENCAP_BYTE_ORDER, // byte order
-              40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f50), ACE_NTOHL (0x6172616d), ACE_NTOHL (0x65746572), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ParameterDescription:1.0
-              21, ACE_NTOHL (0x50617261), ACE_NTOHL (0x6d657465), ACE_NTOHL (0x72446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = ParameterDescription
-              4, // member count
-              5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
-              CORBA::tk_alias, // typecode kind for typedefs
-              64, // encapsulation length
-                TAO_ENCAP_BYTE_ORDER, // byte order
-                30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
-                11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-                CORBA::tk_string, 
-                0U, // string length
-
-              5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
-              CORBA::tk_TypeCode,
-
-              9, ACE_NTOHL (0x74797065), ACE_NTOHL (0x5f646566), ACE_NTOHL (0x0),  // name = type_def
-              CORBA::tk_objref, // typecode kind
-              48, // encapsulation length
-                TAO_ENCAP_BYTE_ORDER, // byte order
-                27, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x444c5479), ACE_NTOHL (0x70653a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/IDLType:1.0
-                8, ACE_NTOHL (0x49444c54), ACE_NTOHL (0x79706500),  // name = IR_IDLType
-
-              5, ACE_NTOHL (0x6d6f6465), ACE_NTOHL (0x0),  // name = mode
-              CORBA::tk_enum, // typecode kind
-              116, // encapsulation length
-                TAO_ENCAP_BYTE_ORDER, // byte order
-                33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f50), ACE_NTOHL (0x6172616d), ACE_NTOHL (0x65746572), ACE_NTOHL (0x4d6f6465), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/ParameterMode:1.0
-                14, ACE_NTOHL (0x50617261), ACE_NTOHL (0x6d657465), ACE_NTOHL (0x724d6f64), ACE_NTOHL (0x65000000),  // name = ParameterMode
-                3, // member count
-                9, ACE_NTOHL (0x50415241), ACE_NTOHL (0x4d5f494e), ACE_NTOHL (0x0),  // name = PARAM_IN
-                10, ACE_NTOHL (0x50415241), ACE_NTOHL (0x4d5f4f55), ACE_NTOHL (0x54000000),  // name = PARAM_OUT
-                12, ACE_NTOHL (0x50415241), ACE_NTOHL (0x4d5f494e), ACE_NTOHL (0x4f555400),  // name = PARAM_INOUT
-
-
-            0U,
-
-
-        11, ACE_NTOHL (0x65786365), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e730000),  // name = exceptions
-        CORBA::tk_alias, // typecode kind for typedefs
-        536, // encapsulation length
-          TAO_ENCAP_BYTE_ORDER, // byte order
-          37, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x78634465), ACE_NTOHL (0x73637269), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e536571), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/ExcDescriptionSeq:1.0
-          18, ACE_NTOHL (0x45786344), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e5365), ACE_NTOHL (0x71000000),  // name = ExcDescriptionSeq
-          CORBA::tk_sequence, // typecode kind
-          456, // encapsulation length
-            TAO_ENCAP_BYTE_ORDER, // byte order
-            CORBA::tk_struct, // typecode kind
-            440, // encapsulation length
-              TAO_ENCAP_BYTE_ORDER, // byte order
-              40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x78636570), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ExceptionDescription:1.0
-              21, ACE_NTOHL (0x45786365), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = ExceptionDescription
-              5, // member count
-              5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
-              CORBA::tk_alias, // typecode kind for typedefs
-              64, // encapsulation length
-                TAO_ENCAP_BYTE_ORDER, // byte order
-                30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
-                11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-                CORBA::tk_string, 
-                0U, // string length
-
-              3, ACE_NTOHL (0x69640000),  // name = id
-              CORBA::tk_alias, // typecode kind for typedefs
-              68, // encapsulation length
-                TAO_ENCAP_BYTE_ORDER, // byte order
-                32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-                13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-                CORBA::tk_string, 
-                0U, // string length
-
-              11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
-              CORBA::tk_alias, // typecode kind for typedefs
-              68, // encapsulation length
-                TAO_ENCAP_BYTE_ORDER, // byte order
-                32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-                13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-                CORBA::tk_string, 
-                0U, // string length
-
-              8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
-              CORBA::tk_alias, // typecode kind for typedefs
-              64, // encapsulation length
-                TAO_ENCAP_BYTE_ORDER, // byte order
-                31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
-                12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
-                CORBA::tk_string, 
-                0U, // string length
-
-              5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
-              CORBA::tk_TypeCode,
-
-
-            0U,
-
-
-
-      0U,
-
-
-  11, ACE_NTOHL (0x61747472), ACE_NTOHL (0x69627574), ACE_NTOHL (0x65730000),  // name = attributes
-  CORBA::tk_alias, // typecode kind for typedefs
-  1788, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    38, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f41), ACE_NTOHL (0x74747244), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e5365), ACE_NTOHL (0x713a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/AttrDescriptionSeq:1.0
-    19, ACE_NTOHL (0x41747472), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x65710000),  // name = AttrDescriptionSeq
-    CORBA::tk_sequence, // typecode kind
-    1708, // encapsulation length
-      TAO_ENCAP_BYTE_ORDER, // byte order
-      CORBA::tk_struct, // typecode kind
-      1692, // encapsulation length
-        TAO_ENCAP_BYTE_ORDER, // byte order
-        40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f41), ACE_NTOHL (0x74747269), ACE_NTOHL (0x62757465), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/AttributeDescription:1.0
-        21, ACE_NTOHL (0x41747472), ACE_NTOHL (0x69627574), ACE_NTOHL (0x65446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = AttributeDescription
-        8, // member count
-        5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
-        CORBA::tk_alias, // typecode kind for typedefs
-        64, // encapsulation length
-          TAO_ENCAP_BYTE_ORDER, // byte order
-          30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
-          11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-          CORBA::tk_string, 
-          0U, // string length
-
-        3, ACE_NTOHL (0x69640000),  // name = id
-        CORBA::tk_alias, // typecode kind for typedefs
-        68, // encapsulation length
-          TAO_ENCAP_BYTE_ORDER, // byte order
-          32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-          13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-          CORBA::tk_string, 
-          0U, // string length
-
-        11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
-        CORBA::tk_alias, // typecode kind for typedefs
-        68, // encapsulation length
-          TAO_ENCAP_BYTE_ORDER, // byte order
-          32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-          13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-          CORBA::tk_string, 
-          0U, // string length
-
-        8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
-        CORBA::tk_alias, // typecode kind for typedefs
-        64, // encapsulation length
-          TAO_ENCAP_BYTE_ORDER, // byte order
-          31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
-          12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
-          CORBA::tk_string, 
-          0U, // string length
-
-        5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
-        CORBA::tk_TypeCode,
-
-        5, ACE_NTOHL (0x6d6f6465), ACE_NTOHL (0x0),  // name = mode
-        CORBA::tk_enum, // typecode kind
-        104, // encapsulation length
-          TAO_ENCAP_BYTE_ORDER, // byte order
-          33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f41), ACE_NTOHL (0x74747269), ACE_NTOHL (0x62757465), ACE_NTOHL (0x4d6f6465), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/AttributeMode:1.0
-          14, ACE_NTOHL (0x41747472), ACE_NTOHL (0x69627574), ACE_NTOHL (0x654d6f64), ACE_NTOHL (0x65000000),  // name = AttributeMode
-          2, // member count
-          12, ACE_NTOHL (0x41545452), ACE_NTOHL (0x5f4e4f52), ACE_NTOHL (0x4d414c00),  // name = ATTR_NORMAL
-          14, ACE_NTOHL (0x41545452), ACE_NTOHL (0x5f524541), ACE_NTOHL (0x444f4e4c), ACE_NTOHL (0x59000000),  // name = ATTR_READONLY
-
-        15, ACE_NTOHL (0x6765745f), ACE_NTOHL (0x65786365), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e730000),  // name = get_exceptions
-        CORBA::tk_alias, // typecode kind for typedefs
-        536, // encapsulation length
-          TAO_ENCAP_BYTE_ORDER, // byte order
-          37, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x78634465), ACE_NTOHL (0x73637269), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e536571), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/ExcDescriptionSeq:1.0
-          18, ACE_NTOHL (0x45786344), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e5365), ACE_NTOHL (0x71000000),  // name = ExcDescriptionSeq
-          CORBA::tk_sequence, // typecode kind
-          456, // encapsulation length
-            TAO_ENCAP_BYTE_ORDER, // byte order
-            CORBA::tk_struct, // typecode kind
-            440, // encapsulation length
-              TAO_ENCAP_BYTE_ORDER, // byte order
-              40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x78636570), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ExceptionDescription:1.0
-              21, ACE_NTOHL (0x45786365), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = ExceptionDescription
-              5, // member count
-              5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
-              CORBA::tk_alias, // typecode kind for typedefs
-              64, // encapsulation length
-                TAO_ENCAP_BYTE_ORDER, // byte order
-                30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
-                11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-                CORBA::tk_string, 
-                0U, // string length
-
-              3, ACE_NTOHL (0x69640000),  // name = id
-              CORBA::tk_alias, // typecode kind for typedefs
-              68, // encapsulation length
-                TAO_ENCAP_BYTE_ORDER, // byte order
-                32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-                13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-                CORBA::tk_string, 
-                0U, // string length
-
-              11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
-              CORBA::tk_alias, // typecode kind for typedefs
-              68, // encapsulation length
-                TAO_ENCAP_BYTE_ORDER, // byte order
-                32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-                13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-                CORBA::tk_string, 
-                0U, // string length
-
-              8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
-              CORBA::tk_alias, // typecode kind for typedefs
-              64, // encapsulation length
-                TAO_ENCAP_BYTE_ORDER, // byte order
-                31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
-                12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
-                CORBA::tk_string, 
-                0U, // string length
-
-              5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
-              CORBA::tk_TypeCode,
-
-
-            0U,
-
-
-        15, ACE_NTOHL (0x7075745f), ACE_NTOHL (0x65786365), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e730000),  // name = put_exceptions
-        CORBA::tk_alias, // typecode kind for typedefs
-        536, // encapsulation length
-          TAO_ENCAP_BYTE_ORDER, // byte order
-          37, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x78634465), ACE_NTOHL (0x73637269), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e536571), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/ExcDescriptionSeq:1.0
-          18, ACE_NTOHL (0x45786344), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e5365), ACE_NTOHL (0x71000000),  // name = ExcDescriptionSeq
-          CORBA::tk_sequence, // typecode kind
-          456, // encapsulation length
-            TAO_ENCAP_BYTE_ORDER, // byte order
-            CORBA::tk_struct, // typecode kind
-            440, // encapsulation length
-              TAO_ENCAP_BYTE_ORDER, // byte order
-              40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x78636570), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ExceptionDescription:1.0
-              21, ACE_NTOHL (0x45786365), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = ExceptionDescription
-              5, // member count
-              5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
-              CORBA::tk_alias, // typecode kind for typedefs
-              64, // encapsulation length
-                TAO_ENCAP_BYTE_ORDER, // byte order
-                30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
-                11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-                CORBA::tk_string, 
-                0U, // string length
-
-              3, ACE_NTOHL (0x69640000),  // name = id
-              CORBA::tk_alias, // typecode kind for typedefs
-              68, // encapsulation length
-                TAO_ENCAP_BYTE_ORDER, // byte order
-                32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-                13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-                CORBA::tk_string, 
-                0U, // string length
-
-              11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
-              CORBA::tk_alias, // typecode kind for typedefs
-              68, // encapsulation length
-                TAO_ENCAP_BYTE_ORDER, // byte order
-                32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-                13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-                CORBA::tk_string, 
-                0U, // string length
-
-              8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
-              CORBA::tk_alias, // typecode kind for typedefs
-              64, // encapsulation length
-                TAO_ENCAP_BYTE_ORDER, // byte order
-                31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
-                12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
-                CORBA::tk_string, 
-                0U, // string length
-
-              5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
-              CORBA::tk_TypeCode,
-
-
-            0U,
-
-
-
-      0U,
-
-
-  16, ACE_NTOHL (0x62617365), ACE_NTOHL (0x5f696e74), ACE_NTOHL (0x65726661), ACE_NTOHL (0x63657300),  // name = base_interfaces
-  CORBA::tk_alias, // typecode kind for typedefs
-  156, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x79496453), ACE_NTOHL (0x65713a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/RepositoryIdSeq:1.0
-    16, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x53657100),  // name = RepositoryIdSeq
-    CORBA::tk_sequence, // typecode kind
-    84, // encapsulation length
-      TAO_ENCAP_BYTE_ORDER, // byte order
-      CORBA::tk_alias, // typecode kind for typedefs
-      68, // encapsulation length
-        TAO_ENCAP_BYTE_ORDER, // byte order
-        32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-        13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-        CORBA::tk_string, 
-        0U, // string length
-
-      0U,
-
-
-  5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
-  CORBA::tk_TypeCode,
-
-  12, ACE_NTOHL (0x69735f61), ACE_NTOHL (0x62737472), ACE_NTOHL (0x61637400),  // name = is_abstract
-  CORBA::tk_boolean,
-
-  9, ACE_NTOHL (0x69735f6c), ACE_NTOHL (0x6f63616c), ACE_NTOHL (0x0),  // name = is_local
-  CORBA::tk_boolean,
-
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_InterfaceDescription (CORBA::tk_struct, sizeof (_oc_IR_InterfaceDescription), (char *) &_oc_IR_InterfaceDescription, 0, sizeof (IR_InterfaceDescription));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_InterfaceDescription, &_tc_TAO_tc_IR_InterfaceDescription)
-TAO_NAMESPACE_END
-
-void IR_InterfaceDescription::_tao_any_destructor (void *x)
-{
-  IR_InterfaceDescription *tmp = ACE_static_cast (IR_InterfaceDescription*,x);
-  delete tmp;
-}
-
-static const CORBA::Long _oc_IR_ValueMember[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x616c7565), ACE_NTOHL (0x4d656d62), ACE_NTOHL (0x65723a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/ValueMember:1.0
-  12, ACE_NTOHL (0x56616c75), ACE_NTOHL (0x654d656d), ACE_NTOHL (0x62657200),  // name = ValueMember
-  7, // member count
-  5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
-  CORBA::tk_alias, // typecode kind for typedefs
-  64, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
-    11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-    CORBA::tk_string, 
-    0U, // string length
-
-  3, ACE_NTOHL (0x69640000),  // name = id
-  CORBA::tk_alias, // typecode kind for typedefs
-  68, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-    13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-    CORBA::tk_string, 
-    0U, // string length
-
-  11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
-  CORBA::tk_alias, // typecode kind for typedefs
-  68, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-    13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-    CORBA::tk_string, 
-    0U, // string length
-
-  8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
-  CORBA::tk_alias, // typecode kind for typedefs
-  64, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
-    12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
-    CORBA::tk_string, 
-    0U, // string length
-
-  5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
-  CORBA::tk_TypeCode,
-
-  9, ACE_NTOHL (0x74797065), ACE_NTOHL (0x5f646566), ACE_NTOHL (0x0),  // name = type_def
-  CORBA::tk_objref, // typecode kind
-  48, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    27, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x444c5479), ACE_NTOHL (0x70653a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/IDLType:1.0
-    8, ACE_NTOHL (0x49444c54), ACE_NTOHL (0x79706500),  // name = IR_IDLType
-
-  7, ACE_NTOHL (0x61636365), ACE_NTOHL (0x73730000),  // name = access
-  CORBA::tk_alias, // typecode kind for typedefs
-  64, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5669), ACE_NTOHL (0x73696269), ACE_NTOHL (0x6c697479), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Visibility:1.0
-    11, ACE_NTOHL (0x56697369), ACE_NTOHL (0x62696c69), ACE_NTOHL (0x74790000),  // name = Visibility
-    CORBA::tk_short,
-
-
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_ValueMember (CORBA::tk_struct, sizeof (_oc_IR_ValueMember), (char *) &_oc_IR_ValueMember, 0, sizeof (IR_ValueMember));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ValueMember, &_tc_TAO_tc_IR_ValueMember)
-TAO_NAMESPACE_END
-
-void IR_ValueMember::_tao_any_destructor (void *x)
-{
-  IR_ValueMember *tmp = ACE_static_cast (IR_ValueMember*,x);
-  delete tmp;
-}
-
-
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  
-  void
-  _TAO_Unbounded_Sequence_IR_ValueMemberSeq::_allocate_buffer (CORBA::ULong length)
-  {
-    IR_ValueMember* tmp = 0;
-    tmp = _TAO_Unbounded_Sequence_IR_ValueMemberSeq::allocbuf (length);
-    
-    if (this->buffer_ != 0)
-    {
-      IR_ValueMember *old = ACE_reinterpret_cast (IR_ValueMember *,this->buffer_);
-      
-      for (CORBA::ULong i = 0; i < this->length_; ++i)
-        tmp[i] = old[i];
-      
-      if (this->release_)
-        _TAO_Unbounded_Sequence_IR_ValueMemberSeq::freebuf (old);
-      
-    }
-    this->buffer_ = tmp;
-  }
-  
-  void
-  _TAO_Unbounded_Sequence_IR_ValueMemberSeq::_deallocate_buffer (void)
-  {
-    if (this->buffer_ == 0 || this->release_ == 0)
-      return;
-    
-    IR_ValueMember *tmp = ACE_reinterpret_cast (IR_ValueMember *,this->buffer_);
-    
-    _TAO_Unbounded_Sequence_IR_ValueMemberSeq::freebuf (tmp);
-    this->buffer_ = 0;
-  } 
-  
-  _TAO_Unbounded_Sequence_IR_ValueMemberSeq::~_TAO_Unbounded_Sequence_IR_ValueMemberSeq (void) // Dtor.
-  {
-    this->_deallocate_buffer ();
-  }
-  
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
-
-// *************************************************************
-// IR_ValueMemberSeq
-// *************************************************************
-
-IR_ValueMemberSeq::IR_ValueMemberSeq (void)
-{}
-IR_ValueMemberSeq::IR_ValueMemberSeq (CORBA::ULong max) // uses max size
-  : 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Sequence_IR_ValueMemberSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Sequence<IR_ValueMember>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
- (max)
-{}
-IR_ValueMemberSeq::IR_ValueMemberSeq (CORBA::ULong max, CORBA::ULong length, IR_ValueMember *buffer, CORBA::Boolean release)
-  : 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Sequence_IR_ValueMemberSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Sequence<IR_ValueMember>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
- (max, length, buffer, release)
-{}
-IR_ValueMemberSeq::IR_ValueMemberSeq (const IR_ValueMemberSeq &seq) // copy ctor
-  : 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Sequence_IR_ValueMemberSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Sequence<IR_ValueMember>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
- (seq)
-{}
-IR_ValueMemberSeq::~IR_ValueMemberSeq (void) // dtor
-{}
-void IR_ValueMemberSeq::_tao_any_destructor (void *x)
-{
-  IR_ValueMemberSeq *tmp = ACE_static_cast (IR_ValueMemberSeq*,x);
-  delete tmp;
-}
-
-static const CORBA::Long _oc_IR_ValueMemberSeq[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  34, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x616c7565), ACE_NTOHL (0x4d656d62), ACE_NTOHL (0x65725365), ACE_NTOHL (0x713a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/ValueMemberSeq:1.0
-  15, ACE_NTOHL (0x56616c75), ACE_NTOHL (0x654d656d), ACE_NTOHL (0x62657253), ACE_NTOHL (0x65710000),  // name = ValueMemberSeq
-  CORBA::tk_sequence, // typecode kind
-  592, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    CORBA::tk_struct, // typecode kind
-    576, // encapsulation length
-      TAO_ENCAP_BYTE_ORDER, // byte order
-      31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x616c7565), ACE_NTOHL (0x4d656d62), ACE_NTOHL (0x65723a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/ValueMember:1.0
-      12, ACE_NTOHL (0x56616c75), ACE_NTOHL (0x654d656d), ACE_NTOHL (0x62657200),  // name = ValueMember
-      7, // member count
-      5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
-      CORBA::tk_alias, // typecode kind for typedefs
-      64, // encapsulation length
-        TAO_ENCAP_BYTE_ORDER, // byte order
-        30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
-        11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-        CORBA::tk_string, 
-        0U, // string length
-
-      3, ACE_NTOHL (0x69640000),  // name = id
-      CORBA::tk_alias, // typecode kind for typedefs
-      68, // encapsulation length
-        TAO_ENCAP_BYTE_ORDER, // byte order
-        32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-        13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-        CORBA::tk_string, 
-        0U, // string length
-
-      11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
-      CORBA::tk_alias, // typecode kind for typedefs
-      68, // encapsulation length
-        TAO_ENCAP_BYTE_ORDER, // byte order
-        32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-        13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-        CORBA::tk_string, 
-        0U, // string length
-
-      8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
-      CORBA::tk_alias, // typecode kind for typedefs
-      64, // encapsulation length
-        TAO_ENCAP_BYTE_ORDER, // byte order
-        31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
-        12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
-        CORBA::tk_string, 
-        0U, // string length
-
-      5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
-      CORBA::tk_TypeCode,
-
-      9, ACE_NTOHL (0x74797065), ACE_NTOHL (0x5f646566), ACE_NTOHL (0x0),  // name = type_def
-      CORBA::tk_objref, // typecode kind
-      48, // encapsulation length
-        TAO_ENCAP_BYTE_ORDER, // byte order
-        27, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x444c5479), ACE_NTOHL (0x70653a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/IDLType:1.0
-        8, ACE_NTOHL (0x49444c54), ACE_NTOHL (0x79706500),  // name = IR_IDLType
-
-      7, ACE_NTOHL (0x61636365), ACE_NTOHL (0x73730000),  // name = access
-      CORBA::tk_alias, // typecode kind for typedefs
-      64, // encapsulation length
-        TAO_ENCAP_BYTE_ORDER, // byte order
-        33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5669), ACE_NTOHL (0x73696269), ACE_NTOHL (0x6c697479), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Visibility:1.0
-        11, ACE_NTOHL (0x56697369), ACE_NTOHL (0x62696c69), ACE_NTOHL (0x74790000),  // name = Visibility
-        CORBA::tk_short,
-
-
-
-    0U,
-
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_ValueMemberSeq (CORBA::tk_alias, sizeof (_oc_IR_ValueMemberSeq), (char *) &_oc_IR_ValueMemberSeq, 0, sizeof (IR_ValueMemberSeq));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ValueMemberSeq, &_tc_TAO_tc_IR_ValueMemberSeq)
-TAO_NAMESPACE_END
-
-///////////////////////////////////////////////////////////////////////
-//                Base & Remote Proxy  Implementation. 
-//
-
-_TAO_ValueMemberDef_Proxy_Impl::_TAO_ValueMemberDef_Proxy_Impl (void)
-{}
-
-_TAO_ValueMemberDef_Remote_Proxy_Impl::_TAO_ValueMemberDef_Remote_Proxy_Impl (void)
-{}
-
-// Remote Implementation of the IDL interface methods
-
-CORBA::TypeCode_ptr _TAO_ValueMemberDef_Remote_Proxy_Impl::type (
-    CORBA_Object *_collocated_tao_target_,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  
-  CORBA::TypeCode_ptr _tao_retval = CORBA::TypeCode::_nil ();
-  CORBA::TypeCode_var _tao_safe_retval (_tao_retval);
-  
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-
-  
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_get_type",
-      9,
-      0,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_ValueMemberDef::TAO_ClientRequestInfo_IR_ValueMemberDef_type_get ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              CORBA::TypeCode_ptr _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-IR_IDLType_ptr _TAO_ValueMemberDef_Remote_Proxy_Impl::type_def (
-    CORBA_Object *_collocated_tao_target_,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  
-  IR_IDLType_ptr _tao_retval = IR_IDLType::_nil ();
-  IR_IDLType_var _tao_safe_retval (_tao_retval);
-  
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-
-  
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_get_type_def",
-      13,
-      0,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_ValueMemberDef::TAO_ClientRequestInfo_IR_ValueMemberDef_type_def_get ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              IR_IDLType_ptr _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-void _TAO_ValueMemberDef_Remote_Proxy_Impl::type_def (
-    CORBA_Object *_collocated_tao_target_,
-    IR_IDLType_ptr type_def,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW (CORBA::INTERNAL ());
-
-  
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_set_type_def",
-      13,
-      1,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_ValueMemberDef::TAO_ClientRequestInfo_IR_ValueMemberDef_type_def_set ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        type_def,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK;
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK;
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK;
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK;
-          
-          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-          if (!(
-                            (_tao_out << type_def)
-            ))
-            TAO_INTERCEPTOR_THROW (
-              CORBA::MARSHAL ()
-            );
-            
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK;
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)
-              );
-              
-            }
-          
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK;
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK;
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  
-}
-
-CORBA::Visibility _TAO_ValueMemberDef_Remote_Proxy_Impl::access (
-    CORBA_Object *_collocated_tao_target_,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  
-  CORBA::Visibility _tao_retval = 0;
-  
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), _tao_retval);
-
-  
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_get_access",
-      11,
-      0,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_ValueMemberDef::TAO_ClientRequestInfo_IR_ValueMemberDef_access_get ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN  (_tao_retval);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                _tao_retval
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_retval)
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                _tao_retval
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              CORBA::Visibility  _tao_retval_info = _tao_retval;
-               ri.result (_tao_retval_info);
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN  (_tao_retval);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_retval;
-}
-
-void _TAO_ValueMemberDef_Remote_Proxy_Impl::access (
-    CORBA_Object *_collocated_tao_target_,
-    CORBA::Visibility access,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW (CORBA::INTERNAL ());
-
-  
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_set_access",
-      11,
-      1,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_ValueMemberDef::TAO_ClientRequestInfo_IR_ValueMemberDef_access_set ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        access,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK;
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK;
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK;
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK;
-          
-          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-          if (!(
-                            (_tao_out << access)
-            ))
-            TAO_INTERCEPTOR_THROW (
-              CORBA::MARSHAL ()
-            );
-            
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK;
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)
-              );
-              
-            }
-          
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK;
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK;
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  
-}
-
-
-//
-//            End  Base & Remote  Proxy Implemeentation. 
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//           Remote & Base  Proxy Broker Implementation
-//
-
-_TAO_ValueMemberDef_Proxy_Broker::_TAO_ValueMemberDef_Proxy_Broker (void)
-{
-}
-
-_TAO_ValueMemberDef_Proxy_Broker::~_TAO_ValueMemberDef_Proxy_Broker (void)
-{
-}
-
-_TAO_ValueMemberDef_Proxy_Broker * (*_TAO_ValueMemberDef_Proxy_Broker_Factory_function_pointer) (
-    CORBA::Object_ptr obj
-  ) = 0;
-
-// Factory Member function Implementation.
-_TAO_ValueMemberDef_Remote_Proxy_Broker *
-_TAO_ValueMemberDef_Remote_Proxy_Broker::the_TAO_ValueMemberDef_Remote_Proxy_Broker (void)
-{
-  static ::_TAO_ValueMemberDef_Remote_Proxy_Broker remote_proxy_broker;
-  return &remote_proxy_broker;
-}
-
-_TAO_ValueMemberDef_Remote_Proxy_Broker::_TAO_ValueMemberDef_Remote_Proxy_Broker (void)
-{
-}
-
-_TAO_ValueMemberDef_Remote_Proxy_Broker::~_TAO_ValueMemberDef_Remote_Proxy_Broker (void)
-{
-}
-
-_TAO_ValueMemberDef_Proxy_Impl&
-_TAO_ValueMemberDef_Remote_Proxy_Broker::select_proxy (
-  ::IR_ValueMemberDef *object,
-  CORBA::Environment &ACE_TRY_ENV
-)
-{
-  ACE_UNUSED_ARG (object);
-  ACE_UNUSED_ARG (ACE_TRY_ENV);
-  return remote_proxy_impl_;
-}
-
-
-//
-//           End Remote & Base Proxy Broker Implementation
-///////////////////////////////////////////////////////////////////////
-
-
-// default constructor
-IR_ValueMemberDef::IR_ValueMemberDef (int collocated)
-{
-  this->IR_ValueMemberDef_setup_collocation (collocated);
-}
-
-// destructor
-IR_ValueMemberDef::~IR_ValueMemberDef (void)
-{}
-
-void
-IR_ValueMemberDef::IR_ValueMemberDef_setup_collocation (int collocated)
-{
-  if (collocated)
-    this->the_TAO_ValueMemberDef_Proxy_Broker_ =
-      _TAO_ValueMemberDef_Proxy_Broker_Factory_function_pointer (this);
-  else
-    this->the_TAO_ValueMemberDef_Proxy_Broker_ =
-      _TAO_ValueMemberDef_Remote_Proxy_Broker::the_TAO_ValueMemberDef_Remote_Proxy_Broker ();
-  
-  this->IR_Contained_setup_collocation (collocated);
-}
-
-void IR_ValueMemberDef::_tao_any_destructor (void *x)
-{
-  IR_ValueMemberDef *tmp = ACE_static_cast (IR_ValueMemberDef*,x);
-  CORBA::release (tmp);
-}
-
-IR_ValueMemberDef_ptr IR_ValueMemberDef::_narrow (
-    CORBA::Object_ptr obj,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  if (CORBA::is_nil (obj))
-    return IR_ValueMemberDef::_nil ();
-  if (! obj->_is_local ())
-    {
-      CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/IR/ValueMemberDef:1.0", ACE_TRY_ENV);
-      ACE_CHECK_RETURN (IR_ValueMemberDef::_nil ());
-      if (is_a == 0)
-        return IR_ValueMemberDef::_nil ();
-    }
-  return IR_ValueMemberDef::_unchecked_narrow (obj, ACE_TRY_ENV);
-}
-
-IR_ValueMemberDef_ptr IR_ValueMemberDef::_unchecked_narrow (
-    CORBA::Object_ptr obj,
-    CORBA::Environment &
-  )
-{
-  if (CORBA::is_nil (obj))
-    return IR_ValueMemberDef::_nil ();
-  if (! obj->_is_local ())
-    {
-      TAO_Stub* stub = obj->_stubobj ();
-      if (stub)
-        stub->_incr_refcnt ();
-      IR_ValueMemberDef_ptr default_proxy = IR_ValueMemberDef::_nil ();
-
-      if (
-          !CORBA::is_nil (stub->servant_orb_var ().ptr ()) &&
-          stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects () &&
-          obj->_is_collocated () &&_TAO_ValueMemberDef_Proxy_Broker_Factory_function_pointer != 0
-        )
-      {
-        ACE_NEW_RETURN (
-          default_proxy,
-          ::IR_ValueMemberDef (
-            stub,
-            1,
-            obj->_servant ()),
-            
-          IR_ValueMemberDef::_nil ());
-        }
-      if (CORBA::is_nil (default_proxy))
-        ACE_NEW_RETURN (default_proxy, ::IR_ValueMemberDef (stub, 0, obj->_servant ()), IR_ValueMemberDef::_nil ());
-        return default_proxy;
-      }
-    else 
-      return
-        ACE_reinterpret_cast
-          (
-            IR_ValueMemberDef_ptr,
-              obj->_tao_QueryInterface
-                (
-                  ACE_reinterpret_cast
-                    (
-                      ptr_arith_t,
-                      &IR_ValueMemberDef::_narrow
-                    )
-                )
-          );
-}
-
-IR_ValueMemberDef_ptr
-IR_ValueMemberDef::_duplicate (IR_ValueMemberDef_ptr obj)
-{
-  if (!CORBA::is_nil (obj))
-    obj->_add_ref ();
-  return obj;
-}
-
-CORBA::Boolean IR_ValueMemberDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
-{
-  if (
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/ValueMemberDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/Contained:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
-  return 1; // success using local knowledge
-  else
-    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
-}
-
-void *IR_ValueMemberDef::_tao_QueryInterface (ptr_arith_t type)
-{
-  void *retv = 0;
-  if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_ValueMemberDef::_narrow))
-    retv = ACE_reinterpret_cast (void*, this);
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_Contained::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            IR_Contained_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &CORBA_IRObject::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            CORBA_IRObject_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
-    retv = ACE_reinterpret_cast (void *,
-      ACE_static_cast (CORBA::Object_ptr, this));
-    
-  if (retv)
-    this->_add_ref ();
-  return retv;
-}
-
-const char* IR_ValueMemberDef::_interface_repository_id (void) const
-{
-  return "IDL:omg.org/IR/ValueMemberDef:1.0";
-}
-
-CORBA::TypeCode_ptr IR_ValueMemberDef::type (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_ValueMemberDef_Proxy_Impl &proxy = 
-    this->the_TAO_ValueMemberDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.type (
-      this,
-      ACE_TRY_ENV
-    );
-}
-
-IR_IDLType_ptr IR_ValueMemberDef::type_def (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_ValueMemberDef_Proxy_Impl &proxy = 
-    this->the_TAO_ValueMemberDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.type_def (
-      this,
-      ACE_TRY_ENV
-    );
-}
-
-void IR_ValueMemberDef::type_def (
-    IR_IDLType_ptr type_def,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_ValueMemberDef_Proxy_Impl &proxy = 
-    this->the_TAO_ValueMemberDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK;
-  
-  proxy.type_def (
-      this,
-      type_def,
-      ACE_TRY_ENV
-    );
-}
-
-CORBA::Visibility IR_ValueMemberDef::access (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_ValueMemberDef_Proxy_Impl &proxy = 
-    this->the_TAO_ValueMemberDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.access (
-      this,
-      ACE_TRY_ENV
-    );
-}
-
-void IR_ValueMemberDef::access (
-    CORBA::Visibility access,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_ValueMemberDef_Proxy_Impl &proxy = 
-    this->the_TAO_ValueMemberDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK;
-  
-  proxy.access (
-      this,
-      access,
-      ACE_TRY_ENV
-    );
-}
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-IR_ValueMemberDef::TAO_ClientRequestInfo_IR_ValueMemberDef_type_get::TAO_ClientRequestInfo_IR_ValueMemberDef_type_get (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
-{}
-
-Dynamic::ParameterList *
-IR_ValueMemberDef::TAO_ClientRequestInfo_IR_ValueMemberDef_type_get::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return parameter_list;
-}
-
-Dynamic::ExceptionList *
-IR_ValueMemberDef::TAO_ClientRequestInfo_IR_ValueMemberDef_type_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_ValueMemberDef::TAO_ClientRequestInfo_IR_ValueMemberDef_type_get::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_ValueMemberDef::TAO_ClientRequestInfo_IR_ValueMemberDef_type_get::result (CORBA::TypeCode_ptr result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_ValueMemberDef::TAO_ClientRequestInfo_IR_ValueMemberDef_type_def_get::TAO_ClientRequestInfo_IR_ValueMemberDef_type_def_get (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
-{}
-
-Dynamic::ParameterList *
-IR_ValueMemberDef::TAO_ClientRequestInfo_IR_ValueMemberDef_type_def_get::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return parameter_list;
-}
-
-Dynamic::ExceptionList *
-IR_ValueMemberDef::TAO_ClientRequestInfo_IR_ValueMemberDef_type_def_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_ValueMemberDef::TAO_ClientRequestInfo_IR_ValueMemberDef_type_def_get::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_ValueMemberDef::TAO_ClientRequestInfo_IR_ValueMemberDef_type_def_get::result (IR_IDLType_ptr result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_ValueMemberDef::TAO_ClientRequestInfo_IR_ValueMemberDef_type_def_set::TAO_ClientRequestInfo_IR_ValueMemberDef_type_def_set (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    IR_IDLType_ptr type_def,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
-    type_def_ (type_def)
-{}
-
-Dynamic::ParameterList *
-IR_ValueMemberDef::TAO_ClientRequestInfo_IR_ValueMemberDef_type_def_set::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
-    
-  CORBA::ULong length_type_def = parameter_list->length ();
-  parameter_list->length (length_type_def + 1);
-  (*parameter_list)[length_type_def].argument <<=  this->type_def_;
-  
-  (*parameter_list)[length_type_def].mode = Dynamic::PARAM_IN;
-  
-  return safe_parameter_list._retn ();
-}
-
-Dynamic::ExceptionList *
-IR_ValueMemberDef::TAO_ClientRequestInfo_IR_ValueMemberDef_type_def_set::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_ValueMemberDef::TAO_ClientRequestInfo_IR_ValueMemberDef_type_def_set::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 1;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return result_any;
-}
-
-IR_ValueMemberDef::TAO_ClientRequestInfo_IR_ValueMemberDef_access_get::TAO_ClientRequestInfo_IR_ValueMemberDef_access_get (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
-{}
-
-Dynamic::ParameterList *
-IR_ValueMemberDef::TAO_ClientRequestInfo_IR_ValueMemberDef_access_get::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return parameter_list;
-}
-
-Dynamic::ExceptionList *
-IR_ValueMemberDef::TAO_ClientRequestInfo_IR_ValueMemberDef_access_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_ValueMemberDef::TAO_ClientRequestInfo_IR_ValueMemberDef_access_get::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_ValueMemberDef::TAO_ClientRequestInfo_IR_ValueMemberDef_access_get::result (CORBA::Visibility result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_ValueMemberDef::TAO_ClientRequestInfo_IR_ValueMemberDef_access_set::TAO_ClientRequestInfo_IR_ValueMemberDef_access_set (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    const CORBA::Visibility & access,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
-    access_ (access)
-{}
-
-Dynamic::ParameterList *
-IR_ValueMemberDef::TAO_ClientRequestInfo_IR_ValueMemberDef_access_set::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
-    
-  CORBA::ULong length_access = parameter_list->length ();
-  parameter_list->length (length_access + 1);
-  (*parameter_list)[length_access].argument <<= access_;
-  (*parameter_list)[length_access].mode = Dynamic::PARAM_IN;
-  
-  return safe_parameter_list._retn ();
-}
-
-Dynamic::ExceptionList *
-IR_ValueMemberDef::TAO_ClientRequestInfo_IR_ValueMemberDef_access_set::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_ValueMemberDef::TAO_ClientRequestInfo_IR_ValueMemberDef_access_set::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 1;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return result_any;
-}
-
-#endif /* TAO_HAS_INTERCEPTORS */
-
-static const CORBA::Long _oc_IR_ValueMemberDef[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  34, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x616c7565), ACE_NTOHL (0x4d656d62), ACE_NTOHL (0x65724465), ACE_NTOHL (0x663a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/ValueMemberDef:1.0
-  15, ACE_NTOHL (0x56616c75), ACE_NTOHL (0x654d656d), ACE_NTOHL (0x62657244), ACE_NTOHL (0x65660000),  // name = IR_ValueMemberDef
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_ValueMemberDef (CORBA::tk_objref, sizeof (_oc_IR_ValueMemberDef), (char *) &_oc_IR_ValueMemberDef, 0, sizeof (IR_ValueMemberDef));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ValueMemberDef, &_tc_TAO_tc_IR_ValueMemberDef)
-TAO_NAMESPACE_END
-
-///////////////////////////////////////////////////////////////////////
-//                Base & Remote Proxy  Implementation. 
-//
-
-_TAO_ValueDef_Proxy_Impl::_TAO_ValueDef_Proxy_Impl (void)
-{}
-
-_TAO_ValueDef_Remote_Proxy_Impl::_TAO_ValueDef_Remote_Proxy_Impl (void)
-{}
-
-// Remote Implementation of the IDL interface methods
-
-IR_InterfaceDefSeq * _TAO_ValueDef_Remote_Proxy_Impl::supported_interfaces (
-    CORBA_Object *_collocated_tao_target_,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  
-  IR_InterfaceDefSeq *_tao_retval = 0;
-  
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-
-  
-  ACE_NEW_RETURN (_tao_retval, IR_InterfaceDefSeq, _tao_retval);
-  IR_InterfaceDefSeq_var _tao_safe_retval (_tao_retval);
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_get_supported_interfaces",
-      25,
-      0,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_supported_interfaces_get ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              IR_InterfaceDefSeq * _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-void _TAO_ValueDef_Remote_Proxy_Impl::supported_interfaces (
-    CORBA_Object *_collocated_tao_target_,
-    const IR_InterfaceDefSeq & supported_interfaces,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW (CORBA::INTERNAL ());
-
-  
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_set_supported_interfaces",
-      25,
-      1,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_supported_interfaces_set ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        supported_interfaces,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK;
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK;
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK;
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK;
-          
-          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-          if (!(
-                            (_tao_out << supported_interfaces)
-            ))
-            TAO_INTERCEPTOR_THROW (
-              CORBA::MARSHAL ()
-            );
-            
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK;
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)
-              );
-              
-            }
-          
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK;
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK;
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  
-}
-
-IR_InitializerSeq * _TAO_ValueDef_Remote_Proxy_Impl::initializers (
-    CORBA_Object *_collocated_tao_target_,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  
-  IR_InitializerSeq *_tao_retval = 0;
-  
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-
-  
-  ACE_NEW_RETURN (_tao_retval, IR_InitializerSeq, _tao_retval);
-  IR_InitializerSeq_var _tao_safe_retval (_tao_retval);
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_get_initializers",
-      17,
-      0,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_initializers_get ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              IR_InitializerSeq * _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-void _TAO_ValueDef_Remote_Proxy_Impl::initializers (
-    CORBA_Object *_collocated_tao_target_,
-    const IR_InitializerSeq & initializers,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW (CORBA::INTERNAL ());
-
-  
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_set_initializers",
-      17,
-      1,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_initializers_set ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        initializers,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK;
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK;
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK;
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK;
-          
-          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-          if (!(
-                            (_tao_out << initializers)
-            ))
-            TAO_INTERCEPTOR_THROW (
-              CORBA::MARSHAL ()
-            );
-            
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK;
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)
-              );
-              
-            }
-          
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK;
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK;
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  
-}
-
-IR_ValueDef_ptr _TAO_ValueDef_Remote_Proxy_Impl::base_value (
-    CORBA_Object *_collocated_tao_target_,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  
-  IR_ValueDef_ptr _tao_retval = IR_ValueDef::_nil ();
-  IR_ValueDef_var _tao_safe_retval (_tao_retval);
-  
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-
-  
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_get_base_value",
-      15,
-      0,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_base_value_get ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              IR_ValueDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-void _TAO_ValueDef_Remote_Proxy_Impl::base_value (
-    CORBA_Object *_collocated_tao_target_,
-    IR_ValueDef_ptr base_value,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW (CORBA::INTERNAL ());
-
-  
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_set_base_value",
-      15,
-      1,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_base_value_set ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        base_value,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK;
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK;
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK;
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK;
-          
-          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-          if (!(
-                            (_tao_out << base_value)
-            ))
-            TAO_INTERCEPTOR_THROW (
-              CORBA::MARSHAL ()
-            );
-            
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK;
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)
-              );
-              
-            }
-          
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK;
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK;
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  
-}
-
-IR_ValueDefSeq * _TAO_ValueDef_Remote_Proxy_Impl::abstract_base_values (
-    CORBA_Object *_collocated_tao_target_,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  
-  IR_ValueDefSeq *_tao_retval = 0;
-  
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-
-  
-  ACE_NEW_RETURN (_tao_retval, IR_ValueDefSeq, _tao_retval);
-  IR_ValueDefSeq_var _tao_safe_retval (_tao_retval);
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_get_abstract_base_values",
-      25,
-      0,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_abstract_base_values_get ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              IR_ValueDefSeq * _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-void _TAO_ValueDef_Remote_Proxy_Impl::abstract_base_values (
-    CORBA_Object *_collocated_tao_target_,
-    const IR_ValueDefSeq & abstract_base_values,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW (CORBA::INTERNAL ());
-
-  
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_set_abstract_base_values",
-      25,
-      1,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_abstract_base_values_set ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        abstract_base_values,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK;
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK;
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK;
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK;
-          
-          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-          if (!(
-                            (_tao_out << abstract_base_values)
-            ))
-            TAO_INTERCEPTOR_THROW (
-              CORBA::MARSHAL ()
-            );
-            
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK;
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)
-              );
-              
-            }
-          
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK;
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK;
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  
-}
-
-CORBA::Boolean _TAO_ValueDef_Remote_Proxy_Impl::is_abstract (
-    CORBA_Object *_collocated_tao_target_,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  
-  CORBA::Boolean _tao_retval = 0;
-  
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), _tao_retval);
-
-  
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_get_is_abstract",
-      16,
-      0,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_is_abstract_get ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN  (_tao_retval);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                _tao_retval
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> CORBA::Any::to_boolean (_tao_retval))
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                _tao_retval
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              CORBA::Boolean  _tao_retval_info = _tao_retval;
-               ri.result (_tao_retval_info);
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN  (_tao_retval);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_retval;
-}
-
-void _TAO_ValueDef_Remote_Proxy_Impl::is_abstract (
-    CORBA_Object *_collocated_tao_target_,
-    CORBA::Boolean is_abstract,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW (CORBA::INTERNAL ());
-
-  
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_set_is_abstract",
-      16,
-      1,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_is_abstract_set ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        is_abstract,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK;
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK;
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK;
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK;
-          
-          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-          if (!(
-                            (_tao_out << CORBA::Any::from_boolean (is_abstract))
-            ))
-            TAO_INTERCEPTOR_THROW (
-              CORBA::MARSHAL ()
-            );
-            
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK;
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)
-              );
-              
-            }
-          
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK;
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK;
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  
-}
-
-CORBA::Boolean _TAO_ValueDef_Remote_Proxy_Impl::is_custom (
-    CORBA_Object *_collocated_tao_target_,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  
-  CORBA::Boolean _tao_retval = 0;
-  
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), _tao_retval);
-
-  
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_get_is_custom",
-      14,
-      0,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_is_custom_get ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN  (_tao_retval);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                _tao_retval
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> CORBA::Any::to_boolean (_tao_retval))
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                _tao_retval
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              CORBA::Boolean  _tao_retval_info = _tao_retval;
-               ri.result (_tao_retval_info);
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN  (_tao_retval);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_retval;
-}
-
-void _TAO_ValueDef_Remote_Proxy_Impl::is_custom (
-    CORBA_Object *_collocated_tao_target_,
-    CORBA::Boolean is_custom,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW (CORBA::INTERNAL ());
-
-  
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_set_is_custom",
-      14,
-      1,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_is_custom_set ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        is_custom,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK;
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK;
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK;
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK;
-          
-          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-          if (!(
-                            (_tao_out << CORBA::Any::from_boolean (is_custom))
-            ))
-            TAO_INTERCEPTOR_THROW (
-              CORBA::MARSHAL ()
-            );
-            
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK;
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)
-              );
-              
-            }
-          
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK;
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK;
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  
-}
-
-CORBA::Boolean _TAO_ValueDef_Remote_Proxy_Impl::is_truncatable (
-    CORBA_Object *_collocated_tao_target_,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  
-  CORBA::Boolean _tao_retval = 0;
-  
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), _tao_retval);
-
-  
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_get_is_truncatable",
-      19,
-      0,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_is_truncatable_get ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN  (_tao_retval);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                _tao_retval
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> CORBA::Any::to_boolean (_tao_retval))
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                _tao_retval
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              CORBA::Boolean  _tao_retval_info = _tao_retval;
-               ri.result (_tao_retval_info);
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN  (_tao_retval);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_retval;
-}
-
-void _TAO_ValueDef_Remote_Proxy_Impl::is_truncatable (
-    CORBA_Object *_collocated_tao_target_,
-    CORBA::Boolean is_truncatable,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW (CORBA::INTERNAL ());
-
-  
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_set_is_truncatable",
-      19,
-      1,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_is_truncatable_set ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        is_truncatable,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK;
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK;
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK;
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK;
-          
-          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-          if (!(
-                            (_tao_out << CORBA::Any::from_boolean (is_truncatable))
-            ))
-            TAO_INTERCEPTOR_THROW (
-              CORBA::MARSHAL ()
-            );
-            
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK;
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)
-              );
-              
-            }
-          
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK;
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK;
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  
-}
-
-CORBA::Boolean _TAO_ValueDef_Remote_Proxy_Impl::is_a (
-    CORBA_Object *_collocated_tao_target_,
-    const char * id,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  
-  CORBA::Boolean _tao_retval = 0;
-  
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), _tao_retval);
-
-  
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "is_a",
-      4,
-      1,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_is_a ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        id,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN  (_tao_retval);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-          if (!(
-                            (_tao_out << id)
-            ))
-            TAO_INTERCEPTOR_THROW_RETURN (
-              CORBA::MARSHAL (),
-              _tao_retval
-            );
-            
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                _tao_retval
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> CORBA::Any::to_boolean (_tao_retval))
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                _tao_retval
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              CORBA::Boolean  _tao_retval_info = _tao_retval;
-               ri.result (_tao_retval_info);
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN  (_tao_retval);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_retval;
-}
-
-IR_ValueMemberDef_ptr _TAO_ValueDef_Remote_Proxy_Impl::create_value_member (
-    CORBA_Object *_collocated_tao_target_,
-    const char * id,
-    const char * name,
-    const char * version,
-    IR_IDLType_ptr type,
-    CORBA::Visibility access,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  
-  IR_ValueMemberDef_ptr _tao_retval = IR_ValueMemberDef::_nil ();
-  IR_ValueMemberDef_var _tao_safe_retval (_tao_retval);
-  
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-
-  
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "create_value_member",
-      19,
-      1,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_create_value_member ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        id,
-        name,
-        version,
-        type,
-        access,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-          if (!(
-                            (_tao_out << id) &&
-              (_tao_out << name) &&
-              (_tao_out << version) &&
-              (_tao_out << type) &&
-              (_tao_out << access)
-            ))
-            TAO_INTERCEPTOR_THROW_RETURN (
-              CORBA::MARSHAL (),
-              0
-            );
-            
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              IR_ValueMemberDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-IR_AttributeDef_ptr _TAO_ValueDef_Remote_Proxy_Impl::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,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  
-  IR_AttributeDef_ptr _tao_retval = IR_AttributeDef::_nil ();
-  IR_AttributeDef_var _tao_safe_retval (_tao_retval);
-  
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-
-  
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "create_attribute",
-      16,
-      1,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_create_attribute ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        id,
-        name,
-        version,
-        type,
-        mode,
-        get_exceptions,
-        put_exceptions,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-          if (!(
-                            (_tao_out << id) &&
-              (_tao_out << name) &&
-              (_tao_out << version) &&
-              (_tao_out << type) &&
-              (_tao_out << mode) &&
-              (_tao_out << get_exceptions) &&
-              (_tao_out << put_exceptions)
-            ))
-            TAO_INTERCEPTOR_THROW_RETURN (
-              CORBA::MARSHAL (),
-              0
-            );
-            
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              IR_AttributeDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-IR_OperationDef_ptr _TAO_ValueDef_Remote_Proxy_Impl::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,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  
-  IR_OperationDef_ptr _tao_retval = IR_OperationDef::_nil ();
-  IR_OperationDef_var _tao_safe_retval (_tao_retval);
-  
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-
-  
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "create_operation",
-      16,
-      1,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_create_operation ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        id,
-        name,
-        version,
-        result,
-        mode,
-        params,
-        exceptions,
-        contexts,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-          if (!(
-                            (_tao_out << id) &&
-              (_tao_out << name) &&
-              (_tao_out << version) &&
-              (_tao_out << result) &&
-              (_tao_out << mode) &&
-              (_tao_out << params) &&
-              (_tao_out << exceptions) &&
-              (_tao_out << contexts)
-            ))
-            TAO_INTERCEPTOR_THROW_RETURN (
-              CORBA::MARSHAL (),
-              0
-            );
-            
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              IR_OperationDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-
-//
-//            End  Base & Remote  Proxy Implemeentation. 
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//           Remote & Base  Proxy Broker Implementation
-//
-
-_TAO_ValueDef_Proxy_Broker::_TAO_ValueDef_Proxy_Broker (void)
-{
-}
-
-_TAO_ValueDef_Proxy_Broker::~_TAO_ValueDef_Proxy_Broker (void)
-{
-}
-
-_TAO_ValueDef_Proxy_Broker * (*_TAO_ValueDef_Proxy_Broker_Factory_function_pointer) (
-    CORBA::Object_ptr obj
-  ) = 0;
-
-// Factory Member function Implementation.
-_TAO_ValueDef_Remote_Proxy_Broker *
-_TAO_ValueDef_Remote_Proxy_Broker::the_TAO_ValueDef_Remote_Proxy_Broker (void)
-{
-  static ::_TAO_ValueDef_Remote_Proxy_Broker remote_proxy_broker;
-  return &remote_proxy_broker;
-}
-
-_TAO_ValueDef_Remote_Proxy_Broker::_TAO_ValueDef_Remote_Proxy_Broker (void)
-{
-}
-
-_TAO_ValueDef_Remote_Proxy_Broker::~_TAO_ValueDef_Remote_Proxy_Broker (void)
-{
-}
-
-_TAO_ValueDef_Proxy_Impl&
-_TAO_ValueDef_Remote_Proxy_Broker::select_proxy (
-  ::IR_ValueDef *object,
-  CORBA::Environment &ACE_TRY_ENV
-)
-{
-  ACE_UNUSED_ARG (object);
-  ACE_UNUSED_ARG (ACE_TRY_ENV);
-  return remote_proxy_impl_;
-}
-
-
-//
-//           End Remote & Base Proxy Broker Implementation
-///////////////////////////////////////////////////////////////////////
-
-
-// default constructor
-IR_ValueDef::IR_ValueDef (int collocated)
-{
-  this->IR_ValueDef_setup_collocation (collocated);
-}
-
-// destructor
-IR_ValueDef::~IR_ValueDef (void)
-{}
-
-void
-IR_ValueDef::IR_ValueDef_setup_collocation (int collocated)
-{
-  if (collocated)
-    this->the_TAO_ValueDef_Proxy_Broker_ =
-      _TAO_ValueDef_Proxy_Broker_Factory_function_pointer (this);
-  else
-    this->the_TAO_ValueDef_Proxy_Broker_ =
-      _TAO_ValueDef_Remote_Proxy_Broker::the_TAO_ValueDef_Remote_Proxy_Broker ();
-  
-  this->IR_Container_setup_collocation (collocated);
-  this->IR_Contained_setup_collocation (collocated);
-  this->IR_IDLType_setup_collocation (collocated);
-}
-
-void IR_ValueDef::_tao_any_destructor (void *x)
-{
-  IR_ValueDef *tmp = ACE_static_cast (IR_ValueDef*,x);
-  CORBA::release (tmp);
-}
-
-IR_ValueDef_ptr IR_ValueDef::_narrow (
-    CORBA::Object_ptr obj,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  if (CORBA::is_nil (obj))
-    return IR_ValueDef::_nil ();
-  if (! obj->_is_local ())
-    {
-      CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/IR/ValueDef:1.0", ACE_TRY_ENV);
-      ACE_CHECK_RETURN (IR_ValueDef::_nil ());
-      if (is_a == 0)
-        return IR_ValueDef::_nil ();
-    }
-  return IR_ValueDef::_unchecked_narrow (obj, ACE_TRY_ENV);
-}
-
-IR_ValueDef_ptr IR_ValueDef::_unchecked_narrow (
-    CORBA::Object_ptr obj,
-    CORBA::Environment &
-  )
-{
-  if (CORBA::is_nil (obj))
-    return IR_ValueDef::_nil ();
-  if (! obj->_is_local ())
-    {
-      TAO_Stub* stub = obj->_stubobj ();
-      if (stub)
-        stub->_incr_refcnt ();
-      IR_ValueDef_ptr default_proxy = IR_ValueDef::_nil ();
-
-      if (
-          !CORBA::is_nil (stub->servant_orb_var ().ptr ()) &&
-          stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects () &&
-          obj->_is_collocated () &&_TAO_ValueDef_Proxy_Broker_Factory_function_pointer != 0
-        )
-      {
-        ACE_NEW_RETURN (
-          default_proxy,
-          ::IR_ValueDef (
-            stub,
-            1,
-            obj->_servant ()),
-            
-          IR_ValueDef::_nil ());
-        }
-      if (CORBA::is_nil (default_proxy))
-        ACE_NEW_RETURN (default_proxy, ::IR_ValueDef (stub, 0, obj->_servant ()), IR_ValueDef::_nil ());
-        return default_proxy;
-      }
-    else 
-      return
-        ACE_reinterpret_cast
-          (
-            IR_ValueDef_ptr,
-              obj->_tao_QueryInterface
-                (
-                  ACE_reinterpret_cast
-                    (
-                      ptr_arith_t,
-                      &IR_ValueDef::_narrow
-                    )
-                )
-          );
-}
-
-IR_ValueDef_ptr
-IR_ValueDef::_duplicate (IR_ValueDef_ptr obj)
-{
-  if (!CORBA::is_nil (obj))
-    obj->_add_ref ();
-  return obj;
-}
-
-CORBA::Boolean IR_ValueDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
-{
-  if (
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/ValueDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/Container:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/Contained:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/IDLType:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
-  return 1; // success using local knowledge
-  else
-    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
-}
-
-void *IR_ValueDef::_tao_QueryInterface (ptr_arith_t type)
-{
-  void *retv = 0;
-  if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_ValueDef::_narrow))
-    retv = ACE_reinterpret_cast (void*, this);
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_Container::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            IR_Container_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_Contained::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            IR_Contained_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_IDLType::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            IR_IDLType_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &CORBA_IRObject::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            CORBA_IRObject_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
-    retv = ACE_reinterpret_cast (void *,
-      ACE_static_cast (CORBA::Object_ptr, this));
-    
-  if (retv)
-    this->_add_ref ();
-  return retv;
-}
-
-const char* IR_ValueDef::_interface_repository_id (void) const
-{
-  return "IDL:omg.org/IR/ValueDef:1.0";
-}
-
-IR_InterfaceDefSeq * IR_ValueDef::supported_interfaces (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_ValueDef_Proxy_Impl &proxy = 
-    this->the_TAO_ValueDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.supported_interfaces (
-      this,
-      ACE_TRY_ENV
-    );
-}
-
-void IR_ValueDef::supported_interfaces (
-    const IR_InterfaceDefSeq & supported_interfaces,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_ValueDef_Proxy_Impl &proxy = 
-    this->the_TAO_ValueDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK;
-  
-  proxy.supported_interfaces (
-      this,
-      supported_interfaces,
-      ACE_TRY_ENV
-    );
-}
-
-IR_InitializerSeq * IR_ValueDef::initializers (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_ValueDef_Proxy_Impl &proxy = 
-    this->the_TAO_ValueDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.initializers (
-      this,
-      ACE_TRY_ENV
-    );
-}
-
-void IR_ValueDef::initializers (
-    const IR_InitializerSeq & initializers,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_ValueDef_Proxy_Impl &proxy = 
-    this->the_TAO_ValueDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK;
-  
-  proxy.initializers (
-      this,
-      initializers,
-      ACE_TRY_ENV
-    );
-}
-
-IR_ValueDef_ptr IR_ValueDef::base_value (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_ValueDef_Proxy_Impl &proxy = 
-    this->the_TAO_ValueDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.base_value (
-      this,
-      ACE_TRY_ENV
-    );
-}
-
-void IR_ValueDef::base_value (
-    IR_ValueDef_ptr base_value,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_ValueDef_Proxy_Impl &proxy = 
-    this->the_TAO_ValueDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK;
-  
-  proxy.base_value (
-      this,
-      base_value,
-      ACE_TRY_ENV
-    );
-}
-
-IR_ValueDefSeq * IR_ValueDef::abstract_base_values (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_ValueDef_Proxy_Impl &proxy = 
-    this->the_TAO_ValueDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.abstract_base_values (
-      this,
-      ACE_TRY_ENV
-    );
-}
-
-void IR_ValueDef::abstract_base_values (
-    const IR_ValueDefSeq & abstract_base_values,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_ValueDef_Proxy_Impl &proxy = 
-    this->the_TAO_ValueDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK;
-  
-  proxy.abstract_base_values (
-      this,
-      abstract_base_values,
-      ACE_TRY_ENV
-    );
-}
-
-CORBA::Boolean IR_ValueDef::is_abstract (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_ValueDef_Proxy_Impl &proxy = 
-    this->the_TAO_ValueDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.is_abstract (
-      this,
-      ACE_TRY_ENV
-    );
-}
-
-void IR_ValueDef::is_abstract (
-    CORBA::Boolean is_abstract,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_ValueDef_Proxy_Impl &proxy = 
-    this->the_TAO_ValueDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK;
-  
-  proxy.is_abstract (
-      this,
-      is_abstract,
-      ACE_TRY_ENV
-    );
-}
-
-CORBA::Boolean IR_ValueDef::is_custom (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_ValueDef_Proxy_Impl &proxy = 
-    this->the_TAO_ValueDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.is_custom (
-      this,
-      ACE_TRY_ENV
-    );
-}
-
-void IR_ValueDef::is_custom (
-    CORBA::Boolean is_custom,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_ValueDef_Proxy_Impl &proxy = 
-    this->the_TAO_ValueDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK;
-  
-  proxy.is_custom (
-      this,
-      is_custom,
-      ACE_TRY_ENV
-    );
-}
-
-CORBA::Boolean IR_ValueDef::is_truncatable (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_ValueDef_Proxy_Impl &proxy = 
-    this->the_TAO_ValueDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.is_truncatable (
-      this,
-      ACE_TRY_ENV
-    );
-}
-
-void IR_ValueDef::is_truncatable (
-    CORBA::Boolean is_truncatable,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_ValueDef_Proxy_Impl &proxy = 
-    this->the_TAO_ValueDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK;
-  
-  proxy.is_truncatable (
-      this,
-      is_truncatable,
-      ACE_TRY_ENV
-    );
-}
-
-CORBA::Boolean IR_ValueDef::is_a (
-    const char * id,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_ValueDef_Proxy_Impl &proxy = 
-    this->the_TAO_ValueDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.is_a (
-      this,
-      id,
-      ACE_TRY_ENV
-    );
-}
-
-IR_ValueMemberDef_ptr IR_ValueDef::create_value_member (
-    const char * id,
-    const char * name,
-    const char * version,
-    IR_IDLType_ptr type,
-    CORBA::Visibility access,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_ValueDef_Proxy_Impl &proxy = 
-    this->the_TAO_ValueDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.create_value_member (
-      this,
-      id,
-      name,
-      version,
-      type,
-      access,
-      ACE_TRY_ENV
-    );
-}
-
-IR_AttributeDef_ptr IR_ValueDef::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,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_ValueDef_Proxy_Impl &proxy = 
-    this->the_TAO_ValueDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.create_attribute (
-      this,
-      id,
-      name,
-      version,
-      type,
-      mode,
-      get_exceptions,
-      put_exceptions,
-      ACE_TRY_ENV
-    );
-}
-
-IR_OperationDef_ptr IR_ValueDef::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,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_ValueDef_Proxy_Impl &proxy = 
-    this->the_TAO_ValueDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.create_operation (
-      this,
-      id,
-      name,
-      version,
-      result,
-      mode,
-      params,
-      exceptions,
-      contexts,
-      ACE_TRY_ENV
-    );
-}
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_supported_interfaces_get::TAO_ClientRequestInfo_IR_ValueDef_supported_interfaces_get (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
-{}
-
-Dynamic::ParameterList *
-IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_supported_interfaces_get::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return parameter_list;
-}
-
-Dynamic::ExceptionList *
-IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_supported_interfaces_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_supported_interfaces_get::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_supported_interfaces_get::result (IR_InterfaceDefSeq * result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_supported_interfaces_set::TAO_ClientRequestInfo_IR_ValueDef_supported_interfaces_set (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    const IR_InterfaceDefSeq & supported_interfaces,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
-    supported_interfaces_ (supported_interfaces)
-{}
-
-Dynamic::ParameterList *
-IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_supported_interfaces_set::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
-    
-  CORBA::ULong length_supported_interfaces = parameter_list->length ();
-  parameter_list->length (length_supported_interfaces + 1);
-  (*parameter_list)[length_supported_interfaces].argument <<=  this->supported_interfaces_;
-  
-  (*parameter_list)[length_supported_interfaces].mode = Dynamic::PARAM_IN;
-  
-  return safe_parameter_list._retn ();
-}
-
-Dynamic::ExceptionList *
-IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_supported_interfaces_set::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_supported_interfaces_set::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 1;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return result_any;
-}
-
-IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_initializers_get::TAO_ClientRequestInfo_IR_ValueDef_initializers_get (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
-{}
-
-Dynamic::ParameterList *
-IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_initializers_get::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return parameter_list;
-}
-
-Dynamic::ExceptionList *
-IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_initializers_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_initializers_get::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_initializers_get::result (IR_InitializerSeq * result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_initializers_set::TAO_ClientRequestInfo_IR_ValueDef_initializers_set (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    const IR_InitializerSeq & initializers,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
-    initializers_ (initializers)
-{}
-
-Dynamic::ParameterList *
-IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_initializers_set::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
-    
-  CORBA::ULong length_initializers = parameter_list->length ();
-  parameter_list->length (length_initializers + 1);
-  (*parameter_list)[length_initializers].argument <<=  this->initializers_;
-  
-  (*parameter_list)[length_initializers].mode = Dynamic::PARAM_IN;
-  
-  return safe_parameter_list._retn ();
-}
-
-Dynamic::ExceptionList *
-IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_initializers_set::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_initializers_set::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 1;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return result_any;
-}
-
-IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_base_value_get::TAO_ClientRequestInfo_IR_ValueDef_base_value_get (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
-{}
-
-Dynamic::ParameterList *
-IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_base_value_get::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return parameter_list;
-}
-
-Dynamic::ExceptionList *
-IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_base_value_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_base_value_get::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_base_value_get::result (IR_ValueDef_ptr result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_base_value_set::TAO_ClientRequestInfo_IR_ValueDef_base_value_set (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    IR_ValueDef_ptr base_value,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
-    base_value_ (base_value)
-{}
-
-Dynamic::ParameterList *
-IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_base_value_set::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
-    
-  CORBA::ULong length_base_value = parameter_list->length ();
-  parameter_list->length (length_base_value + 1);
-  (*parameter_list)[length_base_value].argument <<=  this->base_value_;
-  
-  (*parameter_list)[length_base_value].mode = Dynamic::PARAM_IN;
-  
-  return safe_parameter_list._retn ();
-}
-
-Dynamic::ExceptionList *
-IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_base_value_set::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_base_value_set::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 1;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return result_any;
-}
-
-IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_abstract_base_values_get::TAO_ClientRequestInfo_IR_ValueDef_abstract_base_values_get (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
-{}
-
-Dynamic::ParameterList *
-IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_abstract_base_values_get::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return parameter_list;
-}
-
-Dynamic::ExceptionList *
-IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_abstract_base_values_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_abstract_base_values_get::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_abstract_base_values_get::result (IR_ValueDefSeq * result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_abstract_base_values_set::TAO_ClientRequestInfo_IR_ValueDef_abstract_base_values_set (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    const IR_ValueDefSeq & abstract_base_values,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
-    abstract_base_values_ (abstract_base_values)
-{}
-
-Dynamic::ParameterList *
-IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_abstract_base_values_set::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
-    
-  CORBA::ULong length_abstract_base_values = parameter_list->length ();
-  parameter_list->length (length_abstract_base_values + 1);
-  (*parameter_list)[length_abstract_base_values].argument <<=  this->abstract_base_values_;
-  
-  (*parameter_list)[length_abstract_base_values].mode = Dynamic::PARAM_IN;
-  
-  return safe_parameter_list._retn ();
-}
-
-Dynamic::ExceptionList *
-IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_abstract_base_values_set::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_abstract_base_values_set::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 1;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return result_any;
-}
-
-IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_is_abstract_get::TAO_ClientRequestInfo_IR_ValueDef_is_abstract_get (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
-{}
-
-Dynamic::ParameterList *
-IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_is_abstract_get::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return parameter_list;
-}
-
-Dynamic::ExceptionList *
-IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_is_abstract_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_is_abstract_get::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= CORBA::Any::from_boolean (this->_result);
-  return safe_result_any._retn ();
-}
-
-void 
-IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_is_abstract_get::result (CORBA::Boolean result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_is_abstract_set::TAO_ClientRequestInfo_IR_ValueDef_is_abstract_set (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    const CORBA::Boolean & is_abstract,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
-    is_abstract_ (is_abstract)
-{}
-
-Dynamic::ParameterList *
-IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_is_abstract_set::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
-    
-  CORBA::ULong length_is_abstract = parameter_list->length ();
-  parameter_list->length (length_is_abstract + 1);
-  (*parameter_list)[length_is_abstract].argument <<= CORBA::Any::from_boolean (this->is_abstract_);
-  (*parameter_list)[length_is_abstract].mode = Dynamic::PARAM_IN;
-  
-  return safe_parameter_list._retn ();
-}
-
-Dynamic::ExceptionList *
-IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_is_abstract_set::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_is_abstract_set::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 1;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return result_any;
-}
-
-IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_is_custom_get::TAO_ClientRequestInfo_IR_ValueDef_is_custom_get (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
-{}
-
-Dynamic::ParameterList *
-IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_is_custom_get::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return parameter_list;
-}
-
-Dynamic::ExceptionList *
-IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_is_custom_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_is_custom_get::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= CORBA::Any::from_boolean (this->_result);
-  return safe_result_any._retn ();
-}
-
-void 
-IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_is_custom_get::result (CORBA::Boolean result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_is_custom_set::TAO_ClientRequestInfo_IR_ValueDef_is_custom_set (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    const CORBA::Boolean & is_custom,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
-    is_custom_ (is_custom)
-{}
-
-Dynamic::ParameterList *
-IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_is_custom_set::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
-    
-  CORBA::ULong length_is_custom = parameter_list->length ();
-  parameter_list->length (length_is_custom + 1);
-  (*parameter_list)[length_is_custom].argument <<= CORBA::Any::from_boolean (this->is_custom_);
-  (*parameter_list)[length_is_custom].mode = Dynamic::PARAM_IN;
-  
-  return safe_parameter_list._retn ();
-}
-
-Dynamic::ExceptionList *
-IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_is_custom_set::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_is_custom_set::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 1;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return result_any;
-}
-
-IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_is_truncatable_get::TAO_ClientRequestInfo_IR_ValueDef_is_truncatable_get (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
-{}
-
-Dynamic::ParameterList *
-IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_is_truncatable_get::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return parameter_list;
-}
-
-Dynamic::ExceptionList *
-IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_is_truncatable_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_is_truncatable_get::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= CORBA::Any::from_boolean (this->_result);
-  return safe_result_any._retn ();
-}
-
-void 
-IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_is_truncatable_get::result (CORBA::Boolean result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_is_truncatable_set::TAO_ClientRequestInfo_IR_ValueDef_is_truncatable_set (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    const CORBA::Boolean & is_truncatable,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
-    is_truncatable_ (is_truncatable)
-{}
-
-Dynamic::ParameterList *
-IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_is_truncatable_set::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
-    
-  CORBA::ULong length_is_truncatable = parameter_list->length ();
-  parameter_list->length (length_is_truncatable + 1);
-  (*parameter_list)[length_is_truncatable].argument <<= CORBA::Any::from_boolean (this->is_truncatable_);
-  (*parameter_list)[length_is_truncatable].mode = Dynamic::PARAM_IN;
-  
-  return safe_parameter_list._retn ();
-}
-
-Dynamic::ExceptionList *
-IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_is_truncatable_set::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_is_truncatable_set::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 1;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return result_any;
-}
-
-IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_is_a::TAO_ClientRequestInfo_IR_ValueDef_is_a (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    const char * id,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
-    id_ (id)
-{}
-
-Dynamic::ParameterList *
-IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_is_a::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
-    
-  CORBA::ULong length_id = parameter_list->length ();
-  parameter_list->length (length_id + 1);
-  (*parameter_list)[length_id].argument <<= id_;
-  (*parameter_list)[length_id].mode = Dynamic::PARAM_IN;
-  
-  return safe_parameter_list._retn ();
-}
-
-Dynamic::ExceptionList *
-IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_is_a::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_is_a::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= CORBA::Any::from_boolean (this->_result);
-  return safe_result_any._retn ();
-}
-
-void 
-IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_is_a::result (CORBA::Boolean result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_create_value_member::TAO_ClientRequestInfo_IR_ValueDef_create_value_member (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    const char * id,
-    const char * name,
-    const char * version,
-    IR_IDLType_ptr type,
-    const CORBA::Visibility & access,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
-    id_ (id),
-    name_ (name),
-    version_ (version),
-    type_ (type),
-    access_ (access)
-{}
-
-Dynamic::ParameterList *
-IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_create_value_member::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
-    
-  CORBA::ULong length_id = parameter_list->length ();
-  parameter_list->length (length_id + 1);
-  (*parameter_list)[length_id].argument <<= id_;
-  (*parameter_list)[length_id].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_name = parameter_list->length ();
-  parameter_list->length (length_name + 1);
-  (*parameter_list)[length_name].argument <<= name_;
-  (*parameter_list)[length_name].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_version = parameter_list->length ();
-  parameter_list->length (length_version + 1);
-  (*parameter_list)[length_version].argument <<= version_;
-  (*parameter_list)[length_version].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_type = parameter_list->length ();
-  parameter_list->length (length_type + 1);
-  (*parameter_list)[length_type].argument <<=  this->type_;
-  
-  (*parameter_list)[length_type].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_access = parameter_list->length ();
-  parameter_list->length (length_access + 1);
-  (*parameter_list)[length_access].argument <<= access_;
-  (*parameter_list)[length_access].mode = Dynamic::PARAM_IN;
-  
-  return safe_parameter_list._retn ();
-}
-
-Dynamic::ExceptionList *
-IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_create_value_member::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_create_value_member::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_create_value_member::result (IR_ValueMemberDef_ptr result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_create_attribute::TAO_ClientRequestInfo_IR_ValueDef_create_attribute (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _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 &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
-    id_ (id),
-    name_ (name),
-    version_ (version),
-    type_ (type),
-    mode_ (mode),
-    get_exceptions_ (get_exceptions),
-    put_exceptions_ (put_exceptions)
-{}
-
-Dynamic::ParameterList *
-IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_create_attribute::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
-    
-  CORBA::ULong length_id = parameter_list->length ();
-  parameter_list->length (length_id + 1);
-  (*parameter_list)[length_id].argument <<= id_;
-  (*parameter_list)[length_id].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_name = parameter_list->length ();
-  parameter_list->length (length_name + 1);
-  (*parameter_list)[length_name].argument <<= name_;
-  (*parameter_list)[length_name].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_version = parameter_list->length ();
-  parameter_list->length (length_version + 1);
-  (*parameter_list)[length_version].argument <<= version_;
-  (*parameter_list)[length_version].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_type = parameter_list->length ();
-  parameter_list->length (length_type + 1);
-  (*parameter_list)[length_type].argument <<=  this->type_;
-  
-  (*parameter_list)[length_type].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_mode = parameter_list->length ();
-  parameter_list->length (length_mode + 1);
-  (*parameter_list)[length_mode].argument <<=  this->mode_;
-  
-  (*parameter_list)[length_mode].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_get_exceptions = parameter_list->length ();
-  parameter_list->length (length_get_exceptions + 1);
-  (*parameter_list)[length_get_exceptions].argument <<=  this->get_exceptions_;
-  
-  (*parameter_list)[length_get_exceptions].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_put_exceptions = parameter_list->length ();
-  parameter_list->length (length_put_exceptions + 1);
-  (*parameter_list)[length_put_exceptions].argument <<=  this->put_exceptions_;
-  
-  (*parameter_list)[length_put_exceptions].mode = Dynamic::PARAM_IN;
-  
-  return safe_parameter_list._retn ();
-}
-
-Dynamic::ExceptionList *
-IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_create_attribute::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_create_attribute::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_create_attribute::result (IR_AttributeDef_ptr result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_create_operation::TAO_ClientRequestInfo_IR_ValueDef_create_operation (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _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 &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
-    id_ (id),
-    name_ (name),
-    version_ (version),
-    result_ (result),
-    mode_ (mode),
-    params_ (params),
-    exceptions_ (exceptions),
-    contexts_ (contexts)
-{}
-
-Dynamic::ParameterList *
-IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_create_operation::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
-    
-  CORBA::ULong length_id = parameter_list->length ();
-  parameter_list->length (length_id + 1);
-  (*parameter_list)[length_id].argument <<= id_;
-  (*parameter_list)[length_id].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_name = parameter_list->length ();
-  parameter_list->length (length_name + 1);
-  (*parameter_list)[length_name].argument <<= name_;
-  (*parameter_list)[length_name].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_version = parameter_list->length ();
-  parameter_list->length (length_version + 1);
-  (*parameter_list)[length_version].argument <<= version_;
-  (*parameter_list)[length_version].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_result = parameter_list->length ();
-  parameter_list->length (length_result + 1);
-  (*parameter_list)[length_result].argument <<=  this->result_;
-  
-  (*parameter_list)[length_result].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_mode = parameter_list->length ();
-  parameter_list->length (length_mode + 1);
-  (*parameter_list)[length_mode].argument <<=  this->mode_;
-  
-  (*parameter_list)[length_mode].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_params = parameter_list->length ();
-  parameter_list->length (length_params + 1);
-  (*parameter_list)[length_params].argument <<=  this->params_;
-  
-  (*parameter_list)[length_params].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_exceptions = parameter_list->length ();
-  parameter_list->length (length_exceptions + 1);
-  (*parameter_list)[length_exceptions].argument <<=  this->exceptions_;
-  
-  (*parameter_list)[length_exceptions].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_contexts = parameter_list->length ();
-  parameter_list->length (length_contexts + 1);
-  (*parameter_list)[length_contexts].argument <<=  this->contexts_;
-  
-  (*parameter_list)[length_contexts].mode = Dynamic::PARAM_IN;
-  
-  return safe_parameter_list._retn ();
-}
-
-Dynamic::ExceptionList *
-IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_create_operation::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_create_operation::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_ValueDef::TAO_ClientRequestInfo_IR_ValueDef_create_operation::result (IR_OperationDef_ptr result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-#endif /* TAO_HAS_INTERCEPTORS */
-
-static const CORBA::Long _oc_IR_ValueDef[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  28, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x616c7565), ACE_NTOHL (0x4465663a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ValueDef:1.0
-  9, ACE_NTOHL (0x56616c75), ACE_NTOHL (0x65446566), ACE_NTOHL (0x0),  // name = IR_ValueDef
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_ValueDef (CORBA::tk_objref, sizeof (_oc_IR_ValueDef), (char *) &_oc_IR_ValueDef, 0, sizeof (IR_ValueDef));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ValueDef, &_tc_TAO_tc_IR_ValueDef)
-TAO_NAMESPACE_END
-
-static const CORBA::Long _oc_IR_ValueDescription[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  36, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x616c7565), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ValueDescription:1.0
-  17, ACE_NTOHL (0x56616c75), ACE_NTOHL (0x65446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = ValueDescription
-  15, // member count
-  5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
-  CORBA::tk_alias, // typecode kind for typedefs
-  64, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
-    11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-    CORBA::tk_string, 
-    0U, // string length
-
-  3, ACE_NTOHL (0x69640000),  // name = id
-  CORBA::tk_alias, // typecode kind for typedefs
-  68, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-    13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-    CORBA::tk_string, 
-    0U, // string length
-
-  12, ACE_NTOHL (0x69735f61), ACE_NTOHL (0x62737472), ACE_NTOHL (0x61637400),  // name = is_abstract
-  CORBA::tk_boolean,
-
-  10, ACE_NTOHL (0x69735f63), ACE_NTOHL (0x7573746f), ACE_NTOHL (0x6d000000),  // name = is_custom
-  CORBA::tk_boolean,
-
-  11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
-  CORBA::tk_alias, // typecode kind for typedefs
-  68, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-    13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-    CORBA::tk_string, 
-    0U, // string length
-
-  8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
-  CORBA::tk_alias, // typecode kind for typedefs
-  64, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
-    12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
-    CORBA::tk_string, 
-    0U, // string length
-
-  11, ACE_NTOHL (0x6f706572), ACE_NTOHL (0x6174696f), ACE_NTOHL (0x6e730000),  // name = operations
-  CORBA::tk_alias, // typecode kind for typedefs
-  1972, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    36, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f4f), ACE_NTOHL (0x70446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x5365713a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/OpDescriptionSeq:1.0
-    17, ACE_NTOHL (0x4f704465), ACE_NTOHL (0x73637269), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e536571), ACE_NTOHL (0x0),  // name = OpDescriptionSeq
-    CORBA::tk_sequence, // typecode kind
-    1896, // encapsulation length
-      TAO_ENCAP_BYTE_ORDER, // byte order
-      CORBA::tk_struct, // typecode kind
-      1880, // encapsulation length
-        TAO_ENCAP_BYTE_ORDER, // byte order
-        40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f4f), ACE_NTOHL (0x70657261), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/OperationDescription:1.0
-        21, ACE_NTOHL (0x4f706572), ACE_NTOHL (0x6174696f), ACE_NTOHL (0x6e446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = OperationDescription
-        9, // member count
-        5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
-        CORBA::tk_alias, // typecode kind for typedefs
-        64, // encapsulation length
-          TAO_ENCAP_BYTE_ORDER, // byte order
-          30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
-          11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-          CORBA::tk_string, 
-          0U, // string length
-
-        3, ACE_NTOHL (0x69640000),  // name = id
-        CORBA::tk_alias, // typecode kind for typedefs
-        68, // encapsulation length
-          TAO_ENCAP_BYTE_ORDER, // byte order
-          32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-          13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-          CORBA::tk_string, 
-          0U, // string length
-
-        11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
-        CORBA::tk_alias, // typecode kind for typedefs
-        68, // encapsulation length
-          TAO_ENCAP_BYTE_ORDER, // byte order
-          32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-          13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-          CORBA::tk_string, 
-          0U, // string length
-
-        8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
-        CORBA::tk_alias, // typecode kind for typedefs
-        64, // encapsulation length
-          TAO_ENCAP_BYTE_ORDER, // byte order
-          31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
-          12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
-          CORBA::tk_string, 
-          0U, // string length
-
-        7, ACE_NTOHL (0x72657375), ACE_NTOHL (0x6c740000),  // name = result
-        CORBA::tk_TypeCode,
-
-        5, ACE_NTOHL (0x6d6f6465), ACE_NTOHL (0x0),  // name = mode
-        CORBA::tk_enum, // typecode kind
-        100, // encapsulation length
-          TAO_ENCAP_BYTE_ORDER, // byte order
-          33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f4f), ACE_NTOHL (0x70657261), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x4d6f6465), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/OperationMode:1.0
-          14, ACE_NTOHL (0x4f706572), ACE_NTOHL (0x6174696f), ACE_NTOHL (0x6e4d6f64), ACE_NTOHL (0x65000000),  // name = OperationMode
-          2, // member count
-          10, ACE_NTOHL (0x4f505f4e), ACE_NTOHL (0x4f524d41), ACE_NTOHL (0x4c000000),  // name = OP_NORMAL
-          10, ACE_NTOHL (0x4f505f4f), ACE_NTOHL (0x4e455741), ACE_NTOHL (0x59000000),  // name = OP_ONEWAY
-
-        9, ACE_NTOHL (0x636f6e74), ACE_NTOHL (0x65787473), ACE_NTOHL (0x0),  // name = contexts
-        CORBA::tk_alias, // typecode kind for typedefs
-        228, // encapsulation length
-          TAO_ENCAP_BYTE_ORDER, // byte order
-          32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f43), ACE_NTOHL (0x6f6e7465), ACE_NTOHL (0x78744964), ACE_NTOHL (0x5365713a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ContextIdSeq:1.0
-          13, ACE_NTOHL (0x436f6e74), ACE_NTOHL (0x65787449), ACE_NTOHL (0x64536571), ACE_NTOHL (0x0),  // name = ContextIdSeq
-          CORBA::tk_sequence, // typecode kind
-          160, // encapsulation length
-            TAO_ENCAP_BYTE_ORDER, // byte order
-            CORBA::tk_alias, // typecode kind for typedefs
-            144, // encapsulation length
-              TAO_ENCAP_BYTE_ORDER, // byte order
-              37, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f43), ACE_NTOHL (0x6f6e7465), ACE_NTOHL (0x78744964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/ContextIdentifier:1.0
-              18, ACE_NTOHL (0x436f6e74), ACE_NTOHL (0x65787449), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x72000000),  // name = ContextIdentifier
-              CORBA::tk_alias, // typecode kind for typedefs
-              64, // encapsulation length
-                TAO_ENCAP_BYTE_ORDER, // byte order
-                30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
-                11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-                CORBA::tk_string, 
-                0U, // string length
-
-
-            0U,
-
-
-        11, ACE_NTOHL (0x70617261), ACE_NTOHL (0x6d657465), ACE_NTOHL (0x72730000),  // name = parameters
-        CORBA::tk_alias, // typecode kind for typedefs
-        484, // encapsulation length
-          TAO_ENCAP_BYTE_ORDER, // byte order
-          37, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f50), ACE_NTOHL (0x61724465), ACE_NTOHL (0x73637269), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e536571), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/ParDescriptionSeq:1.0
-          18, ACE_NTOHL (0x50617244), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e5365), ACE_NTOHL (0x71000000),  // name = ParDescriptionSeq
-          CORBA::tk_sequence, // typecode kind
-          404, // encapsulation length
-            TAO_ENCAP_BYTE_ORDER, // byte order
-            CORBA::tk_struct, // typecode kind
-            388, // encapsulation length
-              TAO_ENCAP_BYTE_ORDER, // byte order
-              40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f50), ACE_NTOHL (0x6172616d), ACE_NTOHL (0x65746572), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ParameterDescription:1.0
-              21, ACE_NTOHL (0x50617261), ACE_NTOHL (0x6d657465), ACE_NTOHL (0x72446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = ParameterDescription
-              4, // member count
-              5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
-              CORBA::tk_alias, // typecode kind for typedefs
-              64, // encapsulation length
-                TAO_ENCAP_BYTE_ORDER, // byte order
-                30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
-                11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-                CORBA::tk_string, 
-                0U, // string length
-
-              5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
-              CORBA::tk_TypeCode,
-
-              9, ACE_NTOHL (0x74797065), ACE_NTOHL (0x5f646566), ACE_NTOHL (0x0),  // name = type_def
-              CORBA::tk_objref, // typecode kind
-              48, // encapsulation length
-                TAO_ENCAP_BYTE_ORDER, // byte order
-                27, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x444c5479), ACE_NTOHL (0x70653a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/IDLType:1.0
-                8, ACE_NTOHL (0x49444c54), ACE_NTOHL (0x79706500),  // name = IR_IDLType
-
-              5, ACE_NTOHL (0x6d6f6465), ACE_NTOHL (0x0),  // name = mode
-              CORBA::tk_enum, // typecode kind
-              116, // encapsulation length
-                TAO_ENCAP_BYTE_ORDER, // byte order
-                33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f50), ACE_NTOHL (0x6172616d), ACE_NTOHL (0x65746572), ACE_NTOHL (0x4d6f6465), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/ParameterMode:1.0
-                14, ACE_NTOHL (0x50617261), ACE_NTOHL (0x6d657465), ACE_NTOHL (0x724d6f64), ACE_NTOHL (0x65000000),  // name = ParameterMode
-                3, // member count
-                9, ACE_NTOHL (0x50415241), ACE_NTOHL (0x4d5f494e), ACE_NTOHL (0x0),  // name = PARAM_IN
-                10, ACE_NTOHL (0x50415241), ACE_NTOHL (0x4d5f4f55), ACE_NTOHL (0x54000000),  // name = PARAM_OUT
-                12, ACE_NTOHL (0x50415241), ACE_NTOHL (0x4d5f494e), ACE_NTOHL (0x4f555400),  // name = PARAM_INOUT
-
-
-            0U,
-
-
-        11, ACE_NTOHL (0x65786365), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e730000),  // name = exceptions
-        CORBA::tk_alias, // typecode kind for typedefs
-        536, // encapsulation length
-          TAO_ENCAP_BYTE_ORDER, // byte order
-          37, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x78634465), ACE_NTOHL (0x73637269), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e536571), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/ExcDescriptionSeq:1.0
-          18, ACE_NTOHL (0x45786344), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e5365), ACE_NTOHL (0x71000000),  // name = ExcDescriptionSeq
-          CORBA::tk_sequence, // typecode kind
-          456, // encapsulation length
-            TAO_ENCAP_BYTE_ORDER, // byte order
-            CORBA::tk_struct, // typecode kind
-            440, // encapsulation length
-              TAO_ENCAP_BYTE_ORDER, // byte order
-              40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x78636570), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ExceptionDescription:1.0
-              21, ACE_NTOHL (0x45786365), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = ExceptionDescription
-              5, // member count
-              5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
-              CORBA::tk_alias, // typecode kind for typedefs
-              64, // encapsulation length
-                TAO_ENCAP_BYTE_ORDER, // byte order
-                30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
-                11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-                CORBA::tk_string, 
-                0U, // string length
-
-              3, ACE_NTOHL (0x69640000),  // name = id
-              CORBA::tk_alias, // typecode kind for typedefs
-              68, // encapsulation length
-                TAO_ENCAP_BYTE_ORDER, // byte order
-                32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-                13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-                CORBA::tk_string, 
-                0U, // string length
-
-              11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
-              CORBA::tk_alias, // typecode kind for typedefs
-              68, // encapsulation length
-                TAO_ENCAP_BYTE_ORDER, // byte order
-                32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-                13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-                CORBA::tk_string, 
-                0U, // string length
-
-              8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
-              CORBA::tk_alias, // typecode kind for typedefs
-              64, // encapsulation length
-                TAO_ENCAP_BYTE_ORDER, // byte order
-                31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
-                12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
-                CORBA::tk_string, 
-                0U, // string length
-
-              5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
-              CORBA::tk_TypeCode,
-
-
-            0U,
-
-
-
-      0U,
-
-
-  11, ACE_NTOHL (0x61747472), ACE_NTOHL (0x69627574), ACE_NTOHL (0x65730000),  // name = attributes
-  CORBA::tk_alias, // typecode kind for typedefs
-  1788, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    38, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f41), ACE_NTOHL (0x74747244), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e5365), ACE_NTOHL (0x713a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/AttrDescriptionSeq:1.0
-    19, ACE_NTOHL (0x41747472), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x65710000),  // name = AttrDescriptionSeq
-    CORBA::tk_sequence, // typecode kind
-    1708, // encapsulation length
-      TAO_ENCAP_BYTE_ORDER, // byte order
-      CORBA::tk_struct, // typecode kind
-      1692, // encapsulation length
-        TAO_ENCAP_BYTE_ORDER, // byte order
-        40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f41), ACE_NTOHL (0x74747269), ACE_NTOHL (0x62757465), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/AttributeDescription:1.0
-        21, ACE_NTOHL (0x41747472), ACE_NTOHL (0x69627574), ACE_NTOHL (0x65446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = AttributeDescription
-        8, // member count
-        5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
-        CORBA::tk_alias, // typecode kind for typedefs
-        64, // encapsulation length
-          TAO_ENCAP_BYTE_ORDER, // byte order
-          30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
-          11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-          CORBA::tk_string, 
-          0U, // string length
-
-        3, ACE_NTOHL (0x69640000),  // name = id
-        CORBA::tk_alias, // typecode kind for typedefs
-        68, // encapsulation length
-          TAO_ENCAP_BYTE_ORDER, // byte order
-          32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-          13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-          CORBA::tk_string, 
-          0U, // string length
-
-        11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
-        CORBA::tk_alias, // typecode kind for typedefs
-        68, // encapsulation length
-          TAO_ENCAP_BYTE_ORDER, // byte order
-          32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-          13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-          CORBA::tk_string, 
-          0U, // string length
-
-        8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
-        CORBA::tk_alias, // typecode kind for typedefs
-        64, // encapsulation length
-          TAO_ENCAP_BYTE_ORDER, // byte order
-          31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
-          12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
-          CORBA::tk_string, 
-          0U, // string length
-
-        5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
-        CORBA::tk_TypeCode,
-
-        5, ACE_NTOHL (0x6d6f6465), ACE_NTOHL (0x0),  // name = mode
-        CORBA::tk_enum, // typecode kind
-        104, // encapsulation length
-          TAO_ENCAP_BYTE_ORDER, // byte order
-          33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f41), ACE_NTOHL (0x74747269), ACE_NTOHL (0x62757465), ACE_NTOHL (0x4d6f6465), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/AttributeMode:1.0
-          14, ACE_NTOHL (0x41747472), ACE_NTOHL (0x69627574), ACE_NTOHL (0x654d6f64), ACE_NTOHL (0x65000000),  // name = AttributeMode
-          2, // member count
-          12, ACE_NTOHL (0x41545452), ACE_NTOHL (0x5f4e4f52), ACE_NTOHL (0x4d414c00),  // name = ATTR_NORMAL
-          14, ACE_NTOHL (0x41545452), ACE_NTOHL (0x5f524541), ACE_NTOHL (0x444f4e4c), ACE_NTOHL (0x59000000),  // name = ATTR_READONLY
-
-        15, ACE_NTOHL (0x6765745f), ACE_NTOHL (0x65786365), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e730000),  // name = get_exceptions
-        CORBA::tk_alias, // typecode kind for typedefs
-        536, // encapsulation length
-          TAO_ENCAP_BYTE_ORDER, // byte order
-          37, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x78634465), ACE_NTOHL (0x73637269), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e536571), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/ExcDescriptionSeq:1.0
-          18, ACE_NTOHL (0x45786344), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e5365), ACE_NTOHL (0x71000000),  // name = ExcDescriptionSeq
-          CORBA::tk_sequence, // typecode kind
-          456, // encapsulation length
-            TAO_ENCAP_BYTE_ORDER, // byte order
-            CORBA::tk_struct, // typecode kind
-            440, // encapsulation length
-              TAO_ENCAP_BYTE_ORDER, // byte order
-              40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x78636570), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ExceptionDescription:1.0
-              21, ACE_NTOHL (0x45786365), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = ExceptionDescription
-              5, // member count
-              5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
-              CORBA::tk_alias, // typecode kind for typedefs
-              64, // encapsulation length
-                TAO_ENCAP_BYTE_ORDER, // byte order
-                30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
-                11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-                CORBA::tk_string, 
-                0U, // string length
-
-              3, ACE_NTOHL (0x69640000),  // name = id
-              CORBA::tk_alias, // typecode kind for typedefs
-              68, // encapsulation length
-                TAO_ENCAP_BYTE_ORDER, // byte order
-                32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-                13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-                CORBA::tk_string, 
-                0U, // string length
-
-              11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
-              CORBA::tk_alias, // typecode kind for typedefs
-              68, // encapsulation length
-                TAO_ENCAP_BYTE_ORDER, // byte order
-                32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-                13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-                CORBA::tk_string, 
-                0U, // string length
-
-              8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
-              CORBA::tk_alias, // typecode kind for typedefs
-              64, // encapsulation length
-                TAO_ENCAP_BYTE_ORDER, // byte order
-                31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
-                12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
-                CORBA::tk_string, 
-                0U, // string length
-
-              5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
-              CORBA::tk_TypeCode,
-
-
-            0U,
-
-
-        15, ACE_NTOHL (0x7075745f), ACE_NTOHL (0x65786365), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e730000),  // name = put_exceptions
-        CORBA::tk_alias, // typecode kind for typedefs
-        536, // encapsulation length
-          TAO_ENCAP_BYTE_ORDER, // byte order
-          37, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x78634465), ACE_NTOHL (0x73637269), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e536571), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/ExcDescriptionSeq:1.0
-          18, ACE_NTOHL (0x45786344), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e5365), ACE_NTOHL (0x71000000),  // name = ExcDescriptionSeq
-          CORBA::tk_sequence, // typecode kind
-          456, // encapsulation length
-            TAO_ENCAP_BYTE_ORDER, // byte order
-            CORBA::tk_struct, // typecode kind
-            440, // encapsulation length
-              TAO_ENCAP_BYTE_ORDER, // byte order
-              40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x78636570), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ExceptionDescription:1.0
-              21, ACE_NTOHL (0x45786365), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = ExceptionDescription
-              5, // member count
-              5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
-              CORBA::tk_alias, // typecode kind for typedefs
-              64, // encapsulation length
-                TAO_ENCAP_BYTE_ORDER, // byte order
-                30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
-                11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-                CORBA::tk_string, 
-                0U, // string length
-
-              3, ACE_NTOHL (0x69640000),  // name = id
-              CORBA::tk_alias, // typecode kind for typedefs
-              68, // encapsulation length
-                TAO_ENCAP_BYTE_ORDER, // byte order
-                32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-                13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-                CORBA::tk_string, 
-                0U, // string length
-
-              11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
-              CORBA::tk_alias, // typecode kind for typedefs
-              68, // encapsulation length
-                TAO_ENCAP_BYTE_ORDER, // byte order
-                32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-                13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-                CORBA::tk_string, 
-                0U, // string length
-
-              8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
-              CORBA::tk_alias, // typecode kind for typedefs
-              64, // encapsulation length
-                TAO_ENCAP_BYTE_ORDER, // byte order
-                31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
-                12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
-                CORBA::tk_string, 
-                0U, // string length
-
-              5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
-              CORBA::tk_TypeCode,
-
-
-            0U,
-
-
-
-      0U,
-
-
-  8, ACE_NTOHL (0x6d656d62), ACE_NTOHL (0x65727300),  // name = members
-  CORBA::tk_alias, // typecode kind for typedefs
-  664, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    34, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x616c7565), ACE_NTOHL (0x4d656d62), ACE_NTOHL (0x65725365), ACE_NTOHL (0x713a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/ValueMemberSeq:1.0
-    15, ACE_NTOHL (0x56616c75), ACE_NTOHL (0x654d656d), ACE_NTOHL (0x62657253), ACE_NTOHL (0x65710000),  // name = ValueMemberSeq
-    CORBA::tk_sequence, // typecode kind
-    592, // encapsulation length
-      TAO_ENCAP_BYTE_ORDER, // byte order
-      CORBA::tk_struct, // typecode kind
-      576, // encapsulation length
-        TAO_ENCAP_BYTE_ORDER, // byte order
-        31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x616c7565), ACE_NTOHL (0x4d656d62), ACE_NTOHL (0x65723a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/ValueMember:1.0
-        12, ACE_NTOHL (0x56616c75), ACE_NTOHL (0x654d656d), ACE_NTOHL (0x62657200),  // name = ValueMember
-        7, // member count
-        5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
-        CORBA::tk_alias, // typecode kind for typedefs
-        64, // encapsulation length
-          TAO_ENCAP_BYTE_ORDER, // byte order
-          30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
-          11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-          CORBA::tk_string, 
-          0U, // string length
-
-        3, ACE_NTOHL (0x69640000),  // name = id
-        CORBA::tk_alias, // typecode kind for typedefs
-        68, // encapsulation length
-          TAO_ENCAP_BYTE_ORDER, // byte order
-          32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-          13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-          CORBA::tk_string, 
-          0U, // string length
-
-        11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
-        CORBA::tk_alias, // typecode kind for typedefs
-        68, // encapsulation length
-          TAO_ENCAP_BYTE_ORDER, // byte order
-          32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-          13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-          CORBA::tk_string, 
-          0U, // string length
-
-        8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
-        CORBA::tk_alias, // typecode kind for typedefs
-        64, // encapsulation length
-          TAO_ENCAP_BYTE_ORDER, // byte order
-          31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
-          12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
-          CORBA::tk_string, 
-          0U, // string length
-
-        5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
-        CORBA::tk_TypeCode,
-
-        9, ACE_NTOHL (0x74797065), ACE_NTOHL (0x5f646566), ACE_NTOHL (0x0),  // name = type_def
-        CORBA::tk_objref, // typecode kind
-        48, // encapsulation length
-          TAO_ENCAP_BYTE_ORDER, // byte order
-          27, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x444c5479), ACE_NTOHL (0x70653a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/IDLType:1.0
-          8, ACE_NTOHL (0x49444c54), ACE_NTOHL (0x79706500),  // name = IR_IDLType
-
-        7, ACE_NTOHL (0x61636365), ACE_NTOHL (0x73730000),  // name = access
-        CORBA::tk_alias, // typecode kind for typedefs
-        64, // encapsulation length
-          TAO_ENCAP_BYTE_ORDER, // byte order
-          33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5669), ACE_NTOHL (0x73696269), ACE_NTOHL (0x6c697479), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Visibility:1.0
-          11, ACE_NTOHL (0x56697369), ACE_NTOHL (0x62696c69), ACE_NTOHL (0x74790000),  // name = Visibility
-          CORBA::tk_short,
-
-
-
-      0U,
-
-
-  13, ACE_NTOHL (0x696e6974), ACE_NTOHL (0x69616c69), ACE_NTOHL (0x7a657273), ACE_NTOHL (0x0),  // name = initializers
-  CORBA::tk_alias, // typecode kind for typedefs
-  576, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    34, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x6e697469), ACE_NTOHL (0x616c697a), ACE_NTOHL (0x65725365), ACE_NTOHL (0x713a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/InitializerSeq:1.0
-    15, ACE_NTOHL (0x496e6974), ACE_NTOHL (0x69616c69), ACE_NTOHL (0x7a657253), ACE_NTOHL (0x65710000),  // name = IR_InitializerSeq
-    CORBA::tk_sequence, // typecode kind
-    504, // encapsulation length
-      TAO_ENCAP_BYTE_ORDER, // byte order
-      CORBA::tk_struct, // typecode kind
-      488, // encapsulation length
-        TAO_ENCAP_BYTE_ORDER, // byte order
-        31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x6e697469), ACE_NTOHL (0x616c697a), ACE_NTOHL (0x65723a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/Initializer:1.0
-        12, ACE_NTOHL (0x496e6974), ACE_NTOHL (0x69616c69), ACE_NTOHL (0x7a657200),  // name = IR_Initializer
-        2, // member count
-        8, ACE_NTOHL (0x6d656d62), ACE_NTOHL (0x65727300),  // name = members
-        CORBA::tk_alias, // typecode kind for typedefs
-        324, // encapsulation length
-          TAO_ENCAP_BYTE_ORDER, // byte order
-          35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f53), ACE_NTOHL (0x74727563), ACE_NTOHL (0x744d656d), ACE_NTOHL (0x62657253), ACE_NTOHL (0x65713a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/StructMemberSeq:1.0
-          16, ACE_NTOHL (0x53747275), ACE_NTOHL (0x63744d65), ACE_NTOHL (0x6d626572), ACE_NTOHL (0x53657100),  // name = IR_StructMemberSeq
-          CORBA::tk_sequence, // typecode kind
-          252, // encapsulation length
-            TAO_ENCAP_BYTE_ORDER, // byte order
-            CORBA::tk_struct, // typecode kind
-            236, // encapsulation length
-              TAO_ENCAP_BYTE_ORDER, // byte order
-              32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f53), ACE_NTOHL (0x74727563), ACE_NTOHL (0x744d656d), ACE_NTOHL (0x6265723a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/StructMember:1.0
-              13, ACE_NTOHL (0x53747275), ACE_NTOHL (0x63744d65), ACE_NTOHL (0x6d626572), ACE_NTOHL (0x0),  // name = IR_StructMember
-              3, // member count
-              5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
-              CORBA::tk_alias, // typecode kind for typedefs
-              64, // encapsulation length
-                TAO_ENCAP_BYTE_ORDER, // byte order
-                30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
-                11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-                CORBA::tk_string, 
-                0U, // string length
-
-              5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
-              CORBA::tk_TypeCode,
-
-              9, ACE_NTOHL (0x74797065), ACE_NTOHL (0x5f646566), ACE_NTOHL (0x0),  // name = type_def
-              CORBA::tk_objref, // typecode kind
-              48, // encapsulation length
-                TAO_ENCAP_BYTE_ORDER, // byte order
-                27, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x444c5479), ACE_NTOHL (0x70653a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/IDLType:1.0
-                8, ACE_NTOHL (0x49444c54), ACE_NTOHL (0x79706500),  // name = IR_IDLType
-
-
-            0U,
-
-
-        5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
-        CORBA::tk_alias, // typecode kind for typedefs
-        64, // encapsulation length
-          TAO_ENCAP_BYTE_ORDER, // byte order
-          30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
-          11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-          CORBA::tk_string, 
-          0U, // string length
-
-
-      0U,
-
-
-  21, ACE_NTOHL (0x73757070), ACE_NTOHL (0x6f727465), ACE_NTOHL (0x645f696e), ACE_NTOHL (0x74657266), ACE_NTOHL (0x61636573), ACE_NTOHL (0x0),  // name = supported_interfaces
-  CORBA::tk_alias, // typecode kind for typedefs
-  156, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x79496453), ACE_NTOHL (0x65713a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/RepositoryIdSeq:1.0
-    16, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x53657100),  // name = RepositoryIdSeq
-    CORBA::tk_sequence, // typecode kind
-    84, // encapsulation length
-      TAO_ENCAP_BYTE_ORDER, // byte order
-      CORBA::tk_alias, // typecode kind for typedefs
-      68, // encapsulation length
-        TAO_ENCAP_BYTE_ORDER, // byte order
-        32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-        13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-        CORBA::tk_string, 
-        0U, // string length
-
-      0U,
-
-
-  21, ACE_NTOHL (0x61627374), ACE_NTOHL (0x72616374), ACE_NTOHL (0x5f626173), ACE_NTOHL (0x655f7661), ACE_NTOHL (0x6c756573), ACE_NTOHL (0x0),  // name = abstract_base_values
-  CORBA::tk_alias, // typecode kind for typedefs
-  156, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x79496453), ACE_NTOHL (0x65713a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/RepositoryIdSeq:1.0
-    16, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x53657100),  // name = RepositoryIdSeq
-    CORBA::tk_sequence, // typecode kind
-    84, // encapsulation length
-      TAO_ENCAP_BYTE_ORDER, // byte order
-      CORBA::tk_alias, // typecode kind for typedefs
-      68, // encapsulation length
-        TAO_ENCAP_BYTE_ORDER, // byte order
-        32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-        13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-        CORBA::tk_string, 
-        0U, // string length
-
-      0U,
-
-
-  15, ACE_NTOHL (0x69735f74), ACE_NTOHL (0x72756e63), ACE_NTOHL (0x61746162), ACE_NTOHL (0x6c650000),  // name = is_truncatable
-  CORBA::tk_boolean,
-
-  11, ACE_NTOHL (0x62617365), ACE_NTOHL (0x5f76616c), ACE_NTOHL (0x75650000),  // name = base_value
-  CORBA::tk_alias, // typecode kind for typedefs
-  68, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-    13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-    CORBA::tk_string, 
-    0U, // string length
-
-  5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
-  CORBA::tk_TypeCode,
-
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_ValueDescription (CORBA::tk_struct, sizeof (_oc_IR_ValueDescription), (char *) &_oc_IR_ValueDescription, 0, sizeof (IR_ValueDescription));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ValueDescription, &_tc_TAO_tc_IR_ValueDescription)
-TAO_NAMESPACE_END
-
-void IR_ValueDescription::_tao_any_destructor (void *x)
-{
-  IR_ValueDescription *tmp = ACE_static_cast (IR_ValueDescription*,x);
-  delete tmp;
-}
-
-
-///////////////////////////////////////////////////////////////////////
-//                Base & Remote Proxy  Implementation. 
-//
-
-_TAO_ValueBoxDef_Proxy_Impl::_TAO_ValueBoxDef_Proxy_Impl (void)
-{}
-
-_TAO_ValueBoxDef_Remote_Proxy_Impl::_TAO_ValueBoxDef_Remote_Proxy_Impl (void)
-{}
-
-// Remote Implementation of the IDL interface methods
-
-IR_IDLType_ptr _TAO_ValueBoxDef_Remote_Proxy_Impl::original_type_def (
-    CORBA_Object *_collocated_tao_target_,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  
-  IR_IDLType_ptr _tao_retval = IR_IDLType::_nil ();
-  IR_IDLType_var _tao_safe_retval (_tao_retval);
-  
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-
-  
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_get_original_type_def",
-      22,
-      0,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_ValueBoxDef::TAO_ClientRequestInfo_IR_ValueBoxDef_original_type_def_get ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              IR_IDLType_ptr _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-void _TAO_ValueBoxDef_Remote_Proxy_Impl::original_type_def (
-    CORBA_Object *_collocated_tao_target_,
-    IR_IDLType_ptr original_type_def,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW (CORBA::INTERNAL ());
-
-  
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_set_original_type_def",
-      22,
-      1,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_ValueBoxDef::TAO_ClientRequestInfo_IR_ValueBoxDef_original_type_def_set ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        original_type_def,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK;
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK;
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK;
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK;
-          
-          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-          if (!(
-                            (_tao_out << original_type_def)
-            ))
-            TAO_INTERCEPTOR_THROW (
-              CORBA::MARSHAL ()
-            );
-            
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK;
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)
-              );
-              
-            }
-          
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK;
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK;
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  
-}
-
-
-//
-//            End  Base & Remote  Proxy Implemeentation. 
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//           Remote & Base  Proxy Broker Implementation
-//
-
-_TAO_ValueBoxDef_Proxy_Broker::_TAO_ValueBoxDef_Proxy_Broker (void)
-{
-}
-
-_TAO_ValueBoxDef_Proxy_Broker::~_TAO_ValueBoxDef_Proxy_Broker (void)
-{
-}
-
-_TAO_ValueBoxDef_Proxy_Broker * (*_TAO_ValueBoxDef_Proxy_Broker_Factory_function_pointer) (
-    CORBA::Object_ptr obj
-  ) = 0;
-
-// Factory Member function Implementation.
-_TAO_ValueBoxDef_Remote_Proxy_Broker *
-_TAO_ValueBoxDef_Remote_Proxy_Broker::the_TAO_ValueBoxDef_Remote_Proxy_Broker (void)
-{
-  static ::_TAO_ValueBoxDef_Remote_Proxy_Broker remote_proxy_broker;
-  return &remote_proxy_broker;
-}
-
-_TAO_ValueBoxDef_Remote_Proxy_Broker::_TAO_ValueBoxDef_Remote_Proxy_Broker (void)
-{
-}
-
-_TAO_ValueBoxDef_Remote_Proxy_Broker::~_TAO_ValueBoxDef_Remote_Proxy_Broker (void)
-{
-}
-
-_TAO_ValueBoxDef_Proxy_Impl&
-_TAO_ValueBoxDef_Remote_Proxy_Broker::select_proxy (
-  ::IR_ValueBoxDef *object,
-  CORBA::Environment &ACE_TRY_ENV
-)
-{
-  ACE_UNUSED_ARG (object);
-  ACE_UNUSED_ARG (ACE_TRY_ENV);
-  return remote_proxy_impl_;
-}
-
-
-//
-//           End Remote & Base Proxy Broker Implementation
-///////////////////////////////////////////////////////////////////////
-
-
-// default constructor
-IR_ValueBoxDef::IR_ValueBoxDef (int collocated)
-{
-  this->IR_ValueBoxDef_setup_collocation (collocated);
-}
-
-// destructor
-IR_ValueBoxDef::~IR_ValueBoxDef (void)
-{}
-
-void
-IR_ValueBoxDef::IR_ValueBoxDef_setup_collocation (int collocated)
-{
-  if (collocated)
-    this->the_TAO_ValueBoxDef_Proxy_Broker_ =
-      _TAO_ValueBoxDef_Proxy_Broker_Factory_function_pointer (this);
-  else
-    this->the_TAO_ValueBoxDef_Proxy_Broker_ =
-      _TAO_ValueBoxDef_Remote_Proxy_Broker::the_TAO_ValueBoxDef_Remote_Proxy_Broker ();
-  
-  this->IR_TypedefDef_setup_collocation (collocated);
-}
-
-void IR_ValueBoxDef::_tao_any_destructor (void *x)
-{
-  IR_ValueBoxDef *tmp = ACE_static_cast (IR_ValueBoxDef*,x);
-  CORBA::release (tmp);
-}
-
-IR_ValueBoxDef_ptr IR_ValueBoxDef::_narrow (
-    CORBA::Object_ptr obj,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  if (CORBA::is_nil (obj))
-    return IR_ValueBoxDef::_nil ();
-  if (! obj->_is_local ())
-    {
-      CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/IR/ValueBoxDef:1.0", ACE_TRY_ENV);
-      ACE_CHECK_RETURN (IR_ValueBoxDef::_nil ());
-      if (is_a == 0)
-        return IR_ValueBoxDef::_nil ();
-    }
-  return IR_ValueBoxDef::_unchecked_narrow (obj, ACE_TRY_ENV);
-}
-
-IR_ValueBoxDef_ptr IR_ValueBoxDef::_unchecked_narrow (
-    CORBA::Object_ptr obj,
-    CORBA::Environment &
-  )
-{
-  if (CORBA::is_nil (obj))
-    return IR_ValueBoxDef::_nil ();
-  if (! obj->_is_local ())
-    {
-      TAO_Stub* stub = obj->_stubobj ();
-      if (stub)
-        stub->_incr_refcnt ();
-      IR_ValueBoxDef_ptr default_proxy = IR_ValueBoxDef::_nil ();
-
-      if (
-          !CORBA::is_nil (stub->servant_orb_var ().ptr ()) &&
-          stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects () &&
-          obj->_is_collocated () &&_TAO_ValueBoxDef_Proxy_Broker_Factory_function_pointer != 0
-        )
-      {
-        ACE_NEW_RETURN (
-          default_proxy,
-          ::IR_ValueBoxDef (
-            stub,
-            1,
-            obj->_servant ()),
-            
-          IR_ValueBoxDef::_nil ());
-        }
-      if (CORBA::is_nil (default_proxy))
-        ACE_NEW_RETURN (default_proxy, ::IR_ValueBoxDef (stub, 0, obj->_servant ()), IR_ValueBoxDef::_nil ());
-        return default_proxy;
-      }
-    else 
-      return
-        ACE_reinterpret_cast
-          (
-            IR_ValueBoxDef_ptr,
-              obj->_tao_QueryInterface
-                (
-                  ACE_reinterpret_cast
-                    (
-                      ptr_arith_t,
-                      &IR_ValueBoxDef::_narrow
-                    )
-                )
-          );
-}
-
-IR_ValueBoxDef_ptr
-IR_ValueBoxDef::_duplicate (IR_ValueBoxDef_ptr obj)
-{
-  if (!CORBA::is_nil (obj))
-    obj->_add_ref ();
-  return obj;
-}
-
-CORBA::Boolean IR_ValueBoxDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
-{
-  if (
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/ValueBoxDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/TypedefDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/Contained:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/IDLType:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
-  return 1; // success using local knowledge
-  else
-    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
-}
-
-void *IR_ValueBoxDef::_tao_QueryInterface (ptr_arith_t type)
-{
-  void *retv = 0;
-  if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_ValueBoxDef::_narrow))
-    retv = ACE_reinterpret_cast (void*, this);
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_TypedefDef::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            IR_TypedefDef_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_Contained::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            IR_Contained_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_IDLType::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            IR_IDLType_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &CORBA_IRObject::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            CORBA_IRObject_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
-    retv = ACE_reinterpret_cast (void *,
-      ACE_static_cast (CORBA::Object_ptr, this));
-    
-  if (retv)
-    this->_add_ref ();
-  return retv;
-}
-
-const char* IR_ValueBoxDef::_interface_repository_id (void) const
-{
-  return "IDL:omg.org/IR/ValueBoxDef:1.0";
-}
-
-IR_IDLType_ptr IR_ValueBoxDef::original_type_def (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_ValueBoxDef_Proxy_Impl &proxy = 
-    this->the_TAO_ValueBoxDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.original_type_def (
-      this,
-      ACE_TRY_ENV
-    );
-}
-
-void IR_ValueBoxDef::original_type_def (
-    IR_IDLType_ptr original_type_def,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_ValueBoxDef_Proxy_Impl &proxy = 
-    this->the_TAO_ValueBoxDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK;
-  
-  proxy.original_type_def (
-      this,
-      original_type_def,
-      ACE_TRY_ENV
-    );
-}
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-IR_ValueBoxDef::TAO_ClientRequestInfo_IR_ValueBoxDef_original_type_def_get::TAO_ClientRequestInfo_IR_ValueBoxDef_original_type_def_get (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
-{}
-
-Dynamic::ParameterList *
-IR_ValueBoxDef::TAO_ClientRequestInfo_IR_ValueBoxDef_original_type_def_get::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return parameter_list;
-}
-
-Dynamic::ExceptionList *
-IR_ValueBoxDef::TAO_ClientRequestInfo_IR_ValueBoxDef_original_type_def_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_ValueBoxDef::TAO_ClientRequestInfo_IR_ValueBoxDef_original_type_def_get::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_ValueBoxDef::TAO_ClientRequestInfo_IR_ValueBoxDef_original_type_def_get::result (IR_IDLType_ptr result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_ValueBoxDef::TAO_ClientRequestInfo_IR_ValueBoxDef_original_type_def_set::TAO_ClientRequestInfo_IR_ValueBoxDef_original_type_def_set (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    IR_IDLType_ptr original_type_def,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
-    original_type_def_ (original_type_def)
-{}
-
-Dynamic::ParameterList *
-IR_ValueBoxDef::TAO_ClientRequestInfo_IR_ValueBoxDef_original_type_def_set::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
-    
-  CORBA::ULong length_original_type_def = parameter_list->length ();
-  parameter_list->length (length_original_type_def + 1);
-  (*parameter_list)[length_original_type_def].argument <<=  this->original_type_def_;
-  
-  (*parameter_list)[length_original_type_def].mode = Dynamic::PARAM_IN;
-  
-  return safe_parameter_list._retn ();
-}
-
-Dynamic::ExceptionList *
-IR_ValueBoxDef::TAO_ClientRequestInfo_IR_ValueBoxDef_original_type_def_set::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_ValueBoxDef::TAO_ClientRequestInfo_IR_ValueBoxDef_original_type_def_set::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 1;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return result_any;
-}
-
-#endif /* TAO_HAS_INTERCEPTORS */
-
-static const CORBA::Long _oc_IR_ValueBoxDef[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x616c7565), ACE_NTOHL (0x426f7844), ACE_NTOHL (0x65663a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/ValueBoxDef:1.0
-  12, ACE_NTOHL (0x56616c75), ACE_NTOHL (0x65426f78), ACE_NTOHL (0x44656600),  // name = IR_ValueBoxDef
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_ValueBoxDef (CORBA::tk_objref, sizeof (_oc_IR_ValueBoxDef), (char *) &_oc_IR_ValueBoxDef, 0, sizeof (IR_ValueBoxDef));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ValueBoxDef, &_tc_TAO_tc_IR_ValueBoxDef)
-TAO_NAMESPACE_END
-
-///////////////////////////////////////////////////////////////////////
-//                Base & Remote Proxy  Implementation. 
-//
-
-_TAO_ProvidesDef_Proxy_Impl::_TAO_ProvidesDef_Proxy_Impl (void)
-{}
-
-_TAO_ProvidesDef_Remote_Proxy_Impl::_TAO_ProvidesDef_Remote_Proxy_Impl (void)
-{}
-
-// Remote Implementation of the IDL interface methods
-
-IR_InterfaceDef_ptr _TAO_ProvidesDef_Remote_Proxy_Impl::interface_type (
-    CORBA_Object *_collocated_tao_target_,
-     CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  
-  IR_InterfaceDef_ptr _tao_retval = IR_InterfaceDef::_nil ();
-  IR_InterfaceDef_var _tao_safe_retval (_tao_retval);
-  
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-
-  
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_get_interface_type",
-      19,
-      0,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_ProvidesDef::TAO_ClientRequestInfo_IR_ProvidesDef_interface_type_get ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              IR_InterfaceDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-
-//
-//            End  Base & Remote  Proxy Implemeentation. 
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//           Remote & Base  Proxy Broker Implementation
-//
-
-_TAO_ProvidesDef_Proxy_Broker::_TAO_ProvidesDef_Proxy_Broker (void)
-{
-}
-
-_TAO_ProvidesDef_Proxy_Broker::~_TAO_ProvidesDef_Proxy_Broker (void)
-{
-}
-
-_TAO_ProvidesDef_Proxy_Broker * (*_TAO_ProvidesDef_Proxy_Broker_Factory_function_pointer) (
-    CORBA::Object_ptr obj
-  ) = 0;
-
-// Factory Member function Implementation.
-_TAO_ProvidesDef_Remote_Proxy_Broker *
-_TAO_ProvidesDef_Remote_Proxy_Broker::the_TAO_ProvidesDef_Remote_Proxy_Broker (void)
-{
-  static ::_TAO_ProvidesDef_Remote_Proxy_Broker remote_proxy_broker;
-  return &remote_proxy_broker;
-}
-
-_TAO_ProvidesDef_Remote_Proxy_Broker::_TAO_ProvidesDef_Remote_Proxy_Broker (void)
-{
-}
-
-_TAO_ProvidesDef_Remote_Proxy_Broker::~_TAO_ProvidesDef_Remote_Proxy_Broker (void)
-{
-}
-
-_TAO_ProvidesDef_Proxy_Impl&
-_TAO_ProvidesDef_Remote_Proxy_Broker::select_proxy (
-  ::IR_ProvidesDef *object,
-  CORBA::Environment &ACE_TRY_ENV
-)
-{
-  ACE_UNUSED_ARG (object);
-  ACE_UNUSED_ARG (ACE_TRY_ENV);
-  return remote_proxy_impl_;
-}
-
-
-//
-//           End Remote & Base Proxy Broker Implementation
-///////////////////////////////////////////////////////////////////////
-
-
-// default constructor
-IR_ProvidesDef::IR_ProvidesDef (int collocated)
-{
-  this->IR_ProvidesDef_setup_collocation (collocated);
-}
-
-// destructor
-IR_ProvidesDef::~IR_ProvidesDef (void)
-{}
-
-void
-IR_ProvidesDef::IR_ProvidesDef_setup_collocation (int collocated)
-{
-  if (collocated)
-    this->the_TAO_ProvidesDef_Proxy_Broker_ =
-      _TAO_ProvidesDef_Proxy_Broker_Factory_function_pointer (this);
-  else
-    this->the_TAO_ProvidesDef_Proxy_Broker_ =
-      _TAO_ProvidesDef_Remote_Proxy_Broker::the_TAO_ProvidesDef_Remote_Proxy_Broker ();
-  
-  this->IR_Contained_setup_collocation (collocated);
-}
-
-void IR_ProvidesDef::_tao_any_destructor (void *x)
-{
-  IR_ProvidesDef *tmp = ACE_static_cast (IR_ProvidesDef*,x);
-  CORBA::release (tmp);
-}
-
-IR_ProvidesDef_ptr IR_ProvidesDef::_narrow (
-    CORBA::Object_ptr obj,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  if (CORBA::is_nil (obj))
-    return IR_ProvidesDef::_nil ();
-  if (! obj->_is_local ())
-    {
-      CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/IR/ProvidesDef:1.0", ACE_TRY_ENV);
-      ACE_CHECK_RETURN (IR_ProvidesDef::_nil ());
-      if (is_a == 0)
-        return IR_ProvidesDef::_nil ();
-    }
-  return IR_ProvidesDef::_unchecked_narrow (obj, ACE_TRY_ENV);
-}
-
-IR_ProvidesDef_ptr IR_ProvidesDef::_unchecked_narrow (
-    CORBA::Object_ptr obj,
-    CORBA::Environment &
-  )
-{
-  if (CORBA::is_nil (obj))
-    return IR_ProvidesDef::_nil ();
-  if (! obj->_is_local ())
-    {
-      TAO_Stub* stub = obj->_stubobj ();
-      if (stub)
-        stub->_incr_refcnt ();
-      IR_ProvidesDef_ptr default_proxy = IR_ProvidesDef::_nil ();
-
-      if (
-          !CORBA::is_nil (stub->servant_orb_var ().ptr ()) &&
-          stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects () &&
-          obj->_is_collocated () &&_TAO_ProvidesDef_Proxy_Broker_Factory_function_pointer != 0
-        )
-      {
-        ACE_NEW_RETURN (
-          default_proxy,
-          ::IR_ProvidesDef (
-            stub,
-            1,
-            obj->_servant ()),
-            
-          IR_ProvidesDef::_nil ());
-        }
-      if (CORBA::is_nil (default_proxy))
-        ACE_NEW_RETURN (default_proxy, ::IR_ProvidesDef (stub, 0, obj->_servant ()), IR_ProvidesDef::_nil ());
-        return default_proxy;
-      }
-    else 
-      return
-        ACE_reinterpret_cast
-          (
-            IR_ProvidesDef_ptr,
-              obj->_tao_QueryInterface
-                (
-                  ACE_reinterpret_cast
-                    (
-                      ptr_arith_t,
-                      &IR_ProvidesDef::_narrow
-                    )
-                )
-          );
-}
-
-IR_ProvidesDef_ptr
-IR_ProvidesDef::_duplicate (IR_ProvidesDef_ptr obj)
-{
-  if (!CORBA::is_nil (obj))
-    obj->_add_ref ();
-  return obj;
-}
-
-CORBA::Boolean IR_ProvidesDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
-{
-  if (
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/ProvidesDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/Contained:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
-  return 1; // success using local knowledge
-  else
-    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
-}
-
-void *IR_ProvidesDef::_tao_QueryInterface (ptr_arith_t type)
-{
-  void *retv = 0;
-  if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_ProvidesDef::_narrow))
-    retv = ACE_reinterpret_cast (void*, this);
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_Contained::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            IR_Contained_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &CORBA_IRObject::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            CORBA_IRObject_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
-    retv = ACE_reinterpret_cast (void *,
-      ACE_static_cast (CORBA::Object_ptr, this));
-    
-  if (retv)
-    this->_add_ref ();
-  return retv;
-}
-
-const char* IR_ProvidesDef::_interface_repository_id (void) const
-{
-  return "IDL:omg.org/IR/ProvidesDef:1.0";
-}
-
-IR_InterfaceDef_ptr IR_ProvidesDef::interface_type (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_ProvidesDef_Proxy_Impl &proxy = 
-    this->the_TAO_ProvidesDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.interface_type (
-      this,
-      ACE_TRY_ENV
-    );
-}
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-IR_ProvidesDef::TAO_ClientRequestInfo_IR_ProvidesDef_interface_type_get::TAO_ClientRequestInfo_IR_ProvidesDef_interface_type_get (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
-{}
-
-Dynamic::ParameterList *
-IR_ProvidesDef::TAO_ClientRequestInfo_IR_ProvidesDef_interface_type_get::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return parameter_list;
-}
-
-Dynamic::ExceptionList *
-IR_ProvidesDef::TAO_ClientRequestInfo_IR_ProvidesDef_interface_type_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_ProvidesDef::TAO_ClientRequestInfo_IR_ProvidesDef_interface_type_get::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_ProvidesDef::TAO_ClientRequestInfo_IR_ProvidesDef_interface_type_get::result (IR_InterfaceDef_ptr result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-#endif /* TAO_HAS_INTERCEPTORS */
-
-static const CORBA::Long _oc_IR_ProvidesDef[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f50), ACE_NTOHL (0x726f7669), ACE_NTOHL (0x64657344), ACE_NTOHL (0x65663a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/ProvidesDef:1.0
-  12, ACE_NTOHL (0x50726f76), ACE_NTOHL (0x69646573), ACE_NTOHL (0x44656600),  // name = IR_ProvidesDef
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_ProvidesDef (CORBA::tk_objref, sizeof (_oc_IR_ProvidesDef), (char *) &_oc_IR_ProvidesDef, 0, sizeof (IR_ProvidesDef));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ProvidesDef, &_tc_TAO_tc_IR_ProvidesDef)
-TAO_NAMESPACE_END
-
-static const CORBA::Long _oc_IR_ProvidesDescription[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  39, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f50), ACE_NTOHL (0x726f7669), ACE_NTOHL (0x64657344), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e3a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/ProvidesDescription:1.0
-  20, ACE_NTOHL (0x50726f76), ACE_NTOHL (0x69646573), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e00),  // name = ProvidesDescription
-  5, // member count
-  5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
-  CORBA::tk_alias, // typecode kind for typedefs
-  64, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
-    11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-    CORBA::tk_string, 
-    0U, // string length
-
-  3, ACE_NTOHL (0x69640000),  // name = id
-  CORBA::tk_alias, // typecode kind for typedefs
-  68, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-    13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-    CORBA::tk_string, 
-    0U, // string length
-
-  11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
-  CORBA::tk_alias, // typecode kind for typedefs
-  68, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-    13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-    CORBA::tk_string, 
-    0U, // string length
-
-  8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
-  CORBA::tk_alias, // typecode kind for typedefs
-  64, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
-    12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
-    CORBA::tk_string, 
-    0U, // string length
-
-  15, ACE_NTOHL (0x696e7465), ACE_NTOHL (0x72666163), ACE_NTOHL (0x655f7479), ACE_NTOHL (0x70650000),  // name = interface_type
-  CORBA::tk_objref, // typecode kind
-  60, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x6e746572), ACE_NTOHL (0x66616365), ACE_NTOHL (0x4465663a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/InterfaceDef:1.0
-    13, ACE_NTOHL (0x496e7465), ACE_NTOHL (0x72666163), ACE_NTOHL (0x65446566), ACE_NTOHL (0x0),  // name = IR_InterfaceDef
-
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_ProvidesDescription (CORBA::tk_struct, sizeof (_oc_IR_ProvidesDescription), (char *) &_oc_IR_ProvidesDescription, 0, sizeof (IR_ProvidesDescription));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ProvidesDescription, &_tc_TAO_tc_IR_ProvidesDescription)
-TAO_NAMESPACE_END
-
-void IR_ProvidesDescription::_tao_any_destructor (void *x)
-{
-  IR_ProvidesDescription *tmp = ACE_static_cast (IR_ProvidesDescription*,x);
-  delete tmp;
-}
-
-
-///////////////////////////////////////////////////////////////////////
-//                Base & Remote Proxy  Implementation. 
-//
-
-_TAO_UsesDef_Proxy_Impl::_TAO_UsesDef_Proxy_Impl (void)
-{}
-
-_TAO_UsesDef_Remote_Proxy_Impl::_TAO_UsesDef_Remote_Proxy_Impl (void)
-{}
-
-// Remote Implementation of the IDL interface methods
-
-IR_InterfaceDef_ptr _TAO_UsesDef_Remote_Proxy_Impl::interface_type (
-    CORBA_Object *_collocated_tao_target_,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  
-  IR_InterfaceDef_ptr _tao_retval = IR_InterfaceDef::_nil ();
-  IR_InterfaceDef_var _tao_safe_retval (_tao_retval);
-  
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-
-  
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_get_interface_type",
-      19,
-      0,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_UsesDef::TAO_ClientRequestInfo_IR_UsesDef_interface_type_get ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              IR_InterfaceDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-CORBA::Boolean _TAO_UsesDef_Remote_Proxy_Impl::is_multiple (
-    CORBA_Object *_collocated_tao_target_,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  
-  CORBA::Boolean _tao_retval = 0;
-  
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), _tao_retval);
-
-  
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_get_is_multiple",
-      16,
-      0,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_UsesDef::TAO_ClientRequestInfo_IR_UsesDef_is_multiple_get ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN  (_tao_retval);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                _tao_retval
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> CORBA::Any::to_boolean (_tao_retval))
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                _tao_retval
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              CORBA::Boolean  _tao_retval_info = _tao_retval;
-               ri.result (_tao_retval_info);
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN  (_tao_retval);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_retval;
-}
-
-
-//
-//            End  Base & Remote  Proxy Implemeentation. 
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//           Remote & Base  Proxy Broker Implementation
-//
-
-_TAO_UsesDef_Proxy_Broker::_TAO_UsesDef_Proxy_Broker (void)
-{
-}
-
-_TAO_UsesDef_Proxy_Broker::~_TAO_UsesDef_Proxy_Broker (void)
-{
-}
-
-
-_TAO_UsesDef_Proxy_Broker * (*_TAO_UsesDef_Proxy_Broker_Factory_function_pointer) (
-    CORBA::Object_ptr obj
-  ) = 0;
-
-// Factory Member function Implementation.
-_TAO_UsesDef_Remote_Proxy_Broker *
-_TAO_UsesDef_Remote_Proxy_Broker::the_TAO_UsesDef_Remote_Proxy_Broker (void)
-{
-  static ::_TAO_UsesDef_Remote_Proxy_Broker remote_proxy_broker;
-  return &remote_proxy_broker;
-}
-
-_TAO_UsesDef_Remote_Proxy_Broker::_TAO_UsesDef_Remote_Proxy_Broker (void)
-{
-}
-
-_TAO_UsesDef_Remote_Proxy_Broker::~_TAO_UsesDef_Remote_Proxy_Broker (void)
-{
-}
-
-_TAO_UsesDef_Proxy_Impl&
-_TAO_UsesDef_Remote_Proxy_Broker::select_proxy (
-  ::IR_UsesDef *object,
-  CORBA::Environment &ACE_TRY_ENV
-)
-{
-  ACE_UNUSED_ARG (object);
-  ACE_UNUSED_ARG (ACE_TRY_ENV);
-  return remote_proxy_impl_;
-}
-
-
-//
-//           End Remote & Base Proxy Broker Implementation
-///////////////////////////////////////////////////////////////////////
-
-
-// default constructor
-IR_UsesDef::IR_UsesDef (int collocated)
-{
-  this->IR_UsesDef_setup_collocation (collocated);
-}
-
-// destructor
-IR_UsesDef::~IR_UsesDef (void)
-{}
-
-void
-IR_UsesDef::IR_UsesDef_setup_collocation (int collocated)
-{
-  if (collocated)
-    this->the_TAO_UsesDef_Proxy_Broker_ =
-      _TAO_UsesDef_Proxy_Broker_Factory_function_pointer (this);
-  else
-    this->the_TAO_UsesDef_Proxy_Broker_ =
-      _TAO_UsesDef_Remote_Proxy_Broker::the_TAO_UsesDef_Remote_Proxy_Broker ();
-  
-  this->IR_Contained_setup_collocation (collocated);
-}
-
-void IR_UsesDef::_tao_any_destructor (void *x)
-{
-  IR_UsesDef *tmp = ACE_static_cast (IR_UsesDef*,x);
-  CORBA::release (tmp);
-}
-
-IR_UsesDef_ptr IR_UsesDef::_narrow (
-    CORBA::Object_ptr obj,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  if (CORBA::is_nil (obj))
-    return IR_UsesDef::_nil ();
-  if (! obj->_is_local ())
-    {
-      CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/IR/UsesDef:1.0", ACE_TRY_ENV);
-      ACE_CHECK_RETURN (IR_UsesDef::_nil ());
-      if (is_a == 0)
-        return IR_UsesDef::_nil ();
-    }
-  return IR_UsesDef::_unchecked_narrow (obj, ACE_TRY_ENV);
-}
-
-IR_UsesDef_ptr IR_UsesDef::_unchecked_narrow (
-    CORBA::Object_ptr obj,
-    CORBA::Environment &
-  )
-{
-  if (CORBA::is_nil (obj))
-    return IR_UsesDef::_nil ();
-  if (! obj->_is_local ())
-    {
-      TAO_Stub* stub = obj->_stubobj ();
-      if (stub)
-        stub->_incr_refcnt ();
-      IR_UsesDef_ptr default_proxy = IR_UsesDef::_nil ();
-
-      if (
-          !CORBA::is_nil (stub->servant_orb_var ().ptr ()) &&
-          stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects () &&
-          obj->_is_collocated () &&_TAO_UsesDef_Proxy_Broker_Factory_function_pointer != 0
-        )
-      {
-        ACE_NEW_RETURN (
-          default_proxy,
-          ::IR_UsesDef (
-            stub,
-            1,
-            obj->_servant ()),
-            
-          IR_UsesDef::_nil ());
-        }
-      if (CORBA::is_nil (default_proxy))
-        ACE_NEW_RETURN (default_proxy, ::IR_UsesDef (stub, 0, obj->_servant ()), IR_UsesDef::_nil ());
-        return default_proxy;
-      }
-    else 
-      return
-        ACE_reinterpret_cast
-          (
-            IR_UsesDef_ptr,
-              obj->_tao_QueryInterface
-                (
-                  ACE_reinterpret_cast
-                    (
-                      ptr_arith_t,
-                      &IR_UsesDef::_narrow
-                    )
-                )
-          );
-}
-
-IR_UsesDef_ptr
-IR_UsesDef::_duplicate (IR_UsesDef_ptr obj)
-{
-  if (!CORBA::is_nil (obj))
-    obj->_add_ref ();
-  return obj;
-}
-
-CORBA::Boolean IR_UsesDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
-{
-  if (
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/UsesDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/Contained:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
-  return 1; // success using local knowledge
-  else
-    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
-}
-
-void *IR_UsesDef::_tao_QueryInterface (ptr_arith_t type)
-{
-  void *retv = 0;
-  if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_UsesDef::_narrow))
-    retv = ACE_reinterpret_cast (void*, this);
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_Contained::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            IR_Contained_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &CORBA_IRObject::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            CORBA_IRObject_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
-    retv = ACE_reinterpret_cast (void *,
-      ACE_static_cast (CORBA::Object_ptr, this));
-    
-  if (retv)
-    this->_add_ref ();
-  return retv;
-}
-
-const char* IR_UsesDef::_interface_repository_id (void) const
-{
-  return "IDL:omg.org/IR/UsesDef:1.0";
-}
-
-IR_InterfaceDef_ptr IR_UsesDef::interface_type (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_UsesDef_Proxy_Impl &proxy = 
-    this->the_TAO_UsesDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.interface_type (
-      this,
-      ACE_TRY_ENV
-    );
-}
-
-CORBA::Boolean IR_UsesDef::is_multiple (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_UsesDef_Proxy_Impl &proxy = 
-    this->the_TAO_UsesDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.is_multiple (
-      this,
-      ACE_TRY_ENV
-    );
-}
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-IR_UsesDef::TAO_ClientRequestInfo_IR_UsesDef_interface_type_get::TAO_ClientRequestInfo_IR_UsesDef_interface_type_get (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
-{}
-
-Dynamic::ParameterList *
-IR_UsesDef::TAO_ClientRequestInfo_IR_UsesDef_interface_type_get::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return parameter_list;
-}
-
-Dynamic::ExceptionList *
-IR_UsesDef::TAO_ClientRequestInfo_IR_UsesDef_interface_type_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_UsesDef::TAO_ClientRequestInfo_IR_UsesDef_interface_type_get::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_UsesDef::TAO_ClientRequestInfo_IR_UsesDef_interface_type_get::result (IR_InterfaceDef_ptr result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_UsesDef::TAO_ClientRequestInfo_IR_UsesDef_is_multiple_get::TAO_ClientRequestInfo_IR_UsesDef_is_multiple_get (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
-{}
-
-Dynamic::ParameterList *
-IR_UsesDef::TAO_ClientRequestInfo_IR_UsesDef_is_multiple_get::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return parameter_list;
-}
-
-Dynamic::ExceptionList *
-IR_UsesDef::TAO_ClientRequestInfo_IR_UsesDef_is_multiple_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_UsesDef::TAO_ClientRequestInfo_IR_UsesDef_is_multiple_get::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= CORBA::Any::from_boolean (this->_result);
-  return safe_result_any._retn ();
-}
-
-void 
-IR_UsesDef::TAO_ClientRequestInfo_IR_UsesDef_is_multiple_get::result (CORBA::Boolean result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-#endif /* TAO_HAS_INTERCEPTORS */
-
-static const CORBA::Long _oc_IR_UsesDef[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  27, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f55), ACE_NTOHL (0x73657344), ACE_NTOHL (0x65663a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/UsesDef:1.0
-  8, ACE_NTOHL (0x55736573), ACE_NTOHL (0x44656600),  // name = IR_UsesDef
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_UsesDef (CORBA::tk_objref, sizeof (_oc_IR_UsesDef), (char *) &_oc_IR_UsesDef, 0, sizeof (IR_UsesDef));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_UsesDef, &_tc_TAO_tc_IR_UsesDef)
-TAO_NAMESPACE_END
-
-static const CORBA::Long _oc_IR_UsesDescription[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f55), ACE_NTOHL (0x73657344), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e3a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/UsesDescription:1.0
-  16, ACE_NTOHL (0x55736573), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e00),  // name = UsesDescription
-  6, // member count
-  5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
-  CORBA::tk_alias, // typecode kind for typedefs
-  64, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
-    11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-    CORBA::tk_string, 
-    0U, // string length
-
-  3, ACE_NTOHL (0x69640000),  // name = id
-  CORBA::tk_alias, // typecode kind for typedefs
-  68, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-    13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-    CORBA::tk_string, 
-    0U, // string length
-
-  11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
-  CORBA::tk_alias, // typecode kind for typedefs
-  68, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-    13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-    CORBA::tk_string, 
-    0U, // string length
-
-  8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
-  CORBA::tk_alias, // typecode kind for typedefs
-  64, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
-    12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
-    CORBA::tk_string, 
-    0U, // string length
-
-  15, ACE_NTOHL (0x696e7465), ACE_NTOHL (0x72666163), ACE_NTOHL (0x655f7479), ACE_NTOHL (0x70650000),  // name = interface_type
-  CORBA::tk_objref, // typecode kind
-  60, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x6e746572), ACE_NTOHL (0x66616365), ACE_NTOHL (0x4465663a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/InterfaceDef:1.0
-    13, ACE_NTOHL (0x496e7465), ACE_NTOHL (0x72666163), ACE_NTOHL (0x65446566), ACE_NTOHL (0x0),  // name = IR_InterfaceDef
-
-  12, ACE_NTOHL (0x69735f6d), ACE_NTOHL (0x756c7469), ACE_NTOHL (0x706c6500),  // name = is_multiple
-  CORBA::tk_boolean,
-
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_UsesDescription (CORBA::tk_struct, sizeof (_oc_IR_UsesDescription), (char *) &_oc_IR_UsesDescription, 0, sizeof (IR_UsesDescription));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_UsesDescription, &_tc_TAO_tc_IR_UsesDescription)
-TAO_NAMESPACE_END
-
-void IR_UsesDescription::_tao_any_destructor (void *x)
-{
-  IR_UsesDescription *tmp = ACE_static_cast (IR_UsesDescription*,x);
-  delete tmp;
-}
-
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  
-  void
-  _TAO_Unbounded_Sequence_IR_ProvidesDescSeq::_allocate_buffer (CORBA::ULong length)
-  {
-    IR_ProvidesDescription* tmp = 0;
-    tmp = _TAO_Unbounded_Sequence_IR_ProvidesDescSeq::allocbuf (length);
-    
-    if (this->buffer_ != 0)
-    {
-      IR_ProvidesDescription *old = ACE_reinterpret_cast (IR_ProvidesDescription *,this->buffer_);
-      
-      for (CORBA::ULong i = 0; i < this->length_; ++i)
-        tmp[i] = old[i];
-      
-      if (this->release_)
-        _TAO_Unbounded_Sequence_IR_ProvidesDescSeq::freebuf (old);
-      
-    }
-    this->buffer_ = tmp;
-  }
-  
-  void
-  _TAO_Unbounded_Sequence_IR_ProvidesDescSeq::_deallocate_buffer (void)
-  {
-    if (this->buffer_ == 0 || this->release_ == 0)
-      return;
-    
-    IR_ProvidesDescription *tmp = ACE_reinterpret_cast (IR_ProvidesDescription *,this->buffer_);
-    
-    _TAO_Unbounded_Sequence_IR_ProvidesDescSeq::freebuf (tmp);
-    this->buffer_ = 0;
-  } 
-  
-  _TAO_Unbounded_Sequence_IR_ProvidesDescSeq::~_TAO_Unbounded_Sequence_IR_ProvidesDescSeq (void) // Dtor.
-  {
-    this->_deallocate_buffer ();
-  }
-  
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
-
-// *************************************************************
-// IR_ProvidesDescSeq
-// *************************************************************
-
-IR_ProvidesDescSeq::IR_ProvidesDescSeq (void)
-{}
-IR_ProvidesDescSeq::IR_ProvidesDescSeq (CORBA::ULong max) // uses max size
-  : 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Sequence_IR_ProvidesDescSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Sequence<IR_ProvidesDescription>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
- (max)
-{}
-IR_ProvidesDescSeq::IR_ProvidesDescSeq (CORBA::ULong max, CORBA::ULong length, IR_ProvidesDescription *buffer, CORBA::Boolean release)
-  : 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Sequence_IR_ProvidesDescSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Sequence<IR_ProvidesDescription>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
- (max, length, buffer, release)
-{}
-IR_ProvidesDescSeq::IR_ProvidesDescSeq (const IR_ProvidesDescSeq &seq) // copy ctor
-  : 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Sequence_IR_ProvidesDescSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Sequence<IR_ProvidesDescription>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
- (seq)
-{}
-IR_ProvidesDescSeq::~IR_ProvidesDescSeq (void) // dtor
-{}
-void IR_ProvidesDescSeq::_tao_any_destructor (void *x)
-{
-  IR_ProvidesDescSeq *tmp = ACE_static_cast (IR_ProvidesDescSeq*,x);
-  delete tmp;
-}
-
-static const CORBA::Long _oc_IR_ProvidesDescSeq[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f50), ACE_NTOHL (0x726f7669), ACE_NTOHL (0x64657344), ACE_NTOHL (0x65736353), ACE_NTOHL (0x65713a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/ProvidesDescSeq:1.0
-  16, ACE_NTOHL (0x50726f76), ACE_NTOHL (0x69646573), ACE_NTOHL (0x44657363), ACE_NTOHL (0x53657100),  // name = ProvidesDescSeq
-  CORBA::tk_sequence, // typecode kind
-  524, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    CORBA::tk_struct, // typecode kind
-    508, // encapsulation length
-      TAO_ENCAP_BYTE_ORDER, // byte order
-      39, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f50), ACE_NTOHL (0x726f7669), ACE_NTOHL (0x64657344), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e3a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/ProvidesDescription:1.0
-      20, ACE_NTOHL (0x50726f76), ACE_NTOHL (0x69646573), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e00),  // name = ProvidesDescription
-      5, // member count
-      5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
-      CORBA::tk_alias, // typecode kind for typedefs
-      64, // encapsulation length
-        TAO_ENCAP_BYTE_ORDER, // byte order
-        30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
-        11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-        CORBA::tk_string, 
-        0U, // string length
-
-      3, ACE_NTOHL (0x69640000),  // name = id
-      CORBA::tk_alias, // typecode kind for typedefs
-      68, // encapsulation length
-        TAO_ENCAP_BYTE_ORDER, // byte order
-        32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-        13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-        CORBA::tk_string, 
-        0U, // string length
-
-      11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
-      CORBA::tk_alias, // typecode kind for typedefs
-      68, // encapsulation length
-        TAO_ENCAP_BYTE_ORDER, // byte order
-        32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-        13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-        CORBA::tk_string, 
-        0U, // string length
-
-      8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
-      CORBA::tk_alias, // typecode kind for typedefs
-      64, // encapsulation length
-        TAO_ENCAP_BYTE_ORDER, // byte order
-        31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
-        12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
-        CORBA::tk_string, 
-        0U, // string length
-
-      15, ACE_NTOHL (0x696e7465), ACE_NTOHL (0x72666163), ACE_NTOHL (0x655f7479), ACE_NTOHL (0x70650000),  // name = interface_type
-      CORBA::tk_objref, // typecode kind
-      60, // encapsulation length
-        TAO_ENCAP_BYTE_ORDER, // byte order
-        32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x6e746572), ACE_NTOHL (0x66616365), ACE_NTOHL (0x4465663a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/InterfaceDef:1.0
-        13, ACE_NTOHL (0x496e7465), ACE_NTOHL (0x72666163), ACE_NTOHL (0x65446566), ACE_NTOHL (0x0),  // name = IR_InterfaceDef
-
-
-    0U,
-
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_ProvidesDescSeq (CORBA::tk_alias, sizeof (_oc_IR_ProvidesDescSeq), (char *) &_oc_IR_ProvidesDescSeq, 0, sizeof (IR_ProvidesDescSeq));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ProvidesDescSeq, &_tc_TAO_tc_IR_ProvidesDescSeq)
-TAO_NAMESPACE_END
-
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  
-  void
-  _TAO_Unbounded_Sequence_IR_UsesDescSeq::_allocate_buffer (CORBA::ULong length)
-  {
-    IR_UsesDescription* tmp = 0;
-    tmp = _TAO_Unbounded_Sequence_IR_UsesDescSeq::allocbuf (length);
-    
-    if (this->buffer_ != 0)
-    {
-      IR_UsesDescription *old = ACE_reinterpret_cast (IR_UsesDescription *,this->buffer_);
-      
-      for (CORBA::ULong i = 0; i < this->length_; ++i)
-        tmp[i] = old[i];
-      
-      if (this->release_)
-        _TAO_Unbounded_Sequence_IR_UsesDescSeq::freebuf (old);
-      
-    }
-    this->buffer_ = tmp;
-  }
-  
-  void
-  _TAO_Unbounded_Sequence_IR_UsesDescSeq::_deallocate_buffer (void)
-  {
-    if (this->buffer_ == 0 || this->release_ == 0)
-      return;
-    
-    IR_UsesDescription *tmp = ACE_reinterpret_cast (IR_UsesDescription *,this->buffer_);
-    
-    _TAO_Unbounded_Sequence_IR_UsesDescSeq::freebuf (tmp);
-    this->buffer_ = 0;
-  } 
-  
-  _TAO_Unbounded_Sequence_IR_UsesDescSeq::~_TAO_Unbounded_Sequence_IR_UsesDescSeq (void) // Dtor.
-  {
-    this->_deallocate_buffer ();
-  }
-  
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
-
-// *************************************************************
-// IR_UsesDescSeq
-// *************************************************************
-
-IR_UsesDescSeq::IR_UsesDescSeq (void)
-{}
-IR_UsesDescSeq::IR_UsesDescSeq (CORBA::ULong max) // uses max size
-  : 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Sequence_IR_UsesDescSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Sequence<IR_UsesDescription>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
- (max)
-{}
-IR_UsesDescSeq::IR_UsesDescSeq (CORBA::ULong max, CORBA::ULong length, IR_UsesDescription *buffer, CORBA::Boolean release)
-  : 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Sequence_IR_UsesDescSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Sequence<IR_UsesDescription>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
- (max, length, buffer, release)
-{}
-IR_UsesDescSeq::IR_UsesDescSeq (const IR_UsesDescSeq &seq) // copy ctor
-  : 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Sequence_IR_UsesDescSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Sequence<IR_UsesDescription>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
- (seq)
-{}
-IR_UsesDescSeq::~IR_UsesDescSeq (void) // dtor
-{}
-void IR_UsesDescSeq::_tao_any_destructor (void *x)
-{
-  IR_UsesDescSeq *tmp = ACE_static_cast (IR_UsesDescSeq*,x);
-  delete tmp;
-}
-
-static const CORBA::Long _oc_IR_UsesDescSeq[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f55), ACE_NTOHL (0x73657344), ACE_NTOHL (0x65736353), ACE_NTOHL (0x65713a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/UsesDescSeq:1.0
-  12, ACE_NTOHL (0x55736573), ACE_NTOHL (0x44657363), ACE_NTOHL (0x53657100),  // name = UsesDescSeq
-  CORBA::tk_sequence, // typecode kind
-  536, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    CORBA::tk_struct, // typecode kind
-    520, // encapsulation length
-      TAO_ENCAP_BYTE_ORDER, // byte order
-      35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f55), ACE_NTOHL (0x73657344), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e3a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/UsesDescription:1.0
-      16, ACE_NTOHL (0x55736573), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e00),  // name = UsesDescription
-      6, // member count
-      5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
-      CORBA::tk_alias, // typecode kind for typedefs
-      64, // encapsulation length
-        TAO_ENCAP_BYTE_ORDER, // byte order
-        30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
-        11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-        CORBA::tk_string, 
-        0U, // string length
-
-      3, ACE_NTOHL (0x69640000),  // name = id
-      CORBA::tk_alias, // typecode kind for typedefs
-      68, // encapsulation length
-        TAO_ENCAP_BYTE_ORDER, // byte order
-        32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-        13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-        CORBA::tk_string, 
-        0U, // string length
-
-      11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
-      CORBA::tk_alias, // typecode kind for typedefs
-      68, // encapsulation length
-        TAO_ENCAP_BYTE_ORDER, // byte order
-        32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-        13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-        CORBA::tk_string, 
-        0U, // string length
-
-      8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
-      CORBA::tk_alias, // typecode kind for typedefs
-      64, // encapsulation length
-        TAO_ENCAP_BYTE_ORDER, // byte order
-        31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
-        12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
-        CORBA::tk_string, 
-        0U, // string length
-
-      15, ACE_NTOHL (0x696e7465), ACE_NTOHL (0x72666163), ACE_NTOHL (0x655f7479), ACE_NTOHL (0x70650000),  // name = interface_type
-      CORBA::tk_objref, // typecode kind
-      60, // encapsulation length
-        TAO_ENCAP_BYTE_ORDER, // byte order
-        32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x6e746572), ACE_NTOHL (0x66616365), ACE_NTOHL (0x4465663a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/InterfaceDef:1.0
-        13, ACE_NTOHL (0x496e7465), ACE_NTOHL (0x72666163), ACE_NTOHL (0x65446566), ACE_NTOHL (0x0),  // name = IR_InterfaceDef
-
-      12, ACE_NTOHL (0x69735f6d), ACE_NTOHL (0x756c7469), ACE_NTOHL (0x706c6500),  // name = is_multiple
-      CORBA::tk_boolean,
-
-
-    0U,
-
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_UsesDescSeq (CORBA::tk_alias, sizeof (_oc_IR_UsesDescSeq), (char *) &_oc_IR_UsesDescSeq, 0, sizeof (IR_UsesDescSeq));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_UsesDescSeq, &_tc_TAO_tc_IR_UsesDescSeq)
-TAO_NAMESPACE_END
-
-///////////////////////////////////////////////////////////////////////
-//                Base & Remote Proxy  Implementation. 
-//
-
-_TAO_EventDef_Proxy_Impl::_TAO_EventDef_Proxy_Impl (void)
-{}
-
-_TAO_EventDef_Remote_Proxy_Impl::_TAO_EventDef_Remote_Proxy_Impl (void)
-{}
-
-// Remote Implementation of the IDL interface methods
-
-CORBA::Boolean _TAO_EventDef_Remote_Proxy_Impl::is_a (
-    CORBA_Object *_collocated_tao_target_,
-    const char * event_id,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  
-  CORBA::Boolean _tao_retval = 0;
-  
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), _tao_retval);
-
-  
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "is_a",
-      4,
-      1,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_EventDef::TAO_ClientRequestInfo_IR_EventDef_is_a ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        event_id,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN  (_tao_retval);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-          if (!(
-                            (_tao_out << event_id)
-            ))
-            TAO_INTERCEPTOR_THROW_RETURN (
-              CORBA::MARSHAL (),
-              _tao_retval
-            );
-            
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                _tao_retval
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> CORBA::Any::to_boolean (_tao_retval))
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                _tao_retval
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              CORBA::Boolean  _tao_retval_info = _tao_retval;
-               ri.result (_tao_retval_info);
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN  (_tao_retval);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_retval;
-}
-
-IR_ValueDef_ptr _TAO_EventDef_Remote_Proxy_Impl::event (
-    CORBA_Object *_collocated_tao_target_,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  
-  IR_ValueDef_ptr _tao_retval = IR_ValueDef::_nil ();
-  IR_ValueDef_var _tao_safe_retval (_tao_retval);
-  
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-
-  
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_get_event",
-      10,
-      0,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_EventDef::TAO_ClientRequestInfo_IR_EventDef_event_get ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              IR_ValueDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-
-//
-//            End  Base & Remote  Proxy Implemeentation. 
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//           Remote & Base  Proxy Broker Implementation
-//
-
-_TAO_EventDef_Proxy_Broker::_TAO_EventDef_Proxy_Broker (void)
-{
-}
-
-_TAO_EventDef_Proxy_Broker::~_TAO_EventDef_Proxy_Broker (void)
-{
-}
-
-_TAO_EventDef_Proxy_Broker * (*_TAO_EventDef_Proxy_Broker_Factory_function_pointer) (
-    CORBA::Object_ptr obj
-  ) = 0;
-
-// Factory Member function Implementation.
-_TAO_EventDef_Remote_Proxy_Broker *
-_TAO_EventDef_Remote_Proxy_Broker::the_TAO_EventDef_Remote_Proxy_Broker (void)
-{
-  static ::_TAO_EventDef_Remote_Proxy_Broker remote_proxy_broker;
-  return &remote_proxy_broker;
-}
-
-_TAO_EventDef_Remote_Proxy_Broker::_TAO_EventDef_Remote_Proxy_Broker (void)
-{
-}
-
-_TAO_EventDef_Remote_Proxy_Broker::~_TAO_EventDef_Remote_Proxy_Broker (void)
-{
-}
-
-_TAO_EventDef_Proxy_Impl&
-_TAO_EventDef_Remote_Proxy_Broker::select_proxy (
-  ::IR_EventDef *object,
-  CORBA::Environment &ACE_TRY_ENV
-)
-{
-  ACE_UNUSED_ARG (object);
-  ACE_UNUSED_ARG (ACE_TRY_ENV);
-  return remote_proxy_impl_;
-}
-
-
-//
-//           End Remote & Base Proxy Broker Implementation
-///////////////////////////////////////////////////////////////////////
-
-
-// default constructor
-IR_EventDef::IR_EventDef (int collocated)
-{
-  this->IR_EventDef_setup_collocation (collocated);
-}
-
-// destructor
-IR_EventDef::~IR_EventDef (void)
-{}
-
-void
-IR_EventDef::IR_EventDef_setup_collocation (int collocated)
-{
-  if (collocated)
-    this->the_TAO_EventDef_Proxy_Broker_ =
-      _TAO_EventDef_Proxy_Broker_Factory_function_pointer (this);
-  else
-    this->the_TAO_EventDef_Proxy_Broker_ =
-      _TAO_EventDef_Remote_Proxy_Broker::the_TAO_EventDef_Remote_Proxy_Broker ();
-  
-  this->IR_Contained_setup_collocation (collocated);
-}
-
-void IR_EventDef::_tao_any_destructor (void *x)
-{
-  IR_EventDef *tmp = ACE_static_cast (IR_EventDef*,x);
-  CORBA::release (tmp);
-}
-
-IR_EventDef_ptr IR_EventDef::_narrow (
-    CORBA::Object_ptr obj,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  if (CORBA::is_nil (obj))
-    return IR_EventDef::_nil ();
-  if (! obj->_is_local ())
-    {
-      CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/IR/EventDef:1.0", ACE_TRY_ENV);
-      ACE_CHECK_RETURN (IR_EventDef::_nil ());
-      if (is_a == 0)
-        return IR_EventDef::_nil ();
-    }
-  return IR_EventDef::_unchecked_narrow (obj, ACE_TRY_ENV);
-}
-
-IR_EventDef_ptr IR_EventDef::_unchecked_narrow (
-    CORBA::Object_ptr obj,
-    CORBA::Environment &
-  )
-{
-  if (CORBA::is_nil (obj))
-    return IR_EventDef::_nil ();
-  if (! obj->_is_local ())
-    {
-      TAO_Stub* stub = obj->_stubobj ();
-      if (stub)
-        stub->_incr_refcnt ();
-      IR_EventDef_ptr default_proxy = IR_EventDef::_nil ();
-
-      if (
-          !CORBA::is_nil (stub->servant_orb_var ().ptr ()) &&
-          stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects () &&
-          obj->_is_collocated () &&_TAO_EventDef_Proxy_Broker_Factory_function_pointer != 0
-        )
-      {
-        ACE_NEW_RETURN (
-          default_proxy,
-          ::IR_EventDef (
-            stub,
-            1,
-            obj->_servant ()),
-            
-          IR_EventDef::_nil ());
-        }
-      if (CORBA::is_nil (default_proxy))
-        ACE_NEW_RETURN (default_proxy, ::IR_EventDef (stub, 0, obj->_servant ()), IR_EventDef::_nil ());
-        return default_proxy;
-      }
-    else 
-      return
-        ACE_reinterpret_cast
-          (
-            IR_EventDef_ptr,
-              obj->_tao_QueryInterface
-                (
-                  ACE_reinterpret_cast
-                    (
-                      ptr_arith_t,
-                      &IR_EventDef::_narrow
-                    )
-                )
-          );
-}
-
-IR_EventDef_ptr
-IR_EventDef::_duplicate (IR_EventDef_ptr obj)
-{
-  if (!CORBA::is_nil (obj))
-    obj->_add_ref ();
-  return obj;
-}
-
-CORBA::Boolean IR_EventDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
-{
-  if (
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/EventDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/Contained:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
-  return 1; // success using local knowledge
-  else
-    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
-}
-
-void *IR_EventDef::_tao_QueryInterface (ptr_arith_t type)
-{
-  void *retv = 0;
-  if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_EventDef::_narrow))
-    retv = ACE_reinterpret_cast (void*, this);
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_Contained::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            IR_Contained_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &CORBA_IRObject::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            CORBA_IRObject_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
-    retv = ACE_reinterpret_cast (void *,
-      ACE_static_cast (CORBA::Object_ptr, this));
-    
-  if (retv)
-    this->_add_ref ();
-  return retv;
-}
-
-const char* IR_EventDef::_interface_repository_id (void) const
-{
-  return "IDL:omg.org/IR/EventDef:1.0";
-}
-
-CORBA::Boolean IR_EventDef::is_a (
-    const char * event_id,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_EventDef_Proxy_Impl &proxy = 
-    this->the_TAO_EventDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.is_a (
-      this,
-      event_id,
-      ACE_TRY_ENV
-    );
-}
-
-IR_ValueDef_ptr IR_EventDef::event (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_EventDef_Proxy_Impl &proxy = 
-    this->the_TAO_EventDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.event (
-      this,
-      ACE_TRY_ENV
-    );
-}
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-IR_EventDef::TAO_ClientRequestInfo_IR_EventDef_is_a::TAO_ClientRequestInfo_IR_EventDef_is_a (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    const char * event_id,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
-    event_id_ (event_id)
-{}
-
-Dynamic::ParameterList *
-IR_EventDef::TAO_ClientRequestInfo_IR_EventDef_is_a::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
-    
-  CORBA::ULong length_event_id = parameter_list->length ();
-  parameter_list->length (length_event_id + 1);
-  (*parameter_list)[length_event_id].argument <<= event_id_;
-  (*parameter_list)[length_event_id].mode = Dynamic::PARAM_IN;
-  
-  return safe_parameter_list._retn ();
-}
-
-Dynamic::ExceptionList *
-IR_EventDef::TAO_ClientRequestInfo_IR_EventDef_is_a::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_EventDef::TAO_ClientRequestInfo_IR_EventDef_is_a::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= CORBA::Any::from_boolean (this->_result);
-  return safe_result_any._retn ();
-}
-
-void 
-IR_EventDef::TAO_ClientRequestInfo_IR_EventDef_is_a::result (CORBA::Boolean result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_EventDef::TAO_ClientRequestInfo_IR_EventDef_event_get::TAO_ClientRequestInfo_IR_EventDef_event_get (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
-{}
-
-Dynamic::ParameterList *
-IR_EventDef::TAO_ClientRequestInfo_IR_EventDef_event_get::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return parameter_list;
-}
-
-Dynamic::ExceptionList *
-IR_EventDef::TAO_ClientRequestInfo_IR_EventDef_event_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_EventDef::TAO_ClientRequestInfo_IR_EventDef_event_get::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_EventDef::TAO_ClientRequestInfo_IR_EventDef_event_get::result (IR_ValueDef_ptr result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-#endif /* TAO_HAS_INTERCEPTORS */
-
-static const CORBA::Long _oc_IR_EventDef[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  28, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x76656e74), ACE_NTOHL (0x4465663a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/EventDef:1.0
-  9, ACE_NTOHL (0x4576656e), ACE_NTOHL (0x74446566), ACE_NTOHL (0x0),  // name = IR_EventDef
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_EventDef (CORBA::tk_objref, sizeof (_oc_IR_EventDef), (char *) &_oc_IR_EventDef, 0, sizeof (IR_EventDef));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_EventDef, &_tc_TAO_tc_IR_EventDef)
-TAO_NAMESPACE_END
-
-static const CORBA::Long _oc_IR_EventDescription[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  36, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x76656e74), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/EventDescription:1.0
-  17, ACE_NTOHL (0x4576656e), ACE_NTOHL (0x74446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = EventDescription
-  5, // member count
-  5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
-  CORBA::tk_alias, // typecode kind for typedefs
-  64, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
-    11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-    CORBA::tk_string, 
-    0U, // string length
-
-  3, ACE_NTOHL (0x69640000),  // name = id
-  CORBA::tk_alias, // typecode kind for typedefs
-  68, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-    13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-    CORBA::tk_string, 
-    0U, // string length
-
-  11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
-  CORBA::tk_alias, // typecode kind for typedefs
-  68, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-    13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-    CORBA::tk_string, 
-    0U, // string length
-
-  8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
-  CORBA::tk_alias, // typecode kind for typedefs
-  64, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
-    12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
-    CORBA::tk_string, 
-    0U, // string length
-
-  6, ACE_NTOHL (0x76616c75), ACE_NTOHL (0x65000000),  // name = value
-  CORBA::tk_objref, // typecode kind
-  52, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    28, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x616c7565), ACE_NTOHL (0x4465663a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ValueDef:1.0
-    9, ACE_NTOHL (0x56616c75), ACE_NTOHL (0x65446566), ACE_NTOHL (0x0),  // name = IR_ValueDef
-
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_EventDescription (CORBA::tk_struct, sizeof (_oc_IR_EventDescription), (char *) &_oc_IR_EventDescription, 0, sizeof (IR_EventDescription));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_EventDescription, &_tc_TAO_tc_IR_EventDescription)
-TAO_NAMESPACE_END
-
-void IR_EventDescription::_tao_any_destructor (void *x)
-{
-  IR_EventDescription *tmp = ACE_static_cast (IR_EventDescription*,x);
-  delete tmp;
-}
-
-
-///////////////////////////////////////////////////////////////////////
-//                Base & Remote Proxy  Implementation. 
-//
-
-_TAO_EmitsDef_Proxy_Impl::_TAO_EmitsDef_Proxy_Impl (void)
-{}
-
-_TAO_EmitsDef_Remote_Proxy_Impl::_TAO_EmitsDef_Remote_Proxy_Impl (void)
-{}
-
-// Remote Implementation of the IDL interface methods
-
-
-//
-//            End  Base & Remote  Proxy Implemeentation. 
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//           Remote & Base  Proxy Broker Implementation
-//
-
-_TAO_EmitsDef_Proxy_Broker::_TAO_EmitsDef_Proxy_Broker (void)
-{
-}
-
-_TAO_EmitsDef_Proxy_Broker::~_TAO_EmitsDef_Proxy_Broker (void)
-{
-}
-
-_TAO_EmitsDef_Proxy_Broker * (*_TAO_EmitsDef_Proxy_Broker_Factory_function_pointer) (
-    CORBA::Object_ptr obj
-  ) = 0;
-
-// Factory Member function Implementation.
-_TAO_EmitsDef_Remote_Proxy_Broker *
-_TAO_EmitsDef_Remote_Proxy_Broker::the_TAO_EmitsDef_Remote_Proxy_Broker (void)
-{
-  static ::_TAO_EmitsDef_Remote_Proxy_Broker remote_proxy_broker;
-  return &remote_proxy_broker;
-}
-
-_TAO_EmitsDef_Remote_Proxy_Broker::_TAO_EmitsDef_Remote_Proxy_Broker (void)
-{
-}
-
-_TAO_EmitsDef_Remote_Proxy_Broker::~_TAO_EmitsDef_Remote_Proxy_Broker (void)
-{
-}
-
-_TAO_EmitsDef_Proxy_Impl&
-_TAO_EmitsDef_Remote_Proxy_Broker::select_proxy (
-  ::IR_EmitsDef *object,
-  CORBA::Environment &ACE_TRY_ENV
-)
-{
-  ACE_UNUSED_ARG (object);
-  ACE_UNUSED_ARG (ACE_TRY_ENV);
-  return remote_proxy_impl_;
-}
-
-
-//
-//           End Remote & Base Proxy Broker Implementation
-///////////////////////////////////////////////////////////////////////
-
-
-// default constructor
-IR_EmitsDef::IR_EmitsDef (int collocated)
-{
-  this->IR_EmitsDef_setup_collocation (collocated);
-}
-
-// destructor
-IR_EmitsDef::~IR_EmitsDef (void)
-{}
-
-void
-IR_EmitsDef::IR_EmitsDef_setup_collocation (int collocated)
-{
-  if (collocated)
-    this->the_TAO_EmitsDef_Proxy_Broker_ =
-      _TAO_EmitsDef_Proxy_Broker_Factory_function_pointer (this);
-  else
-    this->the_TAO_EmitsDef_Proxy_Broker_ =
-      _TAO_EmitsDef_Remote_Proxy_Broker::the_TAO_EmitsDef_Remote_Proxy_Broker ();
-  
-  this->IR_EventDef_setup_collocation (collocated);
-}
-
-void IR_EmitsDef::_tao_any_destructor (void *x)
-{
-  IR_EmitsDef *tmp = ACE_static_cast (IR_EmitsDef*,x);
-  CORBA::release (tmp);
-}
-
-IR_EmitsDef_ptr IR_EmitsDef::_narrow (
-    CORBA::Object_ptr obj,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  if (CORBA::is_nil (obj))
-    return IR_EmitsDef::_nil ();
-  if (! obj->_is_local ())
-    {
-      CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/IR/EmitsDef:1.0", ACE_TRY_ENV);
-      ACE_CHECK_RETURN (IR_EmitsDef::_nil ());
-      if (is_a == 0)
-        return IR_EmitsDef::_nil ();
-    }
-  return IR_EmitsDef::_unchecked_narrow (obj, ACE_TRY_ENV);
-}
-
-IR_EmitsDef_ptr IR_EmitsDef::_unchecked_narrow (
-    CORBA::Object_ptr obj,
-    CORBA::Environment &
-  )
-{
-  if (CORBA::is_nil (obj))
-    return IR_EmitsDef::_nil ();
-  if (! obj->_is_local ())
-    {
-      TAO_Stub* stub = obj->_stubobj ();
-      if (stub)
-        stub->_incr_refcnt ();
-      IR_EmitsDef_ptr default_proxy = IR_EmitsDef::_nil ();
-
-      if (
-          !CORBA::is_nil (stub->servant_orb_var ().ptr ()) &&
-          stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects () &&
-          obj->_is_collocated () &&_TAO_EmitsDef_Proxy_Broker_Factory_function_pointer != 0
-        )
-      {
-        ACE_NEW_RETURN (
-          default_proxy,
-          ::IR_EmitsDef (
-            stub,
-            1,
-            obj->_servant ()),
-            
-          IR_EmitsDef::_nil ());
-        }
-      if (CORBA::is_nil (default_proxy))
-        ACE_NEW_RETURN (default_proxy, ::IR_EmitsDef (stub, 0, obj->_servant ()), IR_EmitsDef::_nil ());
-        return default_proxy;
-      }
-    else 
-      return
-        ACE_reinterpret_cast
-          (
-            IR_EmitsDef_ptr,
-              obj->_tao_QueryInterface
-                (
-                  ACE_reinterpret_cast
-                    (
-                      ptr_arith_t,
-                      &IR_EmitsDef::_narrow
-                    )
-                )
-          );
-}
-
-IR_EmitsDef_ptr
-IR_EmitsDef::_duplicate (IR_EmitsDef_ptr obj)
-{
-  if (!CORBA::is_nil (obj))
-    obj->_add_ref ();
-  return obj;
-}
-
-CORBA::Boolean IR_EmitsDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
-{
-  if (
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/EmitsDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/EventDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/Contained:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
-  return 1; // success using local knowledge
-  else
-    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
-}
-
-void *IR_EmitsDef::_tao_QueryInterface (ptr_arith_t type)
-{
-  void *retv = 0;
-  if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_EmitsDef::_narrow))
-    retv = ACE_reinterpret_cast (void*, this);
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_EventDef::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            IR_EventDef_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_Contained::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            IR_Contained_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &CORBA_IRObject::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            CORBA_IRObject_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
-    retv = ACE_reinterpret_cast (void *,
-      ACE_static_cast (CORBA::Object_ptr, this));
-    
-  if (retv)
-    this->_add_ref ();
-  return retv;
-}
-
-const char* IR_EmitsDef::_interface_repository_id (void) const
-{
-  return "IDL:omg.org/IR/EmitsDef:1.0";
-}
-
-static const CORBA::Long _oc_IR_EmitsDef[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  28, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x6d697473), ACE_NTOHL (0x4465663a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/EmitsDef:1.0
-  9, ACE_NTOHL (0x456d6974), ACE_NTOHL (0x73446566), ACE_NTOHL (0x0),  // name = IR_EmitsDef
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_EmitsDef (CORBA::tk_objref, sizeof (_oc_IR_EmitsDef), (char *) &_oc_IR_EmitsDef, 0, sizeof (IR_EmitsDef));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_EmitsDef, &_tc_TAO_tc_IR_EmitsDef)
-TAO_NAMESPACE_END
-
-///////////////////////////////////////////////////////////////////////
-//                Base & Remote Proxy  Implementation. 
-//
-
-_TAO_PublishesDef_Proxy_Impl::_TAO_PublishesDef_Proxy_Impl (void)
-{}
-
-_TAO_PublishesDef_Remote_Proxy_Impl::_TAO_PublishesDef_Remote_Proxy_Impl (void)
-{}
-
-// Remote Implementation of the IDL interface methods
-
-
-//
-//            End  Base & Remote  Proxy Implemeentation. 
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//           Remote & Base  Proxy Broker Implementation
-//
-
-_TAO_PublishesDef_Proxy_Broker::_TAO_PublishesDef_Proxy_Broker (void)
-{
-}
-
-_TAO_PublishesDef_Proxy_Broker::~_TAO_PublishesDef_Proxy_Broker (void)
-{
-}
-
-_TAO_PublishesDef_Proxy_Broker * (*_TAO_PublishesDef_Proxy_Broker_Factory_function_pointer) (
-    CORBA::Object_ptr obj
-  ) = 0;
-
-// Factory Member function Implementation.
-_TAO_PublishesDef_Remote_Proxy_Broker *
-_TAO_PublishesDef_Remote_Proxy_Broker::the_TAO_PublishesDef_Remote_Proxy_Broker (void)
-{
-  static ::_TAO_PublishesDef_Remote_Proxy_Broker remote_proxy_broker;
-  return &remote_proxy_broker;
-}
-
-_TAO_PublishesDef_Remote_Proxy_Broker::_TAO_PublishesDef_Remote_Proxy_Broker (void)
-{
-}
-
-_TAO_PublishesDef_Remote_Proxy_Broker::~_TAO_PublishesDef_Remote_Proxy_Broker (void)
-{
-}
-
-_TAO_PublishesDef_Proxy_Impl&
-_TAO_PublishesDef_Remote_Proxy_Broker::select_proxy (
-  ::IR_PublishesDef *object,
-  CORBA::Environment &ACE_TRY_ENV
-)
-{
-  ACE_UNUSED_ARG (object);
-  ACE_UNUSED_ARG (ACE_TRY_ENV);
-  return remote_proxy_impl_;
-}
-
-
-//
-//           End Remote & Base Proxy Broker Implementation
-///////////////////////////////////////////////////////////////////////
-
-
-// default constructor
-IR_PublishesDef::IR_PublishesDef (int collocated)
-{
-  this->IR_PublishesDef_setup_collocation (collocated);
-}
-
-// destructor
-IR_PublishesDef::~IR_PublishesDef (void)
-{}
-
-void
-IR_PublishesDef::IR_PublishesDef_setup_collocation (int collocated)
-{
-  if (collocated)
-    this->the_TAO_PublishesDef_Proxy_Broker_ =
-      _TAO_PublishesDef_Proxy_Broker_Factory_function_pointer (this);
-  else
-    this->the_TAO_PublishesDef_Proxy_Broker_ =
-      _TAO_PublishesDef_Remote_Proxy_Broker::the_TAO_PublishesDef_Remote_Proxy_Broker ();
-  
-  this->IR_EventDef_setup_collocation (collocated);
-}
-
-void IR_PublishesDef::_tao_any_destructor (void *x)
-{
-  IR_PublishesDef *tmp = ACE_static_cast (IR_PublishesDef*,x);
-  CORBA::release (tmp);
-}
-
-IR_PublishesDef_ptr IR_PublishesDef::_narrow (
-    CORBA::Object_ptr obj,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  if (CORBA::is_nil (obj))
-    return IR_PublishesDef::_nil ();
-  if (! obj->_is_local ())
-    {
-      CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/IR/PublishesDef:1.0", ACE_TRY_ENV);
-      ACE_CHECK_RETURN (IR_PublishesDef::_nil ());
-      if (is_a == 0)
-        return IR_PublishesDef::_nil ();
-    }
-  return IR_PublishesDef::_unchecked_narrow (obj, ACE_TRY_ENV);
-}
-
-IR_PublishesDef_ptr IR_PublishesDef::_unchecked_narrow (
-    CORBA::Object_ptr obj,
-    CORBA::Environment &
-  )
-{
-  if (CORBA::is_nil (obj))
-    return IR_PublishesDef::_nil ();
-  if (! obj->_is_local ())
-    {
-      TAO_Stub* stub = obj->_stubobj ();
-      if (stub)
-        stub->_incr_refcnt ();
-      IR_PublishesDef_ptr default_proxy = IR_PublishesDef::_nil ();
-
-      if (
-          !CORBA::is_nil (stub->servant_orb_var ().ptr ()) &&
-          stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects () &&
-          obj->_is_collocated () &&_TAO_PublishesDef_Proxy_Broker_Factory_function_pointer != 0
-        )
-      {
-        ACE_NEW_RETURN (
-          default_proxy,
-          ::IR_PublishesDef (
-            stub,
-            1,
-            obj->_servant ()),
-            
-          IR_PublishesDef::_nil ());
-        }
-      if (CORBA::is_nil (default_proxy))
-        ACE_NEW_RETURN (default_proxy, ::IR_PublishesDef (stub, 0, obj->_servant ()), IR_PublishesDef::_nil ());
-        return default_proxy;
-      }
-    else 
-      return
-        ACE_reinterpret_cast
-          (
-            IR_PublishesDef_ptr,
-              obj->_tao_QueryInterface
-                (
-                  ACE_reinterpret_cast
-                    (
-                      ptr_arith_t,
-                      &IR_PublishesDef::_narrow
-                    )
-                )
-          );
-}
-
-IR_PublishesDef_ptr
-IR_PublishesDef::_duplicate (IR_PublishesDef_ptr obj)
-{
-  if (!CORBA::is_nil (obj))
-    obj->_add_ref ();
-  return obj;
-}
-
-CORBA::Boolean IR_PublishesDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
-{
-  if (
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/PublishesDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/EventDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/Contained:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
-  return 1; // success using local knowledge
-  else
-    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
-}
-
-void *IR_PublishesDef::_tao_QueryInterface (ptr_arith_t type)
-{
-  void *retv = 0;
-  if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_PublishesDef::_narrow))
-    retv = ACE_reinterpret_cast (void*, this);
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_EventDef::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            IR_EventDef_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_Contained::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            IR_Contained_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &CORBA_IRObject::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            CORBA_IRObject_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
-    retv = ACE_reinterpret_cast (void *,
-      ACE_static_cast (CORBA::Object_ptr, this));
-    
-  if (retv)
-    this->_add_ref ();
-  return retv;
-}
-
-const char* IR_PublishesDef::_interface_repository_id (void) const
-{
-  return "IDL:omg.org/IR/PublishesDef:1.0";
-}
-
-static const CORBA::Long _oc_IR_PublishesDef[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f50), ACE_NTOHL (0x75626c69), ACE_NTOHL (0x73686573), ACE_NTOHL (0x4465663a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/PublishesDef:1.0
-  13, ACE_NTOHL (0x5075626c), ACE_NTOHL (0x69736865), ACE_NTOHL (0x73446566), ACE_NTOHL (0x0),  // name = IR_PublishesDef
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_PublishesDef (CORBA::tk_objref, sizeof (_oc_IR_PublishesDef), (char *) &_oc_IR_PublishesDef, 0, sizeof (IR_PublishesDef));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_PublishesDef, &_tc_TAO_tc_IR_PublishesDef)
-TAO_NAMESPACE_END
-
-///////////////////////////////////////////////////////////////////////
-//                Base & Remote Proxy  Implementation. 
-//
-
-_TAO_ConsumesDef_Proxy_Impl::_TAO_ConsumesDef_Proxy_Impl (void)
-{}
-
-_TAO_ConsumesDef_Remote_Proxy_Impl::_TAO_ConsumesDef_Remote_Proxy_Impl (void)
-{}
-
-// Remote Implementation of the IDL interface methods
-
-
-//
-//            End  Base & Remote  Proxy Implemeentation. 
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//           Remote & Base  Proxy Broker Implementation
-//
-
-_TAO_ConsumesDef_Proxy_Broker::_TAO_ConsumesDef_Proxy_Broker (void)
-{
-}
-
-_TAO_ConsumesDef_Proxy_Broker::~_TAO_ConsumesDef_Proxy_Broker (void)
-{
-}
-
-_TAO_ConsumesDef_Proxy_Broker * (*_TAO_ConsumesDef_Proxy_Broker_Factory_function_pointer) (
-    CORBA::Object_ptr obj
-  ) = 0;
-
-// Factory Member function Implementation.
-_TAO_ConsumesDef_Remote_Proxy_Broker *
-_TAO_ConsumesDef_Remote_Proxy_Broker::the_TAO_ConsumesDef_Remote_Proxy_Broker (void)
-{
-  static ::_TAO_ConsumesDef_Remote_Proxy_Broker remote_proxy_broker;
-  return &remote_proxy_broker;
-}
-
-_TAO_ConsumesDef_Remote_Proxy_Broker::_TAO_ConsumesDef_Remote_Proxy_Broker (void)
-{
-}
-
-_TAO_ConsumesDef_Remote_Proxy_Broker::~_TAO_ConsumesDef_Remote_Proxy_Broker (void)
-{
-}
-
-_TAO_ConsumesDef_Proxy_Impl&
-_TAO_ConsumesDef_Remote_Proxy_Broker::select_proxy (
-  ::IR_ConsumesDef *object,
-  CORBA::Environment &ACE_TRY_ENV
-)
-{
-  ACE_UNUSED_ARG (object);
-  ACE_UNUSED_ARG (ACE_TRY_ENV);
-  return remote_proxy_impl_;
-}
-
-
-//
-//           End Remote & Base Proxy Broker Implementation
-///////////////////////////////////////////////////////////////////////
-
-
-// default constructor
-IR_ConsumesDef::IR_ConsumesDef (int collocated)
-{
-  this->IR_ConsumesDef_setup_collocation (collocated);
-}
-
-// destructor
-IR_ConsumesDef::~IR_ConsumesDef (void)
-{}
-
-void
-IR_ConsumesDef::IR_ConsumesDef_setup_collocation (int collocated)
-{
-  if (collocated)
-    this->the_TAO_ConsumesDef_Proxy_Broker_ =
-      _TAO_ConsumesDef_Proxy_Broker_Factory_function_pointer (this);
-  else
-    this->the_TAO_ConsumesDef_Proxy_Broker_ =
-      _TAO_ConsumesDef_Remote_Proxy_Broker::the_TAO_ConsumesDef_Remote_Proxy_Broker ();
-  
-  this->IR_EventDef_setup_collocation (collocated);
-}
-
-void IR_ConsumesDef::_tao_any_destructor (void *x)
-{
-  IR_ConsumesDef *tmp = ACE_static_cast (IR_ConsumesDef*,x);
-  CORBA::release (tmp);
-}
-
-IR_ConsumesDef_ptr IR_ConsumesDef::_narrow (
-    CORBA::Object_ptr obj,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  if (CORBA::is_nil (obj))
-    return IR_ConsumesDef::_nil ();
-  if (! obj->_is_local ())
-    {
-      CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/IR/ConsumesDef:1.0", ACE_TRY_ENV);
-      ACE_CHECK_RETURN (IR_ConsumesDef::_nil ());
-      if (is_a == 0)
-        return IR_ConsumesDef::_nil ();
-    }
-  return IR_ConsumesDef::_unchecked_narrow (obj, ACE_TRY_ENV);
-}
-
-IR_ConsumesDef_ptr IR_ConsumesDef::_unchecked_narrow (
-    CORBA::Object_ptr obj,
-    CORBA::Environment &
-  )
-{
-  if (CORBA::is_nil (obj))
-    return IR_ConsumesDef::_nil ();
-  if (! obj->_is_local ())
-    {
-      TAO_Stub* stub = obj->_stubobj ();
-      if (stub)
-        stub->_incr_refcnt ();
-      IR_ConsumesDef_ptr default_proxy = IR_ConsumesDef::_nil ();
-
-      if (
-          !CORBA::is_nil (stub->servant_orb_var ().ptr ()) &&
-          stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects () &&
-          obj->_is_collocated () &&_TAO_ConsumesDef_Proxy_Broker_Factory_function_pointer != 0
-        )
-      {
-        ACE_NEW_RETURN (
-          default_proxy,
-          ::IR_ConsumesDef (
-            stub,
-            1,
-            obj->_servant ()),
-            
-          IR_ConsumesDef::_nil ());
-        }
-      if (CORBA::is_nil (default_proxy))
-        ACE_NEW_RETURN (default_proxy, ::IR_ConsumesDef (stub, 0, obj->_servant ()), IR_ConsumesDef::_nil ());
-        return default_proxy;
-      }
-    else 
-      return
-        ACE_reinterpret_cast
-          (
-            IR_ConsumesDef_ptr,
-              obj->_tao_QueryInterface
-                (
-                  ACE_reinterpret_cast
-                    (
-                      ptr_arith_t,
-                      &IR_ConsumesDef::_narrow
-                    )
-                )
-          );
-}
-
-IR_ConsumesDef_ptr
-IR_ConsumesDef::_duplicate (IR_ConsumesDef_ptr obj)
-{
-  if (!CORBA::is_nil (obj))
-    obj->_add_ref ();
-  return obj;
-}
-
-CORBA::Boolean IR_ConsumesDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
-{
-  if (
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/ConsumesDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/EventDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/Contained:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
-  return 1; // success using local knowledge
-  else
-    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
-}
-
-void *IR_ConsumesDef::_tao_QueryInterface (ptr_arith_t type)
-{
-  void *retv = 0;
-  if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_ConsumesDef::_narrow))
-    retv = ACE_reinterpret_cast (void*, this);
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_EventDef::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            IR_EventDef_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_Contained::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            IR_Contained_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &CORBA_IRObject::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            CORBA_IRObject_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
-    retv = ACE_reinterpret_cast (void *,
-      ACE_static_cast (CORBA::Object_ptr, this));
-    
-  if (retv)
-    this->_add_ref ();
-  return retv;
-}
-
-const char* IR_ConsumesDef::_interface_repository_id (void) const
-{
-  return "IDL:omg.org/IR/ConsumesDef:1.0";
-}
-
-static const CORBA::Long _oc_IR_ConsumesDef[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f43), ACE_NTOHL (0x6f6e7375), ACE_NTOHL (0x6d657344), ACE_NTOHL (0x65663a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/ConsumesDef:1.0
-  12, ACE_NTOHL (0x436f6e73), ACE_NTOHL (0x756d6573), ACE_NTOHL (0x44656600),  // name = IR_ConsumesDef
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_ConsumesDef (CORBA::tk_objref, sizeof (_oc_IR_ConsumesDef), (char *) &_oc_IR_ConsumesDef, 0, sizeof (IR_ConsumesDef));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ConsumesDef, &_tc_TAO_tc_IR_ConsumesDef)
-TAO_NAMESPACE_END
-
-///////////////////////////////////////////////////////////////////////
-//                Base & Remote Proxy  Implementation. 
-//
-
-_TAO_ComponentDef_Proxy_Impl::_TAO_ComponentDef_Proxy_Impl (void)
-{}
-
-_TAO_ComponentDef_Remote_Proxy_Impl::_TAO_ComponentDef_Remote_Proxy_Impl (void)
-{}
-
-// Remote Implementation of the IDL interface methods
-
-IR_InterfaceDefSeq * _TAO_ComponentDef_Remote_Proxy_Impl::supported_interfaces (
-    CORBA_Object *_collocated_tao_target_,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  
-  IR_InterfaceDefSeq *_tao_retval = 0;
-  
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-
-  
-  ACE_NEW_RETURN (_tao_retval, IR_InterfaceDefSeq, _tao_retval);
-  IR_InterfaceDefSeq_var _tao_safe_retval (_tao_retval);
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_get_supported_interfaces",
-      25,
-      0,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_supported_interfaces_get ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              IR_InterfaceDefSeq * _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-void _TAO_ComponentDef_Remote_Proxy_Impl::supported_interfaces (
-    CORBA_Object *_collocated_tao_target_,
-    const IR_InterfaceDefSeq & supported_interfaces,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW (CORBA::INTERNAL ());
-
-  
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_set_supported_interfaces",
-      25,
-      1,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_supported_interfaces_set ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        supported_interfaces,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK;
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK;
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK;
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK;
-          
-          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-          if (!(
-                            (_tao_out << supported_interfaces)
-            ))
-            TAO_INTERCEPTOR_THROW (
-              CORBA::MARSHAL ()
-            );
-            
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK;
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)
-              );
-              
-            }
-          
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK;
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK;
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  
-}
-
-IR_ComponentDef_ptr _TAO_ComponentDef_Remote_Proxy_Impl::base_component (
-    CORBA_Object *_collocated_tao_target_,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  
-  IR_ComponentDef_ptr _tao_retval = IR_ComponentDef::_nil ();
-  IR_ComponentDef_var _tao_safe_retval (_tao_retval);
-  
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-
-  
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_get_base_component",
-      19,
-      0,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_base_component_get ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              IR_ComponentDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-IR_ProvidesDefSeq * _TAO_ComponentDef_Remote_Proxy_Impl::provides_interfaces (
-    CORBA_Object *_collocated_tao_target_,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  
-  IR_ProvidesDefSeq *_tao_retval = 0;
-  
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-
-  
-  ACE_NEW_RETURN (_tao_retval, IR_ProvidesDefSeq, _tao_retval);
-  IR_ProvidesDefSeq_var _tao_safe_retval (_tao_retval);
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_get_provides_interfaces",
-      24,
-      0,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_provides_interfaces_get ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              IR_ProvidesDefSeq * _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-IR_UsesDefSeq * _TAO_ComponentDef_Remote_Proxy_Impl::uses_interfaces (
-    CORBA_Object *_collocated_tao_target_,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  
-  IR_UsesDefSeq *_tao_retval = 0;
-  
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-
-  
-  ACE_NEW_RETURN (_tao_retval, IR_UsesDefSeq, _tao_retval);
-  IR_UsesDefSeq_var _tao_safe_retval (_tao_retval);
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_get_uses_interfaces",
-      20,
-      0,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_uses_interfaces_get ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              IR_UsesDefSeq * _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-IR_EmitsDefSeq * _TAO_ComponentDef_Remote_Proxy_Impl::emits_events (
-    CORBA_Object *_collocated_tao_target_,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  
-  IR_EmitsDefSeq *_tao_retval = 0;
-  
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-
-  
-  ACE_NEW_RETURN (_tao_retval, IR_EmitsDefSeq, _tao_retval);
-  IR_EmitsDefSeq_var _tao_safe_retval (_tao_retval);
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_get_emits_events",
-      17,
-      0,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_emits_events_get ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              IR_EmitsDefSeq * _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-IR_PublishesDefSeq * _TAO_ComponentDef_Remote_Proxy_Impl::publishes_events (
-    CORBA_Object *_collocated_tao_target_,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  
-  IR_PublishesDefSeq *_tao_retval = 0;
-  
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-
-  
-  ACE_NEW_RETURN (_tao_retval, IR_PublishesDefSeq, _tao_retval);
-  IR_PublishesDefSeq_var _tao_safe_retval (_tao_retval);
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_get_publishes_events",
-      21,
-      0,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_publishes_events_get ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              IR_PublishesDefSeq * _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-IR_ConsumesDefSeq * _TAO_ComponentDef_Remote_Proxy_Impl::consumes_events (
-    CORBA_Object *_collocated_tao_target_,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  
-  IR_ConsumesDefSeq *_tao_retval = 0;
-  
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-
-  
-  ACE_NEW_RETURN (_tao_retval, IR_ConsumesDefSeq, _tao_retval);
-  IR_ConsumesDefSeq_var _tao_safe_retval (_tao_retval);
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_get_consumes_events",
-      20,
-      0,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_consumes_events_get ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              IR_ConsumesDefSeq * _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-CORBA::Boolean _TAO_ComponentDef_Remote_Proxy_Impl::is_basic (
-    CORBA_Object *_collocated_tao_target_,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  
-  CORBA::Boolean _tao_retval = 0;
-  
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), _tao_retval);
-
-  
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_get_is_basic",
-      13,
-      0,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_is_basic_get ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN  (_tao_retval);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                _tao_retval
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> CORBA::Any::to_boolean (_tao_retval))
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                _tao_retval
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              CORBA::Boolean  _tao_retval_info = _tao_retval;
-               ri.result (_tao_retval_info);
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN  (_tao_retval);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_retval;
-}
-
-IR_ProvidesDef_ptr _TAO_ComponentDef_Remote_Proxy_Impl::create_provides (
-    CORBA_Object *_collocated_tao_target_,
-    const char * id,
-    const char * name,
-    const char * version,
-    IR_InterfaceDef_ptr interface_type,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  
-  IR_ProvidesDef_ptr _tao_retval = IR_ProvidesDef::_nil ();
-  IR_ProvidesDef_var _tao_safe_retval (_tao_retval);
-  
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-
-  
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "create_provides",
-      15,
-      1,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_create_provides ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        id,
-        name,
-        version,
-        interface_type,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-          if (!(
-                            (_tao_out << id) &&
-              (_tao_out << name) &&
-              (_tao_out << version) &&
-              (_tao_out << interface_type)
-            ))
-            TAO_INTERCEPTOR_THROW_RETURN (
-              CORBA::MARSHAL (),
-              0
-            );
-            
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              IR_ProvidesDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-IR_UsesDef_ptr _TAO_ComponentDef_Remote_Proxy_Impl::create_uses (
-    CORBA_Object *_collocated_tao_target_,
-    const char * id,
-    const char * name,
-    const char * version,
-    IR_InterfaceDef_ptr interface_type,
-    CORBA::Boolean is_multiple,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  
-  IR_UsesDef_ptr _tao_retval = IR_UsesDef::_nil ();
-  IR_UsesDef_var _tao_safe_retval (_tao_retval);
-  
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-
-  
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "create_uses",
-      11,
-      1,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_create_uses ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        id,
-        name,
-        version,
-        interface_type,
-        is_multiple,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-          if (!(
-                            (_tao_out << id) &&
-              (_tao_out << name) &&
-              (_tao_out << version) &&
-              (_tao_out << interface_type) &&
-              (_tao_out << CORBA::Any::from_boolean (is_multiple))
-            ))
-            TAO_INTERCEPTOR_THROW_RETURN (
-              CORBA::MARSHAL (),
-              0
-            );
-            
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              IR_UsesDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-IR_EmitsDef_ptr _TAO_ComponentDef_Remote_Proxy_Impl::create_emits (
-    CORBA_Object *_collocated_tao_target_,
-    const char * id,
-    const char * name,
-    const char * version,
-    IR_ValueDef_ptr value,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  
-  IR_EmitsDef_ptr _tao_retval = IR_EmitsDef::_nil ();
-  IR_EmitsDef_var _tao_safe_retval (_tao_retval);
-  
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-
-  
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "create_emits",
-      12,
-      1,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_create_emits ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        id,
-        name,
-        version,
-        value,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-          if (!(
-                            (_tao_out << id) &&
-              (_tao_out << name) &&
-              (_tao_out << version) &&
-              (_tao_out << value)
-            ))
-            TAO_INTERCEPTOR_THROW_RETURN (
-              CORBA::MARSHAL (),
-              0
-            );
-            
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              IR_EmitsDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-IR_PublishesDef_ptr _TAO_ComponentDef_Remote_Proxy_Impl::create_publishes (
-    CORBA_Object *_collocated_tao_target_,
-    const char * id,
-    const char * name,
-    const char * version,
-    IR_ValueDef_ptr value,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  
-  IR_PublishesDef_ptr _tao_retval = IR_PublishesDef::_nil ();
-  IR_PublishesDef_var _tao_safe_retval (_tao_retval);
-  
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-
-  
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "create_publishes",
-      16,
-      1,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_create_publishes ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        id,
-        name,
-        version,
-        value,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-          if (!(
-                            (_tao_out << id) &&
-              (_tao_out << name) &&
-              (_tao_out << version) &&
-              (_tao_out << value)
-            ))
-            TAO_INTERCEPTOR_THROW_RETURN (
-              CORBA::MARSHAL (),
-              0
-            );
-            
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              IR_PublishesDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-IR_ConsumesDef_ptr _TAO_ComponentDef_Remote_Proxy_Impl::create_consumes (
-    CORBA_Object *_collocated_tao_target_,
-    const char * id,
-    const char * name,
-    const char * version,
-    IR_ValueDef_ptr value,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  
-  IR_ConsumesDef_ptr _tao_retval = IR_ConsumesDef::_nil ();
-  IR_ConsumesDef_var _tao_safe_retval (_tao_retval);
-  
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-
-  
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "create_consumes",
-      15,
-      1,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_create_consumes ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        id,
-        name,
-        version,
-        value,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-          if (!(
-                            (_tao_out << id) &&
-              (_tao_out << name) &&
-              (_tao_out << version) &&
-              (_tao_out << value)
-            ))
-            TAO_INTERCEPTOR_THROW_RETURN (
-              CORBA::MARSHAL (),
-              0
-            );
-            
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              IR_ConsumesDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-
-//
-//            End  Base & Remote  Proxy Implemeentation. 
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//           Remote & Base  Proxy Broker Implementation
-//
-
-_TAO_ComponentDef_Proxy_Broker::_TAO_ComponentDef_Proxy_Broker (void)
-{
-}
-
-_TAO_ComponentDef_Proxy_Broker::~_TAO_ComponentDef_Proxy_Broker (void)
-{
-}
-
-_TAO_ComponentDef_Proxy_Broker * (*_TAO_ComponentDef_Proxy_Broker_Factory_function_pointer) (
-    CORBA::Object_ptr obj
-  ) = 0;
-
-// Factory Member function Implementation.
-_TAO_ComponentDef_Remote_Proxy_Broker *
-_TAO_ComponentDef_Remote_Proxy_Broker::the_TAO_ComponentDef_Remote_Proxy_Broker (void)
-{
-  static ::_TAO_ComponentDef_Remote_Proxy_Broker remote_proxy_broker;
-  return &remote_proxy_broker;
-}
-
-_TAO_ComponentDef_Remote_Proxy_Broker::_TAO_ComponentDef_Remote_Proxy_Broker (void)
-{
-}
-
-_TAO_ComponentDef_Remote_Proxy_Broker::~_TAO_ComponentDef_Remote_Proxy_Broker (void)
-{
-}
-
-_TAO_ComponentDef_Proxy_Impl&
-_TAO_ComponentDef_Remote_Proxy_Broker::select_proxy (
-  ::IR_ComponentDef *object,
-  CORBA::Environment &ACE_TRY_ENV
-)
-{
-  ACE_UNUSED_ARG (object);
-  ACE_UNUSED_ARG (ACE_TRY_ENV);
-  return remote_proxy_impl_;
-}
-
-
-//
-//           End Remote & Base Proxy Broker Implementation
-///////////////////////////////////////////////////////////////////////
-
-
-// default constructor
-IR_ComponentDef::IR_ComponentDef (int collocated)
-{
-  this->IR_ComponentDef_setup_collocation (collocated);
-}
-
-// destructor
-IR_ComponentDef::~IR_ComponentDef (void)
-{}
-
-void
-IR_ComponentDef::IR_ComponentDef_setup_collocation (int collocated)
-{
-  if (collocated)
-    this->the_TAO_ComponentDef_Proxy_Broker_ =
-      _TAO_ComponentDef_Proxy_Broker_Factory_function_pointer (this);
-  else
-    this->the_TAO_ComponentDef_Proxy_Broker_ =
-      _TAO_ComponentDef_Remote_Proxy_Broker::the_TAO_ComponentDef_Remote_Proxy_Broker ();
-  
-  this->IR_InterfaceDef_setup_collocation (collocated);
-}
-
-void IR_ComponentDef::_tao_any_destructor (void *x)
-{
-  IR_ComponentDef *tmp = ACE_static_cast (IR_ComponentDef*,x);
-  CORBA::release (tmp);
-}
-
-IR_ComponentDef_ptr IR_ComponentDef::_narrow (
-    CORBA::Object_ptr obj,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  if (CORBA::is_nil (obj))
-    return IR_ComponentDef::_nil ();
-  if (! obj->_is_local ())
-    {
-      CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/IR/ComponentDef:1.0", ACE_TRY_ENV);
-      ACE_CHECK_RETURN (IR_ComponentDef::_nil ());
-      if (is_a == 0)
-        return IR_ComponentDef::_nil ();
-    }
-  return IR_ComponentDef::_unchecked_narrow (obj, ACE_TRY_ENV);
-}
-
-IR_ComponentDef_ptr IR_ComponentDef::_unchecked_narrow (
-    CORBA::Object_ptr obj,
-    CORBA::Environment &
-  )
-{
-  if (CORBA::is_nil (obj))
-    return IR_ComponentDef::_nil ();
-  if (! obj->_is_local ())
-    {
-      TAO_Stub* stub = obj->_stubobj ();
-      if (stub)
-        stub->_incr_refcnt ();
-      IR_ComponentDef_ptr default_proxy = IR_ComponentDef::_nil ();
-
-      if (
-          !CORBA::is_nil (stub->servant_orb_var ().ptr ()) &&
-          stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects () &&
-          obj->_is_collocated () &&_TAO_ComponentDef_Proxy_Broker_Factory_function_pointer != 0
-        )
-      {
-        ACE_NEW_RETURN (
-          default_proxy,
-          ::IR_ComponentDef (
-            stub,
-            1,
-            obj->_servant ()),
-            
-          IR_ComponentDef::_nil ());
-        }
-      if (CORBA::is_nil (default_proxy))
-        ACE_NEW_RETURN (default_proxy, ::IR_ComponentDef (stub, 0, obj->_servant ()), IR_ComponentDef::_nil ());
-        return default_proxy;
-      }
-    else 
-      return
-        ACE_reinterpret_cast
-          (
-            IR_ComponentDef_ptr,
-              obj->_tao_QueryInterface
-                (
-                  ACE_reinterpret_cast
-                    (
-                      ptr_arith_t,
-                      &IR_ComponentDef::_narrow
-                    )
-                )
-          );
-}
-
-IR_ComponentDef_ptr
-IR_ComponentDef::_duplicate (IR_ComponentDef_ptr obj)
-{
-  if (!CORBA::is_nil (obj))
-    obj->_add_ref ();
-  return obj;
-}
-
-CORBA::Boolean IR_ComponentDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
-{
-  if (
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/ComponentDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/InterfaceDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/Container:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/Contained:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/IDLType:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
-  return 1; // success using local knowledge
-  else
-    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
-}
-
-void *IR_ComponentDef::_tao_QueryInterface (ptr_arith_t type)
-{
-  void *retv = 0;
-  if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_ComponentDef::_narrow))
-    retv = ACE_reinterpret_cast (void*, this);
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_InterfaceDef::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            IR_InterfaceDef_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_Container::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            IR_Container_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_Contained::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            IR_Contained_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_IDLType::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            IR_IDLType_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &CORBA_IRObject::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            CORBA_IRObject_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
-    retv = ACE_reinterpret_cast (void *,
-      ACE_static_cast (CORBA::Object_ptr, this));
-    
-  if (retv)
-    this->_add_ref ();
-  return retv;
-}
-
-const char* IR_ComponentDef::_interface_repository_id (void) const
-{
-  return "IDL:omg.org/IR/ComponentDef:1.0";
-}
-
-IR_InterfaceDefSeq * IR_ComponentDef::supported_interfaces (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_ComponentDef_Proxy_Impl &proxy = 
-    this->the_TAO_ComponentDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.supported_interfaces (
-      this,
-      ACE_TRY_ENV
-    );
-}
-
-void IR_ComponentDef::supported_interfaces (
-    const IR_InterfaceDefSeq & supported_interfaces,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_ComponentDef_Proxy_Impl &proxy = 
-    this->the_TAO_ComponentDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK;
-  
-  proxy.supported_interfaces (
-      this,
-      supported_interfaces,
-      ACE_TRY_ENV
-    );
-}
-
-IR_ComponentDef_ptr IR_ComponentDef::base_component (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_ComponentDef_Proxy_Impl &proxy = 
-    this->the_TAO_ComponentDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.base_component (
-      this,
-      ACE_TRY_ENV
-    );
-}
-
-IR_ProvidesDefSeq * IR_ComponentDef::provides_interfaces (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_ComponentDef_Proxy_Impl &proxy = 
-    this->the_TAO_ComponentDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.provides_interfaces (
-      this,
-      ACE_TRY_ENV
-    );
-}
-
-IR_UsesDefSeq * IR_ComponentDef::uses_interfaces (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_ComponentDef_Proxy_Impl &proxy = 
-    this->the_TAO_ComponentDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.uses_interfaces (
-      this,
-      ACE_TRY_ENV
-    );
-}
-
-IR_EmitsDefSeq * IR_ComponentDef::emits_events (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_ComponentDef_Proxy_Impl &proxy = 
-    this->the_TAO_ComponentDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.emits_events (
-      this,
-      ACE_TRY_ENV
-    );
-}
-
-IR_PublishesDefSeq * IR_ComponentDef::publishes_events (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_ComponentDef_Proxy_Impl &proxy = 
-    this->the_TAO_ComponentDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.publishes_events (
-      this,
-      ACE_TRY_ENV
-    );
-}
-
-IR_ConsumesDefSeq * IR_ComponentDef::consumes_events (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_ComponentDef_Proxy_Impl &proxy = 
-    this->the_TAO_ComponentDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.consumes_events (
-      this,
-      ACE_TRY_ENV
-    );
-}
-
-CORBA::Boolean IR_ComponentDef::is_basic (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_ComponentDef_Proxy_Impl &proxy = 
-    this->the_TAO_ComponentDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.is_basic (
-      this,
-      ACE_TRY_ENV
-    );
-}
-
-IR_ProvidesDef_ptr IR_ComponentDef::create_provides (
-    const char * id,
-    const char * name,
-    const char * version,
-    IR_InterfaceDef_ptr interface_type,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_ComponentDef_Proxy_Impl &proxy = 
-    this->the_TAO_ComponentDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.create_provides (
-      this,
-      id,
-      name,
-      version,
-      interface_type,
-      ACE_TRY_ENV
-    );
-}
-
-IR_UsesDef_ptr IR_ComponentDef::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
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_ComponentDef_Proxy_Impl &proxy = 
-    this->the_TAO_ComponentDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.create_uses (
-      this,
-      id,
-      name,
-      version,
-      interface_type,
-      is_multiple,
-      ACE_TRY_ENV
-    );
-}
-
-IR_EmitsDef_ptr IR_ComponentDef::create_emits (
-    const char * id,
-    const char * name,
-    const char * version,
-    IR_ValueDef_ptr value,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_ComponentDef_Proxy_Impl &proxy = 
-    this->the_TAO_ComponentDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.create_emits (
-      this,
-      id,
-      name,
-      version,
-      value,
-      ACE_TRY_ENV
-    );
-}
-
-IR_PublishesDef_ptr IR_ComponentDef::create_publishes (
-    const char * id,
-    const char * name,
-    const char * version,
-    IR_ValueDef_ptr value,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_ComponentDef_Proxy_Impl &proxy = 
-    this->the_TAO_ComponentDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.create_publishes (
-      this,
-      id,
-      name,
-      version,
-      value,
-      ACE_TRY_ENV
-    );
-}
-
-IR_ConsumesDef_ptr IR_ComponentDef::create_consumes (
-    const char * id,
-    const char * name,
-    const char * version,
-    IR_ValueDef_ptr value,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_ComponentDef_Proxy_Impl &proxy = 
-    this->the_TAO_ComponentDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.create_consumes (
-      this,
-      id,
-      name,
-      version,
-      value,
-      ACE_TRY_ENV
-    );
-}
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-IR_ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_supported_interfaces_get::TAO_ClientRequestInfo_IR_ComponentDef_supported_interfaces_get (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
-{}
-
-Dynamic::ParameterList *
-IR_ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_supported_interfaces_get::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return parameter_list;
-}
-
-Dynamic::ExceptionList *
-IR_ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_supported_interfaces_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_supported_interfaces_get::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_supported_interfaces_get::result (IR_InterfaceDefSeq * result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_supported_interfaces_set::TAO_ClientRequestInfo_IR_ComponentDef_supported_interfaces_set (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    const IR_InterfaceDefSeq & supported_interfaces,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
-    supported_interfaces_ (supported_interfaces)
-{}
-
-Dynamic::ParameterList *
-IR_ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_supported_interfaces_set::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
-    
-  CORBA::ULong length_supported_interfaces = parameter_list->length ();
-  parameter_list->length (length_supported_interfaces + 1);
-  (*parameter_list)[length_supported_interfaces].argument <<=  this->supported_interfaces_;
-  
-  (*parameter_list)[length_supported_interfaces].mode = Dynamic::PARAM_IN;
-  
-  return safe_parameter_list._retn ();
-}
-
-Dynamic::ExceptionList *
-IR_ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_supported_interfaces_set::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_supported_interfaces_set::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 1;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return result_any;
-}
-
-IR_ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_base_component_get::TAO_ClientRequestInfo_IR_ComponentDef_base_component_get (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
-{}
-
-Dynamic::ParameterList *
-IR_ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_base_component_get::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return parameter_list;
-}
-
-Dynamic::ExceptionList *
-IR_ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_base_component_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_base_component_get::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_base_component_get::result (IR_ComponentDef_ptr result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_provides_interfaces_get::TAO_ClientRequestInfo_IR_ComponentDef_provides_interfaces_get (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
-{}
-
-Dynamic::ParameterList *
-IR_ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_provides_interfaces_get::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return parameter_list;
-}
-
-Dynamic::ExceptionList *
-IR_ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_provides_interfaces_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_provides_interfaces_get::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_provides_interfaces_get::result (IR_ProvidesDefSeq * result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_uses_interfaces_get::TAO_ClientRequestInfo_IR_ComponentDef_uses_interfaces_get (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
-{}
-
-Dynamic::ParameterList *
-IR_ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_uses_interfaces_get::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return parameter_list;
-}
-
-Dynamic::ExceptionList *
-IR_ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_uses_interfaces_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_uses_interfaces_get::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_uses_interfaces_get::result (IR_UsesDefSeq * result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_emits_events_get::TAO_ClientRequestInfo_IR_ComponentDef_emits_events_get (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
-{}
-
-Dynamic::ParameterList *
-IR_ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_emits_events_get::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return parameter_list;
-}
-
-Dynamic::ExceptionList *
-IR_ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_emits_events_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_emits_events_get::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_emits_events_get::result (IR_EmitsDefSeq * result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_publishes_events_get::TAO_ClientRequestInfo_IR_ComponentDef_publishes_events_get (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
-{}
-
-Dynamic::ParameterList *
-IR_ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_publishes_events_get::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return parameter_list;
-}
-
-Dynamic::ExceptionList *
-IR_ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_publishes_events_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_publishes_events_get::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_publishes_events_get::result (IR_PublishesDefSeq * result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_consumes_events_get::TAO_ClientRequestInfo_IR_ComponentDef_consumes_events_get (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
-{}
-
-Dynamic::ParameterList *
-IR_ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_consumes_events_get::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return parameter_list;
-}
-
-Dynamic::ExceptionList *
-IR_ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_consumes_events_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_consumes_events_get::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_consumes_events_get::result (IR_ConsumesDefSeq * result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_is_basic_get::TAO_ClientRequestInfo_IR_ComponentDef_is_basic_get (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
-{}
-
-Dynamic::ParameterList *
-IR_ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_is_basic_get::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return parameter_list;
-}
-
-Dynamic::ExceptionList *
-IR_ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_is_basic_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_is_basic_get::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= CORBA::Any::from_boolean (this->_result);
-  return safe_result_any._retn ();
-}
-
-void 
-IR_ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_is_basic_get::result (CORBA::Boolean result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_create_provides::TAO_ClientRequestInfo_IR_ComponentDef_create_provides (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    const char * id,
-    const char * name,
-    const char * version,
-    IR_InterfaceDef_ptr interface_type,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
-    id_ (id),
-    name_ (name),
-    version_ (version),
-    interface_type_ (interface_type)
-{}
-
-Dynamic::ParameterList *
-IR_ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_create_provides::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
-    
-  CORBA::ULong length_id = parameter_list->length ();
-  parameter_list->length (length_id + 1);
-  (*parameter_list)[length_id].argument <<= id_;
-  (*parameter_list)[length_id].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_name = parameter_list->length ();
-  parameter_list->length (length_name + 1);
-  (*parameter_list)[length_name].argument <<= name_;
-  (*parameter_list)[length_name].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_version = parameter_list->length ();
-  parameter_list->length (length_version + 1);
-  (*parameter_list)[length_version].argument <<= version_;
-  (*parameter_list)[length_version].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_interface_type = parameter_list->length ();
-  parameter_list->length (length_interface_type + 1);
-  (*parameter_list)[length_interface_type].argument <<=  this->interface_type_;
-  
-  (*parameter_list)[length_interface_type].mode = Dynamic::PARAM_IN;
-  
-  return safe_parameter_list._retn ();
-}
-
-Dynamic::ExceptionList *
-IR_ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_create_provides::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_create_provides::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_create_provides::result (IR_ProvidesDef_ptr result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_create_uses::TAO_ClientRequestInfo_IR_ComponentDef_create_uses (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    const char * id,
-    const char * name,
-    const char * version,
-    IR_InterfaceDef_ptr interface_type,
-    const CORBA::Boolean & is_multiple,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
-    id_ (id),
-    name_ (name),
-    version_ (version),
-    interface_type_ (interface_type),
-    is_multiple_ (is_multiple)
-{}
-
-Dynamic::ParameterList *
-IR_ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_create_uses::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
-    
-  CORBA::ULong length_id = parameter_list->length ();
-  parameter_list->length (length_id + 1);
-  (*parameter_list)[length_id].argument <<= id_;
-  (*parameter_list)[length_id].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_name = parameter_list->length ();
-  parameter_list->length (length_name + 1);
-  (*parameter_list)[length_name].argument <<= name_;
-  (*parameter_list)[length_name].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_version = parameter_list->length ();
-  parameter_list->length (length_version + 1);
-  (*parameter_list)[length_version].argument <<= version_;
-  (*parameter_list)[length_version].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_interface_type = parameter_list->length ();
-  parameter_list->length (length_interface_type + 1);
-  (*parameter_list)[length_interface_type].argument <<=  this->interface_type_;
-  
-  (*parameter_list)[length_interface_type].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_is_multiple = parameter_list->length ();
-  parameter_list->length (length_is_multiple + 1);
-  (*parameter_list)[length_is_multiple].argument <<= CORBA::Any::from_boolean (this->is_multiple_);
-  (*parameter_list)[length_is_multiple].mode = Dynamic::PARAM_IN;
-  
-  return safe_parameter_list._retn ();
-}
-
-Dynamic::ExceptionList *
-IR_ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_create_uses::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_create_uses::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_create_uses::result (IR_UsesDef_ptr result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_create_emits::TAO_ClientRequestInfo_IR_ComponentDef_create_emits (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    const char * id,
-    const char * name,
-    const char * version,
-    IR_ValueDef_ptr value,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
-    id_ (id),
-    name_ (name),
-    version_ (version),
-    value_ (value)
-{}
-
-Dynamic::ParameterList *
-IR_ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_create_emits::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
-    
-  CORBA::ULong length_id = parameter_list->length ();
-  parameter_list->length (length_id + 1);
-  (*parameter_list)[length_id].argument <<= id_;
-  (*parameter_list)[length_id].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_name = parameter_list->length ();
-  parameter_list->length (length_name + 1);
-  (*parameter_list)[length_name].argument <<= name_;
-  (*parameter_list)[length_name].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_version = parameter_list->length ();
-  parameter_list->length (length_version + 1);
-  (*parameter_list)[length_version].argument <<= version_;
-  (*parameter_list)[length_version].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_value = parameter_list->length ();
-  parameter_list->length (length_value + 1);
-  (*parameter_list)[length_value].argument <<=  this->value_;
-  
-  (*parameter_list)[length_value].mode = Dynamic::PARAM_IN;
-  
-  return safe_parameter_list._retn ();
-}
-
-Dynamic::ExceptionList *
-IR_ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_create_emits::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_create_emits::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_create_emits::result (IR_EmitsDef_ptr result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_create_publishes::TAO_ClientRequestInfo_IR_ComponentDef_create_publishes (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    const char * id,
-    const char * name,
-    const char * version,
-    IR_ValueDef_ptr value,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
-    id_ (id),
-    name_ (name),
-    version_ (version),
-    value_ (value)
-{}
-
-Dynamic::ParameterList *
-IR_ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_create_publishes::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
-    
-  CORBA::ULong length_id = parameter_list->length ();
-  parameter_list->length (length_id + 1);
-  (*parameter_list)[length_id].argument <<= id_;
-  (*parameter_list)[length_id].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_name = parameter_list->length ();
-  parameter_list->length (length_name + 1);
-  (*parameter_list)[length_name].argument <<= name_;
-  (*parameter_list)[length_name].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_version = parameter_list->length ();
-  parameter_list->length (length_version + 1);
-  (*parameter_list)[length_version].argument <<= version_;
-  (*parameter_list)[length_version].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_value = parameter_list->length ();
-  parameter_list->length (length_value + 1);
-  (*parameter_list)[length_value].argument <<=  this->value_;
-  
-  (*parameter_list)[length_value].mode = Dynamic::PARAM_IN;
-  
-  return safe_parameter_list._retn ();
-}
-
-Dynamic::ExceptionList *
-IR_ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_create_publishes::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_create_publishes::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_create_publishes::result (IR_PublishesDef_ptr result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_create_consumes::TAO_ClientRequestInfo_IR_ComponentDef_create_consumes (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    const char * id,
-    const char * name,
-    const char * version,
-    IR_ValueDef_ptr value,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
-    id_ (id),
-    name_ (name),
-    version_ (version),
-    value_ (value)
-{}
-
-Dynamic::ParameterList *
-IR_ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_create_consumes::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
-    
-  CORBA::ULong length_id = parameter_list->length ();
-  parameter_list->length (length_id + 1);
-  (*parameter_list)[length_id].argument <<= id_;
-  (*parameter_list)[length_id].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_name = parameter_list->length ();
-  parameter_list->length (length_name + 1);
-  (*parameter_list)[length_name].argument <<= name_;
-  (*parameter_list)[length_name].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_version = parameter_list->length ();
-  parameter_list->length (length_version + 1);
-  (*parameter_list)[length_version].argument <<= version_;
-  (*parameter_list)[length_version].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_value = parameter_list->length ();
-  parameter_list->length (length_value + 1);
-  (*parameter_list)[length_value].argument <<=  this->value_;
-  
-  (*parameter_list)[length_value].mode = Dynamic::PARAM_IN;
-  
-  return safe_parameter_list._retn ();
-}
-
-Dynamic::ExceptionList *
-IR_ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_create_consumes::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_create_consumes::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_ComponentDef::TAO_ClientRequestInfo_IR_ComponentDef_create_consumes::result (IR_ConsumesDef_ptr result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-#endif /* TAO_HAS_INTERCEPTORS */
-
-static const CORBA::Long _oc_IR_ComponentDef[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f43), ACE_NTOHL (0x6f6d706f), ACE_NTOHL (0x6e656e74), ACE_NTOHL (0x4465663a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ComponentDef:1.0
-  13, ACE_NTOHL (0x436f6d70), ACE_NTOHL (0x6f6e656e), ACE_NTOHL (0x74446566), ACE_NTOHL (0x0),  // name = IR_ComponentDef
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_ComponentDef (CORBA::tk_objref, sizeof (_oc_IR_ComponentDef), (char *) &_oc_IR_ComponentDef, 0, sizeof (IR_ComponentDef));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ComponentDef, &_tc_TAO_tc_IR_ComponentDef)
-TAO_NAMESPACE_END
-
-static const CORBA::Long _oc_IR_ComponentDescription[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f43), ACE_NTOHL (0x6f6d706f), ACE_NTOHL (0x6e656e74), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ComponentDescription:1.0
-  21, ACE_NTOHL (0x436f6d70), ACE_NTOHL (0x6f6e656e), ACE_NTOHL (0x74446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = ComponentDescription
-  13, // member count
-  5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
-  CORBA::tk_alias, // typecode kind for typedefs
-  64, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
-    11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-    CORBA::tk_string, 
-    0U, // string length
-
-  3, ACE_NTOHL (0x69640000),  // name = id
-  CORBA::tk_alias, // typecode kind for typedefs
-  68, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-    13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-    CORBA::tk_string, 
-    0U, // string length
-
-  11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
-  CORBA::tk_alias, // typecode kind for typedefs
-  68, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-    13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-    CORBA::tk_string, 
-    0U, // string length
-
-  8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
-  CORBA::tk_alias, // typecode kind for typedefs
-  64, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
-    12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
-    CORBA::tk_string, 
-    0U, // string length
-
-  15, ACE_NTOHL (0x62617365), ACE_NTOHL (0x5f636f6d), ACE_NTOHL (0x706f6e65), ACE_NTOHL (0x6e740000),  // name = base_component
-  CORBA::tk_alias, // typecode kind for typedefs
-  68, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-    13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-    CORBA::tk_string, 
-    0U, // string length
-
-  20, ACE_NTOHL (0x73757070), ACE_NTOHL (0x6f727473), ACE_NTOHL (0x5f696e74), ACE_NTOHL (0x65726661), ACE_NTOHL (0x63657300),  // name = supports_interfaces
-  CORBA::tk_alias, // typecode kind for typedefs
-  156, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x79496453), ACE_NTOHL (0x65713a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/RepositoryIdSeq:1.0
-    16, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x53657100),  // name = RepositoryIdSeq
-    CORBA::tk_sequence, // typecode kind
-    84, // encapsulation length
-      TAO_ENCAP_BYTE_ORDER, // byte order
-      CORBA::tk_alias, // typecode kind for typedefs
-      68, // encapsulation length
-        TAO_ENCAP_BYTE_ORDER, // byte order
-        32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-        13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-        CORBA::tk_string, 
-        0U, // string length
-
-      0U,
-
-
-  20, ACE_NTOHL (0x70726f76), ACE_NTOHL (0x69646573), ACE_NTOHL (0x5f696e74), ACE_NTOHL (0x65726661), ACE_NTOHL (0x63657300),  // name = provides_interfaces
-  CORBA::tk_alias, // typecode kind for typedefs
-  144, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    34, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f50), ACE_NTOHL (0x726f7669), ACE_NTOHL (0x64657344), ACE_NTOHL (0x65665365), ACE_NTOHL (0x713a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/ProvidesDefSeq:1.0
-    15, ACE_NTOHL (0x50726f76), ACE_NTOHL (0x69646573), ACE_NTOHL (0x44656653), ACE_NTOHL (0x65710000),  // name = IR_ProvidesDefSeq
-    CORBA::tk_sequence, // typecode kind
-    72, // encapsulation length
-      TAO_ENCAP_BYTE_ORDER, // byte order
-      CORBA::tk_objref, // typecode kind
-      56, // encapsulation length
-        TAO_ENCAP_BYTE_ORDER, // byte order
-        31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f50), ACE_NTOHL (0x726f7669), ACE_NTOHL (0x64657344), ACE_NTOHL (0x65663a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/ProvidesDef:1.0
-        12, ACE_NTOHL (0x50726f76), ACE_NTOHL (0x69646573), ACE_NTOHL (0x44656600),  // name = IR_ProvidesDef
-
-      0U,
-
-
-  16, ACE_NTOHL (0x75736573), ACE_NTOHL (0x5f696e74), ACE_NTOHL (0x65726661), ACE_NTOHL (0x63657300),  // name = uses_interfaces
-  CORBA::tk_alias, // typecode kind for typedefs
-  128, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f55), ACE_NTOHL (0x73657344), ACE_NTOHL (0x65665365), ACE_NTOHL (0x713a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/UsesDefSeq:1.0
-    11, ACE_NTOHL (0x55736573), ACE_NTOHL (0x44656653), ACE_NTOHL (0x65710000),  // name = IR_UsesDefSeq
-    CORBA::tk_sequence, // typecode kind
-    64, // encapsulation length
-      TAO_ENCAP_BYTE_ORDER, // byte order
-      CORBA::tk_objref, // typecode kind
-      48, // encapsulation length
-        TAO_ENCAP_BYTE_ORDER, // byte order
-        27, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f55), ACE_NTOHL (0x73657344), ACE_NTOHL (0x65663a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/UsesDef:1.0
-        8, ACE_NTOHL (0x55736573), ACE_NTOHL (0x44656600),  // name = IR_UsesDef
-
-      0U,
-
-
-  11, ACE_NTOHL (0x61747472), ACE_NTOHL (0x69627574), ACE_NTOHL (0x65730000),  // name = attributes
-  CORBA::tk_alias, // typecode kind for typedefs
-  1788, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    38, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f41), ACE_NTOHL (0x74747244), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e5365), ACE_NTOHL (0x713a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/AttrDescriptionSeq:1.0
-    19, ACE_NTOHL (0x41747472), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x65710000),  // name = AttrDescriptionSeq
-    CORBA::tk_sequence, // typecode kind
-    1708, // encapsulation length
-      TAO_ENCAP_BYTE_ORDER, // byte order
-      CORBA::tk_struct, // typecode kind
-      1692, // encapsulation length
-        TAO_ENCAP_BYTE_ORDER, // byte order
-        40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f41), ACE_NTOHL (0x74747269), ACE_NTOHL (0x62757465), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/AttributeDescription:1.0
-        21, ACE_NTOHL (0x41747472), ACE_NTOHL (0x69627574), ACE_NTOHL (0x65446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = AttributeDescription
-        8, // member count
-        5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
-        CORBA::tk_alias, // typecode kind for typedefs
-        64, // encapsulation length
-          TAO_ENCAP_BYTE_ORDER, // byte order
-          30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
-          11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-          CORBA::tk_string, 
-          0U, // string length
-
-        3, ACE_NTOHL (0x69640000),  // name = id
-        CORBA::tk_alias, // typecode kind for typedefs
-        68, // encapsulation length
-          TAO_ENCAP_BYTE_ORDER, // byte order
-          32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-          13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-          CORBA::tk_string, 
-          0U, // string length
-
-        11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
-        CORBA::tk_alias, // typecode kind for typedefs
-        68, // encapsulation length
-          TAO_ENCAP_BYTE_ORDER, // byte order
-          32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-          13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-          CORBA::tk_string, 
-          0U, // string length
-
-        8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
-        CORBA::tk_alias, // typecode kind for typedefs
-        64, // encapsulation length
-          TAO_ENCAP_BYTE_ORDER, // byte order
-          31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
-          12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
-          CORBA::tk_string, 
-          0U, // string length
-
-        5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
-        CORBA::tk_TypeCode,
-
-        5, ACE_NTOHL (0x6d6f6465), ACE_NTOHL (0x0),  // name = mode
-        CORBA::tk_enum, // typecode kind
-        104, // encapsulation length
-          TAO_ENCAP_BYTE_ORDER, // byte order
-          33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f41), ACE_NTOHL (0x74747269), ACE_NTOHL (0x62757465), ACE_NTOHL (0x4d6f6465), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/AttributeMode:1.0
-          14, ACE_NTOHL (0x41747472), ACE_NTOHL (0x69627574), ACE_NTOHL (0x654d6f64), ACE_NTOHL (0x65000000),  // name = AttributeMode
-          2, // member count
-          12, ACE_NTOHL (0x41545452), ACE_NTOHL (0x5f4e4f52), ACE_NTOHL (0x4d414c00),  // name = ATTR_NORMAL
-          14, ACE_NTOHL (0x41545452), ACE_NTOHL (0x5f524541), ACE_NTOHL (0x444f4e4c), ACE_NTOHL (0x59000000),  // name = ATTR_READONLY
-
-        15, ACE_NTOHL (0x6765745f), ACE_NTOHL (0x65786365), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e730000),  // name = get_exceptions
-        CORBA::tk_alias, // typecode kind for typedefs
-        536, // encapsulation length
-          TAO_ENCAP_BYTE_ORDER, // byte order
-          37, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x78634465), ACE_NTOHL (0x73637269), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e536571), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/ExcDescriptionSeq:1.0
-          18, ACE_NTOHL (0x45786344), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e5365), ACE_NTOHL (0x71000000),  // name = ExcDescriptionSeq
-          CORBA::tk_sequence, // typecode kind
-          456, // encapsulation length
-            TAO_ENCAP_BYTE_ORDER, // byte order
-            CORBA::tk_struct, // typecode kind
-            440, // encapsulation length
-              TAO_ENCAP_BYTE_ORDER, // byte order
-              40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x78636570), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ExceptionDescription:1.0
-              21, ACE_NTOHL (0x45786365), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = ExceptionDescription
-              5, // member count
-              5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
-              CORBA::tk_alias, // typecode kind for typedefs
-              64, // encapsulation length
-                TAO_ENCAP_BYTE_ORDER, // byte order
-                30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
-                11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-                CORBA::tk_string, 
-                0U, // string length
-
-              3, ACE_NTOHL (0x69640000),  // name = id
-              CORBA::tk_alias, // typecode kind for typedefs
-              68, // encapsulation length
-                TAO_ENCAP_BYTE_ORDER, // byte order
-                32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-                13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-                CORBA::tk_string, 
-                0U, // string length
-
-              11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
-              CORBA::tk_alias, // typecode kind for typedefs
-              68, // encapsulation length
-                TAO_ENCAP_BYTE_ORDER, // byte order
-                32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-                13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-                CORBA::tk_string, 
-                0U, // string length
-
-              8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
-              CORBA::tk_alias, // typecode kind for typedefs
-              64, // encapsulation length
-                TAO_ENCAP_BYTE_ORDER, // byte order
-                31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
-                12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
-                CORBA::tk_string, 
-                0U, // string length
-
-              5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
-              CORBA::tk_TypeCode,
-
-
-            0U,
-
-
-        15, ACE_NTOHL (0x7075745f), ACE_NTOHL (0x65786365), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e730000),  // name = put_exceptions
-        CORBA::tk_alias, // typecode kind for typedefs
-        536, // encapsulation length
-          TAO_ENCAP_BYTE_ORDER, // byte order
-          37, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x78634465), ACE_NTOHL (0x73637269), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e536571), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/ExcDescriptionSeq:1.0
-          18, ACE_NTOHL (0x45786344), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e5365), ACE_NTOHL (0x71000000),  // name = ExcDescriptionSeq
-          CORBA::tk_sequence, // typecode kind
-          456, // encapsulation length
-            TAO_ENCAP_BYTE_ORDER, // byte order
-            CORBA::tk_struct, // typecode kind
-            440, // encapsulation length
-              TAO_ENCAP_BYTE_ORDER, // byte order
-              40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x78636570), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ExceptionDescription:1.0
-              21, ACE_NTOHL (0x45786365), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = ExceptionDescription
-              5, // member count
-              5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
-              CORBA::tk_alias, // typecode kind for typedefs
-              64, // encapsulation length
-                TAO_ENCAP_BYTE_ORDER, // byte order
-                30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
-                11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-                CORBA::tk_string, 
-                0U, // string length
-
-              3, ACE_NTOHL (0x69640000),  // name = id
-              CORBA::tk_alias, // typecode kind for typedefs
-              68, // encapsulation length
-                TAO_ENCAP_BYTE_ORDER, // byte order
-                32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-                13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-                CORBA::tk_string, 
-                0U, // string length
-
-              11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
-              CORBA::tk_alias, // typecode kind for typedefs
-              68, // encapsulation length
-                TAO_ENCAP_BYTE_ORDER, // byte order
-                32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-                13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-                CORBA::tk_string, 
-                0U, // string length
-
-              8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
-              CORBA::tk_alias, // typecode kind for typedefs
-              64, // encapsulation length
-                TAO_ENCAP_BYTE_ORDER, // byte order
-                31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
-                12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
-                CORBA::tk_string, 
-                0U, // string length
-
-              5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
-              CORBA::tk_TypeCode,
-
-
-            0U,
-
-
-
-      0U,
-
-
-  13, ACE_NTOHL (0x656d6974), ACE_NTOHL (0x735f6576), ACE_NTOHL (0x656e7473), ACE_NTOHL (0x0),  // name = emits_events
-  CORBA::tk_alias, // typecode kind for typedefs
-  132, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x6d697473), ACE_NTOHL (0x44656653), ACE_NTOHL (0x65713a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/EmitsDefSeq:1.0
-    12, ACE_NTOHL (0x456d6974), ACE_NTOHL (0x73446566), ACE_NTOHL (0x53657100),  // name = IR_EmitsDefSeq
-    CORBA::tk_sequence, // typecode kind
-    68, // encapsulation length
-      TAO_ENCAP_BYTE_ORDER, // byte order
-      CORBA::tk_objref, // typecode kind
-      52, // encapsulation length
-        TAO_ENCAP_BYTE_ORDER, // byte order
-        28, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x6d697473), ACE_NTOHL (0x4465663a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/EmitsDef:1.0
-        9, ACE_NTOHL (0x456d6974), ACE_NTOHL (0x73446566), ACE_NTOHL (0x0),  // name = IR_EmitsDef
-
-      0U,
-
-
-  17, ACE_NTOHL (0x7075626c), ACE_NTOHL (0x69736865), ACE_NTOHL (0x735f6576), ACE_NTOHL (0x656e7473), ACE_NTOHL (0x0),  // name = publishes_events
-  CORBA::tk_alias, // typecode kind for typedefs
-  148, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f50), ACE_NTOHL (0x75626c69), ACE_NTOHL (0x73686573), ACE_NTOHL (0x44656653), ACE_NTOHL (0x65713a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/PublishesDefSeq:1.0
-    16, ACE_NTOHL (0x5075626c), ACE_NTOHL (0x69736865), ACE_NTOHL (0x73446566), ACE_NTOHL (0x53657100),  // name = IR_PublishesDefSeq
-    CORBA::tk_sequence, // typecode kind
-    76, // encapsulation length
-      TAO_ENCAP_BYTE_ORDER, // byte order
-      CORBA::tk_objref, // typecode kind
-      60, // encapsulation length
-        TAO_ENCAP_BYTE_ORDER, // byte order
-        32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f50), ACE_NTOHL (0x75626c69), ACE_NTOHL (0x73686573), ACE_NTOHL (0x4465663a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/PublishesDef:1.0
-        13, ACE_NTOHL (0x5075626c), ACE_NTOHL (0x69736865), ACE_NTOHL (0x73446566), ACE_NTOHL (0x0),  // name = IR_PublishesDef
-
-      0U,
-
-
-  16, ACE_NTOHL (0x636f6e73), ACE_NTOHL (0x756d6573), ACE_NTOHL (0x5f657665), ACE_NTOHL (0x6e747300),  // name = consumes_events
-  CORBA::tk_alias, // typecode kind for typedefs
-  144, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    34, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f43), ACE_NTOHL (0x6f6e7375), ACE_NTOHL (0x6d657344), ACE_NTOHL (0x65665365), ACE_NTOHL (0x713a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/ConsumesDefSeq:1.0
-    15, ACE_NTOHL (0x436f6e73), ACE_NTOHL (0x756d6573), ACE_NTOHL (0x44656653), ACE_NTOHL (0x65710000),  // name = IR_ConsumesDefSeq
-    CORBA::tk_sequence, // typecode kind
-    72, // encapsulation length
-      TAO_ENCAP_BYTE_ORDER, // byte order
-      CORBA::tk_objref, // typecode kind
-      56, // encapsulation length
-        TAO_ENCAP_BYTE_ORDER, // byte order
-        31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f43), ACE_NTOHL (0x6f6e7375), ACE_NTOHL (0x6d657344), ACE_NTOHL (0x65663a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/ConsumesDef:1.0
-        12, ACE_NTOHL (0x436f6e73), ACE_NTOHL (0x756d6573), ACE_NTOHL (0x44656600),  // name = IR_ConsumesDef
-
-      0U,
-
-
-  9, ACE_NTOHL (0x69735f62), ACE_NTOHL (0x61736963), ACE_NTOHL (0x0),  // name = is_basic
-  CORBA::tk_boolean,
-
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_ComponentDescription (CORBA::tk_struct, sizeof (_oc_IR_ComponentDescription), (char *) &_oc_IR_ComponentDescription, 0, sizeof (IR_ComponentDescription));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ComponentDescription, &_tc_TAO_tc_IR_ComponentDescription)
-TAO_NAMESPACE_END
-
-void IR_ComponentDescription::_tao_any_destructor (void *x)
-{
-  IR_ComponentDescription *tmp = ACE_static_cast (IR_ComponentDescription*,x);
-  delete tmp;
-}
-
-
-///////////////////////////////////////////////////////////////////////
-//                Base & Remote Proxy  Implementation. 
-//
-
-_TAO_PrimaryKeyDef_Proxy_Impl::_TAO_PrimaryKeyDef_Proxy_Impl (void)
-{}
-
-_TAO_PrimaryKeyDef_Remote_Proxy_Impl::_TAO_PrimaryKeyDef_Remote_Proxy_Impl (void)
-{}
-
-// Remote Implementation of the IDL interface methods
-
-CORBA::Boolean _TAO_PrimaryKeyDef_Remote_Proxy_Impl::is_a (
-    CORBA_Object *_collocated_tao_target_,
-    const char * primary_key_id,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  
-  CORBA::Boolean _tao_retval = 0;
-  
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), _tao_retval);
-
-  
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "is_a",
-      4,
-      1,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_PrimaryKeyDef::TAO_ClientRequestInfo_IR_PrimaryKeyDef_is_a ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        primary_key_id,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN  (_tao_retval);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-          if (!(
-                            (_tao_out << primary_key_id)
-            ))
-            TAO_INTERCEPTOR_THROW_RETURN (
-              CORBA::MARSHAL (),
-              _tao_retval
-            );
-            
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                _tao_retval
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> CORBA::Any::to_boolean (_tao_retval))
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                _tao_retval
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              CORBA::Boolean  _tao_retval_info = _tao_retval;
-               ri.result (_tao_retval_info);
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN  (_tao_retval);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_retval;
-}
-
-IR_ValueDef_ptr _TAO_PrimaryKeyDef_Remote_Proxy_Impl::primary_key (
-    CORBA_Object *_collocated_tao_target_,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  
-  IR_ValueDef_ptr _tao_retval = IR_ValueDef::_nil ();
-  IR_ValueDef_var _tao_safe_retval (_tao_retval);
-  
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-
-  
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_get_primary_key",
-      16,
-      0,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_PrimaryKeyDef::TAO_ClientRequestInfo_IR_PrimaryKeyDef_primary_key_get ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              IR_ValueDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-
-//
-//            End  Base & Remote  Proxy Implemeentation. 
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//           Remote & Base  Proxy Broker Implementation
-//
-
-_TAO_PrimaryKeyDef_Proxy_Broker::_TAO_PrimaryKeyDef_Proxy_Broker (void)
-{
-}
-
-_TAO_PrimaryKeyDef_Proxy_Broker::~_TAO_PrimaryKeyDef_Proxy_Broker (void)
-{
-}
-
-_TAO_PrimaryKeyDef_Proxy_Broker * (*_TAO_PrimaryKeyDef_Proxy_Broker_Factory_function_pointer) (
-    CORBA::Object_ptr obj
-  ) = 0;
-
-// Factory Member function Implementation.
-_TAO_PrimaryKeyDef_Remote_Proxy_Broker *
-_TAO_PrimaryKeyDef_Remote_Proxy_Broker::the_TAO_PrimaryKeyDef_Remote_Proxy_Broker (void)
-{
-  static ::_TAO_PrimaryKeyDef_Remote_Proxy_Broker remote_proxy_broker;
-  return &remote_proxy_broker;
-}
-
-_TAO_PrimaryKeyDef_Remote_Proxy_Broker::_TAO_PrimaryKeyDef_Remote_Proxy_Broker (void)
-{
-}
-
-_TAO_PrimaryKeyDef_Remote_Proxy_Broker::~_TAO_PrimaryKeyDef_Remote_Proxy_Broker (void)
-{
-}
-
-_TAO_PrimaryKeyDef_Proxy_Impl&
-_TAO_PrimaryKeyDef_Remote_Proxy_Broker::select_proxy (
-  ::IR_PrimaryKeyDef *object,
-  CORBA::Environment &ACE_TRY_ENV
-)
-{
-  ACE_UNUSED_ARG (object);
-  ACE_UNUSED_ARG (ACE_TRY_ENV);
-  return remote_proxy_impl_;
-}
-
-
-//
-//           End Remote & Base Proxy Broker Implementation
-///////////////////////////////////////////////////////////////////////
-
-
-// default constructor
-IR_PrimaryKeyDef::IR_PrimaryKeyDef (int collocated)
-{
-  this->IR_PrimaryKeyDef_setup_collocation (collocated);
-}
-
-// destructor
-IR_PrimaryKeyDef::~IR_PrimaryKeyDef (void)
-{}
-
-void
-IR_PrimaryKeyDef::IR_PrimaryKeyDef_setup_collocation (int collocated)
-{
-  if (collocated)
-    this->the_TAO_PrimaryKeyDef_Proxy_Broker_ =
-      _TAO_PrimaryKeyDef_Proxy_Broker_Factory_function_pointer (this);
-  else
-    this->the_TAO_PrimaryKeyDef_Proxy_Broker_ =
-      _TAO_PrimaryKeyDef_Remote_Proxy_Broker::the_TAO_PrimaryKeyDef_Remote_Proxy_Broker ();
-  
-  this->IR_Contained_setup_collocation (collocated);
-}
-
-void IR_PrimaryKeyDef::_tao_any_destructor (void *x)
-{
-  IR_PrimaryKeyDef *tmp = ACE_static_cast (IR_PrimaryKeyDef*,x);
-  CORBA::release (tmp);
-}
-
-IR_PrimaryKeyDef_ptr IR_PrimaryKeyDef::_narrow (
-    CORBA::Object_ptr obj,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  if (CORBA::is_nil (obj))
-    return IR_PrimaryKeyDef::_nil ();
-  if (! obj->_is_local ())
-    {
-      CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/IR/PrimaryKeyDef:1.0", ACE_TRY_ENV);
-      ACE_CHECK_RETURN (IR_PrimaryKeyDef::_nil ());
-      if (is_a == 0)
-        return IR_PrimaryKeyDef::_nil ();
-    }
-  return IR_PrimaryKeyDef::_unchecked_narrow (obj, ACE_TRY_ENV);
-}
-
-IR_PrimaryKeyDef_ptr IR_PrimaryKeyDef::_unchecked_narrow (
-    CORBA::Object_ptr obj,
-    CORBA::Environment &
-  )
-{
-  if (CORBA::is_nil (obj))
-    return IR_PrimaryKeyDef::_nil ();
-  if (! obj->_is_local ())
-    {
-      TAO_Stub* stub = obj->_stubobj ();
-      if (stub)
-        stub->_incr_refcnt ();
-      IR_PrimaryKeyDef_ptr default_proxy = IR_PrimaryKeyDef::_nil ();
-
-      if (
-          !CORBA::is_nil (stub->servant_orb_var ().ptr ()) &&
-          stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects () &&
-          obj->_is_collocated () &&_TAO_PrimaryKeyDef_Proxy_Broker_Factory_function_pointer != 0
-        )
-      {
-        ACE_NEW_RETURN (
-          default_proxy,
-          ::IR_PrimaryKeyDef (
-            stub,
-            1,
-            obj->_servant ()),
-            
-          IR_PrimaryKeyDef::_nil ());
-        }
-      if (CORBA::is_nil (default_proxy))
-        ACE_NEW_RETURN (default_proxy, ::IR_PrimaryKeyDef (stub, 0, obj->_servant ()), IR_PrimaryKeyDef::_nil ());
-        return default_proxy;
-      }
-    else 
-      return
-        ACE_reinterpret_cast
-          (
-            IR_PrimaryKeyDef_ptr,
-              obj->_tao_QueryInterface
-                (
-                  ACE_reinterpret_cast
-                    (
-                      ptr_arith_t,
-                      &IR_PrimaryKeyDef::_narrow
-                    )
-                )
-          );
-}
-
-IR_PrimaryKeyDef_ptr
-IR_PrimaryKeyDef::_duplicate (IR_PrimaryKeyDef_ptr obj)
-{
-  if (!CORBA::is_nil (obj))
-    obj->_add_ref ();
-  return obj;
-}
-
-CORBA::Boolean IR_PrimaryKeyDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
-{
-  if (
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/PrimaryKeyDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/Contained:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
-  return 1; // success using local knowledge
-  else
-    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
-}
-
-void *IR_PrimaryKeyDef::_tao_QueryInterface (ptr_arith_t type)
-{
-  void *retv = 0;
-  if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_PrimaryKeyDef::_narrow))
-    retv = ACE_reinterpret_cast (void*, this);
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_Contained::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            IR_Contained_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &CORBA_IRObject::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            CORBA_IRObject_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
-    retv = ACE_reinterpret_cast (void *,
-      ACE_static_cast (CORBA::Object_ptr, this));
-    
-  if (retv)
-    this->_add_ref ();
-  return retv;
-}
-
-const char* IR_PrimaryKeyDef::_interface_repository_id (void) const
-{
-  return "IDL:omg.org/IR/PrimaryKeyDef:1.0";
-}
-
-CORBA::Boolean IR_PrimaryKeyDef::is_a (
-    const char * primary_key_id,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_PrimaryKeyDef_Proxy_Impl &proxy = 
-    this->the_TAO_PrimaryKeyDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.is_a (
-      this,
-      primary_key_id,
-      ACE_TRY_ENV
-    );
-}
-
-IR_ValueDef_ptr IR_PrimaryKeyDef::primary_key (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_PrimaryKeyDef_Proxy_Impl &proxy = 
-    this->the_TAO_PrimaryKeyDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.primary_key (
-      this,
-      ACE_TRY_ENV
-    );
-}
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-IR_PrimaryKeyDef::TAO_ClientRequestInfo_IR_PrimaryKeyDef_is_a::TAO_ClientRequestInfo_IR_PrimaryKeyDef_is_a (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    const char * primary_key_id,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
-    primary_key_id_ (primary_key_id)
-{}
-
-Dynamic::ParameterList *
-IR_PrimaryKeyDef::TAO_ClientRequestInfo_IR_PrimaryKeyDef_is_a::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
-    
-  CORBA::ULong length_primary_key_id = parameter_list->length ();
-  parameter_list->length (length_primary_key_id + 1);
-  (*parameter_list)[length_primary_key_id].argument <<= primary_key_id_;
-  (*parameter_list)[length_primary_key_id].mode = Dynamic::PARAM_IN;
-  
-  return safe_parameter_list._retn ();
-}
-
-Dynamic::ExceptionList *
-IR_PrimaryKeyDef::TAO_ClientRequestInfo_IR_PrimaryKeyDef_is_a::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_PrimaryKeyDef::TAO_ClientRequestInfo_IR_PrimaryKeyDef_is_a::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= CORBA::Any::from_boolean (this->_result);
-  return safe_result_any._retn ();
-}
-
-void 
-IR_PrimaryKeyDef::TAO_ClientRequestInfo_IR_PrimaryKeyDef_is_a::result (CORBA::Boolean result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_PrimaryKeyDef::TAO_ClientRequestInfo_IR_PrimaryKeyDef_primary_key_get::TAO_ClientRequestInfo_IR_PrimaryKeyDef_primary_key_get (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
-{}
-
-Dynamic::ParameterList *
-IR_PrimaryKeyDef::TAO_ClientRequestInfo_IR_PrimaryKeyDef_primary_key_get::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return parameter_list;
-}
-
-Dynamic::ExceptionList *
-IR_PrimaryKeyDef::TAO_ClientRequestInfo_IR_PrimaryKeyDef_primary_key_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_PrimaryKeyDef::TAO_ClientRequestInfo_IR_PrimaryKeyDef_primary_key_get::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_PrimaryKeyDef::TAO_ClientRequestInfo_IR_PrimaryKeyDef_primary_key_get::result (IR_ValueDef_ptr result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-#endif /* TAO_HAS_INTERCEPTORS */
-
-static const CORBA::Long _oc_IR_PrimaryKeyDef[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f50), ACE_NTOHL (0x72696d61), ACE_NTOHL (0x72794b65), ACE_NTOHL (0x79446566), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/PrimaryKeyDef:1.0
-  14, ACE_NTOHL (0x5072696d), ACE_NTOHL (0x6172794b), ACE_NTOHL (0x65794465), ACE_NTOHL (0x66000000),  // name = IR_PrimaryKeyDef
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_PrimaryKeyDef (CORBA::tk_objref, sizeof (_oc_IR_PrimaryKeyDef), (char *) &_oc_IR_PrimaryKeyDef, 0, sizeof (IR_PrimaryKeyDef));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_PrimaryKeyDef, &_tc_TAO_tc_IR_PrimaryKeyDef)
-TAO_NAMESPACE_END
-
-static const CORBA::Long _oc_IR_PrimaryKeyDescription[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  41, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f50), ACE_NTOHL (0x72696d61), ACE_NTOHL (0x72794b65), ACE_NTOHL (0x79446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/PrimaryKeyDescription:1.0
-  22, ACE_NTOHL (0x5072696d), ACE_NTOHL (0x6172794b), ACE_NTOHL (0x65794465), ACE_NTOHL (0x73637269), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e000000),  // name = PrimaryKeyDescription
-  5, // member count
-  5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
-  CORBA::tk_alias, // typecode kind for typedefs
-  64, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
-    11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-    CORBA::tk_string, 
-    0U, // string length
-
-  3, ACE_NTOHL (0x69640000),  // name = id
-  CORBA::tk_alias, // typecode kind for typedefs
-  68, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-    13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-    CORBA::tk_string, 
-    0U, // string length
-
-  11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
-  CORBA::tk_alias, // typecode kind for typedefs
-  68, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-    13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-    CORBA::tk_string, 
-    0U, // string length
-
-  8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
-  CORBA::tk_alias, // typecode kind for typedefs
-  64, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
-    12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
-    CORBA::tk_string, 
-    0U, // string length
-
-  12, ACE_NTOHL (0x7072696d), ACE_NTOHL (0x6172795f), ACE_NTOHL (0x6b657900),  // name = primary_key
-  CORBA::tk_objref, // typecode kind
-  52, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    28, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x616c7565), ACE_NTOHL (0x4465663a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ValueDef:1.0
-    9, ACE_NTOHL (0x56616c75), ACE_NTOHL (0x65446566), ACE_NTOHL (0x0),  // name = IR_ValueDef
-
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_PrimaryKeyDescription (CORBA::tk_struct, sizeof (_oc_IR_PrimaryKeyDescription), (char *) &_oc_IR_PrimaryKeyDescription, 0, sizeof (IR_PrimaryKeyDescription));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_PrimaryKeyDescription, &_tc_TAO_tc_IR_PrimaryKeyDescription)
-TAO_NAMESPACE_END
-
-void IR_PrimaryKeyDescription::_tao_any_destructor (void *x)
-{
-  IR_PrimaryKeyDescription *tmp = ACE_static_cast (IR_PrimaryKeyDescription*,x);
-  delete tmp;
-}
-
-
-///////////////////////////////////////////////////////////////////////
-//                Base & Remote Proxy  Implementation. 
-//
-
-_TAO_FactoryDef_Proxy_Impl::_TAO_FactoryDef_Proxy_Impl (void)
-{}
-
-_TAO_FactoryDef_Remote_Proxy_Impl::_TAO_FactoryDef_Remote_Proxy_Impl (void)
-{}
-
-// Remote Implementation of the IDL interface methods
-
-
-//
-//            End  Base & Remote  Proxy Implemeentation. 
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//           Remote & Base  Proxy Broker Implementation
-//
-
-_TAO_FactoryDef_Proxy_Broker::_TAO_FactoryDef_Proxy_Broker (void)
-{
-}
-
-_TAO_FactoryDef_Proxy_Broker::~_TAO_FactoryDef_Proxy_Broker (void)
-{
-}
-
-_TAO_FactoryDef_Proxy_Broker * (*_TAO_FactoryDef_Proxy_Broker_Factory_function_pointer) (
-    CORBA::Object_ptr obj
-  ) = 0;
-
-// Factory Member function Implementation.
-_TAO_FactoryDef_Remote_Proxy_Broker *
-_TAO_FactoryDef_Remote_Proxy_Broker::the_TAO_FactoryDef_Remote_Proxy_Broker (void)
-{
-  static ::_TAO_FactoryDef_Remote_Proxy_Broker remote_proxy_broker;
-  return &remote_proxy_broker;
-}
-
-_TAO_FactoryDef_Remote_Proxy_Broker::_TAO_FactoryDef_Remote_Proxy_Broker (void)
-{
-}
-
-_TAO_FactoryDef_Remote_Proxy_Broker::~_TAO_FactoryDef_Remote_Proxy_Broker (void)
-{
-}
-
-_TAO_FactoryDef_Proxy_Impl&
-_TAO_FactoryDef_Remote_Proxy_Broker::select_proxy (
-  ::IR_FactoryDef *object,
-  CORBA::Environment &ACE_TRY_ENV
-)
-{
-  ACE_UNUSED_ARG (object);
-  ACE_UNUSED_ARG (ACE_TRY_ENV);
-  return remote_proxy_impl_;
-}
-
-
-//
-//           End Remote & Base Proxy Broker Implementation
-///////////////////////////////////////////////////////////////////////
-
-
-// default constructor
-IR_FactoryDef::IR_FactoryDef (int collocated)
-{
-  this->IR_FactoryDef_setup_collocation (collocated);
-}
-
-// destructor
-IR_FactoryDef::~IR_FactoryDef (void)
-{}
-
-void
-IR_FactoryDef::IR_FactoryDef_setup_collocation (int collocated)
-{
-  if (collocated)
-    this->the_TAO_FactoryDef_Proxy_Broker_ =
-      _TAO_FactoryDef_Proxy_Broker_Factory_function_pointer (this);
-  else
-    this->the_TAO_FactoryDef_Proxy_Broker_ =
-      _TAO_FactoryDef_Remote_Proxy_Broker::the_TAO_FactoryDef_Remote_Proxy_Broker ();
-  
-  this->IR_OperationDef_setup_collocation (collocated);
-}
-
-void IR_FactoryDef::_tao_any_destructor (void *x)
-{
-  IR_FactoryDef *tmp = ACE_static_cast (IR_FactoryDef*,x);
-  CORBA::release (tmp);
-}
-
-IR_FactoryDef_ptr IR_FactoryDef::_narrow (
-    CORBA::Object_ptr obj,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  if (CORBA::is_nil (obj))
-    return IR_FactoryDef::_nil ();
-  if (! obj->_is_local ())
-    {
-      CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/IR/FactoryDef:1.0", ACE_TRY_ENV);
-      ACE_CHECK_RETURN (IR_FactoryDef::_nil ());
-      if (is_a == 0)
-        return IR_FactoryDef::_nil ();
-    }
-  return IR_FactoryDef::_unchecked_narrow (obj, ACE_TRY_ENV);
-}
-
-IR_FactoryDef_ptr IR_FactoryDef::_unchecked_narrow (
-    CORBA::Object_ptr obj,
-    CORBA::Environment &
-  )
-{
-  if (CORBA::is_nil (obj))
-    return IR_FactoryDef::_nil ();
-  if (! obj->_is_local ())
-    {
-      TAO_Stub* stub = obj->_stubobj ();
-      if (stub)
-        stub->_incr_refcnt ();
-      IR_FactoryDef_ptr default_proxy = IR_FactoryDef::_nil ();
-
-      if (
-          !CORBA::is_nil (stub->servant_orb_var ().ptr ()) &&
-          stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects () &&
-          obj->_is_collocated () &&_TAO_FactoryDef_Proxy_Broker_Factory_function_pointer != 0
-        )
-      {
-        ACE_NEW_RETURN (
-          default_proxy,
-          ::IR_FactoryDef (
-            stub,
-            1,
-            obj->_servant ()),
-            
-          IR_FactoryDef::_nil ());
-        }
-      if (CORBA::is_nil (default_proxy))
-        ACE_NEW_RETURN (default_proxy, ::IR_FactoryDef (stub, 0, obj->_servant ()), IR_FactoryDef::_nil ());
-        return default_proxy;
-      }
-    else 
-      return
-        ACE_reinterpret_cast
-          (
-            IR_FactoryDef_ptr,
-              obj->_tao_QueryInterface
-                (
-                  ACE_reinterpret_cast
-                    (
-                      ptr_arith_t,
-                      &IR_FactoryDef::_narrow
-                    )
-                )
-          );
-}
-
-IR_FactoryDef_ptr
-IR_FactoryDef::_duplicate (IR_FactoryDef_ptr obj)
-{
-  if (!CORBA::is_nil (obj))
-    obj->_add_ref ();
-  return obj;
-}
-
-CORBA::Boolean IR_FactoryDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
-{
-  if (
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/FactoryDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/OperationDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/Contained:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
-  return 1; // success using local knowledge
-  else
-    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
-}
-
-void *IR_FactoryDef::_tao_QueryInterface (ptr_arith_t type)
-{
-  void *retv = 0;
-  if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_FactoryDef::_narrow))
-    retv = ACE_reinterpret_cast (void*, this);
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_OperationDef::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            IR_OperationDef_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_Contained::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            IR_Contained_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &CORBA_IRObject::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            CORBA_IRObject_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
-    retv = ACE_reinterpret_cast (void *,
-      ACE_static_cast (CORBA::Object_ptr, this));
-    
-  if (retv)
-    this->_add_ref ();
-  return retv;
-}
-
-const char* IR_FactoryDef::_interface_repository_id (void) const
-{
-  return "IDL:omg.org/IR/FactoryDef:1.0";
-}
-
-static const CORBA::Long _oc_IR_FactoryDef[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f46), ACE_NTOHL (0x6163746f), ACE_NTOHL (0x72794465), ACE_NTOHL (0x663a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/FactoryDef:1.0
-  11, ACE_NTOHL (0x46616374), ACE_NTOHL (0x6f727944), ACE_NTOHL (0x65660000),  // name = IR_FactoryDef
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_FactoryDef (CORBA::tk_objref, sizeof (_oc_IR_FactoryDef), (char *) &_oc_IR_FactoryDef, 0, sizeof (IR_FactoryDef));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_FactoryDef, &_tc_TAO_tc_IR_FactoryDef)
-TAO_NAMESPACE_END
-
-///////////////////////////////////////////////////////////////////////
-//                Base & Remote Proxy  Implementation. 
-//
-
-_TAO_FinderDef_Proxy_Impl::_TAO_FinderDef_Proxy_Impl (void)
-{}
-
-_TAO_FinderDef_Remote_Proxy_Impl::_TAO_FinderDef_Remote_Proxy_Impl (void)
-{}
-
-// Remote Implementation of the IDL interface methods
-
-
-//
-//            End  Base & Remote  Proxy Implemeentation. 
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//           Remote & Base  Proxy Broker Implementation
-//
-
-_TAO_FinderDef_Proxy_Broker::_TAO_FinderDef_Proxy_Broker (void)
-{
-}
-
-_TAO_FinderDef_Proxy_Broker::~_TAO_FinderDef_Proxy_Broker (void)
-{
-}
-
-_TAO_FinderDef_Proxy_Broker * (*_TAO_FinderDef_Proxy_Broker_Factory_function_pointer) (
-    CORBA::Object_ptr obj
-  ) = 0;
-
-// Factory Member function Implementation.
-_TAO_FinderDef_Remote_Proxy_Broker *
-_TAO_FinderDef_Remote_Proxy_Broker::the_TAO_FinderDef_Remote_Proxy_Broker (void)
-{
-  static ::_TAO_FinderDef_Remote_Proxy_Broker remote_proxy_broker;
-  return &remote_proxy_broker;
-}
-
-_TAO_FinderDef_Remote_Proxy_Broker::_TAO_FinderDef_Remote_Proxy_Broker (void)
-{
-}
-
-_TAO_FinderDef_Remote_Proxy_Broker::~_TAO_FinderDef_Remote_Proxy_Broker (void)
-{
-}
-
-_TAO_FinderDef_Proxy_Impl&
-_TAO_FinderDef_Remote_Proxy_Broker::select_proxy (
-  ::IR_FinderDef *object,
-  CORBA::Environment &ACE_TRY_ENV
-)
-{
-  ACE_UNUSED_ARG (object);
-  ACE_UNUSED_ARG (ACE_TRY_ENV);
-  return remote_proxy_impl_;
-}
-
-
-//
-//           End Remote & Base Proxy Broker Implementation
-///////////////////////////////////////////////////////////////////////
-
-
-// default constructor
-IR_FinderDef::IR_FinderDef (int collocated)
-{
-  this->IR_FinderDef_setup_collocation (collocated);
-}
-
-// destructor
-IR_FinderDef::~IR_FinderDef (void)
-{}
-
-void
-IR_FinderDef::IR_FinderDef_setup_collocation (int collocated)
-{
-  if (collocated)
-    this->the_TAO_FinderDef_Proxy_Broker_ =
-      _TAO_FinderDef_Proxy_Broker_Factory_function_pointer (this);
-  else
-    this->the_TAO_FinderDef_Proxy_Broker_ =
-      _TAO_FinderDef_Remote_Proxy_Broker::the_TAO_FinderDef_Remote_Proxy_Broker ();
-  
-  this->IR_OperationDef_setup_collocation (collocated);
-}
-
-void IR_FinderDef::_tao_any_destructor (void *x)
-{
-  IR_FinderDef *tmp = ACE_static_cast (IR_FinderDef*,x);
-  CORBA::release (tmp);
-}
-
-IR_FinderDef_ptr IR_FinderDef::_narrow (
-    CORBA::Object_ptr obj,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  if (CORBA::is_nil (obj))
-    return IR_FinderDef::_nil ();
-  if (! obj->_is_local ())
-    {
-      CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/IR/FinderDef:1.0", ACE_TRY_ENV);
-      ACE_CHECK_RETURN (IR_FinderDef::_nil ());
-      if (is_a == 0)
-        return IR_FinderDef::_nil ();
-    }
-  return IR_FinderDef::_unchecked_narrow (obj, ACE_TRY_ENV);
-}
-
-IR_FinderDef_ptr IR_FinderDef::_unchecked_narrow (
-    CORBA::Object_ptr obj,
-    CORBA::Environment &
-  )
-{
-  if (CORBA::is_nil (obj))
-    return IR_FinderDef::_nil ();
-  if (! obj->_is_local ())
-    {
-      TAO_Stub* stub = obj->_stubobj ();
-      if (stub)
-        stub->_incr_refcnt ();
-      IR_FinderDef_ptr default_proxy = IR_FinderDef::_nil ();
-
-      if (
-          !CORBA::is_nil (stub->servant_orb_var ().ptr ()) &&
-          stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects () &&
-          obj->_is_collocated () &&_TAO_FinderDef_Proxy_Broker_Factory_function_pointer != 0
-        )
-      {
-        ACE_NEW_RETURN (
-          default_proxy,
-          ::IR_FinderDef (
-            stub,
-            1,
-            obj->_servant ()),
-            
-          IR_FinderDef::_nil ());
-        }
-      if (CORBA::is_nil (default_proxy))
-        ACE_NEW_RETURN (default_proxy, ::IR_FinderDef (stub, 0, obj->_servant ()), IR_FinderDef::_nil ());
-        return default_proxy;
-      }
-    else 
-      return
-        ACE_reinterpret_cast
-          (
-            IR_FinderDef_ptr,
-              obj->_tao_QueryInterface
-                (
-                  ACE_reinterpret_cast
-                    (
-                      ptr_arith_t,
-                      &IR_FinderDef::_narrow
-                    )
-                )
-          );
-}
-
-IR_FinderDef_ptr
-IR_FinderDef::_duplicate (IR_FinderDef_ptr obj)
-{
-  if (!CORBA::is_nil (obj))
-    obj->_add_ref ();
-  return obj;
-}
-
-CORBA::Boolean IR_FinderDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
-{
-  if (
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/FinderDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/OperationDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/Contained:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
-  return 1; // success using local knowledge
-  else
-    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
-}
-
-void *IR_FinderDef::_tao_QueryInterface (ptr_arith_t type)
-{
-  void *retv = 0;
-  if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_FinderDef::_narrow))
-    retv = ACE_reinterpret_cast (void*, this);
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_OperationDef::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            IR_OperationDef_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_Contained::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            IR_Contained_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &CORBA_IRObject::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            CORBA_IRObject_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
-    retv = ACE_reinterpret_cast (void *,
-      ACE_static_cast (CORBA::Object_ptr, this));
-    
-  if (retv)
-    this->_add_ref ();
-  return retv;
-}
-
-const char* IR_FinderDef::_interface_repository_id (void) const
-{
-  return "IDL:omg.org/IR/FinderDef:1.0";
-}
-
-static const CORBA::Long _oc_IR_FinderDef[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  29, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f46), ACE_NTOHL (0x696e6465), ACE_NTOHL (0x72446566), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/FinderDef:1.0
-  10, ACE_NTOHL (0x46696e64), ACE_NTOHL (0x65724465), ACE_NTOHL (0x66000000),  // name = IR_FinderDef
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_FinderDef (CORBA::tk_objref, sizeof (_oc_IR_FinderDef), (char *) &_oc_IR_FinderDef, 0, sizeof (IR_FinderDef));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_FinderDef, &_tc_TAO_tc_IR_FinderDef)
-TAO_NAMESPACE_END
-
-///////////////////////////////////////////////////////////////////////
-//                Base & Remote Proxy  Implementation. 
-//
-
-_TAO_HomeDef_Proxy_Impl::_TAO_HomeDef_Proxy_Impl (void)
-{}
-
-_TAO_HomeDef_Remote_Proxy_Impl::_TAO_HomeDef_Remote_Proxy_Impl (void)
-{}
-
-// Remote Implementation of the IDL interface methods
-
-IR_HomeDef_ptr _TAO_HomeDef_Remote_Proxy_Impl::base_home (
-    CORBA_Object *_collocated_tao_target_,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  
-  IR_HomeDef_ptr _tao_retval = IR_HomeDef::_nil ();
-  IR_HomeDef_var _tao_safe_retval (_tao_retval);
-  
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-
-  
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_get_base_home",
-      14,
-      0,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_HomeDef::TAO_ClientRequestInfo_IR_HomeDef_base_home_get ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              IR_HomeDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-IR_ComponentDef_ptr _TAO_HomeDef_Remote_Proxy_Impl::managed_component (
-    CORBA_Object *_collocated_tao_target_,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  
-  IR_ComponentDef_ptr _tao_retval = IR_ComponentDef::_nil ();
-  IR_ComponentDef_var _tao_safe_retval (_tao_retval);
-  
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-
-  
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_get_managed_component",
-      22,
-      0,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_HomeDef::TAO_ClientRequestInfo_IR_HomeDef_managed_component_get ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              IR_ComponentDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-IR_PrimaryKeyDef_ptr _TAO_HomeDef_Remote_Proxy_Impl::primary_key (
-    CORBA_Object *_collocated_tao_target_,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  
-  IR_PrimaryKeyDef_ptr _tao_retval = IR_PrimaryKeyDef::_nil ();
-  IR_PrimaryKeyDef_var _tao_safe_retval (_tao_retval);
-  
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-
-  
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_get_primary_key",
-      16,
-      0,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_HomeDef::TAO_ClientRequestInfo_IR_HomeDef_primary_key_get ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              IR_PrimaryKeyDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-IR_FactoryDefSeq * _TAO_HomeDef_Remote_Proxy_Impl::factories (
-    CORBA_Object *_collocated_tao_target_,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  
-  IR_FactoryDefSeq *_tao_retval = 0;
-  
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-
-  
-  ACE_NEW_RETURN (_tao_retval, IR_FactoryDefSeq, _tao_retval);
-  IR_FactoryDefSeq_var _tao_safe_retval (_tao_retval);
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_get_factories",
-      14,
-      0,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_HomeDef::TAO_ClientRequestInfo_IR_HomeDef_factories_get ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              IR_FactoryDefSeq * _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-IR_FinderDefSeq * _TAO_HomeDef_Remote_Proxy_Impl::finders (
-    CORBA_Object *_collocated_tao_target_,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  
-  IR_FinderDefSeq *_tao_retval = 0;
-  
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-
-  
-  ACE_NEW_RETURN (_tao_retval, IR_FinderDefSeq, _tao_retval);
-  IR_FinderDefSeq_var _tao_safe_retval (_tao_retval);
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_get_finders",
-      12,
-      0,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_HomeDef::TAO_ClientRequestInfo_IR_HomeDef_finders_get ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              IR_FinderDefSeq * _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-CORBA::Boolean _TAO_HomeDef_Remote_Proxy_Impl::is_basic (
-    CORBA_Object *_collocated_tao_target_,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  
-  CORBA::Boolean _tao_retval = 0;
-  
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), _tao_retval);
-
-  
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_get_is_basic",
-      13,
-      0,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_HomeDef::TAO_ClientRequestInfo_IR_HomeDef_is_basic_get ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN  (_tao_retval);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                _tao_retval
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> CORBA::Any::to_boolean (_tao_retval))
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                _tao_retval
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              CORBA::Boolean  _tao_retval_info = _tao_retval;
-               ri.result (_tao_retval_info);
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN  (_tao_retval);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_retval;
-}
-
-IR_PrimaryKeyDef_ptr _TAO_HomeDef_Remote_Proxy_Impl::create_primary_key (
-    CORBA_Object *_collocated_tao_target_,
-    const char * id,
-    const char * name,
-    const char * version,
-    IR_ValueDef_ptr primary_key,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  
-  IR_PrimaryKeyDef_ptr _tao_retval = IR_PrimaryKeyDef::_nil ();
-  IR_PrimaryKeyDef_var _tao_safe_retval (_tao_retval);
-  
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-
-  
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "create_primary_key",
-      18,
-      1,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_HomeDef::TAO_ClientRequestInfo_IR_HomeDef_create_primary_key ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        id,
-        name,
-        version,
-        primary_key,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-          if (!(
-                            (_tao_out << id) &&
-              (_tao_out << name) &&
-              (_tao_out << version) &&
-              (_tao_out << primary_key)
-            ))
-            TAO_INTERCEPTOR_THROW_RETURN (
-              CORBA::MARSHAL (),
-              0
-            );
-            
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              IR_PrimaryKeyDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-IR_FactoryDef_ptr _TAO_HomeDef_Remote_Proxy_Impl::create_factory (
-    CORBA_Object *_collocated_tao_target_,
-    const char * id,
-    const char * name,
-    const char * version,
-    const IR_ParDescriptionSeq & params,
-    const IR_ExceptionDefSeq & exceptions,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  
-  IR_FactoryDef_ptr _tao_retval = IR_FactoryDef::_nil ();
-  IR_FactoryDef_var _tao_safe_retval (_tao_retval);
-  
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-
-  
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "create_factory",
-      14,
-      1,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_HomeDef::TAO_ClientRequestInfo_IR_HomeDef_create_factory ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        id,
-        name,
-        version,
-        params,
-        exceptions,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-          if (!(
-                            (_tao_out << id) &&
-              (_tao_out << name) &&
-              (_tao_out << version) &&
-              (_tao_out << params) &&
-              (_tao_out << exceptions)
-            ))
-            TAO_INTERCEPTOR_THROW_RETURN (
-              CORBA::MARSHAL (),
-              0
-            );
-            
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              IR_FactoryDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-IR_FinderDef_ptr _TAO_HomeDef_Remote_Proxy_Impl::create_finder (
-    CORBA_Object *_collocated_tao_target_,
-    const char * id,
-    const char * name,
-    const char * version,
-    const IR_ParDescriptionSeq & params,
-    const IR_ExceptionDefSeq & exceptions,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  
-  IR_FinderDef_ptr _tao_retval = IR_FinderDef::_nil ();
-  IR_FinderDef_var _tao_safe_retval (_tao_retval);
-  
-  
-  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
-
-  
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "create_finder",
-      13,
-      1,
-      istub->orb_core ()
-    );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
-      istub->orb_core ()->client_request_interceptors ()
-    );
-  
-#endif  /* TAO_HAS_INTERCEPTORS */
-  
-  for (;;)
-    {
-      int _invoke_status = TAO_INVOKE_EXCEPTION;
-      
-#if TAO_HAS_INTERCEPTORS == 1
-      IR_HomeDef::TAO_ClientRequestInfo_IR_HomeDef_create_finder ri (
-        &_tao_call,
-        _collocated_tao_target_,
-        id,
-        name,
-        version,
-        params,
-        exceptions,
-        ACE_TRY_ENV
-      );
-      ACE_CHECK_RETURN (0);
-      
-      ACE_TRY
-        {
-#endif /* TAO_HAS_INTERCEPTORS */
-        
-          _tao_call.start (ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
-          TAO_INTERCEPTOR (ri.response_expected (1));
-          
-          TAO_INTERCEPTOR (
-            _tao_vfr.send_request (
-              &ri,
-              ACE_TRY_ENV
-            )
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          _tao_call.prepare_header (
-              ACE_static_cast (CORBA::Octet, _tao_response_flag),
-              ACE_TRY_ENV
-            );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-          if (!(
-                            (_tao_out << id) &&
-              (_tao_out << name) &&
-              (_tao_out << version) &&
-              (_tao_out << params) &&
-              (_tao_out << exceptions)
-            ))
-            TAO_INTERCEPTOR_THROW_RETURN (
-              CORBA::MARSHAL (),
-              0
-            );
-            
-          _invoke_status =
-            _tao_call.invoke (0, 0, ACE_TRY_ENV);
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-          if (_invoke_status == TAO_INVOKE_EXCEPTION)
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-          if (!(
-                            (_tao_in >> _tao_safe_retval.inout ())
-              ))
-            {
-              TAO_INTERCEPTOR_THROW_RETURN (
-                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
-                0
-              );
-              
-            }
-          
-          TAO_INTERCEPTOR (
-              IR_FinderDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
-              ri.result (_tao_retval_info);
-              _tao_safe_retval = _tao_retval_info;
-            );
-          
-          TAO_INTERCEPTOR (
-            ri.reply_status (_invoke_status);
-            if (_invoke_status == TAO_INVOKE_OK)
-              {
-                _tao_vfr.receive_reply (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            else
-              {
-                _tao_vfr.receive_other (
-                  &ri,
-                  ACE_TRY_ENV
-                );
-              }
-            
-          );
-          TAO_INTERCEPTOR_CHECK_RETURN (0);
-          
-#if TAO_HAS_INTERCEPTORS == 1
-        }
-      ACE_CATCH (PortableInterceptor::ForwardRequest, exc)
-        {
-          _invoke_status =
-            _tao_call.location_forward (exc.forward.in (), ACE_TRY_ENV);
-          ACE_TRY_CHECK;
-          
-          ri.forward_reference (exc); 
-          _tao_vfr.receive_other (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-        }
-      ACE_CATCHANY
-        {
-          ri.exception (&ACE_ANY_EXCEPTION);
-          _tao_vfr.receive_exception (
-            &ri,
-            ACE_TRY_ENV
-          );
-          ACE_TRY_CHECK;
-          ACE_RE_THROW;
-        }
-      ACE_ENDTRY;
-      ACE_CHECK_RETURN (0);
-      
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      if (_invoke_status == TAO_INVOKE_RESTART)
-        {
-          _tao_call.restart_flag (1);
-          continue;
-        }
-      
-      break;
-    }
-  return _tao_safe_retval._retn ();
-}
-
-
-//
-//            End  Base & Remote  Proxy Implemeentation. 
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//           Remote & Base  Proxy Broker Implementation
-//
-
-_TAO_HomeDef_Proxy_Broker::_TAO_HomeDef_Proxy_Broker (void)
-{
-}
-
-_TAO_HomeDef_Proxy_Broker::~_TAO_HomeDef_Proxy_Broker (void)
-{
-}
-
-_TAO_HomeDef_Proxy_Broker * (*_TAO_HomeDef_Proxy_Broker_Factory_function_pointer) (
-    CORBA::Object_ptr obj
-  ) = 0;
-
-// Factory Member function Implementation.
-_TAO_HomeDef_Remote_Proxy_Broker *
-_TAO_HomeDef_Remote_Proxy_Broker::the_TAO_HomeDef_Remote_Proxy_Broker (void)
-{
-  static ::_TAO_HomeDef_Remote_Proxy_Broker remote_proxy_broker;
-  return &remote_proxy_broker;
-}
-
-_TAO_HomeDef_Remote_Proxy_Broker::_TAO_HomeDef_Remote_Proxy_Broker (void)
-{
-}
-
-_TAO_HomeDef_Remote_Proxy_Broker::~_TAO_HomeDef_Remote_Proxy_Broker (void)
-{
-}
-
-_TAO_HomeDef_Proxy_Impl&
-_TAO_HomeDef_Remote_Proxy_Broker::select_proxy (
-  ::IR_HomeDef *object,
-  CORBA::Environment &ACE_TRY_ENV
-)
-{
-  ACE_UNUSED_ARG (object);
-  ACE_UNUSED_ARG (ACE_TRY_ENV);
-  return remote_proxy_impl_;
-}
-
-
-//
-//           End Remote & Base Proxy Broker Implementation
-///////////////////////////////////////////////////////////////////////
-
-
-// default constructor
-IR_HomeDef::IR_HomeDef (int collocated)
-{
-  this->IR_HomeDef_setup_collocation (collocated);
-}
-
-// destructor
-IR_HomeDef::~IR_HomeDef (void)
-{}
-
-void
-IR_HomeDef::IR_HomeDef_setup_collocation (int collocated)
-{
-  if (collocated)
-    this->the_TAO_HomeDef_Proxy_Broker_ =
-      _TAO_HomeDef_Proxy_Broker_Factory_function_pointer (this);
-  else
-    this->the_TAO_HomeDef_Proxy_Broker_ =
-      _TAO_HomeDef_Remote_Proxy_Broker::the_TAO_HomeDef_Remote_Proxy_Broker ();
-  
-  this->IR_InterfaceDef_setup_collocation (collocated);
-}
-
-void IR_HomeDef::_tao_any_destructor (void *x)
-{
-  IR_HomeDef *tmp = ACE_static_cast (IR_HomeDef*,x);
-  CORBA::release (tmp);
-}
-
-IR_HomeDef_ptr IR_HomeDef::_narrow (
-    CORBA::Object_ptr obj,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  if (CORBA::is_nil (obj))
-    return IR_HomeDef::_nil ();
-  if (! obj->_is_local ())
-    {
-      CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/IR/HomeDef:1.0", ACE_TRY_ENV);
-      ACE_CHECK_RETURN (IR_HomeDef::_nil ());
-      if (is_a == 0)
-        return IR_HomeDef::_nil ();
-    }
-  return IR_HomeDef::_unchecked_narrow (obj, ACE_TRY_ENV);
-}
-
-IR_HomeDef_ptr IR_HomeDef::_unchecked_narrow (
-    CORBA::Object_ptr obj,
-    CORBA::Environment &
-  )
-{
-  if (CORBA::is_nil (obj))
-    return IR_HomeDef::_nil ();
-  if (! obj->_is_local ())
-    {
-      TAO_Stub* stub = obj->_stubobj ();
-      if (stub)
-        stub->_incr_refcnt ();
-      IR_HomeDef_ptr default_proxy = IR_HomeDef::_nil ();
-
-      if (
-          !CORBA::is_nil (stub->servant_orb_var ().ptr ()) &&
-          stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects () &&
-          obj->_is_collocated () &&_TAO_HomeDef_Proxy_Broker_Factory_function_pointer != 0
-        )
-      {
-        ACE_NEW_RETURN (
-          default_proxy,
-          ::IR_HomeDef (
-            stub,
-            1,
-            obj->_servant ()),
-            
-          IR_HomeDef::_nil ());
-        }
-      if (CORBA::is_nil (default_proxy))
-        ACE_NEW_RETURN (default_proxy, ::IR_HomeDef (stub, 0, obj->_servant ()), IR_HomeDef::_nil ());
-        return default_proxy;
-      }
-    else 
-      return
-        ACE_reinterpret_cast
-          (
-            IR_HomeDef_ptr,
-              obj->_tao_QueryInterface
-                (
-                  ACE_reinterpret_cast
-                    (
-                      ptr_arith_t,
-                      &IR_HomeDef::_narrow
-                    )
-                )
-          );
-}
-
-IR_HomeDef_ptr
-IR_HomeDef::_duplicate (IR_HomeDef_ptr obj)
-{
-  if (!CORBA::is_nil (obj))
-    obj->_add_ref ();
-  return obj;
-}
-
-CORBA::Boolean IR_HomeDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
-{
-  if (
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/HomeDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/InterfaceDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/Container:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/Contained:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/IDLType:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
-  return 1; // success using local knowledge
-  else
-    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
-}
-
-void *IR_HomeDef::_tao_QueryInterface (ptr_arith_t type)
-{
-  void *retv = 0;
-  if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_HomeDef::_narrow))
-    retv = ACE_reinterpret_cast (void*, this);
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_InterfaceDef::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            IR_InterfaceDef_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_Container::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            IR_Container_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_Contained::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            IR_Contained_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &IR_IDLType::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            IR_IDLType_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast
-    (ptr_arith_t,
-      &CORBA_IRObject::_narrow))
-    retv = ACE_reinterpret_cast
-      (
-        void *,
-        ACE_static_cast
-          (
-            CORBA_IRObject_ptr,
-            this
-          )
-      );
-  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
-    retv = ACE_reinterpret_cast (void *,
-      ACE_static_cast (CORBA::Object_ptr, this));
-    
-  if (retv)
-    this->_add_ref ();
-  return retv;
-}
-
-const char* IR_HomeDef::_interface_repository_id (void) const
-{
-  return "IDL:omg.org/IR/HomeDef:1.0";
-}
-
-IR_HomeDef_ptr IR_HomeDef::base_home (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_HomeDef_Proxy_Impl &proxy = 
-    this->the_TAO_HomeDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.base_home (
-      this,
-      ACE_TRY_ENV
-    );
-}
-
-IR_ComponentDef_ptr IR_HomeDef::managed_component (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_HomeDef_Proxy_Impl &proxy = 
-    this->the_TAO_HomeDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.managed_component (
-      this,
-      ACE_TRY_ENV
-    );
-}
-
-IR_PrimaryKeyDef_ptr IR_HomeDef::primary_key (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_HomeDef_Proxy_Impl &proxy = 
-    this->the_TAO_HomeDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.primary_key (
-      this,
-      ACE_TRY_ENV
-    );
-}
-
-IR_FactoryDefSeq * IR_HomeDef::factories (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_HomeDef_Proxy_Impl &proxy = 
-    this->the_TAO_HomeDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.factories (
-      this,
-      ACE_TRY_ENV
-    );
-}
-
-IR_FinderDefSeq * IR_HomeDef::finders (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_HomeDef_Proxy_Impl &proxy = 
-    this->the_TAO_HomeDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.finders (
-      this,
-      ACE_TRY_ENV
-    );
-}
-
-CORBA::Boolean IR_HomeDef::is_basic (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_HomeDef_Proxy_Impl &proxy = 
-    this->the_TAO_HomeDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.is_basic (
-      this,
-      ACE_TRY_ENV
-    );
-}
-
-IR_PrimaryKeyDef_ptr IR_HomeDef::create_primary_key (
-    const char * id,
-    const char * name,
-    const char * version,
-    IR_ValueDef_ptr primary_key,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_HomeDef_Proxy_Impl &proxy = 
-    this->the_TAO_HomeDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.create_primary_key (
-      this,
-      id,
-      name,
-      version,
-      primary_key,
-      ACE_TRY_ENV
-    );
-}
-
-IR_FactoryDef_ptr IR_HomeDef::create_factory (
-    const char * id,
-    const char * name,
-    const char * version,
-    const IR_ParDescriptionSeq & params,
-    const IR_ExceptionDefSeq & exceptions,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_HomeDef_Proxy_Impl &proxy = 
-    this->the_TAO_HomeDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.create_factory (
-      this,
-      id,
-      name,
-      version,
-      params,
-      exceptions,
-      ACE_TRY_ENV
-    );
-}
-
-IR_FinderDef_ptr IR_HomeDef::create_finder (
-    const char * id,
-    const char * name,
-    const char * version,
-    const IR_ParDescriptionSeq & params,
-    const IR_ExceptionDefSeq & exceptions,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  _TAO_HomeDef_Proxy_Impl &proxy = 
-    this->the_TAO_HomeDef_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return proxy.create_finder (
-      this,
-      id,
-      name,
-      version,
-      params,
-      exceptions,
-      ACE_TRY_ENV
-    );
-}
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-IR_HomeDef::TAO_ClientRequestInfo_IR_HomeDef_base_home_get::TAO_ClientRequestInfo_IR_HomeDef_base_home_get (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
-{}
-
-Dynamic::ParameterList *
-IR_HomeDef::TAO_ClientRequestInfo_IR_HomeDef_base_home_get::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return parameter_list;
-}
-
-Dynamic::ExceptionList *
-IR_HomeDef::TAO_ClientRequestInfo_IR_HomeDef_base_home_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_HomeDef::TAO_ClientRequestInfo_IR_HomeDef_base_home_get::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_HomeDef::TAO_ClientRequestInfo_IR_HomeDef_base_home_get::result (IR_HomeDef_ptr result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_HomeDef::TAO_ClientRequestInfo_IR_HomeDef_managed_component_get::TAO_ClientRequestInfo_IR_HomeDef_managed_component_get (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
-{}
-
-Dynamic::ParameterList *
-IR_HomeDef::TAO_ClientRequestInfo_IR_HomeDef_managed_component_get::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return parameter_list;
-}
-
-Dynamic::ExceptionList *
-IR_HomeDef::TAO_ClientRequestInfo_IR_HomeDef_managed_component_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_HomeDef::TAO_ClientRequestInfo_IR_HomeDef_managed_component_get::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_HomeDef::TAO_ClientRequestInfo_IR_HomeDef_managed_component_get::result (IR_ComponentDef_ptr result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_HomeDef::TAO_ClientRequestInfo_IR_HomeDef_primary_key_get::TAO_ClientRequestInfo_IR_HomeDef_primary_key_get (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
-{}
-
-Dynamic::ParameterList *
-IR_HomeDef::TAO_ClientRequestInfo_IR_HomeDef_primary_key_get::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return parameter_list;
-}
-
-Dynamic::ExceptionList *
-IR_HomeDef::TAO_ClientRequestInfo_IR_HomeDef_primary_key_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_HomeDef::TAO_ClientRequestInfo_IR_HomeDef_primary_key_get::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_HomeDef::TAO_ClientRequestInfo_IR_HomeDef_primary_key_get::result (IR_PrimaryKeyDef_ptr result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_HomeDef::TAO_ClientRequestInfo_IR_HomeDef_factories_get::TAO_ClientRequestInfo_IR_HomeDef_factories_get (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
-{}
-
-Dynamic::ParameterList *
-IR_HomeDef::TAO_ClientRequestInfo_IR_HomeDef_factories_get::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return parameter_list;
-}
-
-Dynamic::ExceptionList *
-IR_HomeDef::TAO_ClientRequestInfo_IR_HomeDef_factories_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_HomeDef::TAO_ClientRequestInfo_IR_HomeDef_factories_get::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_HomeDef::TAO_ClientRequestInfo_IR_HomeDef_factories_get::result (IR_FactoryDefSeq * result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_HomeDef::TAO_ClientRequestInfo_IR_HomeDef_finders_get::TAO_ClientRequestInfo_IR_HomeDef_finders_get (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
-{}
-
-Dynamic::ParameterList *
-IR_HomeDef::TAO_ClientRequestInfo_IR_HomeDef_finders_get::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return parameter_list;
-}
-
-Dynamic::ExceptionList *
-IR_HomeDef::TAO_ClientRequestInfo_IR_HomeDef_finders_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_HomeDef::TAO_ClientRequestInfo_IR_HomeDef_finders_get::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_HomeDef::TAO_ClientRequestInfo_IR_HomeDef_finders_get::result (IR_FinderDefSeq * result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_HomeDef::TAO_ClientRequestInfo_IR_HomeDef_is_basic_get::TAO_ClientRequestInfo_IR_HomeDef_is_basic_get (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target)
-{}
-
-Dynamic::ParameterList *
-IR_HomeDef::TAO_ClientRequestInfo_IR_HomeDef_is_basic_get::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return parameter_list;
-}
-
-Dynamic::ExceptionList *
-IR_HomeDef::TAO_ClientRequestInfo_IR_HomeDef_is_basic_get::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_HomeDef::TAO_ClientRequestInfo_IR_HomeDef_is_basic_get::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= CORBA::Any::from_boolean (this->_result);
-  return safe_result_any._retn ();
-}
-
-void 
-IR_HomeDef::TAO_ClientRequestInfo_IR_HomeDef_is_basic_get::result (CORBA::Boolean result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_HomeDef::TAO_ClientRequestInfo_IR_HomeDef_create_primary_key::TAO_ClientRequestInfo_IR_HomeDef_create_primary_key (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    const char * id,
-    const char * name,
-    const char * version,
-    IR_ValueDef_ptr primary_key,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
-    id_ (id),
-    name_ (name),
-    version_ (version),
-    primary_key_ (primary_key)
-{}
-
-Dynamic::ParameterList *
-IR_HomeDef::TAO_ClientRequestInfo_IR_HomeDef_create_primary_key::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
-    
-  CORBA::ULong length_id = parameter_list->length ();
-  parameter_list->length (length_id + 1);
-  (*parameter_list)[length_id].argument <<= id_;
-  (*parameter_list)[length_id].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_name = parameter_list->length ();
-  parameter_list->length (length_name + 1);
-  (*parameter_list)[length_name].argument <<= name_;
-  (*parameter_list)[length_name].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_version = parameter_list->length ();
-  parameter_list->length (length_version + 1);
-  (*parameter_list)[length_version].argument <<= version_;
-  (*parameter_list)[length_version].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_primary_key = parameter_list->length ();
-  parameter_list->length (length_primary_key + 1);
-  (*parameter_list)[length_primary_key].argument <<=  this->primary_key_;
-  
-  (*parameter_list)[length_primary_key].mode = Dynamic::PARAM_IN;
-  
-  return safe_parameter_list._retn ();
-}
-
-Dynamic::ExceptionList *
-IR_HomeDef::TAO_ClientRequestInfo_IR_HomeDef_create_primary_key::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_HomeDef::TAO_ClientRequestInfo_IR_HomeDef_create_primary_key::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_HomeDef::TAO_ClientRequestInfo_IR_HomeDef_create_primary_key::result (IR_PrimaryKeyDef_ptr result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_HomeDef::TAO_ClientRequestInfo_IR_HomeDef_create_factory::TAO_ClientRequestInfo_IR_HomeDef_create_factory (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    const char * id,
-    const char * name,
-    const char * version,
-    const IR_ParDescriptionSeq & params,
-    const IR_ExceptionDefSeq & exceptions,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
-    id_ (id),
-    name_ (name),
-    version_ (version),
-    params_ (params),
-    exceptions_ (exceptions)
-{}
-
-Dynamic::ParameterList *
-IR_HomeDef::TAO_ClientRequestInfo_IR_HomeDef_create_factory::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
-    
-  CORBA::ULong length_id = parameter_list->length ();
-  parameter_list->length (length_id + 1);
-  (*parameter_list)[length_id].argument <<= id_;
-  (*parameter_list)[length_id].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_name = parameter_list->length ();
-  parameter_list->length (length_name + 1);
-  (*parameter_list)[length_name].argument <<= name_;
-  (*parameter_list)[length_name].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_version = parameter_list->length ();
-  parameter_list->length (length_version + 1);
-  (*parameter_list)[length_version].argument <<= version_;
-  (*parameter_list)[length_version].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_params = parameter_list->length ();
-  parameter_list->length (length_params + 1);
-  (*parameter_list)[length_params].argument <<=  this->params_;
-  
-  (*parameter_list)[length_params].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_exceptions = parameter_list->length ();
-  parameter_list->length (length_exceptions + 1);
-  (*parameter_list)[length_exceptions].argument <<=  this->exceptions_;
-  
-  (*parameter_list)[length_exceptions].mode = Dynamic::PARAM_IN;
-  
-  return safe_parameter_list._retn ();
-}
-
-Dynamic::ExceptionList *
-IR_HomeDef::TAO_ClientRequestInfo_IR_HomeDef_create_factory::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_HomeDef::TAO_ClientRequestInfo_IR_HomeDef_create_factory::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_HomeDef::TAO_ClientRequestInfo_IR_HomeDef_create_factory::result (IR_FactoryDef_ptr result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-IR_HomeDef::TAO_ClientRequestInfo_IR_HomeDef_create_finder::TAO_ClientRequestInfo_IR_HomeDef_create_finder (
-    TAO_GIOP_Invocation *_tao_invocation,
-    CORBA::Object_ptr _tao_target,
-    const char * id,
-    const char * name,
-    const char * version,
-    const IR_ParDescriptionSeq & params,
-    const IR_ExceptionDefSeq & exceptions,
-    CORBA::Environment &    
-  )
-  : TAO_ClientRequestInfo (_tao_invocation, _tao_target),
-    id_ (id),
-    name_ (name),
-    version_ (version),
-    params_ (params),
-    exceptions_ (exceptions)
-{}
-
-Dynamic::ParameterList *
-IR_HomeDef::TAO_ClientRequestInfo_IR_HomeDef_create_finder::arguments (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the argument list on demand.
-  Dynamic::ParameterList *parameter_list =
-    TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
-    
-  CORBA::ULong length_id = parameter_list->length ();
-  parameter_list->length (length_id + 1);
-  (*parameter_list)[length_id].argument <<= id_;
-  (*parameter_list)[length_id].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_name = parameter_list->length ();
-  parameter_list->length (length_name + 1);
-  (*parameter_list)[length_name].argument <<= name_;
-  (*parameter_list)[length_name].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_version = parameter_list->length ();
-  parameter_list->length (length_version + 1);
-  (*parameter_list)[length_version].argument <<= version_;
-  (*parameter_list)[length_version].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_params = parameter_list->length ();
-  parameter_list->length (length_params + 1);
-  (*parameter_list)[length_params].argument <<=  this->params_;
-  
-  (*parameter_list)[length_params].mode = Dynamic::PARAM_IN;
-    
-  CORBA::ULong length_exceptions = parameter_list->length ();
-  parameter_list->length (length_exceptions + 1);
-  (*parameter_list)[length_exceptions].argument <<=  this->exceptions_;
-  
-  (*parameter_list)[length_exceptions].mode = Dynamic::PARAM_IN;
-  
-  return safe_parameter_list._retn ();
-}
-
-Dynamic::ExceptionList *
-IR_HomeDef::TAO_ClientRequestInfo_IR_HomeDef_create_finder::exceptions (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the exception list on demand.
-  Dynamic::ExceptionList *exception_list =
-    TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  return exception_list;
-}
-
-
-CORBA::Any * 
-IR_HomeDef::TAO_ClientRequestInfo_IR_HomeDef_create_finder::result (CORBA::Environment &ACE_TRY_ENV)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  // Generate the result on demand.
-  CORBA::Boolean tk_void_any = 0;
-  CORBA::Any *result_any =
-    TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  
-  CORBA::Any_var safe_result_any = result_any;
-  
-  (*result_any) <<= this->_result;
-  return safe_result_any._retn ();
-}
-
-void 
-IR_HomeDef::TAO_ClientRequestInfo_IR_HomeDef_create_finder::result (IR_FinderDef_ptr result)
-{
-  // update the result 
-  this->_result = result;
-}
-
-#endif /* TAO_HAS_INTERCEPTORS */
-
-static const CORBA::Long _oc_IR_HomeDef[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  27, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f48), ACE_NTOHL (0x6f6d6544), ACE_NTOHL (0x65663a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/HomeDef:1.0
-  8, ACE_NTOHL (0x486f6d65), ACE_NTOHL (0x44656600),  // name = IR_HomeDef
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_HomeDef (CORBA::tk_objref, sizeof (_oc_IR_HomeDef), (char *) &_oc_IR_HomeDef, 0, sizeof (IR_HomeDef));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_HomeDef, &_tc_TAO_tc_IR_HomeDef)
-TAO_NAMESPACE_END
-
-static const CORBA::Long _oc_IR_HomeDescription[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f48), ACE_NTOHL (0x6f6d6544), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e3a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/HomeDescription:1.0
-  16, ACE_NTOHL (0x486f6d65), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e00),  // name = HomeDescription
-  12, // member count
-  5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
-  CORBA::tk_alias, // typecode kind for typedefs
-  64, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
-    11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-    CORBA::tk_string, 
-    0U, // string length
-
-  3, ACE_NTOHL (0x69640000),  // name = id
-  CORBA::tk_alias, // typecode kind for typedefs
-  68, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-    13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-    CORBA::tk_string, 
-    0U, // string length
-
-  11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
-  CORBA::tk_alias, // typecode kind for typedefs
-  68, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-    13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-    CORBA::tk_string, 
-    0U, // string length
-
-  8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
-  CORBA::tk_alias, // typecode kind for typedefs
-  64, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
-    12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
-    CORBA::tk_string, 
-    0U, // string length
-
-  10, ACE_NTOHL (0x62617365), ACE_NTOHL (0x5f686f6d), ACE_NTOHL (0x65000000),  // name = base_home
-  CORBA::tk_alias, // typecode kind for typedefs
-  68, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-    13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-    CORBA::tk_string, 
-    0U, // string length
-
-  18, ACE_NTOHL (0x6d616e61), ACE_NTOHL (0x6765645f), ACE_NTOHL (0x636f6d70), ACE_NTOHL (0x6f6e656e), ACE_NTOHL (0x74000000),  // name = managed_component
-  CORBA::tk_alias, // typecode kind for typedefs
-  68, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-    13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-    CORBA::tk_string, 
-    0U, // string length
-
-  16, ACE_NTOHL (0x7072696d), ACE_NTOHL (0x6172795f), ACE_NTOHL (0x6b65795f), ACE_NTOHL (0x64656600),  // name = primary_key_def
-  CORBA::tk_objref, // typecode kind
-  64, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f50), ACE_NTOHL (0x72696d61), ACE_NTOHL (0x72794b65), ACE_NTOHL (0x79446566), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/PrimaryKeyDef:1.0
-    14, ACE_NTOHL (0x5072696d), ACE_NTOHL (0x6172794b), ACE_NTOHL (0x65794465), ACE_NTOHL (0x66000000),  // name = IR_PrimaryKeyDef
-
-  10, ACE_NTOHL (0x66616374), ACE_NTOHL (0x6f726965), ACE_NTOHL (0x73000000),  // name = factories
-  CORBA::tk_alias, // typecode kind for typedefs
-  144, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f46), ACE_NTOHL (0x6163746f), ACE_NTOHL (0x72794465), ACE_NTOHL (0x66536571), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/FactoryDefSeq:1.0
-    14, ACE_NTOHL (0x46616374), ACE_NTOHL (0x6f727944), ACE_NTOHL (0x65665365), ACE_NTOHL (0x71000000),  // name = IR_FactoryDefSeq
-    CORBA::tk_sequence, // typecode kind
-    72, // encapsulation length
-      TAO_ENCAP_BYTE_ORDER, // byte order
-      CORBA::tk_objref, // typecode kind
-      56, // encapsulation length
-        TAO_ENCAP_BYTE_ORDER, // byte order
-        30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f46), ACE_NTOHL (0x6163746f), ACE_NTOHL (0x72794465), ACE_NTOHL (0x663a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/FactoryDef:1.0
-        11, ACE_NTOHL (0x46616374), ACE_NTOHL (0x6f727944), ACE_NTOHL (0x65660000),  // name = IR_FactoryDef
-
-      0U,
-
-
-  8, ACE_NTOHL (0x66696e64), ACE_NTOHL (0x65727300),  // name = finders
-  CORBA::tk_alias, // typecode kind for typedefs
-  140, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f46), ACE_NTOHL (0x696e6465), ACE_NTOHL (0x72446566), ACE_NTOHL (0x5365713a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/FinderDefSeq:1.0
-    13, ACE_NTOHL (0x46696e64), ACE_NTOHL (0x65724465), ACE_NTOHL (0x66536571), ACE_NTOHL (0x0),  // name = IR_FinderDefSeq
-    CORBA::tk_sequence, // typecode kind
-    72, // encapsulation length
-      TAO_ENCAP_BYTE_ORDER, // byte order
-      CORBA::tk_objref, // typecode kind
-      56, // encapsulation length
-        TAO_ENCAP_BYTE_ORDER, // byte order
-        29, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f46), ACE_NTOHL (0x696e6465), ACE_NTOHL (0x72446566), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/FinderDef:1.0
-        10, ACE_NTOHL (0x46696e64), ACE_NTOHL (0x65724465), ACE_NTOHL (0x66000000),  // name = IR_FinderDef
-
-      0U,
-
-
-  11, ACE_NTOHL (0x6f706572), ACE_NTOHL (0x6174696f), ACE_NTOHL (0x6e730000),  // name = operations
-  CORBA::tk_alias, // typecode kind for typedefs
-  1972, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    36, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f4f), ACE_NTOHL (0x70446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x5365713a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/OpDescriptionSeq:1.0
-    17, ACE_NTOHL (0x4f704465), ACE_NTOHL (0x73637269), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e536571), ACE_NTOHL (0x0),  // name = OpDescriptionSeq
-    CORBA::tk_sequence, // typecode kind
-    1896, // encapsulation length
-      TAO_ENCAP_BYTE_ORDER, // byte order
-      CORBA::tk_struct, // typecode kind
-      1880, // encapsulation length
-        TAO_ENCAP_BYTE_ORDER, // byte order
-        40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f4f), ACE_NTOHL (0x70657261), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/OperationDescription:1.0
-        21, ACE_NTOHL (0x4f706572), ACE_NTOHL (0x6174696f), ACE_NTOHL (0x6e446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = OperationDescription
-        9, // member count
-        5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
-        CORBA::tk_alias, // typecode kind for typedefs
-        64, // encapsulation length
-          TAO_ENCAP_BYTE_ORDER, // byte order
-          30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
-          11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-          CORBA::tk_string, 
-          0U, // string length
-
-        3, ACE_NTOHL (0x69640000),  // name = id
-        CORBA::tk_alias, // typecode kind for typedefs
-        68, // encapsulation length
-          TAO_ENCAP_BYTE_ORDER, // byte order
-          32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-          13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-          CORBA::tk_string, 
-          0U, // string length
-
-        11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
-        CORBA::tk_alias, // typecode kind for typedefs
-        68, // encapsulation length
-          TAO_ENCAP_BYTE_ORDER, // byte order
-          32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-          13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-          CORBA::tk_string, 
-          0U, // string length
-
-        8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
-        CORBA::tk_alias, // typecode kind for typedefs
-        64, // encapsulation length
-          TAO_ENCAP_BYTE_ORDER, // byte order
-          31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
-          12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
-          CORBA::tk_string, 
-          0U, // string length
-
-        7, ACE_NTOHL (0x72657375), ACE_NTOHL (0x6c740000),  // name = result
-        CORBA::tk_TypeCode,
-
-        5, ACE_NTOHL (0x6d6f6465), ACE_NTOHL (0x0),  // name = mode
-        CORBA::tk_enum, // typecode kind
-        100, // encapsulation length
-          TAO_ENCAP_BYTE_ORDER, // byte order
-          33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f4f), ACE_NTOHL (0x70657261), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x4d6f6465), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/OperationMode:1.0
-          14, ACE_NTOHL (0x4f706572), ACE_NTOHL (0x6174696f), ACE_NTOHL (0x6e4d6f64), ACE_NTOHL (0x65000000),  // name = OperationMode
-          2, // member count
-          10, ACE_NTOHL (0x4f505f4e), ACE_NTOHL (0x4f524d41), ACE_NTOHL (0x4c000000),  // name = OP_NORMAL
-          10, ACE_NTOHL (0x4f505f4f), ACE_NTOHL (0x4e455741), ACE_NTOHL (0x59000000),  // name = OP_ONEWAY
-
-        9, ACE_NTOHL (0x636f6e74), ACE_NTOHL (0x65787473), ACE_NTOHL (0x0),  // name = contexts
-        CORBA::tk_alias, // typecode kind for typedefs
-        228, // encapsulation length
-          TAO_ENCAP_BYTE_ORDER, // byte order
-          32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f43), ACE_NTOHL (0x6f6e7465), ACE_NTOHL (0x78744964), ACE_NTOHL (0x5365713a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ContextIdSeq:1.0
-          13, ACE_NTOHL (0x436f6e74), ACE_NTOHL (0x65787449), ACE_NTOHL (0x64536571), ACE_NTOHL (0x0),  // name = ContextIdSeq
-          CORBA::tk_sequence, // typecode kind
-          160, // encapsulation length
-            TAO_ENCAP_BYTE_ORDER, // byte order
-            CORBA::tk_alias, // typecode kind for typedefs
-            144, // encapsulation length
-              TAO_ENCAP_BYTE_ORDER, // byte order
-              37, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f43), ACE_NTOHL (0x6f6e7465), ACE_NTOHL (0x78744964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/ContextIdentifier:1.0
-              18, ACE_NTOHL (0x436f6e74), ACE_NTOHL (0x65787449), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x72000000),  // name = ContextIdentifier
-              CORBA::tk_alias, // typecode kind for typedefs
-              64, // encapsulation length
-                TAO_ENCAP_BYTE_ORDER, // byte order
-                30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
-                11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-                CORBA::tk_string, 
-                0U, // string length
-
-
-            0U,
-
-
-        11, ACE_NTOHL (0x70617261), ACE_NTOHL (0x6d657465), ACE_NTOHL (0x72730000),  // name = parameters
-        CORBA::tk_alias, // typecode kind for typedefs
-        484, // encapsulation length
-          TAO_ENCAP_BYTE_ORDER, // byte order
-          37, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f50), ACE_NTOHL (0x61724465), ACE_NTOHL (0x73637269), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e536571), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/ParDescriptionSeq:1.0
-          18, ACE_NTOHL (0x50617244), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e5365), ACE_NTOHL (0x71000000),  // name = ParDescriptionSeq
-          CORBA::tk_sequence, // typecode kind
-          404, // encapsulation length
-            TAO_ENCAP_BYTE_ORDER, // byte order
-            CORBA::tk_struct, // typecode kind
-            388, // encapsulation length
-              TAO_ENCAP_BYTE_ORDER, // byte order
-              40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f50), ACE_NTOHL (0x6172616d), ACE_NTOHL (0x65746572), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ParameterDescription:1.0
-              21, ACE_NTOHL (0x50617261), ACE_NTOHL (0x6d657465), ACE_NTOHL (0x72446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = ParameterDescription
-              4, // member count
-              5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
-              CORBA::tk_alias, // typecode kind for typedefs
-              64, // encapsulation length
-                TAO_ENCAP_BYTE_ORDER, // byte order
-                30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
-                11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-                CORBA::tk_string, 
-                0U, // string length
-
-              5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
-              CORBA::tk_TypeCode,
-
-              9, ACE_NTOHL (0x74797065), ACE_NTOHL (0x5f646566), ACE_NTOHL (0x0),  // name = type_def
-              CORBA::tk_objref, // typecode kind
-              48, // encapsulation length
-                TAO_ENCAP_BYTE_ORDER, // byte order
-                27, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x444c5479), ACE_NTOHL (0x70653a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/IDLType:1.0
-                8, ACE_NTOHL (0x49444c54), ACE_NTOHL (0x79706500),  // name = IR_IDLType
-
-              5, ACE_NTOHL (0x6d6f6465), ACE_NTOHL (0x0),  // name = mode
-              CORBA::tk_enum, // typecode kind
-              116, // encapsulation length
-                TAO_ENCAP_BYTE_ORDER, // byte order
-                33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f50), ACE_NTOHL (0x6172616d), ACE_NTOHL (0x65746572), ACE_NTOHL (0x4d6f6465), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/ParameterMode:1.0
-                14, ACE_NTOHL (0x50617261), ACE_NTOHL (0x6d657465), ACE_NTOHL (0x724d6f64), ACE_NTOHL (0x65000000),  // name = ParameterMode
-                3, // member count
-                9, ACE_NTOHL (0x50415241), ACE_NTOHL (0x4d5f494e), ACE_NTOHL (0x0),  // name = PARAM_IN
-                10, ACE_NTOHL (0x50415241), ACE_NTOHL (0x4d5f4f55), ACE_NTOHL (0x54000000),  // name = PARAM_OUT
-                12, ACE_NTOHL (0x50415241), ACE_NTOHL (0x4d5f494e), ACE_NTOHL (0x4f555400),  // name = PARAM_INOUT
-
-
-            0U,
-
-
-        11, ACE_NTOHL (0x65786365), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e730000),  // name = exceptions
-        CORBA::tk_alias, // typecode kind for typedefs
-        536, // encapsulation length
-          TAO_ENCAP_BYTE_ORDER, // byte order
-          37, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x78634465), ACE_NTOHL (0x73637269), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e536571), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/ExcDescriptionSeq:1.0
-          18, ACE_NTOHL (0x45786344), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e5365), ACE_NTOHL (0x71000000),  // name = ExcDescriptionSeq
-          CORBA::tk_sequence, // typecode kind
-          456, // encapsulation length
-            TAO_ENCAP_BYTE_ORDER, // byte order
-            CORBA::tk_struct, // typecode kind
-            440, // encapsulation length
-              TAO_ENCAP_BYTE_ORDER, // byte order
-              40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x78636570), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ExceptionDescription:1.0
-              21, ACE_NTOHL (0x45786365), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = ExceptionDescription
-              5, // member count
-              5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
-              CORBA::tk_alias, // typecode kind for typedefs
-              64, // encapsulation length
-                TAO_ENCAP_BYTE_ORDER, // byte order
-                30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
-                11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-                CORBA::tk_string, 
-                0U, // string length
-
-              3, ACE_NTOHL (0x69640000),  // name = id
-              CORBA::tk_alias, // typecode kind for typedefs
-              68, // encapsulation length
-                TAO_ENCAP_BYTE_ORDER, // byte order
-                32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-                13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-                CORBA::tk_string, 
-                0U, // string length
-
-              11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
-              CORBA::tk_alias, // typecode kind for typedefs
-              68, // encapsulation length
-                TAO_ENCAP_BYTE_ORDER, // byte order
-                32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-                13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-                CORBA::tk_string, 
-                0U, // string length
-
-              8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
-              CORBA::tk_alias, // typecode kind for typedefs
-              64, // encapsulation length
-                TAO_ENCAP_BYTE_ORDER, // byte order
-                31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
-                12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
-                CORBA::tk_string, 
-                0U, // string length
-
-              5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
-              CORBA::tk_TypeCode,
-
-
-            0U,
-
-
-
-      0U,
-
-
-  11, ACE_NTOHL (0x61747472), ACE_NTOHL (0x69627574), ACE_NTOHL (0x65730000),  // name = attributes
-  CORBA::tk_alias, // typecode kind for typedefs
-  1788, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    38, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f41), ACE_NTOHL (0x74747244), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e5365), ACE_NTOHL (0x713a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/AttrDescriptionSeq:1.0
-    19, ACE_NTOHL (0x41747472), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x65710000),  // name = AttrDescriptionSeq
-    CORBA::tk_sequence, // typecode kind
-    1708, // encapsulation length
-      TAO_ENCAP_BYTE_ORDER, // byte order
-      CORBA::tk_struct, // typecode kind
-      1692, // encapsulation length
-        TAO_ENCAP_BYTE_ORDER, // byte order
-        40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f41), ACE_NTOHL (0x74747269), ACE_NTOHL (0x62757465), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/AttributeDescription:1.0
-        21, ACE_NTOHL (0x41747472), ACE_NTOHL (0x69627574), ACE_NTOHL (0x65446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = AttributeDescription
-        8, // member count
-        5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
-        CORBA::tk_alias, // typecode kind for typedefs
-        64, // encapsulation length
-          TAO_ENCAP_BYTE_ORDER, // byte order
-          30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
-          11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-          CORBA::tk_string, 
-          0U, // string length
-
-        3, ACE_NTOHL (0x69640000),  // name = id
-        CORBA::tk_alias, // typecode kind for typedefs
-        68, // encapsulation length
-          TAO_ENCAP_BYTE_ORDER, // byte order
-          32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-          13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-          CORBA::tk_string, 
-          0U, // string length
-
-        11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
-        CORBA::tk_alias, // typecode kind for typedefs
-        68, // encapsulation length
-          TAO_ENCAP_BYTE_ORDER, // byte order
-          32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-          13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-          CORBA::tk_string, 
-          0U, // string length
-
-        8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
-        CORBA::tk_alias, // typecode kind for typedefs
-        64, // encapsulation length
-          TAO_ENCAP_BYTE_ORDER, // byte order
-          31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
-          12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
-          CORBA::tk_string, 
-          0U, // string length
-
-        5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
-        CORBA::tk_TypeCode,
-
-        5, ACE_NTOHL (0x6d6f6465), ACE_NTOHL (0x0),  // name = mode
-        CORBA::tk_enum, // typecode kind
-        104, // encapsulation length
-          TAO_ENCAP_BYTE_ORDER, // byte order
-          33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f41), ACE_NTOHL (0x74747269), ACE_NTOHL (0x62757465), ACE_NTOHL (0x4d6f6465), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/AttributeMode:1.0
-          14, ACE_NTOHL (0x41747472), ACE_NTOHL (0x69627574), ACE_NTOHL (0x654d6f64), ACE_NTOHL (0x65000000),  // name = AttributeMode
-          2, // member count
-          12, ACE_NTOHL (0x41545452), ACE_NTOHL (0x5f4e4f52), ACE_NTOHL (0x4d414c00),  // name = ATTR_NORMAL
-          14, ACE_NTOHL (0x41545452), ACE_NTOHL (0x5f524541), ACE_NTOHL (0x444f4e4c), ACE_NTOHL (0x59000000),  // name = ATTR_READONLY
-
-        15, ACE_NTOHL (0x6765745f), ACE_NTOHL (0x65786365), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e730000),  // name = get_exceptions
-        CORBA::tk_alias, // typecode kind for typedefs
-        536, // encapsulation length
-          TAO_ENCAP_BYTE_ORDER, // byte order
-          37, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x78634465), ACE_NTOHL (0x73637269), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e536571), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/ExcDescriptionSeq:1.0
-          18, ACE_NTOHL (0x45786344), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e5365), ACE_NTOHL (0x71000000),  // name = ExcDescriptionSeq
-          CORBA::tk_sequence, // typecode kind
-          456, // encapsulation length
-            TAO_ENCAP_BYTE_ORDER, // byte order
-            CORBA::tk_struct, // typecode kind
-            440, // encapsulation length
-              TAO_ENCAP_BYTE_ORDER, // byte order
-              40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x78636570), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ExceptionDescription:1.0
-              21, ACE_NTOHL (0x45786365), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = ExceptionDescription
-              5, // member count
-              5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
-              CORBA::tk_alias, // typecode kind for typedefs
-              64, // encapsulation length
-                TAO_ENCAP_BYTE_ORDER, // byte order
-                30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
-                11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-                CORBA::tk_string, 
-                0U, // string length
-
-              3, ACE_NTOHL (0x69640000),  // name = id
-              CORBA::tk_alias, // typecode kind for typedefs
-              68, // encapsulation length
-                TAO_ENCAP_BYTE_ORDER, // byte order
-                32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-                13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-                CORBA::tk_string, 
-                0U, // string length
-
-              11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
-              CORBA::tk_alias, // typecode kind for typedefs
-              68, // encapsulation length
-                TAO_ENCAP_BYTE_ORDER, // byte order
-                32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-                13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-                CORBA::tk_string, 
-                0U, // string length
-
-              8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
-              CORBA::tk_alias, // typecode kind for typedefs
-              64, // encapsulation length
-                TAO_ENCAP_BYTE_ORDER, // byte order
-                31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
-                12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
-                CORBA::tk_string, 
-                0U, // string length
-
-              5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
-              CORBA::tk_TypeCode,
-
-
-            0U,
-
-
-        15, ACE_NTOHL (0x7075745f), ACE_NTOHL (0x65786365), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e730000),  // name = put_exceptions
-        CORBA::tk_alias, // typecode kind for typedefs
-        536, // encapsulation length
-          TAO_ENCAP_BYTE_ORDER, // byte order
-          37, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x78634465), ACE_NTOHL (0x73637269), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e536571), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/ExcDescriptionSeq:1.0
-          18, ACE_NTOHL (0x45786344), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e5365), ACE_NTOHL (0x71000000),  // name = ExcDescriptionSeq
-          CORBA::tk_sequence, // typecode kind
-          456, // encapsulation length
-            TAO_ENCAP_BYTE_ORDER, // byte order
-            CORBA::tk_struct, // typecode kind
-            440, // encapsulation length
-              TAO_ENCAP_BYTE_ORDER, // byte order
-              40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x78636570), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ExceptionDescription:1.0
-              21, ACE_NTOHL (0x45786365), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = ExceptionDescription
-              5, // member count
-              5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
-              CORBA::tk_alias, // typecode kind for typedefs
-              64, // encapsulation length
-                TAO_ENCAP_BYTE_ORDER, // byte order
-                30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
-                11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-                CORBA::tk_string, 
-                0U, // string length
-
-              3, ACE_NTOHL (0x69640000),  // name = id
-              CORBA::tk_alias, // typecode kind for typedefs
-              68, // encapsulation length
-                TAO_ENCAP_BYTE_ORDER, // byte order
-                32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-                13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-                CORBA::tk_string, 
-                0U, // string length
-
-              11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
-              CORBA::tk_alias, // typecode kind for typedefs
-              68, // encapsulation length
-                TAO_ENCAP_BYTE_ORDER, // byte order
-                32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
-                13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-                CORBA::tk_string, 
-                0U, // string length
-
-              8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
-              CORBA::tk_alias, // typecode kind for typedefs
-              64, // encapsulation length
-                TAO_ENCAP_BYTE_ORDER, // byte order
-                31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
-                12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
-                CORBA::tk_string, 
-                0U, // string length
-
-              5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
-              CORBA::tk_TypeCode,
-
-
-            0U,
-
-
-
-      0U,
-
-
-  9, ACE_NTOHL (0x69735f62), ACE_NTOHL (0x61736963), ACE_NTOHL (0x0),  // name = is_basic
-  CORBA::tk_boolean,
-
-};
-static CORBA::TypeCode _tc_TAO_tc_IR_HomeDescription (CORBA::tk_struct, sizeof (_oc_IR_HomeDescription), (char *) &_oc_IR_HomeDescription, 0, sizeof (IR_HomeDescription));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (IR)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_HomeDescription, &_tc_TAO_tc_IR_HomeDescription)
-TAO_NAMESPACE_END
-
-void IR_HomeDescription::_tao_any_destructor (void *x)
-{
-  IR_HomeDescription *tmp = ACE_static_cast (IR_HomeDescription*,x);
-  delete tmp;
-}
-
-void operator<<= (CORBA::Any &_tao_any, IR_DefinitionKind _tao_elem)
-{
-  TAO_OutputCDR stream;
-  stream << _tao_elem;
-  _tao_any._tao_replace (
-      IR::_tc_DefinitionKind,
-      TAO_ENCAP_BYTE_ORDER,
-      stream.begin ()
-    );
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR_DefinitionKind &_tao_elem)
-{
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (IR::_tc_DefinitionKind, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    TAO_InputCDR stream (
-        _tao_any._tao_get_cdr (),
-        _tao_any._tao_byte_order ()
-      );
-    if (stream >> _tao_elem)
-    {
-      return 1;
-    }
-  }
-  ACE_CATCHANY
-  {
-    return 0;
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-void operator<<= (CORBA::Any &_tao_any, CORBA_IRObject_ptr _tao_elem)
-{
-  TAO_OutputCDR stream;
-  if (stream << _tao_elem)
-  {
-    _tao_any._tao_replace (
-        CORBA::_tc_IRObject, 
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin (),
-        1,
-        CORBA_IRObject::_duplicate (_tao_elem),
-        CORBA_IRObject::_tao_any_destructor
-      );
-  }
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA_IRObject_ptr &_tao_elem)
-{
-  ACE_TRY_NEW_ENV
-  {
-    _tao_elem = CORBA_IRObject::_nil ();
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (CORBA::_tc_IRObject, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    TAO_InputCDR stream (
-        _tao_any._tao_get_cdr (),
-        _tao_any._tao_byte_order ()
-      );
-    if (stream >> _tao_elem)
-    {
-      ((CORBA::Any *)&_tao_any)->_tao_replace (
-          CORBA::_tc_IRObject,
-          1,
-          _tao_elem,
-          CORBA_IRObject::_tao_any_destructor
-        );
-      return 1;
-    }
-  }
-  ACE_CATCHANY
-  {
-    _tao_elem = CORBA_IRObject::_nil ();
-    return 0;
-  }
-  ACE_ENDTRY;
-  _tao_elem = CORBA_IRObject::_nil ();
-  return 0;
-}
-
-#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
-    defined (ACE_HAS_GNU_REPO)
-    template class TAO_Object_Manager<CORBA_IRObject,CORBA_IRObject_var>;
-  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
-  #  pragma instantiate TAO_Object_Manager<CORBA_IRObject,CORBA_IRObject_var>
-#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
-
-void operator<<= (CORBA::Any &_tao_any, IR_Contained_ptr _tao_elem)
-{
-  TAO_OutputCDR stream;
-  if (stream << _tao_elem)
-  {
-    _tao_any._tao_replace (
-        IR::_tc_Contained, 
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin (),
-        1,
-        IR_Contained::_duplicate (_tao_elem),
-        IR_Contained::_tao_any_destructor
-      );
-  }
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR_Contained_ptr &_tao_elem)
-{
-  ACE_TRY_NEW_ENV
-  {
-    _tao_elem = IR_Contained::_nil ();
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (IR::_tc_Contained, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    TAO_InputCDR stream (
-        _tao_any._tao_get_cdr (),
-        _tao_any._tao_byte_order ()
-      );
-    if (stream >> _tao_elem)
-    {
-      ((CORBA::Any *)&_tao_any)->_tao_replace (
-          IR::_tc_Contained,
-          1,
-          _tao_elem,
-          IR_Contained::_tao_any_destructor
-        );
-      return 1;
-    }
-  }
-  ACE_CATCHANY
-  {
-    _tao_elem = IR_Contained::_nil ();
-    return 0;
-  }
-  ACE_ENDTRY;
-  _tao_elem = IR_Contained::_nil ();
-  return 0;
-}
-
-#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
-    defined (ACE_HAS_GNU_REPO)
-    template class TAO_Object_Manager<IR_Contained,IR_Contained_var>;
-  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
-  #  pragma instantiate TAO_Object_Manager<IR_Contained,IR_Contained_var>
-#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
-
-void operator<<= (CORBA::Any &_tao_any, const IR_Contained::Description &_tao_elem) // copying
-{
-  TAO_OutputCDR stream;
-  stream << _tao_elem;
-  _tao_any._tao_replace (
-      IR_Contained::_tc_Description,
-      TAO_ENCAP_BYTE_ORDER,
-      stream.begin ()
-    );
-}
-
-void operator<<= (CORBA::Any &_tao_any, IR_Contained::Description *_tao_elem) // non copying
-{
-  TAO_OutputCDR stream;
-  stream << *_tao_elem;
-  _tao_any._tao_replace (
-      IR_Contained::_tc_Description,
-      TAO_ENCAP_BYTE_ORDER,
-      stream.begin (),
-      1,
-      _tao_elem,
-      IR_Contained::Description::_tao_any_destructor
-    );
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR_Contained::Description *&_tao_elem)
-{
-  return _tao_any >>= ACE_const_cast(const IR_Contained::Description*&,_tao_elem);
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR_Contained::Description *&_tao_elem)
-{
-  _tao_elem = 0;
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (IR_Contained::_tc_Description, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    if (_tao_any.any_owns_data ())
-    {
-      _tao_elem = ACE_static_cast(
-          const IR_Contained::Description*,
-          _tao_any.value ()
-        );
-      return 1;
-    }
-    else
-    {
-      IR_Contained::Description *tmp;
-      ACE_NEW_RETURN (tmp, IR_Contained::Description, 0);
-      TAO_InputCDR stream (
-          _tao_any._tao_get_cdr (),
-          _tao_any._tao_byte_order ()
-        );
-      if (stream >> *tmp)
-      {
-        ((CORBA::Any *)&_tao_any)->_tao_replace (
-            IR_Contained::_tc_Description,
-            1,
-            ACE_static_cast (void *, tmp),
-            IR_Contained::Description::_tao_any_destructor
-          );
-        _tao_elem = tmp;
-        return 1;
-      }
-      else
-      {
-        delete tmp;
-      }
-    }
-  }
-  ACE_CATCHANY
-  {
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-void operator<<= (
-    CORBA::Any &_tao_any,
-    const IR_InterfaceDefSeq &_tao_elem
-  ) // copying
-{
-  TAO_OutputCDR stream;
-  if (stream << _tao_elem)
-  {
-    _tao_any._tao_replace (
-        IR::_tc_InterfaceDefSeq,
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin ()
-      );
-  }
-}
-
-void operator<<= (CORBA::Any &_tao_any, IR_InterfaceDefSeq *_tao_elem) // non copying
-{
-  TAO_OutputCDR stream;
-  stream << *_tao_elem;
-  _tao_any._tao_replace (
-      IR::_tc_InterfaceDefSeq,
-      TAO_ENCAP_BYTE_ORDER,
-      stream.begin (),
-      1,
-      _tao_elem,
-      IR_InterfaceDefSeq::_tao_any_destructor
-    );
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR_InterfaceDefSeq *&_tao_elem)
-{
-  return _tao_any >>= ACE_const_cast(
-      const IR_InterfaceDefSeq*&,
-      _tao_elem
-    );
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR_InterfaceDefSeq *&_tao_elem)
-{
-  _tao_elem = 0;
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (IR::_tc_InterfaceDefSeq, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    if (_tao_any.any_owns_data ())
-    {
-      _tao_elem = ACE_static_cast(
-          const IR_InterfaceDefSeq*,
-          _tao_any.value ()
-        );
-      return 1;
-    }
-    else
-    {
-      IR_InterfaceDefSeq *tmp;
-      ACE_NEW_RETURN (tmp, IR_InterfaceDefSeq, 0);
-      TAO_InputCDR stream (
-          _tao_any._tao_get_cdr (),
-          _tao_any._tao_byte_order ()
-        );
-      if (stream >> *tmp)
-      {
-        ((CORBA::Any *)&_tao_any)->_tao_replace (
-            IR::_tc_InterfaceDefSeq,
-            1,
-            ACE_static_cast (void *, tmp),
-            IR_InterfaceDefSeq::_tao_any_destructor
-          );
-        _tao_elem = tmp;
-        return 1;
-      }
-      else
-      {
-        delete tmp;
-      }
-    }
-  }
-  ACE_CATCHANY
-  {
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-void operator<<= (
-    CORBA::Any &_tao_any,
-    const IR_ValueDefSeq &_tao_elem
-  ) // copying
-{
-  TAO_OutputCDR stream;
-  if (stream << _tao_elem)
-  {
-    _tao_any._tao_replace (
-        IR::_tc_ValueDefSeq,
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin ()
-      );
-  }
-}
-
-void operator<<= (CORBA::Any &_tao_any, IR_ValueDefSeq *_tao_elem) // non copying
-{
-  TAO_OutputCDR stream;
-  stream << *_tao_elem;
-  _tao_any._tao_replace (
-      IR::_tc_ValueDefSeq,
-      TAO_ENCAP_BYTE_ORDER,
-      stream.begin (),
-      1,
-      _tao_elem,
-      IR_ValueDefSeq::_tao_any_destructor
-    );
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR_ValueDefSeq *&_tao_elem)
-{
-  return _tao_any >>= ACE_const_cast(
-      const IR_ValueDefSeq*&,
-      _tao_elem
-    );
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR_ValueDefSeq *&_tao_elem)
-{
-  _tao_elem = 0;
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (IR::_tc_ValueDefSeq, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    if (_tao_any.any_owns_data ())
-    {
-      _tao_elem = ACE_static_cast(
-          const IR_ValueDefSeq*,
-          _tao_any.value ()
-        );
-      return 1;
-    }
-    else
-    {
-      IR_ValueDefSeq *tmp;
-      ACE_NEW_RETURN (tmp, IR_ValueDefSeq, 0);
-      TAO_InputCDR stream (
-          _tao_any._tao_get_cdr (),
-          _tao_any._tao_byte_order ()
-        );
-      if (stream >> *tmp)
-      {
-        ((CORBA::Any *)&_tao_any)->_tao_replace (
-            IR::_tc_ValueDefSeq,
-            1,
-            ACE_static_cast (void *, tmp),
-            IR_ValueDefSeq::_tao_any_destructor
-          );
-        _tao_elem = tmp;
-        return 1;
-      }
-      else
-      {
-        delete tmp;
-      }
-    }
-  }
-  ACE_CATCHANY
-  {
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-void operator<<= (
-    CORBA::Any &_tao_any,
-    const IR_ComponentDefSeq &_tao_elem
-  ) // copying
-{
-  TAO_OutputCDR stream;
-  if (stream << _tao_elem)
-  {
-    _tao_any._tao_replace (
-        IR::_tc_ComponentDefSeq,
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin ()
-      );
-  }
-}
-
-void operator<<= (CORBA::Any &_tao_any, IR_ComponentDefSeq *_tao_elem) // non copying
-{
-  TAO_OutputCDR stream;
-  stream << *_tao_elem;
-  _tao_any._tao_replace (
-      IR::_tc_ComponentDefSeq,
-      TAO_ENCAP_BYTE_ORDER,
-      stream.begin (),
-      1,
-      _tao_elem,
-      IR_ComponentDefSeq::_tao_any_destructor
-    );
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR_ComponentDefSeq *&_tao_elem)
-{
-  return _tao_any >>= ACE_const_cast(
-      const IR_ComponentDefSeq*&,
-      _tao_elem
-    );
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR_ComponentDefSeq *&_tao_elem)
-{
-  _tao_elem = 0;
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (IR::_tc_ComponentDefSeq, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    if (_tao_any.any_owns_data ())
-    {
-      _tao_elem = ACE_static_cast(
-          const IR_ComponentDefSeq*,
-          _tao_any.value ()
-        );
-      return 1;
-    }
-    else
-    {
-      IR_ComponentDefSeq *tmp;
-      ACE_NEW_RETURN (tmp, IR_ComponentDefSeq, 0);
-      TAO_InputCDR stream (
-          _tao_any._tao_get_cdr (),
-          _tao_any._tao_byte_order ()
-        );
-      if (stream >> *tmp)
-      {
-        ((CORBA::Any *)&_tao_any)->_tao_replace (
-            IR::_tc_ComponentDefSeq,
-            1,
-            ACE_static_cast (void *, tmp),
-            IR_ComponentDefSeq::_tao_any_destructor
-          );
-        _tao_elem = tmp;
-        return 1;
-      }
-      else
-      {
-        delete tmp;
-      }
-    }
-  }
-  ACE_CATCHANY
-  {
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-void operator<<= (
-    CORBA::Any &_tao_any,
-    const IR_ProvidesDefSeq &_tao_elem
-  ) // copying
-{
-  TAO_OutputCDR stream;
-  if (stream << _tao_elem)
-  {
-    _tao_any._tao_replace (
-        IR::_tc_ProvidesDefSeq,
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin ()
-      );
-  }
-}
-
-void operator<<= (CORBA::Any &_tao_any, IR_ProvidesDefSeq *_tao_elem) // non copying
-{
-  TAO_OutputCDR stream;
-  stream << *_tao_elem;
-  _tao_any._tao_replace (
-      IR::_tc_ProvidesDefSeq,
-      TAO_ENCAP_BYTE_ORDER,
-      stream.begin (),
-      1,
-      _tao_elem,
-      IR_ProvidesDefSeq::_tao_any_destructor
-    );
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR_ProvidesDefSeq *&_tao_elem)
-{
-  return _tao_any >>= ACE_const_cast(
-      const IR_ProvidesDefSeq*&,
-      _tao_elem
-    );
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR_ProvidesDefSeq *&_tao_elem)
-{
-  _tao_elem = 0;
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (IR::_tc_ProvidesDefSeq, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    if (_tao_any.any_owns_data ())
-    {
-      _tao_elem = ACE_static_cast(
-          const IR_ProvidesDefSeq*,
-          _tao_any.value ()
-        );
-      return 1;
-    }
-    else
-    {
-      IR_ProvidesDefSeq *tmp;
-      ACE_NEW_RETURN (tmp, IR_ProvidesDefSeq, 0);
-      TAO_InputCDR stream (
-          _tao_any._tao_get_cdr (),
-          _tao_any._tao_byte_order ()
-        );
-      if (stream >> *tmp)
-      {
-        ((CORBA::Any *)&_tao_any)->_tao_replace (
-            IR::_tc_ProvidesDefSeq,
-            1,
-            ACE_static_cast (void *, tmp),
-            IR_ProvidesDefSeq::_tao_any_destructor
-          );
-        _tao_elem = tmp;
-        return 1;
-      }
-      else
-      {
-        delete tmp;
-      }
-    }
-  }
-  ACE_CATCHANY
-  {
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-void operator<<= (
-    CORBA::Any &_tao_any,
-    const IR_UsesDefSeq &_tao_elem
-  ) // copying
-{
-  TAO_OutputCDR stream;
-  if (stream << _tao_elem)
-  {
-    _tao_any._tao_replace (
-        IR::_tc_UsesDefSeq,
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin ()
-      );
-  }
-}
-
-void operator<<= (CORBA::Any &_tao_any, IR_UsesDefSeq *_tao_elem) // non copying
-{
-  TAO_OutputCDR stream;
-  stream << *_tao_elem;
-  _tao_any._tao_replace (
-      IR::_tc_UsesDefSeq,
-      TAO_ENCAP_BYTE_ORDER,
-      stream.begin (),
-      1,
-      _tao_elem,
-      IR_UsesDefSeq::_tao_any_destructor
-    );
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR_UsesDefSeq *&_tao_elem)
-{
-  return _tao_any >>= ACE_const_cast(
-      const IR_UsesDefSeq*&,
-      _tao_elem
-    );
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR_UsesDefSeq *&_tao_elem)
-{
-  _tao_elem = 0;
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (IR::_tc_UsesDefSeq, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    if (_tao_any.any_owns_data ())
-    {
-      _tao_elem = ACE_static_cast(
-          const IR_UsesDefSeq*,
-          _tao_any.value ()
-        );
-      return 1;
-    }
-    else
-    {
-      IR_UsesDefSeq *tmp;
-      ACE_NEW_RETURN (tmp, IR_UsesDefSeq, 0);
-      TAO_InputCDR stream (
-          _tao_any._tao_get_cdr (),
-          _tao_any._tao_byte_order ()
-        );
-      if (stream >> *tmp)
-      {
-        ((CORBA::Any *)&_tao_any)->_tao_replace (
-            IR::_tc_UsesDefSeq,
-            1,
-            ACE_static_cast (void *, tmp),
-            IR_UsesDefSeq::_tao_any_destructor
-          );
-        _tao_elem = tmp;
-        return 1;
-      }
-      else
-      {
-        delete tmp;
-      }
-    }
-  }
-  ACE_CATCHANY
-  {
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-void operator<<= (
-    CORBA::Any &_tao_any,
-    const IR_HomeDefSeq &_tao_elem
-  ) // copying
-{
-  TAO_OutputCDR stream;
-  if (stream << _tao_elem)
-  {
-    _tao_any._tao_replace (
-        IR::_tc_HomeDefSeq,
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin ()
-      );
-  }
-}
-
-void operator<<= (CORBA::Any &_tao_any, IR_HomeDefSeq *_tao_elem) // non copying
-{
-  TAO_OutputCDR stream;
-  stream << *_tao_elem;
-  _tao_any._tao_replace (
-      IR::_tc_HomeDefSeq,
-      TAO_ENCAP_BYTE_ORDER,
-      stream.begin (),
-      1,
-      _tao_elem,
-      IR_HomeDefSeq::_tao_any_destructor
-    );
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR_HomeDefSeq *&_tao_elem)
-{
-  return _tao_any >>= ACE_const_cast(
-      const IR_HomeDefSeq*&,
-      _tao_elem
-    );
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR_HomeDefSeq *&_tao_elem)
-{
-  _tao_elem = 0;
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (IR::_tc_HomeDefSeq, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    if (_tao_any.any_owns_data ())
-    {
-      _tao_elem = ACE_static_cast(
-          const IR_HomeDefSeq*,
-          _tao_any.value ()
-        );
-      return 1;
-    }
-    else
-    {
-      IR_HomeDefSeq *tmp;
-      ACE_NEW_RETURN (tmp, IR_HomeDefSeq, 0);
-      TAO_InputCDR stream (
-          _tao_any._tao_get_cdr (),
-          _tao_any._tao_byte_order ()
-        );
-      if (stream >> *tmp)
-      {
-        ((CORBA::Any *)&_tao_any)->_tao_replace (
-            IR::_tc_HomeDefSeq,
-            1,
-            ACE_static_cast (void *, tmp),
-            IR_HomeDefSeq::_tao_any_destructor
-          );
-        _tao_elem = tmp;
-        return 1;
-      }
-      else
-      {
-        delete tmp;
-      }
-    }
-  }
-  ACE_CATCHANY
-  {
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-void operator<<= (
-    CORBA::Any &_tao_any,
-    const IR_EmitsDefSeq &_tao_elem
-  ) // copying
-{
-  TAO_OutputCDR stream;
-  if (stream << _tao_elem)
-  {
-    _tao_any._tao_replace (
-        IR::_tc_EmitsDefSeq,
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin ()
-      );
-  }
-}
-
-void operator<<= (CORBA::Any &_tao_any, IR_EmitsDefSeq *_tao_elem) // non copying
-{
-  TAO_OutputCDR stream;
-  stream << *_tao_elem;
-  _tao_any._tao_replace (
-      IR::_tc_EmitsDefSeq,
-      TAO_ENCAP_BYTE_ORDER,
-      stream.begin (),
-      1,
-      _tao_elem,
-      IR_EmitsDefSeq::_tao_any_destructor
-    );
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR_EmitsDefSeq *&_tao_elem)
-{
-  return _tao_any >>= ACE_const_cast(
-      const IR_EmitsDefSeq*&,
-      _tao_elem
-    );
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR_EmitsDefSeq *&_tao_elem)
-{
-  _tao_elem = 0;
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (IR::_tc_EmitsDefSeq, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    if (_tao_any.any_owns_data ())
-    {
-      _tao_elem = ACE_static_cast(
-          const IR_EmitsDefSeq*,
-          _tao_any.value ()
-        );
-      return 1;
-    }
-    else
-    {
-      IR_EmitsDefSeq *tmp;
-      ACE_NEW_RETURN (tmp, IR_EmitsDefSeq, 0);
-      TAO_InputCDR stream (
-          _tao_any._tao_get_cdr (),
-          _tao_any._tao_byte_order ()
-        );
-      if (stream >> *tmp)
-      {
-        ((CORBA::Any *)&_tao_any)->_tao_replace (
-            IR::_tc_EmitsDefSeq,
-            1,
-            ACE_static_cast (void *, tmp),
-            IR_EmitsDefSeq::_tao_any_destructor
-          );
-        _tao_elem = tmp;
-        return 1;
-      }
-      else
-      {
-        delete tmp;
-      }
-    }
-  }
-  ACE_CATCHANY
-  {
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-void operator<<= (
-    CORBA::Any &_tao_any,
-    const IR_PublishesDefSeq &_tao_elem
-  ) // copying
-{
-  TAO_OutputCDR stream;
-  if (stream << _tao_elem)
-  {
-    _tao_any._tao_replace (
-        IR::_tc_PublishesDefSeq,
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin ()
-      );
-  }
-}
-
-void operator<<= (CORBA::Any &_tao_any, IR_PublishesDefSeq *_tao_elem) // non copying
-{
-  TAO_OutputCDR stream;
-  stream << *_tao_elem;
-  _tao_any._tao_replace (
-      IR::_tc_PublishesDefSeq,
-      TAO_ENCAP_BYTE_ORDER,
-      stream.begin (),
-      1,
-      _tao_elem,
-      IR_PublishesDefSeq::_tao_any_destructor
-    );
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR_PublishesDefSeq *&_tao_elem)
-{
-  return _tao_any >>= ACE_const_cast(
-      const IR_PublishesDefSeq*&,
-      _tao_elem
-    );
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR_PublishesDefSeq *&_tao_elem)
-{
-  _tao_elem = 0;
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (IR::_tc_PublishesDefSeq, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    if (_tao_any.any_owns_data ())
-    {
-      _tao_elem = ACE_static_cast(
-          const IR_PublishesDefSeq*,
-          _tao_any.value ()
-        );
-      return 1;
-    }
-    else
-    {
-      IR_PublishesDefSeq *tmp;
-      ACE_NEW_RETURN (tmp, IR_PublishesDefSeq, 0);
-      TAO_InputCDR stream (
-          _tao_any._tao_get_cdr (),
-          _tao_any._tao_byte_order ()
-        );
-      if (stream >> *tmp)
-      {
-        ((CORBA::Any *)&_tao_any)->_tao_replace (
-            IR::_tc_PublishesDefSeq,
-            1,
-            ACE_static_cast (void *, tmp),
-            IR_PublishesDefSeq::_tao_any_destructor
-          );
-        _tao_elem = tmp;
-        return 1;
-      }
-      else
-      {
-        delete tmp;
-      }
-    }
-  }
-  ACE_CATCHANY
-  {
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-void operator<<= (
-    CORBA::Any &_tao_any,
-    const IR_ConsumesDefSeq &_tao_elem
-  ) // copying
-{
-  TAO_OutputCDR stream;
-  if (stream << _tao_elem)
-  {
-    _tao_any._tao_replace (
-        IR::_tc_ConsumesDefSeq,
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin ()
-      );
-  }
-}
-
-void operator<<= (CORBA::Any &_tao_any, IR_ConsumesDefSeq *_tao_elem) // non copying
-{
-  TAO_OutputCDR stream;
-  stream << *_tao_elem;
-  _tao_any._tao_replace (
-      IR::_tc_ConsumesDefSeq,
-      TAO_ENCAP_BYTE_ORDER,
-      stream.begin (),
-      1,
-      _tao_elem,
-      IR_ConsumesDefSeq::_tao_any_destructor
-    );
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR_ConsumesDefSeq *&_tao_elem)
-{
-  return _tao_any >>= ACE_const_cast(
-      const IR_ConsumesDefSeq*&,
-      _tao_elem
-    );
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR_ConsumesDefSeq *&_tao_elem)
-{
-  _tao_elem = 0;
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (IR::_tc_ConsumesDefSeq, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    if (_tao_any.any_owns_data ())
-    {
-      _tao_elem = ACE_static_cast(
-          const IR_ConsumesDefSeq*,
-          _tao_any.value ()
-        );
-      return 1;
-    }
-    else
-    {
-      IR_ConsumesDefSeq *tmp;
-      ACE_NEW_RETURN (tmp, IR_ConsumesDefSeq, 0);
-      TAO_InputCDR stream (
-          _tao_any._tao_get_cdr (),
-          _tao_any._tao_byte_order ()
-        );
-      if (stream >> *tmp)
-      {
-        ((CORBA::Any *)&_tao_any)->_tao_replace (
-            IR::_tc_ConsumesDefSeq,
-            1,
-            ACE_static_cast (void *, tmp),
-            IR_ConsumesDefSeq::_tao_any_destructor
-          );
-        _tao_elem = tmp;
-        return 1;
-      }
-      else
-      {
-        delete tmp;
-      }
-    }
-  }
-  ACE_CATCHANY
-  {
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-void operator<<= (
-    CORBA::Any &_tao_any,
-    const IR_FactoryDefSeq &_tao_elem
-  ) // copying
-{
-  TAO_OutputCDR stream;
-  if (stream << _tao_elem)
-  {
-    _tao_any._tao_replace (
-        IR::_tc_FactoryDefSeq,
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin ()
-      );
-  }
-}
-
-void operator<<= (CORBA::Any &_tao_any, IR_FactoryDefSeq *_tao_elem) // non copying
-{
-  TAO_OutputCDR stream;
-  stream << *_tao_elem;
-  _tao_any._tao_replace (
-      IR::_tc_FactoryDefSeq,
-      TAO_ENCAP_BYTE_ORDER,
-      stream.begin (),
-      1,
-      _tao_elem,
-      IR_FactoryDefSeq::_tao_any_destructor
-    );
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR_FactoryDefSeq *&_tao_elem)
-{
-  return _tao_any >>= ACE_const_cast(
-      const IR_FactoryDefSeq*&,
-      _tao_elem
-    );
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR_FactoryDefSeq *&_tao_elem)
-{
-  _tao_elem = 0;
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (IR::_tc_FactoryDefSeq, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    if (_tao_any.any_owns_data ())
-    {
-      _tao_elem = ACE_static_cast(
-          const IR_FactoryDefSeq*,
-          _tao_any.value ()
-        );
-      return 1;
-    }
-    else
-    {
-      IR_FactoryDefSeq *tmp;
-      ACE_NEW_RETURN (tmp, IR_FactoryDefSeq, 0);
-      TAO_InputCDR stream (
-          _tao_any._tao_get_cdr (),
-          _tao_any._tao_byte_order ()
-        );
-      if (stream >> *tmp)
-      {
-        ((CORBA::Any *)&_tao_any)->_tao_replace (
-            IR::_tc_FactoryDefSeq,
-            1,
-            ACE_static_cast (void *, tmp),
-            IR_FactoryDefSeq::_tao_any_destructor
-          );
-        _tao_elem = tmp;
-        return 1;
-      }
-      else
-      {
-        delete tmp;
-      }
-    }
-  }
-  ACE_CATCHANY
-  {
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-void operator<<= (
-    CORBA::Any &_tao_any,
-    const IR_FinderDefSeq &_tao_elem
-  ) // copying
-{
-  TAO_OutputCDR stream;
-  if (stream << _tao_elem)
-  {
-    _tao_any._tao_replace (
-        IR::_tc_FinderDefSeq,
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin ()
-      );
-  }
-}
-
-void operator<<= (CORBA::Any &_tao_any, IR_FinderDefSeq *_tao_elem) // non copying
-{
-  TAO_OutputCDR stream;
-  stream << *_tao_elem;
-  _tao_any._tao_replace (
-      IR::_tc_FinderDefSeq,
-      TAO_ENCAP_BYTE_ORDER,
-      stream.begin (),
-      1,
-      _tao_elem,
-      IR_FinderDefSeq::_tao_any_destructor
-    );
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR_FinderDefSeq *&_tao_elem)
-{
-  return _tao_any >>= ACE_const_cast(
-      const IR_FinderDefSeq*&,
-      _tao_elem
-    );
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR_FinderDefSeq *&_tao_elem)
-{
-  _tao_elem = 0;
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (IR::_tc_FinderDefSeq, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    if (_tao_any.any_owns_data ())
-    {
-      _tao_elem = ACE_static_cast(
-          const IR_FinderDefSeq*,
-          _tao_any.value ()
-        );
-      return 1;
-    }
-    else
-    {
-      IR_FinderDefSeq *tmp;
-      ACE_NEW_RETURN (tmp, IR_FinderDefSeq, 0);
-      TAO_InputCDR stream (
-          _tao_any._tao_get_cdr (),
-          _tao_any._tao_byte_order ()
-        );
-      if (stream >> *tmp)
-      {
-        ((CORBA::Any *)&_tao_any)->_tao_replace (
-            IR::_tc_FinderDefSeq,
-            1,
-            ACE_static_cast (void *, tmp),
-            IR_FinderDefSeq::_tao_any_destructor
-          );
-        _tao_elem = tmp;
-        return 1;
-      }
-      else
-      {
-        delete tmp;
-      }
-    }
-  }
-  ACE_CATCHANY
-  {
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-void operator<<= (
-    CORBA::Any &_tao_any,
-    const IR_ContainedSeq &_tao_elem
-  ) // copying
-{
-  TAO_OutputCDR stream;
-  if (stream << _tao_elem)
-  {
-    _tao_any._tao_replace (
-        IR::_tc_ContainedSeq,
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin ()
-      );
-  }
-}
-
-void operator<<= (CORBA::Any &_tao_any, IR_ContainedSeq *_tao_elem) // non copying
-{
-  TAO_OutputCDR stream;
-  stream << *_tao_elem;
-  _tao_any._tao_replace (
-      IR::_tc_ContainedSeq,
-      TAO_ENCAP_BYTE_ORDER,
-      stream.begin (),
-      1,
-      _tao_elem,
-      IR_ContainedSeq::_tao_any_destructor
-    );
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR_ContainedSeq *&_tao_elem)
-{
-  return _tao_any >>= ACE_const_cast(
-      const IR_ContainedSeq*&,
-      _tao_elem
-    );
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR_ContainedSeq *&_tao_elem)
-{
-  _tao_elem = 0;
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (IR::_tc_ContainedSeq, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    if (_tao_any.any_owns_data ())
-    {
-      _tao_elem = ACE_static_cast(
-          const IR_ContainedSeq*,
-          _tao_any.value ()
-        );
-      return 1;
-    }
-    else
-    {
-      IR_ContainedSeq *tmp;
-      ACE_NEW_RETURN (tmp, IR_ContainedSeq, 0);
-      TAO_InputCDR stream (
-          _tao_any._tao_get_cdr (),
-          _tao_any._tao_byte_order ()
-        );
-      if (stream >> *tmp)
-      {
-        ((CORBA::Any *)&_tao_any)->_tao_replace (
-            IR::_tc_ContainedSeq,
-            1,
-            ACE_static_cast (void *, tmp),
-            IR_ContainedSeq::_tao_any_destructor
-          );
-        _tao_elem = tmp;
-        return 1;
-      }
-      else
-      {
-        delete tmp;
-      }
-    }
-  }
-  ACE_CATCHANY
-  {
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-void operator<<= (CORBA::Any &_tao_any, const IR_StructMember &_tao_elem) // copying
-{
-  TAO_OutputCDR stream;
-  stream << _tao_elem;
-  _tao_any._tao_replace (
-      IR::_tc_StructMember,
-      TAO_ENCAP_BYTE_ORDER,
-      stream.begin ()
-    );
-}
-
-void operator<<= (CORBA::Any &_tao_any, IR_StructMember *_tao_elem) // non copying
-{
-  TAO_OutputCDR stream;
-  stream << *_tao_elem;
-  _tao_any._tao_replace (
-      IR::_tc_StructMember,
-      TAO_ENCAP_BYTE_ORDER,
-      stream.begin (),
-      1,
-      _tao_elem,
-      IR_StructMember::_tao_any_destructor
-    );
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR_StructMember *&_tao_elem)
-{
-  return _tao_any >>= ACE_const_cast(const IR_StructMember*&,_tao_elem);
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR_StructMember *&_tao_elem)
-{
-  _tao_elem = 0;
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (IR::_tc_StructMember, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    if (_tao_any.any_owns_data ())
-    {
-      _tao_elem = ACE_static_cast(
-          const IR_StructMember*,
-          _tao_any.value ()
-        );
-      return 1;
-    }
-    else
-    {
-      IR_StructMember *tmp;
-      ACE_NEW_RETURN (tmp, IR_StructMember, 0);
-      TAO_InputCDR stream (
-          _tao_any._tao_get_cdr (),
-          _tao_any._tao_byte_order ()
-        );
-      if (stream >> *tmp)
-      {
-        ((CORBA::Any *)&_tao_any)->_tao_replace (
-            IR::_tc_StructMember,
-            1,
-            ACE_static_cast (void *, tmp),
-            IR_StructMember::_tao_any_destructor
-          );
-        _tao_elem = tmp;
-        return 1;
-      }
-      else
-      {
-        delete tmp;
-      }
-    }
-  }
-  ACE_CATCHANY
-  {
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-void operator<<= (
-    CORBA::Any &_tao_any,
-    const IR_StructMemberSeq &_tao_elem
-  ) // copying
-{
-  TAO_OutputCDR stream;
-  if (stream << _tao_elem)
-  {
-    _tao_any._tao_replace (
-        IR::_tc_StructMemberSeq,
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin ()
-      );
-  }
-}
-
-void operator<<= (CORBA::Any &_tao_any, IR_StructMemberSeq *_tao_elem) // non copying
-{
-  TAO_OutputCDR stream;
-  stream << *_tao_elem;
-  _tao_any._tao_replace (
-      IR::_tc_StructMemberSeq,
-      TAO_ENCAP_BYTE_ORDER,
-      stream.begin (),
-      1,
-      _tao_elem,
-      IR_StructMemberSeq::_tao_any_destructor
-    );
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR_StructMemberSeq *&_tao_elem)
-{
-  return _tao_any >>= ACE_const_cast(
-      const IR_StructMemberSeq*&,
-      _tao_elem
-    );
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR_StructMemberSeq *&_tao_elem)
-{
-  _tao_elem = 0;
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (IR::_tc_StructMemberSeq, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    if (_tao_any.any_owns_data ())
-    {
-      _tao_elem = ACE_static_cast(
-          const IR_StructMemberSeq*,
-          _tao_any.value ()
-        );
-      return 1;
-    }
-    else
-    {
-      IR_StructMemberSeq *tmp;
-      ACE_NEW_RETURN (tmp, IR_StructMemberSeq, 0);
-      TAO_InputCDR stream (
-          _tao_any._tao_get_cdr (),
-          _tao_any._tao_byte_order ()
-        );
-      if (stream >> *tmp)
-      {
-        ((CORBA::Any *)&_tao_any)->_tao_replace (
-            IR::_tc_StructMemberSeq,
-            1,
-            ACE_static_cast (void *, tmp),
-            IR_StructMemberSeq::_tao_any_destructor
-          );
-        _tao_elem = tmp;
-        return 1;
-      }
-      else
-      {
-        delete tmp;
-      }
-    }
-  }
-  ACE_CATCHANY
-  {
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-void operator<<= (CORBA::Any &_tao_any, const IR_Initializer &_tao_elem) // copying
-{
-  TAO_OutputCDR stream;
-  stream << _tao_elem;
-  _tao_any._tao_replace (
-      IR::_tc_Initializer,
-      TAO_ENCAP_BYTE_ORDER,
-      stream.begin ()
-    );
-}
-
-void operator<<= (CORBA::Any &_tao_any, IR_Initializer *_tao_elem) // non copying
-{
-  TAO_OutputCDR stream;
-  stream << *_tao_elem;
-  _tao_any._tao_replace (
-      IR::_tc_Initializer,
-      TAO_ENCAP_BYTE_ORDER,
-      stream.begin (),
-      1,
-      _tao_elem,
-      IR_Initializer::_tao_any_destructor
-    );
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR_Initializer *&_tao_elem)
-{
-  return _tao_any >>= ACE_const_cast(const IR_Initializer*&,_tao_elem);
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR_Initializer *&_tao_elem)
-{
-  _tao_elem = 0;
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (IR::_tc_Initializer, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    if (_tao_any.any_owns_data ())
-    {
-      _tao_elem = ACE_static_cast(
-          const IR_Initializer*,
-          _tao_any.value ()
-        );
-      return 1;
-    }
-    else
-    {
-      IR_Initializer *tmp;
-      ACE_NEW_RETURN (tmp, IR_Initializer, 0);
-      TAO_InputCDR stream (
-          _tao_any._tao_get_cdr (),
-          _tao_any._tao_byte_order ()
-        );
-      if (stream >> *tmp)
-      {
-        ((CORBA::Any *)&_tao_any)->_tao_replace (
-            IR::_tc_Initializer,
-            1,
-            ACE_static_cast (void *, tmp),
-            IR_Initializer::_tao_any_destructor
-          );
-        _tao_elem = tmp;
-        return 1;
-      }
-      else
-      {
-        delete tmp;
-      }
-    }
-  }
-  ACE_CATCHANY
-  {
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-void operator<<= (
-    CORBA::Any &_tao_any,
-    const IR_InitializerSeq &_tao_elem
-  ) // copying
-{
-  TAO_OutputCDR stream;
-  if (stream << _tao_elem)
-  {
-    _tao_any._tao_replace (
-        IR::_tc_InitializerSeq,
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin ()
-      );
-  }
-}
-
-void operator<<= (CORBA::Any &_tao_any, IR_InitializerSeq *_tao_elem) // non copying
-{
-  TAO_OutputCDR stream;
-  stream << *_tao_elem;
-  _tao_any._tao_replace (
-      IR::_tc_InitializerSeq,
-      TAO_ENCAP_BYTE_ORDER,
-      stream.begin (),
-      1,
-      _tao_elem,
-      IR_InitializerSeq::_tao_any_destructor
-    );
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR_InitializerSeq *&_tao_elem)
-{
-  return _tao_any >>= ACE_const_cast(
-      const IR_InitializerSeq*&,
-      _tao_elem
-    );
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR_InitializerSeq *&_tao_elem)
-{
-  _tao_elem = 0;
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (IR::_tc_InitializerSeq, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    if (_tao_any.any_owns_data ())
-    {
-      _tao_elem = ACE_static_cast(
-          const IR_InitializerSeq*,
-          _tao_any.value ()
-        );
-      return 1;
-    }
-    else
-    {
-      IR_InitializerSeq *tmp;
-      ACE_NEW_RETURN (tmp, IR_InitializerSeq, 0);
-      TAO_InputCDR stream (
-          _tao_any._tao_get_cdr (),
-          _tao_any._tao_byte_order ()
-        );
-      if (stream >> *tmp)
-      {
-        ((CORBA::Any *)&_tao_any)->_tao_replace (
-            IR::_tc_InitializerSeq,
-            1,
-            ACE_static_cast (void *, tmp),
-            IR_InitializerSeq::_tao_any_destructor
-          );
-        _tao_elem = tmp;
-        return 1;
-      }
-      else
-      {
-        delete tmp;
-      }
-    }
-  }
-  ACE_CATCHANY
-  {
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-void operator<<= (CORBA::Any &_tao_any, const IR_UnionMember &_tao_elem) // copying
-{
-  TAO_OutputCDR stream;
-  stream << _tao_elem;
-  _tao_any._tao_replace (
-      IR::_tc_UnionMember,
-      TAO_ENCAP_BYTE_ORDER,
-      stream.begin ()
-    );
-}
-
-void operator<<= (CORBA::Any &_tao_any, IR_UnionMember *_tao_elem) // non copying
-{
-  TAO_OutputCDR stream;
-  stream << *_tao_elem;
-  _tao_any._tao_replace (
-      IR::_tc_UnionMember,
-      TAO_ENCAP_BYTE_ORDER,
-      stream.begin (),
-      1,
-      _tao_elem,
-      IR_UnionMember::_tao_any_destructor
-    );
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR_UnionMember *&_tao_elem)
-{
-  return _tao_any >>= ACE_const_cast(const IR_UnionMember*&,_tao_elem);
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR_UnionMember *&_tao_elem)
-{
-  _tao_elem = 0;
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (IR::_tc_UnionMember, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    if (_tao_any.any_owns_data ())
-    {
-      _tao_elem = ACE_static_cast(
-          const IR_UnionMember*,
-          _tao_any.value ()
-        );
-      return 1;
-    }
-    else
-    {
-      IR_UnionMember *tmp;
-      ACE_NEW_RETURN (tmp, IR_UnionMember, 0);
-      TAO_InputCDR stream (
-          _tao_any._tao_get_cdr (),
-          _tao_any._tao_byte_order ()
-        );
-      if (stream >> *tmp)
-      {
-        ((CORBA::Any *)&_tao_any)->_tao_replace (
-            IR::_tc_UnionMember,
-            1,
-            ACE_static_cast (void *, tmp),
-            IR_UnionMember::_tao_any_destructor
-          );
-        _tao_elem = tmp;
-        return 1;
-      }
-      else
-      {
-        delete tmp;
-      }
-    }
-  }
-  ACE_CATCHANY
-  {
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-void operator<<= (
-    CORBA::Any &_tao_any,
-    const IR_UnionMemberSeq &_tao_elem
-  ) // copying
-{
-  TAO_OutputCDR stream;
-  if (stream << _tao_elem)
-  {
-    _tao_any._tao_replace (
-        IR::_tc_UnionMemberSeq,
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin ()
-      );
-  }
-}
-
-void operator<<= (CORBA::Any &_tao_any, IR_UnionMemberSeq *_tao_elem) // non copying
-{
-  TAO_OutputCDR stream;
-  stream << *_tao_elem;
-  _tao_any._tao_replace (
-      IR::_tc_UnionMemberSeq,
-      TAO_ENCAP_BYTE_ORDER,
-      stream.begin (),
-      1,
-      _tao_elem,
-      IR_UnionMemberSeq::_tao_any_destructor
-    );
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR_UnionMemberSeq *&_tao_elem)
-{
-  return _tao_any >>= ACE_const_cast(
-      const IR_UnionMemberSeq*&,
-      _tao_elem
-    );
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR_UnionMemberSeq *&_tao_elem)
-{
-  _tao_elem = 0;
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (IR::_tc_UnionMemberSeq, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    if (_tao_any.any_owns_data ())
-    {
-      _tao_elem = ACE_static_cast(
-          const IR_UnionMemberSeq*,
-          _tao_any.value ()
-        );
-      return 1;
-    }
-    else
-    {
-      IR_UnionMemberSeq *tmp;
-      ACE_NEW_RETURN (tmp, IR_UnionMemberSeq, 0);
-      TAO_InputCDR stream (
-          _tao_any._tao_get_cdr (),
-          _tao_any._tao_byte_order ()
-        );
-      if (stream >> *tmp)
-      {
-        ((CORBA::Any *)&_tao_any)->_tao_replace (
-            IR::_tc_UnionMemberSeq,
-            1,
-            ACE_static_cast (void *, tmp),
-            IR_UnionMemberSeq::_tao_any_destructor
-          );
-        _tao_elem = tmp;
-        return 1;
-      }
-      else
-      {
-        delete tmp;
-      }
-    }
-  }
-  ACE_CATCHANY
-  {
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-void operator<<= (
-    CORBA::Any &_tao_any,
-    const IR_EnumMemberSeq &_tao_elem
-  ) // copying
-{
-  TAO_OutputCDR stream;
-  if (stream << _tao_elem)
-  {
-    _tao_any._tao_replace (
-        IR::_tc_EnumMemberSeq,
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin ()
-      );
-  }
-}
-
-void operator<<= (CORBA::Any &_tao_any, IR_EnumMemberSeq *_tao_elem) // non copying
-{
-  TAO_OutputCDR stream;
-  stream << *_tao_elem;
-  _tao_any._tao_replace (
-      IR::_tc_EnumMemberSeq,
-      TAO_ENCAP_BYTE_ORDER,
-      stream.begin (),
-      1,
-      _tao_elem,
-      IR_EnumMemberSeq::_tao_any_destructor
-    );
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR_EnumMemberSeq *&_tao_elem)
-{
-  return _tao_any >>= ACE_const_cast(
-      const IR_EnumMemberSeq*&,
-      _tao_elem
-    );
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR_EnumMemberSeq *&_tao_elem)
-{
-  _tao_elem = 0;
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (IR::_tc_EnumMemberSeq, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    if (_tao_any.any_owns_data ())
-    {
-      _tao_elem = ACE_static_cast(
-          const IR_EnumMemberSeq*,
-          _tao_any.value ()
-        );
-      return 1;
-    }
-    else
-    {
-      IR_EnumMemberSeq *tmp;
-      ACE_NEW_RETURN (tmp, IR_EnumMemberSeq, 0);
-      TAO_InputCDR stream (
-          _tao_any._tao_get_cdr (),
-          _tao_any._tao_byte_order ()
-        );
-      if (stream >> *tmp)
-      {
-        ((CORBA::Any *)&_tao_any)->_tao_replace (
-            IR::_tc_EnumMemberSeq,
-            1,
-            ACE_static_cast (void *, tmp),
-            IR_EnumMemberSeq::_tao_any_destructor
-          );
-        _tao_elem = tmp;
-        return 1;
-      }
-      else
-      {
-        delete tmp;
-      }
-    }
-  }
-  ACE_CATCHANY
-  {
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-void operator<<= (CORBA::Any &_tao_any, IR_Container_ptr _tao_elem)
-{
-  TAO_OutputCDR stream;
-  if (stream << _tao_elem)
-  {
-    _tao_any._tao_replace (
-        IR::_tc_Container, 
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin (),
-        1,
-        IR_Container::_duplicate (_tao_elem),
-        IR_Container::_tao_any_destructor
-      );
-  }
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR_Container_ptr &_tao_elem)
-{
-  ACE_TRY_NEW_ENV
-  {
-    _tao_elem = IR_Container::_nil ();
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (IR::_tc_Container, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    TAO_InputCDR stream (
-        _tao_any._tao_get_cdr (),
-        _tao_any._tao_byte_order ()
-      );
-    if (stream >> _tao_elem)
-    {
-      ((CORBA::Any *)&_tao_any)->_tao_replace (
-          IR::_tc_Container,
-          1,
-          _tao_elem,
-          IR_Container::_tao_any_destructor
-        );
-      return 1;
-    }
-  }
-  ACE_CATCHANY
-  {
-    _tao_elem = IR_Container::_nil ();
-    return 0;
-  }
-  ACE_ENDTRY;
-  _tao_elem = IR_Container::_nil ();
-  return 0;
-}
-
-#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
-    defined (ACE_HAS_GNU_REPO)
-    template class TAO_Object_Manager<IR_Container,IR_Container_var>;
-  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
-  #  pragma instantiate TAO_Object_Manager<IR_Container,IR_Container_var>
-#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
-
-void operator<<= (CORBA::Any &_tao_any, const IR_Container::Description &_tao_elem) // copying
-{
-  TAO_OutputCDR stream;
-  stream << _tao_elem;
-  _tao_any._tao_replace (
-      IR_Container::_tc_Description,
-      TAO_ENCAP_BYTE_ORDER,
-      stream.begin ()
-    );
-}
-
-void operator<<= (CORBA::Any &_tao_any, IR_Container::Description *_tao_elem) // non copying
-{
-  TAO_OutputCDR stream;
-  stream << *_tao_elem;
-  _tao_any._tao_replace (
-      IR_Container::_tc_Description,
-      TAO_ENCAP_BYTE_ORDER,
-      stream.begin (),
-      1,
-      _tao_elem,
-      IR_Container::Description::_tao_any_destructor
-    );
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR_Container::Description *&_tao_elem)
-{
-  return _tao_any >>= ACE_const_cast(const IR_Container::Description*&,_tao_elem);
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR_Container::Description *&_tao_elem)
-{
-  _tao_elem = 0;
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (IR_Container::_tc_Description, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    if (_tao_any.any_owns_data ())
-    {
-      _tao_elem = ACE_static_cast(
-          const IR_Container::Description*,
-          _tao_any.value ()
-        );
-      return 1;
-    }
-    else
-    {
-      IR_Container::Description *tmp;
-      ACE_NEW_RETURN (tmp, IR_Container::Description, 0);
-      TAO_InputCDR stream (
-          _tao_any._tao_get_cdr (),
-          _tao_any._tao_byte_order ()
-        );
-      if (stream >> *tmp)
-      {
-        ((CORBA::Any *)&_tao_any)->_tao_replace (
-            IR_Container::_tc_Description,
-            1,
-            ACE_static_cast (void *, tmp),
-            IR_Container::Description::_tao_any_destructor
-          );
-        _tao_elem = tmp;
-        return 1;
-      }
-      else
-      {
-        delete tmp;
-      }
-    }
-  }
-  ACE_CATCHANY
-  {
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-void operator<<= (
-    CORBA::Any &_tao_any,
-    const IR_Container::DescriptionSeq &_tao_elem
-  ) // copying
-{
-  TAO_OutputCDR stream;
-  if (stream << _tao_elem)
-  {
-    _tao_any._tao_replace (
-        IR_Container::_tc_DescriptionSeq,
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin ()
-      );
-  }
-}
-
-void operator<<= (CORBA::Any &_tao_any, IR_Container::DescriptionSeq *_tao_elem) // non copying
-{
-  TAO_OutputCDR stream;
-  stream << *_tao_elem;
-  _tao_any._tao_replace (
-      IR_Container::_tc_DescriptionSeq,
-      TAO_ENCAP_BYTE_ORDER,
-      stream.begin (),
-      1,
-      _tao_elem,
-      IR_Container::DescriptionSeq::_tao_any_destructor
-    );
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR_Container::DescriptionSeq *&_tao_elem)
-{
-  return _tao_any >>= ACE_const_cast(
-      const IR_Container::DescriptionSeq*&,
-      _tao_elem
-    );
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR_Container::DescriptionSeq *&_tao_elem)
-{
-  _tao_elem = 0;
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (IR_Container::_tc_DescriptionSeq, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    if (_tao_any.any_owns_data ())
-    {
-      _tao_elem = ACE_static_cast(
-          const IR_Container::DescriptionSeq*,
-          _tao_any.value ()
-        );
-      return 1;
-    }
-    else
-    {
-      IR_Container::DescriptionSeq *tmp;
-      ACE_NEW_RETURN (tmp, IR_Container::DescriptionSeq, 0);
-      TAO_InputCDR stream (
-          _tao_any._tao_get_cdr (),
-          _tao_any._tao_byte_order ()
-        );
-      if (stream >> *tmp)
-      {
-        ((CORBA::Any *)&_tao_any)->_tao_replace (
-            IR_Container::_tc_DescriptionSeq,
-            1,
-            ACE_static_cast (void *, tmp),
-            IR_Container::DescriptionSeq::_tao_any_destructor
-          );
-        _tao_elem = tmp;
-        return 1;
-      }
-      else
-      {
-        delete tmp;
-      }
-    }
-  }
-  ACE_CATCHANY
-  {
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-void operator<<= (CORBA::Any &_tao_any, IR_IDLType_ptr _tao_elem)
-{
-  TAO_OutputCDR stream;
-  if (stream << _tao_elem)
-  {
-    _tao_any._tao_replace (
-        IR::_tc_IDLType, 
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin (),
-        1,
-        IR_IDLType::_duplicate (_tao_elem),
-        IR_IDLType::_tao_any_destructor
-      );
-  }
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR_IDLType_ptr &_tao_elem)
-{
-  ACE_TRY_NEW_ENV
-  {
-    _tao_elem = IR_IDLType::_nil ();
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (IR::_tc_IDLType, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    TAO_InputCDR stream (
-        _tao_any._tao_get_cdr (),
-        _tao_any._tao_byte_order ()
-      );
-    if (stream >> _tao_elem)
-    {
-      ((CORBA::Any *)&_tao_any)->_tao_replace (
-          IR::_tc_IDLType,
-          1,
-          _tao_elem,
-          IR_IDLType::_tao_any_destructor
-        );
-      return 1;
-    }
-  }
-  ACE_CATCHANY
-  {
-    _tao_elem = IR_IDLType::_nil ();
-    return 0;
-  }
-  ACE_ENDTRY;
-  _tao_elem = IR_IDLType::_nil ();
-  return 0;
-}
-
-#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
-    defined (ACE_HAS_GNU_REPO)
-    template class TAO_Object_Manager<IR_IDLType,IR_IDLType_var>;
-  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
-  #  pragma instantiate TAO_Object_Manager<IR_IDLType,IR_IDLType_var>
-#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
-
-void operator<<= (CORBA::Any &_tao_any, IR_PrimitiveKind _tao_elem)
-{
-  TAO_OutputCDR stream;
-  stream << _tao_elem;
-  _tao_any._tao_replace (
-      IR::_tc_PrimitiveKind,
-      TAO_ENCAP_BYTE_ORDER,
-      stream.begin ()
-    );
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR_PrimitiveKind &_tao_elem)
-{
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (IR::_tc_PrimitiveKind, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    TAO_InputCDR stream (
-        _tao_any._tao_get_cdr (),
-        _tao_any._tao_byte_order ()
-      );
-    if (stream >> _tao_elem)
-    {
-      return 1;
-    }
-  }
-  ACE_CATCHANY
-  {
-    return 0;
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-void operator<<= (CORBA::Any &_tao_any, IR_Repository_ptr _tao_elem)
-{
-  TAO_OutputCDR stream;
-  if (stream << _tao_elem)
-  {
-    _tao_any._tao_replace (
-        IR::_tc_Repository, 
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin (),
-        1,
-        IR_Repository::_duplicate (_tao_elem),
-        IR_Repository::_tao_any_destructor
-      );
-  }
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR_Repository_ptr &_tao_elem)
-{
-  ACE_TRY_NEW_ENV
-  {
-    _tao_elem = IR_Repository::_nil ();
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (IR::_tc_Repository, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    TAO_InputCDR stream (
-        _tao_any._tao_get_cdr (),
-        _tao_any._tao_byte_order ()
-      );
-    if (stream >> _tao_elem)
-    {
-      ((CORBA::Any *)&_tao_any)->_tao_replace (
-          IR::_tc_Repository,
-          1,
-          _tao_elem,
-          IR_Repository::_tao_any_destructor
-        );
-      return 1;
-    }
-  }
-  ACE_CATCHANY
-  {
-    _tao_elem = IR_Repository::_nil ();
-    return 0;
-  }
-  ACE_ENDTRY;
-  _tao_elem = IR_Repository::_nil ();
-  return 0;
-}
-
-#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
-    defined (ACE_HAS_GNU_REPO)
-    template class TAO_Object_Manager<IR_Repository,IR_Repository_var>;
-  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
-  #  pragma instantiate TAO_Object_Manager<IR_Repository,IR_Repository_var>
-#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
-
-void operator<<= (CORBA::Any &_tao_any, IR_ComponentRepository_ptr _tao_elem)
-{
-  TAO_OutputCDR stream;
-  if (stream << _tao_elem)
-  {
-    _tao_any._tao_replace (
-        IR::_tc_ComponentRepository, 
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin (),
-        1,
-        IR_ComponentRepository::_duplicate (_tao_elem),
-        IR_ComponentRepository::_tao_any_destructor
-      );
-  }
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR_ComponentRepository_ptr &_tao_elem)
-{
-  ACE_TRY_NEW_ENV
-  {
-    _tao_elem = IR_ComponentRepository::_nil ();
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (IR::_tc_ComponentRepository, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    TAO_InputCDR stream (
-        _tao_any._tao_get_cdr (),
-        _tao_any._tao_byte_order ()
-      );
-    if (stream >> _tao_elem)
-    {
-      ((CORBA::Any *)&_tao_any)->_tao_replace (
-          IR::_tc_ComponentRepository,
-          1,
-          _tao_elem,
-          IR_ComponentRepository::_tao_any_destructor
-        );
-      return 1;
-    }
-  }
-  ACE_CATCHANY
-  {
-    _tao_elem = IR_ComponentRepository::_nil ();
-    return 0;
-  }
-  ACE_ENDTRY;
-  _tao_elem = IR_ComponentRepository::_nil ();
-  return 0;
-}
-
-#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
-    defined (ACE_HAS_GNU_REPO)
-    template class TAO_Object_Manager<IR_ComponentRepository,IR_ComponentRepository_var>;
-  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
-  #  pragma instantiate TAO_Object_Manager<IR_ComponentRepository,IR_ComponentRepository_var>
-#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
-
-void operator<<= (CORBA::Any &_tao_any, IR_ModuleDef_ptr _tao_elem)
-{
-  TAO_OutputCDR stream;
-  if (stream << _tao_elem)
-  {
-    _tao_any._tao_replace (
-        IR::_tc_ModuleDef, 
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin (),
-        1,
-        IR_ModuleDef::_duplicate (_tao_elem),
-        IR_ModuleDef::_tao_any_destructor
-      );
-  }
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR_ModuleDef_ptr &_tao_elem)
-{
-  ACE_TRY_NEW_ENV
-  {
-    _tao_elem = IR_ModuleDef::_nil ();
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (IR::_tc_ModuleDef, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    TAO_InputCDR stream (
-        _tao_any._tao_get_cdr (),
-        _tao_any._tao_byte_order ()
-      );
-    if (stream >> _tao_elem)
-    {
-      ((CORBA::Any *)&_tao_any)->_tao_replace (
-          IR::_tc_ModuleDef,
-          1,
-          _tao_elem,
-          IR_ModuleDef::_tao_any_destructor
-        );
-      return 1;
-    }
-  }
-  ACE_CATCHANY
-  {
-    _tao_elem = IR_ModuleDef::_nil ();
-    return 0;
-  }
-  ACE_ENDTRY;
-  _tao_elem = IR_ModuleDef::_nil ();
-  return 0;
-}
-
-#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
-    defined (ACE_HAS_GNU_REPO)
-    template class TAO_Object_Manager<IR_ModuleDef,IR_ModuleDef_var>;
-  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
-  #  pragma instantiate TAO_Object_Manager<IR_ModuleDef,IR_ModuleDef_var>
-#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
-
-void operator<<= (CORBA::Any &_tao_any, const IR_ModuleDescription &_tao_elem) // copying
-{
-  TAO_OutputCDR stream;
-  stream << _tao_elem;
-  _tao_any._tao_replace (
-      IR::_tc_ModuleDescription,
-      TAO_ENCAP_BYTE_ORDER,
-      stream.begin ()
-    );
-}
-
-void operator<<= (CORBA::Any &_tao_any, IR_ModuleDescription *_tao_elem) // non copying
-{
-  TAO_OutputCDR stream;
-  stream << *_tao_elem;
-  _tao_any._tao_replace (
-      IR::_tc_ModuleDescription,
-      TAO_ENCAP_BYTE_ORDER,
-      stream.begin (),
-      1,
-      _tao_elem,
-      IR_ModuleDescription::_tao_any_destructor
-    );
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR_ModuleDescription *&_tao_elem)
-{
-  return _tao_any >>= ACE_const_cast(const IR_ModuleDescription*&,_tao_elem);
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR_ModuleDescription *&_tao_elem)
-{
-  _tao_elem = 0;
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (IR::_tc_ModuleDescription, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    if (_tao_any.any_owns_data ())
-    {
-      _tao_elem = ACE_static_cast(
-          const IR_ModuleDescription*,
-          _tao_any.value ()
-        );
-      return 1;
-    }
-    else
-    {
-      IR_ModuleDescription *tmp;
-      ACE_NEW_RETURN (tmp, IR_ModuleDescription, 0);
-      TAO_InputCDR stream (
-          _tao_any._tao_get_cdr (),
-          _tao_any._tao_byte_order ()
-        );
-      if (stream >> *tmp)
-      {
-        ((CORBA::Any *)&_tao_any)->_tao_replace (
-            IR::_tc_ModuleDescription,
-            1,
-            ACE_static_cast (void *, tmp),
-            IR_ModuleDescription::_tao_any_destructor
-          );
-        _tao_elem = tmp;
-        return 1;
-      }
-      else
-      {
-        delete tmp;
-      }
-    }
-  }
-  ACE_CATCHANY
-  {
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-void operator<<= (CORBA::Any &_tao_any, IR_ConstantDef_ptr _tao_elem)
-{
-  TAO_OutputCDR stream;
-  if (stream << _tao_elem)
-  {
-    _tao_any._tao_replace (
-        IR::_tc_ConstantDef, 
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin (),
-        1,
-        IR_ConstantDef::_duplicate (_tao_elem),
-        IR_ConstantDef::_tao_any_destructor
-      );
-  }
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR_ConstantDef_ptr &_tao_elem)
-{
-  ACE_TRY_NEW_ENV
-  {
-    _tao_elem = IR_ConstantDef::_nil ();
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (IR::_tc_ConstantDef, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    TAO_InputCDR stream (
-        _tao_any._tao_get_cdr (),
-        _tao_any._tao_byte_order ()
-      );
-    if (stream >> _tao_elem)
-    {
-      ((CORBA::Any *)&_tao_any)->_tao_replace (
-          IR::_tc_ConstantDef,
-          1,
-          _tao_elem,
-          IR_ConstantDef::_tao_any_destructor
-        );
-      return 1;
-    }
-  }
-  ACE_CATCHANY
-  {
-    _tao_elem = IR_ConstantDef::_nil ();
-    return 0;
-  }
-  ACE_ENDTRY;
-  _tao_elem = IR_ConstantDef::_nil ();
-  return 0;
-}
-
-#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
-    defined (ACE_HAS_GNU_REPO)
-    template class TAO_Object_Manager<IR_ConstantDef,IR_ConstantDef_var>;
-  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
-  #  pragma instantiate TAO_Object_Manager<IR_ConstantDef,IR_ConstantDef_var>
-#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
-
-void operator<<= (CORBA::Any &_tao_any, const IR_ConstantDescription &_tao_elem) // copying
-{
-  TAO_OutputCDR stream;
-  stream << _tao_elem;
-  _tao_any._tao_replace (
-      IR::_tc_ConstantDescription,
-      TAO_ENCAP_BYTE_ORDER,
-      stream.begin ()
-    );
-}
-
-void operator<<= (CORBA::Any &_tao_any, IR_ConstantDescription *_tao_elem) // non copying
-{
-  TAO_OutputCDR stream;
-  stream << *_tao_elem;
-  _tao_any._tao_replace (
-      IR::_tc_ConstantDescription,
-      TAO_ENCAP_BYTE_ORDER,
-      stream.begin (),
-      1,
-      _tao_elem,
-      IR_ConstantDescription::_tao_any_destructor
-    );
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR_ConstantDescription *&_tao_elem)
-{
-  return _tao_any >>= ACE_const_cast(const IR_ConstantDescription*&,_tao_elem);
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR_ConstantDescription *&_tao_elem)
-{
-  _tao_elem = 0;
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (IR::_tc_ConstantDescription, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    if (_tao_any.any_owns_data ())
-    {
-      _tao_elem = ACE_static_cast(
-          const IR_ConstantDescription*,
-          _tao_any.value ()
-        );
-      return 1;
-    }
-    else
-    {
-      IR_ConstantDescription *tmp;
-      ACE_NEW_RETURN (tmp, IR_ConstantDescription, 0);
-      TAO_InputCDR stream (
-          _tao_any._tao_get_cdr (),
-          _tao_any._tao_byte_order ()
-        );
-      if (stream >> *tmp)
-      {
-        ((CORBA::Any *)&_tao_any)->_tao_replace (
-            IR::_tc_ConstantDescription,
-            1,
-            ACE_static_cast (void *, tmp),
-            IR_ConstantDescription::_tao_any_destructor
-          );
-        _tao_elem = tmp;
-        return 1;
-      }
-      else
-      {
-        delete tmp;
-      }
-    }
-  }
-  ACE_CATCHANY
-  {
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-void operator<<= (CORBA::Any &_tao_any, IR_TypedefDef_ptr _tao_elem)
-{
-  TAO_OutputCDR stream;
-  if (stream << _tao_elem)
-  {
-    _tao_any._tao_replace (
-        IR::_tc_TypedefDef, 
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin (),
-        1,
-        IR_TypedefDef::_duplicate (_tao_elem),
-        IR_TypedefDef::_tao_any_destructor
-      );
-  }
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR_TypedefDef_ptr &_tao_elem)
-{
-  ACE_TRY_NEW_ENV
-  {
-    _tao_elem = IR_TypedefDef::_nil ();
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (IR::_tc_TypedefDef, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    TAO_InputCDR stream (
-        _tao_any._tao_get_cdr (),
-        _tao_any._tao_byte_order ()
-      );
-    if (stream >> _tao_elem)
-    {
-      ((CORBA::Any *)&_tao_any)->_tao_replace (
-          IR::_tc_TypedefDef,
-          1,
-          _tao_elem,
-          IR_TypedefDef::_tao_any_destructor
-        );
-      return 1;
-    }
-  }
-  ACE_CATCHANY
-  {
-    _tao_elem = IR_TypedefDef::_nil ();
-    return 0;
-  }
-  ACE_ENDTRY;
-  _tao_elem = IR_TypedefDef::_nil ();
-  return 0;
-}
-
-#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
-    defined (ACE_HAS_GNU_REPO)
-    template class TAO_Object_Manager<IR_TypedefDef,IR_TypedefDef_var>;
-  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
-  #  pragma instantiate TAO_Object_Manager<IR_TypedefDef,IR_TypedefDef_var>
-#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
-
-void operator<<= (CORBA::Any &_tao_any, const IR_TypeDescription &_tao_elem) // copying
-{
-  TAO_OutputCDR stream;
-  stream << _tao_elem;
-  _tao_any._tao_replace (
-      IR::_tc_TypeDescription,
-      TAO_ENCAP_BYTE_ORDER,
-      stream.begin ()
-    );
-}
-
-void operator<<= (CORBA::Any &_tao_any, IR_TypeDescription *_tao_elem) // non copying
-{
-  TAO_OutputCDR stream;
-  stream << *_tao_elem;
-  _tao_any._tao_replace (
-      IR::_tc_TypeDescription,
-      TAO_ENCAP_BYTE_ORDER,
-      stream.begin (),
-      1,
-      _tao_elem,
-      IR_TypeDescription::_tao_any_destructor
-    );
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR_TypeDescription *&_tao_elem)
-{
-  return _tao_any >>= ACE_const_cast(const IR_TypeDescription*&,_tao_elem);
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR_TypeDescription *&_tao_elem)
-{
-  _tao_elem = 0;
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (IR::_tc_TypeDescription, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    if (_tao_any.any_owns_data ())
-    {
-      _tao_elem = ACE_static_cast(
-          const IR_TypeDescription*,
-          _tao_any.value ()
-        );
-      return 1;
-    }
-    else
-    {
-      IR_TypeDescription *tmp;
-      ACE_NEW_RETURN (tmp, IR_TypeDescription, 0);
-      TAO_InputCDR stream (
-          _tao_any._tao_get_cdr (),
-          _tao_any._tao_byte_order ()
-        );
-      if (stream >> *tmp)
-      {
-        ((CORBA::Any *)&_tao_any)->_tao_replace (
-            IR::_tc_TypeDescription,
-            1,
-            ACE_static_cast (void *, tmp),
-            IR_TypeDescription::_tao_any_destructor
-          );
-        _tao_elem = tmp;
-        return 1;
-      }
-      else
-      {
-        delete tmp;
-      }
-    }
-  }
-  ACE_CATCHANY
-  {
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-void operator<<= (CORBA::Any &_tao_any, IR_StructDef_ptr _tao_elem)
-{
-  TAO_OutputCDR stream;
-  if (stream << _tao_elem)
-  {
-    _tao_any._tao_replace (
-        IR::_tc_StructDef, 
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin (),
-        1,
-        IR_StructDef::_duplicate (_tao_elem),
-        IR_StructDef::_tao_any_destructor
-      );
-  }
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR_StructDef_ptr &_tao_elem)
-{
-  ACE_TRY_NEW_ENV
-  {
-    _tao_elem = IR_StructDef::_nil ();
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (IR::_tc_StructDef, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    TAO_InputCDR stream (
-        _tao_any._tao_get_cdr (),
-        _tao_any._tao_byte_order ()
-      );
-    if (stream >> _tao_elem)
-    {
-      ((CORBA::Any *)&_tao_any)->_tao_replace (
-          IR::_tc_StructDef,
-          1,
-          _tao_elem,
-          IR_StructDef::_tao_any_destructor
-        );
-      return 1;
-    }
-  }
-  ACE_CATCHANY
-  {
-    _tao_elem = IR_StructDef::_nil ();
-    return 0;
-  }
-  ACE_ENDTRY;
-  _tao_elem = IR_StructDef::_nil ();
-  return 0;
-}
-
-#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
-    defined (ACE_HAS_GNU_REPO)
-    template class TAO_Object_Manager<IR_StructDef,IR_StructDef_var>;
-  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
-  #  pragma instantiate TAO_Object_Manager<IR_StructDef,IR_StructDef_var>
-#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
-
-void operator<<= (CORBA::Any &_tao_any, IR_UnionDef_ptr _tao_elem)
-{
-  TAO_OutputCDR stream;
-  if (stream << _tao_elem)
-  {
-    _tao_any._tao_replace (
-        IR::_tc_UnionDef, 
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin (),
-        1,
-        IR_UnionDef::_duplicate (_tao_elem),
-        IR_UnionDef::_tao_any_destructor
-      );
-  }
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR_UnionDef_ptr &_tao_elem)
-{
-  ACE_TRY_NEW_ENV
-  {
-    _tao_elem = IR_UnionDef::_nil ();
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (IR::_tc_UnionDef, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    TAO_InputCDR stream (
-        _tao_any._tao_get_cdr (),
-        _tao_any._tao_byte_order ()
-      );
-    if (stream >> _tao_elem)
-    {
-      ((CORBA::Any *)&_tao_any)->_tao_replace (
-          IR::_tc_UnionDef,
-          1,
-          _tao_elem,
-          IR_UnionDef::_tao_any_destructor
-        );
-      return 1;
-    }
-  }
-  ACE_CATCHANY
-  {
-    _tao_elem = IR_UnionDef::_nil ();
-    return 0;
-  }
-  ACE_ENDTRY;
-  _tao_elem = IR_UnionDef::_nil ();
-  return 0;
-}
-
-#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
-    defined (ACE_HAS_GNU_REPO)
-    template class TAO_Object_Manager<IR_UnionDef,IR_UnionDef_var>;
-  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
-  #  pragma instantiate TAO_Object_Manager<IR_UnionDef,IR_UnionDef_var>
-#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
-
-void operator<<= (CORBA::Any &_tao_any, IR_EnumDef_ptr _tao_elem)
-{
-  TAO_OutputCDR stream;
-  if (stream << _tao_elem)
-  {
-    _tao_any._tao_replace (
-        IR::_tc_EnumDef, 
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin (),
-        1,
-        IR_EnumDef::_duplicate (_tao_elem),
-        IR_EnumDef::_tao_any_destructor
-      );
-  }
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR_EnumDef_ptr &_tao_elem)
-{
-  ACE_TRY_NEW_ENV
-  {
-    _tao_elem = IR_EnumDef::_nil ();
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (IR::_tc_EnumDef, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    TAO_InputCDR stream (
-        _tao_any._tao_get_cdr (),
-        _tao_any._tao_byte_order ()
-      );
-    if (stream >> _tao_elem)
-    {
-      ((CORBA::Any *)&_tao_any)->_tao_replace (
-          IR::_tc_EnumDef,
-          1,
-          _tao_elem,
-          IR_EnumDef::_tao_any_destructor
-        );
-      return 1;
-    }
-  }
-  ACE_CATCHANY
-  {
-    _tao_elem = IR_EnumDef::_nil ();
-    return 0;
-  }
-  ACE_ENDTRY;
-  _tao_elem = IR_EnumDef::_nil ();
-  return 0;
-}
-
-#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
-    defined (ACE_HAS_GNU_REPO)
-    template class TAO_Object_Manager<IR_EnumDef,IR_EnumDef_var>;
-  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
-  #  pragma instantiate TAO_Object_Manager<IR_EnumDef,IR_EnumDef_var>
-#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
-
-void operator<<= (CORBA::Any &_tao_any, IR_AliasDef_ptr _tao_elem)
-{
-  TAO_OutputCDR stream;
-  if (stream << _tao_elem)
-  {
-    _tao_any._tao_replace (
-        IR::_tc_AliasDef, 
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin (),
-        1,
-        IR_AliasDef::_duplicate (_tao_elem),
-        IR_AliasDef::_tao_any_destructor
-      );
-  }
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR_AliasDef_ptr &_tao_elem)
-{
-  ACE_TRY_NEW_ENV
-  {
-    _tao_elem = IR_AliasDef::_nil ();
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (IR::_tc_AliasDef, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    TAO_InputCDR stream (
-        _tao_any._tao_get_cdr (),
-        _tao_any._tao_byte_order ()
-      );
-    if (stream >> _tao_elem)
-    {
-      ((CORBA::Any *)&_tao_any)->_tao_replace (
-          IR::_tc_AliasDef,
-          1,
-          _tao_elem,
-          IR_AliasDef::_tao_any_destructor
-        );
-      return 1;
-    }
-  }
-  ACE_CATCHANY
-  {
-    _tao_elem = IR_AliasDef::_nil ();
-    return 0;
-  }
-  ACE_ENDTRY;
-  _tao_elem = IR_AliasDef::_nil ();
-  return 0;
-}
-
-#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
-    defined (ACE_HAS_GNU_REPO)
-    template class TAO_Object_Manager<IR_AliasDef,IR_AliasDef_var>;
-  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
-  #  pragma instantiate TAO_Object_Manager<IR_AliasDef,IR_AliasDef_var>
-#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
-
-void operator<<= (CORBA::Any &_tao_any, IR_NativeDef_ptr _tao_elem)
-{
-  TAO_OutputCDR stream;
-  if (stream << _tao_elem)
-  {
-    _tao_any._tao_replace (
-        IR::_tc_NativeDef, 
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin (),
-        1,
-        IR_NativeDef::_duplicate (_tao_elem),
-        IR_NativeDef::_tao_any_destructor
-      );
-  }
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR_NativeDef_ptr &_tao_elem)
-{
-  ACE_TRY_NEW_ENV
-  {
-    _tao_elem = IR_NativeDef::_nil ();
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (IR::_tc_NativeDef, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    TAO_InputCDR stream (
-        _tao_any._tao_get_cdr (),
-        _tao_any._tao_byte_order ()
-      );
-    if (stream >> _tao_elem)
-    {
-      ((CORBA::Any *)&_tao_any)->_tao_replace (
-          IR::_tc_NativeDef,
-          1,
-          _tao_elem,
-          IR_NativeDef::_tao_any_destructor
-        );
-      return 1;
-    }
-  }
-  ACE_CATCHANY
-  {
-    _tao_elem = IR_NativeDef::_nil ();
-    return 0;
-  }
-  ACE_ENDTRY;
-  _tao_elem = IR_NativeDef::_nil ();
-  return 0;
-}
-
-#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
-    defined (ACE_HAS_GNU_REPO)
-    template class TAO_Object_Manager<IR_NativeDef,IR_NativeDef_var>;
-  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
-  #  pragma instantiate TAO_Object_Manager<IR_NativeDef,IR_NativeDef_var>
-#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
-
-void operator<<= (CORBA::Any &_tao_any, IR_PrimitiveDef_ptr _tao_elem)
-{
-  TAO_OutputCDR stream;
-  if (stream << _tao_elem)
-  {
-    _tao_any._tao_replace (
-        IR::_tc_PrimitiveDef, 
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin (),
-        1,
-        IR_PrimitiveDef::_duplicate (_tao_elem),
-        IR_PrimitiveDef::_tao_any_destructor
-      );
-  }
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR_PrimitiveDef_ptr &_tao_elem)
-{
-  ACE_TRY_NEW_ENV
-  {
-    _tao_elem = IR_PrimitiveDef::_nil ();
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (IR::_tc_PrimitiveDef, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    TAO_InputCDR stream (
-        _tao_any._tao_get_cdr (),
-        _tao_any._tao_byte_order ()
-      );
-    if (stream >> _tao_elem)
-    {
-      ((CORBA::Any *)&_tao_any)->_tao_replace (
-          IR::_tc_PrimitiveDef,
-          1,
-          _tao_elem,
-          IR_PrimitiveDef::_tao_any_destructor
-        );
-      return 1;
-    }
-  }
-  ACE_CATCHANY
-  {
-    _tao_elem = IR_PrimitiveDef::_nil ();
-    return 0;
-  }
-  ACE_ENDTRY;
-  _tao_elem = IR_PrimitiveDef::_nil ();
-  return 0;
-}
-
-#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
-    defined (ACE_HAS_GNU_REPO)
-    template class TAO_Object_Manager<IR_PrimitiveDef,IR_PrimitiveDef_var>;
-  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
-  #  pragma instantiate TAO_Object_Manager<IR_PrimitiveDef,IR_PrimitiveDef_var>
-#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
-
-void operator<<= (CORBA::Any &_tao_any, IR_StringDef_ptr _tao_elem)
-{
-  TAO_OutputCDR stream;
-  if (stream << _tao_elem)
-  {
-    _tao_any._tao_replace (
-        IR::_tc_StringDef, 
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin (),
-        1,
-        IR_StringDef::_duplicate (_tao_elem),
-        IR_StringDef::_tao_any_destructor
-      );
-  }
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR_StringDef_ptr &_tao_elem)
-{
-  ACE_TRY_NEW_ENV
-  {
-    _tao_elem = IR_StringDef::_nil ();
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (IR::_tc_StringDef, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    TAO_InputCDR stream (
-        _tao_any._tao_get_cdr (),
-        _tao_any._tao_byte_order ()
-      );
-    if (stream >> _tao_elem)
-    {
-      ((CORBA::Any *)&_tao_any)->_tao_replace (
-          IR::_tc_StringDef,
-          1,
-          _tao_elem,
-          IR_StringDef::_tao_any_destructor
-        );
-      return 1;
-    }
-  }
-  ACE_CATCHANY
-  {
-    _tao_elem = IR_StringDef::_nil ();
-    return 0;
-  }
-  ACE_ENDTRY;
-  _tao_elem = IR_StringDef::_nil ();
-  return 0;
-}
-
-#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
-    defined (ACE_HAS_GNU_REPO)
-    template class TAO_Object_Manager<IR_StringDef,IR_StringDef_var>;
-  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
-  #  pragma instantiate TAO_Object_Manager<IR_StringDef,IR_StringDef_var>
-#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
-
-void operator<<= (CORBA::Any &_tao_any, IR_WstringDef_ptr _tao_elem)
-{
-  TAO_OutputCDR stream;
-  if (stream << _tao_elem)
-  {
-    _tao_any._tao_replace (
-        IR::_tc_WstringDef, 
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin (),
-        1,
-        IR_WstringDef::_duplicate (_tao_elem),
-        IR_WstringDef::_tao_any_destructor
-      );
-  }
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR_WstringDef_ptr &_tao_elem)
-{
-  ACE_TRY_NEW_ENV
-  {
-    _tao_elem = IR_WstringDef::_nil ();
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (IR::_tc_WstringDef, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    TAO_InputCDR stream (
-        _tao_any._tao_get_cdr (),
-        _tao_any._tao_byte_order ()
-      );
-    if (stream >> _tao_elem)
-    {
-      ((CORBA::Any *)&_tao_any)->_tao_replace (
-          IR::_tc_WstringDef,
-          1,
-          _tao_elem,
-          IR_WstringDef::_tao_any_destructor
-        );
-      return 1;
-    }
-  }
-  ACE_CATCHANY
-  {
-    _tao_elem = IR_WstringDef::_nil ();
-    return 0;
-  }
-  ACE_ENDTRY;
-  _tao_elem = IR_WstringDef::_nil ();
-  return 0;
-}
-
-#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
-    defined (ACE_HAS_GNU_REPO)
-    template class TAO_Object_Manager<IR_WstringDef,IR_WstringDef_var>;
-  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
-  #  pragma instantiate TAO_Object_Manager<IR_WstringDef,IR_WstringDef_var>
-#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
-
-void operator<<= (CORBA::Any &_tao_any, IR_FixedDef_ptr _tao_elem)
-{
-  TAO_OutputCDR stream;
-  if (stream << _tao_elem)
-  {
-    _tao_any._tao_replace (
-        IR::_tc_FixedDef, 
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin (),
-        1,
-        IR_FixedDef::_duplicate (_tao_elem),
-        IR_FixedDef::_tao_any_destructor
-      );
-  }
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR_FixedDef_ptr &_tao_elem)
-{
-  ACE_TRY_NEW_ENV
-  {
-    _tao_elem = IR_FixedDef::_nil ();
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (IR::_tc_FixedDef, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    TAO_InputCDR stream (
-        _tao_any._tao_get_cdr (),
-        _tao_any._tao_byte_order ()
-      );
-    if (stream >> _tao_elem)
-    {
-      ((CORBA::Any *)&_tao_any)->_tao_replace (
-          IR::_tc_FixedDef,
-          1,
-          _tao_elem,
-          IR_FixedDef::_tao_any_destructor
-        );
-      return 1;
-    }
-  }
-  ACE_CATCHANY
-  {
-    _tao_elem = IR_FixedDef::_nil ();
-    return 0;
-  }
-  ACE_ENDTRY;
-  _tao_elem = IR_FixedDef::_nil ();
-  return 0;
-}
-
-#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
-    defined (ACE_HAS_GNU_REPO)
-    template class TAO_Object_Manager<IR_FixedDef,IR_FixedDef_var>;
-  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
-  #  pragma instantiate TAO_Object_Manager<IR_FixedDef,IR_FixedDef_var>
-#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
-
-void operator<<= (CORBA::Any &_tao_any, IR_SequenceDef_ptr _tao_elem)
-{
-  TAO_OutputCDR stream;
-  if (stream << _tao_elem)
-  {
-    _tao_any._tao_replace (
-        IR::_tc_SequenceDef, 
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin (),
-        1,
-        IR_SequenceDef::_duplicate (_tao_elem),
-        IR_SequenceDef::_tao_any_destructor
-      );
-  }
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR_SequenceDef_ptr &_tao_elem)
-{
-  ACE_TRY_NEW_ENV
-  {
-    _tao_elem = IR_SequenceDef::_nil ();
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (IR::_tc_SequenceDef, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    TAO_InputCDR stream (
-        _tao_any._tao_get_cdr (),
-        _tao_any._tao_byte_order ()
-      );
-    if (stream >> _tao_elem)
-    {
-      ((CORBA::Any *)&_tao_any)->_tao_replace (
-          IR::_tc_SequenceDef,
-          1,
-          _tao_elem,
-          IR_SequenceDef::_tao_any_destructor
-        );
-      return 1;
-    }
-  }
-  ACE_CATCHANY
-  {
-    _tao_elem = IR_SequenceDef::_nil ();
-    return 0;
-  }
-  ACE_ENDTRY;
-  _tao_elem = IR_SequenceDef::_nil ();
-  return 0;
-}
-
-#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
-    defined (ACE_HAS_GNU_REPO)
-    template class TAO_Object_Manager<IR_SequenceDef,IR_SequenceDef_var>;
-  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
-  #  pragma instantiate TAO_Object_Manager<IR_SequenceDef,IR_SequenceDef_var>
-#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
-
-void operator<<= (CORBA::Any &_tao_any, IR_ArrayDef_ptr _tao_elem)
-{
-  TAO_OutputCDR stream;
-  if (stream << _tao_elem)
-  {
-    _tao_any._tao_replace (
-        IR::_tc_ArrayDef, 
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin (),
-        1,
-        IR_ArrayDef::_duplicate (_tao_elem),
-        IR_ArrayDef::_tao_any_destructor
-      );
-  }
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR_ArrayDef_ptr &_tao_elem)
-{
-  ACE_TRY_NEW_ENV
-  {
-    _tao_elem = IR_ArrayDef::_nil ();
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (IR::_tc_ArrayDef, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    TAO_InputCDR stream (
-        _tao_any._tao_get_cdr (),
-        _tao_any._tao_byte_order ()
-      );
-    if (stream >> _tao_elem)
-    {
-      ((CORBA::Any *)&_tao_any)->_tao_replace (
-          IR::_tc_ArrayDef,
-          1,
-          _tao_elem,
-          IR_ArrayDef::_tao_any_destructor
-        );
-      return 1;
-    }
-  }
-  ACE_CATCHANY
-  {
-    _tao_elem = IR_ArrayDef::_nil ();
-    return 0;
-  }
-  ACE_ENDTRY;
-  _tao_elem = IR_ArrayDef::_nil ();
-  return 0;
-}
-
-#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
-    defined (ACE_HAS_GNU_REPO)
-    template class TAO_Object_Manager<IR_ArrayDef,IR_ArrayDef_var>;
-  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
-  #  pragma instantiate TAO_Object_Manager<IR_ArrayDef,IR_ArrayDef_var>
-#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
-
-void operator<<= (CORBA::Any &_tao_any, IR_ExceptionDef_ptr _tao_elem)
-{
-  TAO_OutputCDR stream;
-  if (stream << _tao_elem)
-  {
-    _tao_any._tao_replace (
-        IR::_tc_ExceptionDef, 
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin (),
-        1,
-        IR_ExceptionDef::_duplicate (_tao_elem),
-        IR_ExceptionDef::_tao_any_destructor
-      );
-  }
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR_ExceptionDef_ptr &_tao_elem)
-{
-  ACE_TRY_NEW_ENV
-  {
-    _tao_elem = IR_ExceptionDef::_nil ();
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (IR::_tc_ExceptionDef, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    TAO_InputCDR stream (
-        _tao_any._tao_get_cdr (),
-        _tao_any._tao_byte_order ()
-      );
-    if (stream >> _tao_elem)
-    {
-      ((CORBA::Any *)&_tao_any)->_tao_replace (
-          IR::_tc_ExceptionDef,
-          1,
-          _tao_elem,
-          IR_ExceptionDef::_tao_any_destructor
-        );
-      return 1;
-    }
-  }
-  ACE_CATCHANY
-  {
-    _tao_elem = IR_ExceptionDef::_nil ();
-    return 0;
-  }
-  ACE_ENDTRY;
-  _tao_elem = IR_ExceptionDef::_nil ();
-  return 0;
-}
-
-#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
-    defined (ACE_HAS_GNU_REPO)
-    template class TAO_Object_Manager<IR_ExceptionDef,IR_ExceptionDef_var>;
-  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
-  #  pragma instantiate TAO_Object_Manager<IR_ExceptionDef,IR_ExceptionDef_var>
-#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
-
-void operator<<= (CORBA::Any &_tao_any, const IR_ExceptionDescription &_tao_elem) // copying
-{
-  TAO_OutputCDR stream;
-  stream << _tao_elem;
-  _tao_any._tao_replace (
-      IR::_tc_ExceptionDescription,
-      TAO_ENCAP_BYTE_ORDER,
-      stream.begin ()
-    );
-}
-
-void operator<<= (CORBA::Any &_tao_any, IR_ExceptionDescription *_tao_elem) // non copying
-{
-  TAO_OutputCDR stream;
-  stream << *_tao_elem;
-  _tao_any._tao_replace (
-      IR::_tc_ExceptionDescription,
-      TAO_ENCAP_BYTE_ORDER,
-      stream.begin (),
-      1,
-      _tao_elem,
-      IR_ExceptionDescription::_tao_any_destructor
-    );
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR_ExceptionDescription *&_tao_elem)
-{
-  return _tao_any >>= ACE_const_cast(const IR_ExceptionDescription*&,_tao_elem);
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR_ExceptionDescription *&_tao_elem)
-{
-  _tao_elem = 0;
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (IR::_tc_ExceptionDescription, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    if (_tao_any.any_owns_data ())
-    {
-      _tao_elem = ACE_static_cast(
-          const IR_ExceptionDescription*,
-          _tao_any.value ()
-        );
-      return 1;
-    }
-    else
-    {
-      IR_ExceptionDescription *tmp;
-      ACE_NEW_RETURN (tmp, IR_ExceptionDescription, 0);
-      TAO_InputCDR stream (
-          _tao_any._tao_get_cdr (),
-          _tao_any._tao_byte_order ()
-        );
-      if (stream >> *tmp)
-      {
-        ((CORBA::Any *)&_tao_any)->_tao_replace (
-            IR::_tc_ExceptionDescription,
-            1,
-            ACE_static_cast (void *, tmp),
-            IR_ExceptionDescription::_tao_any_destructor
-          );
-        _tao_elem = tmp;
-        return 1;
-      }
-      else
-      {
-        delete tmp;
-      }
-    }
-  }
-  ACE_CATCHANY
-  {
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-void operator<<= (
-    CORBA::Any &_tao_any,
-    const IR_ExceptionDefSeq &_tao_elem
-  ) // copying
-{
-  TAO_OutputCDR stream;
-  if (stream << _tao_elem)
-  {
-    _tao_any._tao_replace (
-        IR::_tc_ExceptionDefSeq,
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin ()
-      );
-  }
-}
-
-void operator<<= (CORBA::Any &_tao_any, IR_ExceptionDefSeq *_tao_elem) // non copying
-{
-  TAO_OutputCDR stream;
-  stream << *_tao_elem;
-  _tao_any._tao_replace (
-      IR::_tc_ExceptionDefSeq,
-      TAO_ENCAP_BYTE_ORDER,
-      stream.begin (),
-      1,
-      _tao_elem,
-      IR_ExceptionDefSeq::_tao_any_destructor
-    );
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR_ExceptionDefSeq *&_tao_elem)
-{
-  return _tao_any >>= ACE_const_cast(
-      const IR_ExceptionDefSeq*&,
-      _tao_elem
-    );
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR_ExceptionDefSeq *&_tao_elem)
-{
-  _tao_elem = 0;
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (IR::_tc_ExceptionDefSeq, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    if (_tao_any.any_owns_data ())
-    {
-      _tao_elem = ACE_static_cast(
-          const IR_ExceptionDefSeq*,
-          _tao_any.value ()
-        );
-      return 1;
-    }
-    else
-    {
-      IR_ExceptionDefSeq *tmp;
-      ACE_NEW_RETURN (tmp, IR_ExceptionDefSeq, 0);
-      TAO_InputCDR stream (
-          _tao_any._tao_get_cdr (),
-          _tao_any._tao_byte_order ()
-        );
-      if (stream >> *tmp)
-      {
-        ((CORBA::Any *)&_tao_any)->_tao_replace (
-            IR::_tc_ExceptionDefSeq,
-            1,
-            ACE_static_cast (void *, tmp),
-            IR_ExceptionDefSeq::_tao_any_destructor
-          );
-        _tao_elem = tmp;
-        return 1;
-      }
-      else
-      {
-        delete tmp;
-      }
-    }
-  }
-  ACE_CATCHANY
-  {
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-void operator<<= (
-    CORBA::Any &_tao_any,
-    const IR_ExcDescriptionSeq &_tao_elem
-  ) // copying
-{
-  TAO_OutputCDR stream;
-  if (stream << _tao_elem)
-  {
-    _tao_any._tao_replace (
-        IR::_tc_ExcDescriptionSeq,
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin ()
-      );
-  }
-}
-
-void operator<<= (CORBA::Any &_tao_any, IR_ExcDescriptionSeq *_tao_elem) // non copying
-{
-  TAO_OutputCDR stream;
-  stream << *_tao_elem;
-  _tao_any._tao_replace (
-      IR::_tc_ExcDescriptionSeq,
-      TAO_ENCAP_BYTE_ORDER,
-      stream.begin (),
-      1,
-      _tao_elem,
-      IR_ExcDescriptionSeq::_tao_any_destructor
-    );
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR_ExcDescriptionSeq *&_tao_elem)
-{
-  return _tao_any >>= ACE_const_cast(
-      const IR_ExcDescriptionSeq*&,
-      _tao_elem
-    );
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR_ExcDescriptionSeq *&_tao_elem)
-{
-  _tao_elem = 0;
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (IR::_tc_ExcDescriptionSeq, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    if (_tao_any.any_owns_data ())
-    {
-      _tao_elem = ACE_static_cast(
-          const IR_ExcDescriptionSeq*,
-          _tao_any.value ()
-        );
-      return 1;
-    }
-    else
-    {
-      IR_ExcDescriptionSeq *tmp;
-      ACE_NEW_RETURN (tmp, IR_ExcDescriptionSeq, 0);
-      TAO_InputCDR stream (
-          _tao_any._tao_get_cdr (),
-          _tao_any._tao_byte_order ()
-        );
-      if (stream >> *tmp)
-      {
-        ((CORBA::Any *)&_tao_any)->_tao_replace (
-            IR::_tc_ExcDescriptionSeq,
-            1,
-            ACE_static_cast (void *, tmp),
-            IR_ExcDescriptionSeq::_tao_any_destructor
-          );
-        _tao_elem = tmp;
-        return 1;
-      }
-      else
-      {
-        delete tmp;
-      }
-    }
-  }
-  ACE_CATCHANY
-  {
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-void operator<<= (CORBA::Any &_tao_any, IR_AttributeMode _tao_elem)
-{
-  TAO_OutputCDR stream;
-  stream << _tao_elem;
-  _tao_any._tao_replace (
-      IR::_tc_AttributeMode,
-      TAO_ENCAP_BYTE_ORDER,
-      stream.begin ()
-    );
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR_AttributeMode &_tao_elem)
-{
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (IR::_tc_AttributeMode, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    TAO_InputCDR stream (
-        _tao_any._tao_get_cdr (),
-        _tao_any._tao_byte_order ()
-      );
-    if (stream >> _tao_elem)
-    {
-      return 1;
-    }
-  }
-  ACE_CATCHANY
-  {
-    return 0;
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-void operator<<= (CORBA::Any &_tao_any, IR_AttributeDef_ptr _tao_elem)
-{
-  TAO_OutputCDR stream;
-  if (stream << _tao_elem)
-  {
-    _tao_any._tao_replace (
-        IR::_tc_AttributeDef, 
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin (),
-        1,
-        IR_AttributeDef::_duplicate (_tao_elem),
-        IR_AttributeDef::_tao_any_destructor
-      );
-  }
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR_AttributeDef_ptr &_tao_elem)
-{
-  ACE_TRY_NEW_ENV
-  {
-    _tao_elem = IR_AttributeDef::_nil ();
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (IR::_tc_AttributeDef, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    TAO_InputCDR stream (
-        _tao_any._tao_get_cdr (),
-        _tao_any._tao_byte_order ()
-      );
-    if (stream >> _tao_elem)
-    {
-      ((CORBA::Any *)&_tao_any)->_tao_replace (
-          IR::_tc_AttributeDef,
-          1,
-          _tao_elem,
-          IR_AttributeDef::_tao_any_destructor
-        );
-      return 1;
-    }
-  }
-  ACE_CATCHANY
-  {
-    _tao_elem = IR_AttributeDef::_nil ();
-    return 0;
-  }
-  ACE_ENDTRY;
-  _tao_elem = IR_AttributeDef::_nil ();
-  return 0;
-}
-
-#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
-    defined (ACE_HAS_GNU_REPO)
-    template class TAO_Object_Manager<IR_AttributeDef,IR_AttributeDef_var>;
-  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
-  #  pragma instantiate TAO_Object_Manager<IR_AttributeDef,IR_AttributeDef_var>
-#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
-
-void operator<<= (CORBA::Any &_tao_any, const IR_AttributeDescription &_tao_elem) // copying
-{
-  TAO_OutputCDR stream;
-  stream << _tao_elem;
-  _tao_any._tao_replace (
-      IR::_tc_AttributeDescription,
-      TAO_ENCAP_BYTE_ORDER,
-      stream.begin ()
-    );
-}
-
-void operator<<= (CORBA::Any &_tao_any, IR_AttributeDescription *_tao_elem) // non copying
-{
-  TAO_OutputCDR stream;
-  stream << *_tao_elem;
-  _tao_any._tao_replace (
-      IR::_tc_AttributeDescription,
-      TAO_ENCAP_BYTE_ORDER,
-      stream.begin (),
-      1,
-      _tao_elem,
-      IR_AttributeDescription::_tao_any_destructor
-    );
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR_AttributeDescription *&_tao_elem)
-{
-  return _tao_any >>= ACE_const_cast(const IR_AttributeDescription*&,_tao_elem);
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR_AttributeDescription *&_tao_elem)
-{
-  _tao_elem = 0;
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (IR::_tc_AttributeDescription, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    if (_tao_any.any_owns_data ())
-    {
-      _tao_elem = ACE_static_cast(
-          const IR_AttributeDescription*,
-          _tao_any.value ()
-        );
-      return 1;
-    }
-    else
-    {
-      IR_AttributeDescription *tmp;
-      ACE_NEW_RETURN (tmp, IR_AttributeDescription, 0);
-      TAO_InputCDR stream (
-          _tao_any._tao_get_cdr (),
-          _tao_any._tao_byte_order ()
-        );
-      if (stream >> *tmp)
-      {
-        ((CORBA::Any *)&_tao_any)->_tao_replace (
-            IR::_tc_AttributeDescription,
-            1,
-            ACE_static_cast (void *, tmp),
-            IR_AttributeDescription::_tao_any_destructor
-          );
-        _tao_elem = tmp;
-        return 1;
-      }
-      else
-      {
-        delete tmp;
-      }
-    }
-  }
-  ACE_CATCHANY
-  {
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-void operator<<= (CORBA::Any &_tao_any, IR_OperationMode _tao_elem)
-{
-  TAO_OutputCDR stream;
-  stream << _tao_elem;
-  _tao_any._tao_replace (
-      IR::_tc_OperationMode,
-      TAO_ENCAP_BYTE_ORDER,
-      stream.begin ()
-    );
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR_OperationMode &_tao_elem)
-{
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (IR::_tc_OperationMode, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    TAO_InputCDR stream (
-        _tao_any._tao_get_cdr (),
-        _tao_any._tao_byte_order ()
-      );
-    if (stream >> _tao_elem)
-    {
-      return 1;
-    }
-  }
-  ACE_CATCHANY
-  {
-    return 0;
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-void operator<<= (CORBA::Any &_tao_any, IR_ParameterMode _tao_elem)
-{
-  TAO_OutputCDR stream;
-  stream << _tao_elem;
-  _tao_any._tao_replace (
-      IR::_tc_ParameterMode,
-      TAO_ENCAP_BYTE_ORDER,
-      stream.begin ()
-    );
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR_ParameterMode &_tao_elem)
-{
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (IR::_tc_ParameterMode, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    TAO_InputCDR stream (
-        _tao_any._tao_get_cdr (),
-        _tao_any._tao_byte_order ()
-      );
-    if (stream >> _tao_elem)
-    {
-      return 1;
-    }
-  }
-  ACE_CATCHANY
-  {
-    return 0;
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-void operator<<= (CORBA::Any &_tao_any, const IR_ParameterDescription &_tao_elem) // copying
-{
-  TAO_OutputCDR stream;
-  stream << _tao_elem;
-  _tao_any._tao_replace (
-      IR::_tc_ParameterDescription,
-      TAO_ENCAP_BYTE_ORDER,
-      stream.begin ()
-    );
-}
-
-void operator<<= (CORBA::Any &_tao_any, IR_ParameterDescription *_tao_elem) // non copying
-{
-  TAO_OutputCDR stream;
-  stream << *_tao_elem;
-  _tao_any._tao_replace (
-      IR::_tc_ParameterDescription,
-      TAO_ENCAP_BYTE_ORDER,
-      stream.begin (),
-      1,
-      _tao_elem,
-      IR_ParameterDescription::_tao_any_destructor
-    );
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR_ParameterDescription *&_tao_elem)
-{
-  return _tao_any >>= ACE_const_cast(const IR_ParameterDescription*&,_tao_elem);
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR_ParameterDescription *&_tao_elem)
-{
-  _tao_elem = 0;
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (IR::_tc_ParameterDescription, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    if (_tao_any.any_owns_data ())
-    {
-      _tao_elem = ACE_static_cast(
-          const IR_ParameterDescription*,
-          _tao_any.value ()
-        );
-      return 1;
-    }
-    else
-    {
-      IR_ParameterDescription *tmp;
-      ACE_NEW_RETURN (tmp, IR_ParameterDescription, 0);
-      TAO_InputCDR stream (
-          _tao_any._tao_get_cdr (),
-          _tao_any._tao_byte_order ()
-        );
-      if (stream >> *tmp)
-      {
-        ((CORBA::Any *)&_tao_any)->_tao_replace (
-            IR::_tc_ParameterDescription,
-            1,
-            ACE_static_cast (void *, tmp),
-            IR_ParameterDescription::_tao_any_destructor
-          );
-        _tao_elem = tmp;
-        return 1;
-      }
-      else
-      {
-        delete tmp;
-      }
-    }
-  }
-  ACE_CATCHANY
-  {
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-void operator<<= (
-    CORBA::Any &_tao_any,
-    const IR_ParDescriptionSeq &_tao_elem
-  ) // copying
-{
-  TAO_OutputCDR stream;
-  if (stream << _tao_elem)
-  {
-    _tao_any._tao_replace (
-        IR::_tc_ParDescriptionSeq,
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin ()
-      );
-  }
-}
-
-void operator<<= (CORBA::Any &_tao_any, IR_ParDescriptionSeq *_tao_elem) // non copying
-{
-  TAO_OutputCDR stream;
-  stream << *_tao_elem;
-  _tao_any._tao_replace (
-      IR::_tc_ParDescriptionSeq,
-      TAO_ENCAP_BYTE_ORDER,
-      stream.begin (),
-      1,
-      _tao_elem,
-      IR_ParDescriptionSeq::_tao_any_destructor
-    );
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR_ParDescriptionSeq *&_tao_elem)
-{
-  return _tao_any >>= ACE_const_cast(
-      const IR_ParDescriptionSeq*&,
-      _tao_elem
-    );
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR_ParDescriptionSeq *&_tao_elem)
-{
-  _tao_elem = 0;
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (IR::_tc_ParDescriptionSeq, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    if (_tao_any.any_owns_data ())
-    {
-      _tao_elem = ACE_static_cast(
-          const IR_ParDescriptionSeq*,
-          _tao_any.value ()
-        );
-      return 1;
-    }
-    else
-    {
-      IR_ParDescriptionSeq *tmp;
-      ACE_NEW_RETURN (tmp, IR_ParDescriptionSeq, 0);
-      TAO_InputCDR stream (
-          _tao_any._tao_get_cdr (),
-          _tao_any._tao_byte_order ()
-        );
-      if (stream >> *tmp)
-      {
-        ((CORBA::Any *)&_tao_any)->_tao_replace (
-            IR::_tc_ParDescriptionSeq,
-            1,
-            ACE_static_cast (void *, tmp),
-            IR_ParDescriptionSeq::_tao_any_destructor
-          );
-        _tao_elem = tmp;
-        return 1;
-      }
-      else
-      {
-        delete tmp;
-      }
-    }
-  }
-  ACE_CATCHANY
-  {
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-void operator<<= (
-    CORBA::Any &_tao_any,
-    const IR_ContextIdSeq &_tao_elem
-  ) // copying
-{
-  TAO_OutputCDR stream;
-  if (stream << _tao_elem)
-  {
-    _tao_any._tao_replace (
-        IR::_tc_ContextIdSeq,
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin ()
-      );
-  }
-}
-
-void operator<<= (CORBA::Any &_tao_any, IR_ContextIdSeq *_tao_elem) // non copying
-{
-  TAO_OutputCDR stream;
-  stream << *_tao_elem;
-  _tao_any._tao_replace (
-      IR::_tc_ContextIdSeq,
-      TAO_ENCAP_BYTE_ORDER,
-      stream.begin (),
-      1,
-      _tao_elem,
-      IR_ContextIdSeq::_tao_any_destructor
-    );
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR_ContextIdSeq *&_tao_elem)
-{
-  return _tao_any >>= ACE_const_cast(
-      const IR_ContextIdSeq*&,
-      _tao_elem
-    );
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR_ContextIdSeq *&_tao_elem)
-{
-  _tao_elem = 0;
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (IR::_tc_ContextIdSeq, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    if (_tao_any.any_owns_data ())
-    {
-      _tao_elem = ACE_static_cast(
-          const IR_ContextIdSeq*,
-          _tao_any.value ()
-        );
-      return 1;
-    }
-    else
-    {
-      IR_ContextIdSeq *tmp;
-      ACE_NEW_RETURN (tmp, IR_ContextIdSeq, 0);
-      TAO_InputCDR stream (
-          _tao_any._tao_get_cdr (),
-          _tao_any._tao_byte_order ()
-        );
-      if (stream >> *tmp)
-      {
-        ((CORBA::Any *)&_tao_any)->_tao_replace (
-            IR::_tc_ContextIdSeq,
-            1,
-            ACE_static_cast (void *, tmp),
-            IR_ContextIdSeq::_tao_any_destructor
-          );
-        _tao_elem = tmp;
-        return 1;
-      }
-      else
-      {
-        delete tmp;
-      }
-    }
-  }
-  ACE_CATCHANY
-  {
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-void operator<<= (CORBA::Any &_tao_any, IR_OperationDef_ptr _tao_elem)
-{
-  TAO_OutputCDR stream;
-  if (stream << _tao_elem)
-  {
-    _tao_any._tao_replace (
-        IR::_tc_OperationDef, 
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin (),
-        1,
-        IR_OperationDef::_duplicate (_tao_elem),
-        IR_OperationDef::_tao_any_destructor
-      );
-  }
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR_OperationDef_ptr &_tao_elem)
-{
-  ACE_TRY_NEW_ENV
-  {
-    _tao_elem = IR_OperationDef::_nil ();
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (IR::_tc_OperationDef, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    TAO_InputCDR stream (
-        _tao_any._tao_get_cdr (),
-        _tao_any._tao_byte_order ()
-      );
-    if (stream >> _tao_elem)
-    {
-      ((CORBA::Any *)&_tao_any)->_tao_replace (
-          IR::_tc_OperationDef,
-          1,
-          _tao_elem,
-          IR_OperationDef::_tao_any_destructor
-        );
-      return 1;
-    }
-  }
-  ACE_CATCHANY
-  {
-    _tao_elem = IR_OperationDef::_nil ();
-    return 0;
-  }
-  ACE_ENDTRY;
-  _tao_elem = IR_OperationDef::_nil ();
-  return 0;
-}
-
-#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
-    defined (ACE_HAS_GNU_REPO)
-    template class TAO_Object_Manager<IR_OperationDef,IR_OperationDef_var>;
-  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
-  #  pragma instantiate TAO_Object_Manager<IR_OperationDef,IR_OperationDef_var>
-#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
-
-void operator<<= (CORBA::Any &_tao_any, const IR_OperationDescription &_tao_elem) // copying
-{
-  TAO_OutputCDR stream;
-  stream << _tao_elem;
-  _tao_any._tao_replace (
-      IR::_tc_OperationDescription,
-      TAO_ENCAP_BYTE_ORDER,
-      stream.begin ()
-    );
-}
-
-void operator<<= (CORBA::Any &_tao_any, IR_OperationDescription *_tao_elem) // non copying
-{
-  TAO_OutputCDR stream;
-  stream << *_tao_elem;
-  _tao_any._tao_replace (
-      IR::_tc_OperationDescription,
-      TAO_ENCAP_BYTE_ORDER,
-      stream.begin (),
-      1,
-      _tao_elem,
-      IR_OperationDescription::_tao_any_destructor
-    );
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR_OperationDescription *&_tao_elem)
-{
-  return _tao_any >>= ACE_const_cast(const IR_OperationDescription*&,_tao_elem);
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR_OperationDescription *&_tao_elem)
-{
-  _tao_elem = 0;
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (IR::_tc_OperationDescription, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    if (_tao_any.any_owns_data ())
-    {
-      _tao_elem = ACE_static_cast(
-          const IR_OperationDescription*,
-          _tao_any.value ()
-        );
-      return 1;
-    }
-    else
-    {
-      IR_OperationDescription *tmp;
-      ACE_NEW_RETURN (tmp, IR_OperationDescription, 0);
-      TAO_InputCDR stream (
-          _tao_any._tao_get_cdr (),
-          _tao_any._tao_byte_order ()
-        );
-      if (stream >> *tmp)
-      {
-        ((CORBA::Any *)&_tao_any)->_tao_replace (
-            IR::_tc_OperationDescription,
-            1,
-            ACE_static_cast (void *, tmp),
-            IR_OperationDescription::_tao_any_destructor
-          );
-        _tao_elem = tmp;
-        return 1;
-      }
-      else
-      {
-        delete tmp;
-      }
-    }
-  }
-  ACE_CATCHANY
-  {
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-void operator<<= (
-    CORBA::Any &_tao_any,
-    const IR_RepositoryIdSeq &_tao_elem
-  ) // copying
-{
-  TAO_OutputCDR stream;
-  if (stream << _tao_elem)
-  {
-    _tao_any._tao_replace (
-        IR::_tc_RepositoryIdSeq,
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin ()
-      );
-  }
-}
-
-void operator<<= (CORBA::Any &_tao_any, IR_RepositoryIdSeq *_tao_elem) // non copying
-{
-  TAO_OutputCDR stream;
-  stream << *_tao_elem;
-  _tao_any._tao_replace (
-      IR::_tc_RepositoryIdSeq,
-      TAO_ENCAP_BYTE_ORDER,
-      stream.begin (),
-      1,
-      _tao_elem,
-      IR_RepositoryIdSeq::_tao_any_destructor
-    );
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR_RepositoryIdSeq *&_tao_elem)
-{
-  return _tao_any >>= ACE_const_cast(
-      const IR_RepositoryIdSeq*&,
-      _tao_elem
-    );
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR_RepositoryIdSeq *&_tao_elem)
-{
-  _tao_elem = 0;
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (IR::_tc_RepositoryIdSeq, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    if (_tao_any.any_owns_data ())
-    {
-      _tao_elem = ACE_static_cast(
-          const IR_RepositoryIdSeq*,
-          _tao_any.value ()
-        );
-      return 1;
-    }
-    else
-    {
-      IR_RepositoryIdSeq *tmp;
-      ACE_NEW_RETURN (tmp, IR_RepositoryIdSeq, 0);
-      TAO_InputCDR stream (
-          _tao_any._tao_get_cdr (),
-          _tao_any._tao_byte_order ()
-        );
-      if (stream >> *tmp)
-      {
-        ((CORBA::Any *)&_tao_any)->_tao_replace (
-            IR::_tc_RepositoryIdSeq,
-            1,
-            ACE_static_cast (void *, tmp),
-            IR_RepositoryIdSeq::_tao_any_destructor
-          );
-        _tao_elem = tmp;
-        return 1;
-      }
-      else
-      {
-        delete tmp;
-      }
-    }
-  }
-  ACE_CATCHANY
-  {
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-void operator<<= (
-    CORBA::Any &_tao_any,
-    const IR_OpDescriptionSeq &_tao_elem
-  ) // copying
-{
-  TAO_OutputCDR stream;
-  if (stream << _tao_elem)
-  {
-    _tao_any._tao_replace (
-        IR::_tc_OpDescriptionSeq,
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin ()
-      );
-  }
-}
-
-void operator<<= (CORBA::Any &_tao_any, IR_OpDescriptionSeq *_tao_elem) // non copying
-{
-  TAO_OutputCDR stream;
-  stream << *_tao_elem;
-  _tao_any._tao_replace (
-      IR::_tc_OpDescriptionSeq,
-      TAO_ENCAP_BYTE_ORDER,
-      stream.begin (),
-      1,
-      _tao_elem,
-      IR_OpDescriptionSeq::_tao_any_destructor
-    );
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR_OpDescriptionSeq *&_tao_elem)
-{
-  return _tao_any >>= ACE_const_cast(
-      const IR_OpDescriptionSeq*&,
-      _tao_elem
-    );
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR_OpDescriptionSeq *&_tao_elem)
-{
-  _tao_elem = 0;
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (IR::_tc_OpDescriptionSeq, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    if (_tao_any.any_owns_data ())
-    {
-      _tao_elem = ACE_static_cast(
-          const IR_OpDescriptionSeq*,
-          _tao_any.value ()
-        );
-      return 1;
-    }
-    else
-    {
-      IR_OpDescriptionSeq *tmp;
-      ACE_NEW_RETURN (tmp, IR_OpDescriptionSeq, 0);
-      TAO_InputCDR stream (
-          _tao_any._tao_get_cdr (),
-          _tao_any._tao_byte_order ()
-        );
-      if (stream >> *tmp)
-      {
-        ((CORBA::Any *)&_tao_any)->_tao_replace (
-            IR::_tc_OpDescriptionSeq,
-            1,
-            ACE_static_cast (void *, tmp),
-            IR_OpDescriptionSeq::_tao_any_destructor
-          );
-        _tao_elem = tmp;
-        return 1;
-      }
-      else
-      {
-        delete tmp;
-      }
-    }
-  }
-  ACE_CATCHANY
-  {
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-void operator<<= (
-    CORBA::Any &_tao_any,
-    const IR_AttrDescriptionSeq &_tao_elem
-  ) // copying
-{
-  TAO_OutputCDR stream;
-  if (stream << _tao_elem)
-  {
-    _tao_any._tao_replace (
-        IR::_tc_AttrDescriptionSeq,
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin ()
-      );
-  }
-}
-
-void operator<<= (CORBA::Any &_tao_any, IR_AttrDescriptionSeq *_tao_elem) // non copying
-{
-  TAO_OutputCDR stream;
-  stream << *_tao_elem;
-  _tao_any._tao_replace (
-      IR::_tc_AttrDescriptionSeq,
-      TAO_ENCAP_BYTE_ORDER,
-      stream.begin (),
-      1,
-      _tao_elem,
-      IR_AttrDescriptionSeq::_tao_any_destructor
-    );
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR_AttrDescriptionSeq *&_tao_elem)
-{
-  return _tao_any >>= ACE_const_cast(
-      const IR_AttrDescriptionSeq*&,
-      _tao_elem
-    );
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR_AttrDescriptionSeq *&_tao_elem)
-{
-  _tao_elem = 0;
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (IR::_tc_AttrDescriptionSeq, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    if (_tao_any.any_owns_data ())
-    {
-      _tao_elem = ACE_static_cast(
-          const IR_AttrDescriptionSeq*,
-          _tao_any.value ()
-        );
-      return 1;
-    }
-    else
-    {
-      IR_AttrDescriptionSeq *tmp;
-      ACE_NEW_RETURN (tmp, IR_AttrDescriptionSeq, 0);
-      TAO_InputCDR stream (
-          _tao_any._tao_get_cdr (),
-          _tao_any._tao_byte_order ()
-        );
-      if (stream >> *tmp)
-      {
-        ((CORBA::Any *)&_tao_any)->_tao_replace (
-            IR::_tc_AttrDescriptionSeq,
-            1,
-            ACE_static_cast (void *, tmp),
-            IR_AttrDescriptionSeq::_tao_any_destructor
-          );
-        _tao_elem = tmp;
-        return 1;
-      }
-      else
-      {
-        delete tmp;
-      }
-    }
-  }
-  ACE_CATCHANY
-  {
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-void operator<<= (CORBA::Any &_tao_any, IR_InterfaceDef_ptr _tao_elem)
-{
-  TAO_OutputCDR stream;
-  if (stream << _tao_elem)
-  {
-    _tao_any._tao_replace (
-        IR::_tc_InterfaceDef, 
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin (),
-        1,
-        IR_InterfaceDef::_duplicate (_tao_elem),
-        IR_InterfaceDef::_tao_any_destructor
-      );
-  }
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR_InterfaceDef_ptr &_tao_elem)
-{
-  ACE_TRY_NEW_ENV
-  {
-    _tao_elem = IR_InterfaceDef::_nil ();
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (IR::_tc_InterfaceDef, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    TAO_InputCDR stream (
-        _tao_any._tao_get_cdr (),
-        _tao_any._tao_byte_order ()
-      );
-    if (stream >> _tao_elem)
-    {
-      ((CORBA::Any *)&_tao_any)->_tao_replace (
-          IR::_tc_InterfaceDef,
-          1,
-          _tao_elem,
-          IR_InterfaceDef::_tao_any_destructor
-        );
-      return 1;
-    }
-  }
-  ACE_CATCHANY
-  {
-    _tao_elem = IR_InterfaceDef::_nil ();
-    return 0;
-  }
-  ACE_ENDTRY;
-  _tao_elem = IR_InterfaceDef::_nil ();
-  return 0;
-}
-
-#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
-    defined (ACE_HAS_GNU_REPO)
-    template class TAO_Object_Manager<IR_InterfaceDef,IR_InterfaceDef_var>;
-  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
-  #  pragma instantiate TAO_Object_Manager<IR_InterfaceDef,IR_InterfaceDef_var>
-#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
-
-void operator<<= (CORBA::Any &_tao_any, const IR_InterfaceDescription &_tao_elem) // copying
-{
-  TAO_OutputCDR stream;
-  stream << _tao_elem;
-  _tao_any._tao_replace (
-      IR::_tc_InterfaceDescription,
-      TAO_ENCAP_BYTE_ORDER,
-      stream.begin ()
-    );
-}
-
-void operator<<= (CORBA::Any &_tao_any, IR_InterfaceDescription *_tao_elem) // non copying
-{
-  TAO_OutputCDR stream;
-  stream << *_tao_elem;
-  _tao_any._tao_replace (
-      IR::_tc_InterfaceDescription,
-      TAO_ENCAP_BYTE_ORDER,
-      stream.begin (),
-      1,
-      _tao_elem,
-      IR_InterfaceDescription::_tao_any_destructor
-    );
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR_InterfaceDescription *&_tao_elem)
-{
-  return _tao_any >>= ACE_const_cast(const IR_InterfaceDescription*&,_tao_elem);
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR_InterfaceDescription *&_tao_elem)
-{
-  _tao_elem = 0;
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (IR::_tc_InterfaceDescription, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    if (_tao_any.any_owns_data ())
-    {
-      _tao_elem = ACE_static_cast(
-          const IR_InterfaceDescription*,
-          _tao_any.value ()
-        );
-      return 1;
-    }
-    else
-    {
-      IR_InterfaceDescription *tmp;
-      ACE_NEW_RETURN (tmp, IR_InterfaceDescription, 0);
-      TAO_InputCDR stream (
-          _tao_any._tao_get_cdr (),
-          _tao_any._tao_byte_order ()
-        );
-      if (stream >> *tmp)
-      {
-        ((CORBA::Any *)&_tao_any)->_tao_replace (
-            IR::_tc_InterfaceDescription,
-            1,
-            ACE_static_cast (void *, tmp),
-            IR_InterfaceDescription::_tao_any_destructor
-          );
-        _tao_elem = tmp;
-        return 1;
-      }
-      else
-      {
-        delete tmp;
-      }
-    }
-  }
-  ACE_CATCHANY
-  {
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-void operator<<= (CORBA::Any &_tao_any, const IR_ValueMember &_tao_elem) // copying
-{
-  TAO_OutputCDR stream;
-  stream << _tao_elem;
-  _tao_any._tao_replace (
-      IR::_tc_ValueMember,
-      TAO_ENCAP_BYTE_ORDER,
-      stream.begin ()
-    );
-}
-
-void operator<<= (CORBA::Any &_tao_any, IR_ValueMember *_tao_elem) // non copying
-{
-  TAO_OutputCDR stream;
-  stream << *_tao_elem;
-  _tao_any._tao_replace (
-      IR::_tc_ValueMember,
-      TAO_ENCAP_BYTE_ORDER,
-      stream.begin (),
-      1,
-      _tao_elem,
-      IR_ValueMember::_tao_any_destructor
-    );
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR_ValueMember *&_tao_elem)
-{
-  return _tao_any >>= ACE_const_cast(const IR_ValueMember*&,_tao_elem);
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR_ValueMember *&_tao_elem)
-{
-  _tao_elem = 0;
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (IR::_tc_ValueMember, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    if (_tao_any.any_owns_data ())
-    {
-      _tao_elem = ACE_static_cast(
-          const IR_ValueMember*,
-          _tao_any.value ()
-        );
-      return 1;
-    }
-    else
-    {
-      IR_ValueMember *tmp;
-      ACE_NEW_RETURN (tmp, IR_ValueMember, 0);
-      TAO_InputCDR stream (
-          _tao_any._tao_get_cdr (),
-          _tao_any._tao_byte_order ()
-        );
-      if (stream >> *tmp)
-      {
-        ((CORBA::Any *)&_tao_any)->_tao_replace (
-            IR::_tc_ValueMember,
-            1,
-            ACE_static_cast (void *, tmp),
-            IR_ValueMember::_tao_any_destructor
-          );
-        _tao_elem = tmp;
-        return 1;
-      }
-      else
-      {
-        delete tmp;
-      }
-    }
-  }
-  ACE_CATCHANY
-  {
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-void operator<<= (
-    CORBA::Any &_tao_any,
-    const IR_ValueMemberSeq &_tao_elem
-  ) // copying
-{
-  TAO_OutputCDR stream;
-  if (stream << _tao_elem)
-  {
-    _tao_any._tao_replace (
-        IR::_tc_ValueMemberSeq,
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin ()
-      );
-  }
-}
-
-void operator<<= (CORBA::Any &_tao_any, IR_ValueMemberSeq *_tao_elem) // non copying
-{
-  TAO_OutputCDR stream;
-  stream << *_tao_elem;
-  _tao_any._tao_replace (
-      IR::_tc_ValueMemberSeq,
-      TAO_ENCAP_BYTE_ORDER,
-      stream.begin (),
-      1,
-      _tao_elem,
-      IR_ValueMemberSeq::_tao_any_destructor
-    );
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR_ValueMemberSeq *&_tao_elem)
-{
-  return _tao_any >>= ACE_const_cast(
-      const IR_ValueMemberSeq*&,
-      _tao_elem
-    );
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR_ValueMemberSeq *&_tao_elem)
-{
-  _tao_elem = 0;
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (IR::_tc_ValueMemberSeq, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    if (_tao_any.any_owns_data ())
-    {
-      _tao_elem = ACE_static_cast(
-          const IR_ValueMemberSeq*,
-          _tao_any.value ()
-        );
-      return 1;
-    }
-    else
-    {
-      IR_ValueMemberSeq *tmp;
-      ACE_NEW_RETURN (tmp, IR_ValueMemberSeq, 0);
-      TAO_InputCDR stream (
-          _tao_any._tao_get_cdr (),
-          _tao_any._tao_byte_order ()
-        );
-      if (stream >> *tmp)
-      {
-        ((CORBA::Any *)&_tao_any)->_tao_replace (
-            IR::_tc_ValueMemberSeq,
-            1,
-            ACE_static_cast (void *, tmp),
-            IR_ValueMemberSeq::_tao_any_destructor
-          );
-        _tao_elem = tmp;
-        return 1;
-      }
-      else
-      {
-        delete tmp;
-      }
-    }
-  }
-  ACE_CATCHANY
-  {
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-void operator<<= (CORBA::Any &_tao_any, IR_ValueMemberDef_ptr _tao_elem)
-{
-  TAO_OutputCDR stream;
-  if (stream << _tao_elem)
-  {
-    _tao_any._tao_replace (
-        IR::_tc_ValueMemberDef, 
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin (),
-        1,
-        IR_ValueMemberDef::_duplicate (_tao_elem),
-        IR_ValueMemberDef::_tao_any_destructor
-      );
-  }
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR_ValueMemberDef_ptr &_tao_elem)
-{
-  ACE_TRY_NEW_ENV
-  {
-    _tao_elem = IR_ValueMemberDef::_nil ();
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (IR::_tc_ValueMemberDef, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    TAO_InputCDR stream (
-        _tao_any._tao_get_cdr (),
-        _tao_any._tao_byte_order ()
-      );
-    if (stream >> _tao_elem)
-    {
-      ((CORBA::Any *)&_tao_any)->_tao_replace (
-          IR::_tc_ValueMemberDef,
-          1,
-          _tao_elem,
-          IR_ValueMemberDef::_tao_any_destructor
-        );
-      return 1;
-    }
-  }
-  ACE_CATCHANY
-  {
-    _tao_elem = IR_ValueMemberDef::_nil ();
-    return 0;
-  }
-  ACE_ENDTRY;
-  _tao_elem = IR_ValueMemberDef::_nil ();
-  return 0;
-}
-
-#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
-    defined (ACE_HAS_GNU_REPO)
-    template class TAO_Object_Manager<IR_ValueMemberDef,IR_ValueMemberDef_var>;
-  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
-  #  pragma instantiate TAO_Object_Manager<IR_ValueMemberDef,IR_ValueMemberDef_var>
-#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
-
-void operator<<= (CORBA::Any &_tao_any, IR_ValueDef_ptr _tao_elem)
-{
-  TAO_OutputCDR stream;
-  if (stream << _tao_elem)
-  {
-    _tao_any._tao_replace (
-        IR::_tc_ValueDef, 
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin (),
-        1,
-        IR_ValueDef::_duplicate (_tao_elem),
-        IR_ValueDef::_tao_any_destructor
-      );
-  }
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR_ValueDef_ptr &_tao_elem)
-{
-  ACE_TRY_NEW_ENV
-  {
-    _tao_elem = IR_ValueDef::_nil ();
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (IR::_tc_ValueDef, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    TAO_InputCDR stream (
-        _tao_any._tao_get_cdr (),
-        _tao_any._tao_byte_order ()
-      );
-    if (stream >> _tao_elem)
-    {
-      ((CORBA::Any *)&_tao_any)->_tao_replace (
-          IR::_tc_ValueDef,
-          1,
-          _tao_elem,
-          IR_ValueDef::_tao_any_destructor
-        );
-      return 1;
-    }
-  }
-  ACE_CATCHANY
-  {
-    _tao_elem = IR_ValueDef::_nil ();
-    return 0;
-  }
-  ACE_ENDTRY;
-  _tao_elem = IR_ValueDef::_nil ();
-  return 0;
-}
-
-#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
-    defined (ACE_HAS_GNU_REPO)
-    template class TAO_Object_Manager<IR_ValueDef,IR_ValueDef_var>;
-  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
-  #  pragma instantiate TAO_Object_Manager<IR_ValueDef,IR_ValueDef_var>
-#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
-
-void operator<<= (CORBA::Any &_tao_any, const IR_ValueDescription &_tao_elem) // copying
-{
-  TAO_OutputCDR stream;
-  stream << _tao_elem;
-  _tao_any._tao_replace (
-      IR::_tc_ValueDescription,
-      TAO_ENCAP_BYTE_ORDER,
-      stream.begin ()
-    );
-}
-
-void operator<<= (CORBA::Any &_tao_any, IR_ValueDescription *_tao_elem) // non copying
-{
-  TAO_OutputCDR stream;
-  stream << *_tao_elem;
-  _tao_any._tao_replace (
-      IR::_tc_ValueDescription,
-      TAO_ENCAP_BYTE_ORDER,
-      stream.begin (),
-      1,
-      _tao_elem,
-      IR_ValueDescription::_tao_any_destructor
-    );
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR_ValueDescription *&_tao_elem)
-{
-  return _tao_any >>= ACE_const_cast(const IR_ValueDescription*&,_tao_elem);
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR_ValueDescription *&_tao_elem)
-{
-  _tao_elem = 0;
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (IR::_tc_ValueDescription, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    if (_tao_any.any_owns_data ())
-    {
-      _tao_elem = ACE_static_cast(
-          const IR_ValueDescription*,
-          _tao_any.value ()
-        );
-      return 1;
-    }
-    else
-    {
-      IR_ValueDescription *tmp;
-      ACE_NEW_RETURN (tmp, IR_ValueDescription, 0);
-      TAO_InputCDR stream (
-          _tao_any._tao_get_cdr (),
-          _tao_any._tao_byte_order ()
-        );
-      if (stream >> *tmp)
-      {
-        ((CORBA::Any *)&_tao_any)->_tao_replace (
-            IR::_tc_ValueDescription,
-            1,
-            ACE_static_cast (void *, tmp),
-            IR_ValueDescription::_tao_any_destructor
-          );
-        _tao_elem = tmp;
-        return 1;
-      }
-      else
-      {
-        delete tmp;
-      }
-    }
-  }
-  ACE_CATCHANY
-  {
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-void operator<<= (CORBA::Any &_tao_any, IR_ValueBoxDef_ptr _tao_elem)
-{
-  TAO_OutputCDR stream;
-  if (stream << _tao_elem)
-  {
-    _tao_any._tao_replace (
-        IR::_tc_ValueBoxDef, 
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin (),
-        1,
-        IR_ValueBoxDef::_duplicate (_tao_elem),
-        IR_ValueBoxDef::_tao_any_destructor
-      );
-  }
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR_ValueBoxDef_ptr &_tao_elem)
-{
-  ACE_TRY_NEW_ENV
-  {
-    _tao_elem = IR_ValueBoxDef::_nil ();
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (IR::_tc_ValueBoxDef, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    TAO_InputCDR stream (
-        _tao_any._tao_get_cdr (),
-        _tao_any._tao_byte_order ()
-      );
-    if (stream >> _tao_elem)
-    {
-      ((CORBA::Any *)&_tao_any)->_tao_replace (
-          IR::_tc_ValueBoxDef,
-          1,
-          _tao_elem,
-          IR_ValueBoxDef::_tao_any_destructor
-        );
-      return 1;
-    }
-  }
-  ACE_CATCHANY
-  {
-    _tao_elem = IR_ValueBoxDef::_nil ();
-    return 0;
-  }
-  ACE_ENDTRY;
-  _tao_elem = IR_ValueBoxDef::_nil ();
-  return 0;
-}
-
-#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
-    defined (ACE_HAS_GNU_REPO)
-    template class TAO_Object_Manager<IR_ValueBoxDef,IR_ValueBoxDef_var>;
-  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
-  #  pragma instantiate TAO_Object_Manager<IR_ValueBoxDef,IR_ValueBoxDef_var>
-#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
-
-void operator<<= (CORBA::Any &_tao_any, IR_ProvidesDef_ptr _tao_elem)
-{
-  TAO_OutputCDR stream;
-  if (stream << _tao_elem)
-  {
-    _tao_any._tao_replace (
-        IR::_tc_ProvidesDef, 
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin (),
-        1,
-        IR_ProvidesDef::_duplicate (_tao_elem),
-        IR_ProvidesDef::_tao_any_destructor
-      );
-  }
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR_ProvidesDef_ptr &_tao_elem)
-{
-  ACE_TRY_NEW_ENV
-  {
-    _tao_elem = IR_ProvidesDef::_nil ();
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (IR::_tc_ProvidesDef, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    TAO_InputCDR stream (
-        _tao_any._tao_get_cdr (),
-        _tao_any._tao_byte_order ()
-      );
-    if (stream >> _tao_elem)
-    {
-      ((CORBA::Any *)&_tao_any)->_tao_replace (
-          IR::_tc_ProvidesDef,
-          1,
-          _tao_elem,
-          IR_ProvidesDef::_tao_any_destructor
-        );
-      return 1;
-    }
-  }
-  ACE_CATCHANY
-  {
-    _tao_elem = IR_ProvidesDef::_nil ();
-    return 0;
-  }
-  ACE_ENDTRY;
-  _tao_elem = IR_ProvidesDef::_nil ();
-  return 0;
-}
-
-#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
-    defined (ACE_HAS_GNU_REPO)
-    template class TAO_Object_Manager<IR_ProvidesDef,IR_ProvidesDef_var>;
-  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
-  #  pragma instantiate TAO_Object_Manager<IR_ProvidesDef,IR_ProvidesDef_var>
-#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
-
-void operator<<= (CORBA::Any &_tao_any, const IR_ProvidesDescription &_tao_elem) // copying
-{
-  TAO_OutputCDR stream;
-  stream << _tao_elem;
-  _tao_any._tao_replace (
-      IR::_tc_ProvidesDescription,
-      TAO_ENCAP_BYTE_ORDER,
-      stream.begin ()
-    );
-}
-
-void operator<<= (CORBA::Any &_tao_any, IR_ProvidesDescription *_tao_elem) // non copying
-{
-  TAO_OutputCDR stream;
-  stream << *_tao_elem;
-  _tao_any._tao_replace (
-      IR::_tc_ProvidesDescription,
-      TAO_ENCAP_BYTE_ORDER,
-      stream.begin (),
-      1,
-      _tao_elem,
-      IR_ProvidesDescription::_tao_any_destructor
-    );
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR_ProvidesDescription *&_tao_elem)
-{
-  return _tao_any >>= ACE_const_cast(const IR_ProvidesDescription*&,_tao_elem);
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR_ProvidesDescription *&_tao_elem)
-{
-  _tao_elem = 0;
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (IR::_tc_ProvidesDescription, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    if (_tao_any.any_owns_data ())
-    {
-      _tao_elem = ACE_static_cast(
-          const IR_ProvidesDescription*,
-          _tao_any.value ()
-        );
-      return 1;
-    }
-    else
-    {
-      IR_ProvidesDescription *tmp;
-      ACE_NEW_RETURN (tmp, IR_ProvidesDescription, 0);
-      TAO_InputCDR stream (
-          _tao_any._tao_get_cdr (),
-          _tao_any._tao_byte_order ()
-        );
-      if (stream >> *tmp)
-      {
-        ((CORBA::Any *)&_tao_any)->_tao_replace (
-            IR::_tc_ProvidesDescription,
-            1,
-            ACE_static_cast (void *, tmp),
-            IR_ProvidesDescription::_tao_any_destructor
-          );
-        _tao_elem = tmp;
-        return 1;
-      }
-      else
-      {
-        delete tmp;
-      }
-    }
-  }
-  ACE_CATCHANY
-  {
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-void operator<<= (CORBA::Any &_tao_any, IR_UsesDef_ptr _tao_elem)
-{
-  TAO_OutputCDR stream;
-  if (stream << _tao_elem)
-  {
-    _tao_any._tao_replace (
-        IR::_tc_UsesDef, 
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin (),
-        1,
-        IR_UsesDef::_duplicate (_tao_elem),
-        IR_UsesDef::_tao_any_destructor
-      );
-  }
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR_UsesDef_ptr &_tao_elem)
-{
-  ACE_TRY_NEW_ENV
-  {
-    _tao_elem = IR_UsesDef::_nil ();
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (IR::_tc_UsesDef, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    TAO_InputCDR stream (
-        _tao_any._tao_get_cdr (),
-        _tao_any._tao_byte_order ()
-      );
-    if (stream >> _tao_elem)
-    {
-      ((CORBA::Any *)&_tao_any)->_tao_replace (
-          IR::_tc_UsesDef,
-          1,
-          _tao_elem,
-          IR_UsesDef::_tao_any_destructor
-        );
-      return 1;
-    }
-  }
-  ACE_CATCHANY
-  {
-    _tao_elem = IR_UsesDef::_nil ();
-    return 0;
-  }
-  ACE_ENDTRY;
-  _tao_elem = IR_UsesDef::_nil ();
-  return 0;
-}
-
-#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
-    defined (ACE_HAS_GNU_REPO)
-    template class TAO_Object_Manager<IR_UsesDef,IR_UsesDef_var>;
-  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
-  #  pragma instantiate TAO_Object_Manager<IR_UsesDef,IR_UsesDef_var>
-#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
-
-void operator<<= (CORBA::Any &_tao_any, const IR_UsesDescription &_tao_elem) // copying
-{
-  TAO_OutputCDR stream;
-  stream << _tao_elem;
-  _tao_any._tao_replace (
-      IR::_tc_UsesDescription,
-      TAO_ENCAP_BYTE_ORDER,
-      stream.begin ()
-    );
-}
-
-void operator<<= (CORBA::Any &_tao_any, IR_UsesDescription *_tao_elem) // non copying
-{
-  TAO_OutputCDR stream;
-  stream << *_tao_elem;
-  _tao_any._tao_replace (
-      IR::_tc_UsesDescription,
-      TAO_ENCAP_BYTE_ORDER,
-      stream.begin (),
-      1,
-      _tao_elem,
-      IR_UsesDescription::_tao_any_destructor
-    );
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR_UsesDescription *&_tao_elem)
-{
-  return _tao_any >>= ACE_const_cast(const IR_UsesDescription*&,_tao_elem);
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR_UsesDescription *&_tao_elem)
-{
-  _tao_elem = 0;
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (IR::_tc_UsesDescription, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    if (_tao_any.any_owns_data ())
-    {
-      _tao_elem = ACE_static_cast(
-          const IR_UsesDescription*,
-          _tao_any.value ()
-        );
-      return 1;
-    }
-    else
-    {
-      IR_UsesDescription *tmp;
-      ACE_NEW_RETURN (tmp, IR_UsesDescription, 0);
-      TAO_InputCDR stream (
-          _tao_any._tao_get_cdr (),
-          _tao_any._tao_byte_order ()
-        );
-      if (stream >> *tmp)
-      {
-        ((CORBA::Any *)&_tao_any)->_tao_replace (
-            IR::_tc_UsesDescription,
-            1,
-            ACE_static_cast (void *, tmp),
-            IR_UsesDescription::_tao_any_destructor
-          );
-        _tao_elem = tmp;
-        return 1;
-      }
-      else
-      {
-        delete tmp;
-      }
-    }
-  }
-  ACE_CATCHANY
-  {
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-void operator<<= (
-    CORBA::Any &_tao_any,
-    const IR_ProvidesDescSeq &_tao_elem
-  ) // copying
-{
-  TAO_OutputCDR stream;
-  if (stream << _tao_elem)
-  {
-    _tao_any._tao_replace (
-        IR::_tc_ProvidesDescSeq,
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin ()
-      );
-  }
-}
-
-void operator<<= (CORBA::Any &_tao_any, IR_ProvidesDescSeq *_tao_elem) // non copying
-{
-  TAO_OutputCDR stream;
-  stream << *_tao_elem;
-  _tao_any._tao_replace (
-      IR::_tc_ProvidesDescSeq,
-      TAO_ENCAP_BYTE_ORDER,
-      stream.begin (),
-      1,
-      _tao_elem,
-      IR_ProvidesDescSeq::_tao_any_destructor
-    );
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR_ProvidesDescSeq *&_tao_elem)
-{
-  return _tao_any >>= ACE_const_cast(
-      const IR_ProvidesDescSeq*&,
-      _tao_elem
-    );
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR_ProvidesDescSeq *&_tao_elem)
-{
-  _tao_elem = 0;
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (IR::_tc_ProvidesDescSeq, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    if (_tao_any.any_owns_data ())
-    {
-      _tao_elem = ACE_static_cast(
-          const IR_ProvidesDescSeq*,
-          _tao_any.value ()
-        );
-      return 1;
-    }
-    else
-    {
-      IR_ProvidesDescSeq *tmp;
-      ACE_NEW_RETURN (tmp, IR_ProvidesDescSeq, 0);
-      TAO_InputCDR stream (
-          _tao_any._tao_get_cdr (),
-          _tao_any._tao_byte_order ()
-        );
-      if (stream >> *tmp)
-      {
-        ((CORBA::Any *)&_tao_any)->_tao_replace (
-            IR::_tc_ProvidesDescSeq,
-            1,
-            ACE_static_cast (void *, tmp),
-            IR_ProvidesDescSeq::_tao_any_destructor
-          );
-        _tao_elem = tmp;
-        return 1;
-      }
-      else
-      {
-        delete tmp;
-      }
-    }
-  }
-  ACE_CATCHANY
-  {
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-void operator<<= (
-    CORBA::Any &_tao_any,
-    const IR_UsesDescSeq &_tao_elem
-  ) // copying
-{
-  TAO_OutputCDR stream;
-  if (stream << _tao_elem)
-  {
-    _tao_any._tao_replace (
-        IR::_tc_UsesDescSeq,
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin ()
-      );
-  }
-}
-
-void operator<<= (CORBA::Any &_tao_any, IR_UsesDescSeq *_tao_elem) // non copying
-{
-  TAO_OutputCDR stream;
-  stream << *_tao_elem;
-  _tao_any._tao_replace (
-      IR::_tc_UsesDescSeq,
-      TAO_ENCAP_BYTE_ORDER,
-      stream.begin (),
-      1,
-      _tao_elem,
-      IR_UsesDescSeq::_tao_any_destructor
-    );
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR_UsesDescSeq *&_tao_elem)
-{
-  return _tao_any >>= ACE_const_cast(
-      const IR_UsesDescSeq*&,
-      _tao_elem
-    );
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR_UsesDescSeq *&_tao_elem)
-{
-  _tao_elem = 0;
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (IR::_tc_UsesDescSeq, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    if (_tao_any.any_owns_data ())
-    {
-      _tao_elem = ACE_static_cast(
-          const IR_UsesDescSeq*,
-          _tao_any.value ()
-        );
-      return 1;
-    }
-    else
-    {
-      IR_UsesDescSeq *tmp;
-      ACE_NEW_RETURN (tmp, IR_UsesDescSeq, 0);
-      TAO_InputCDR stream (
-          _tao_any._tao_get_cdr (),
-          _tao_any._tao_byte_order ()
-        );
-      if (stream >> *tmp)
-      {
-        ((CORBA::Any *)&_tao_any)->_tao_replace (
-            IR::_tc_UsesDescSeq,
-            1,
-            ACE_static_cast (void *, tmp),
-            IR_UsesDescSeq::_tao_any_destructor
-          );
-        _tao_elem = tmp;
-        return 1;
-      }
-      else
-      {
-        delete tmp;
-      }
-    }
-  }
-  ACE_CATCHANY
-  {
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-void operator<<= (CORBA::Any &_tao_any, IR_EventDef_ptr _tao_elem)
-{
-  TAO_OutputCDR stream;
-  if (stream << _tao_elem)
-  {
-    _tao_any._tao_replace (
-        IR::_tc_EventDef, 
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin (),
-        1,
-        IR_EventDef::_duplicate (_tao_elem),
-        IR_EventDef::_tao_any_destructor
-      );
-  }
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR_EventDef_ptr &_tao_elem)
-{
-  ACE_TRY_NEW_ENV
-  {
-    _tao_elem = IR_EventDef::_nil ();
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (IR::_tc_EventDef, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    TAO_InputCDR stream (
-        _tao_any._tao_get_cdr (),
-        _tao_any._tao_byte_order ()
-      );
-    if (stream >> _tao_elem)
-    {
-      ((CORBA::Any *)&_tao_any)->_tao_replace (
-          IR::_tc_EventDef,
-          1,
-          _tao_elem,
-          IR_EventDef::_tao_any_destructor
-        );
-      return 1;
-    }
-  }
-  ACE_CATCHANY
-  {
-    _tao_elem = IR_EventDef::_nil ();
-    return 0;
-  }
-  ACE_ENDTRY;
-  _tao_elem = IR_EventDef::_nil ();
-  return 0;
-}
-
-#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
-    defined (ACE_HAS_GNU_REPO)
-    template class TAO_Object_Manager<IR_EventDef,IR_EventDef_var>;
-  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
-  #  pragma instantiate TAO_Object_Manager<IR_EventDef,IR_EventDef_var>
-#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
-
-void operator<<= (CORBA::Any &_tao_any, const IR_EventDescription &_tao_elem) // copying
-{
-  TAO_OutputCDR stream;
-  stream << _tao_elem;
-  _tao_any._tao_replace (
-      IR::_tc_EventDescription,
-      TAO_ENCAP_BYTE_ORDER,
-      stream.begin ()
-    );
-}
-
-void operator<<= (CORBA::Any &_tao_any, IR_EventDescription *_tao_elem) // non copying
-{
-  TAO_OutputCDR stream;
-  stream << *_tao_elem;
-  _tao_any._tao_replace (
-      IR::_tc_EventDescription,
-      TAO_ENCAP_BYTE_ORDER,
-      stream.begin (),
-      1,
-      _tao_elem,
-      IR_EventDescription::_tao_any_destructor
-    );
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR_EventDescription *&_tao_elem)
-{
-  return _tao_any >>= ACE_const_cast(const IR_EventDescription*&,_tao_elem);
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR_EventDescription *&_tao_elem)
-{
-  _tao_elem = 0;
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (IR::_tc_EventDescription, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    if (_tao_any.any_owns_data ())
-    {
-      _tao_elem = ACE_static_cast(
-          const IR_EventDescription*,
-          _tao_any.value ()
-        );
-      return 1;
-    }
-    else
-    {
-      IR_EventDescription *tmp;
-      ACE_NEW_RETURN (tmp, IR_EventDescription, 0);
-      TAO_InputCDR stream (
-          _tao_any._tao_get_cdr (),
-          _tao_any._tao_byte_order ()
-        );
-      if (stream >> *tmp)
-      {
-        ((CORBA::Any *)&_tao_any)->_tao_replace (
-            IR::_tc_EventDescription,
-            1,
-            ACE_static_cast (void *, tmp),
-            IR_EventDescription::_tao_any_destructor
-          );
-        _tao_elem = tmp;
-        return 1;
-      }
-      else
-      {
-        delete tmp;
-      }
-    }
-  }
-  ACE_CATCHANY
-  {
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-void operator<<= (CORBA::Any &_tao_any, IR_EmitsDef_ptr _tao_elem)
-{
-  TAO_OutputCDR stream;
-  if (stream << _tao_elem)
-  {
-    _tao_any._tao_replace (
-        IR::_tc_EmitsDef, 
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin (),
-        1,
-        IR_EmitsDef::_duplicate (_tao_elem),
-        IR_EmitsDef::_tao_any_destructor
-      );
-  }
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR_EmitsDef_ptr &_tao_elem)
-{
-  ACE_TRY_NEW_ENV
-  {
-    _tao_elem = IR_EmitsDef::_nil ();
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (IR::_tc_EmitsDef, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    TAO_InputCDR stream (
-        _tao_any._tao_get_cdr (),
-        _tao_any._tao_byte_order ()
-      );
-    if (stream >> _tao_elem)
-    {
-      ((CORBA::Any *)&_tao_any)->_tao_replace (
-          IR::_tc_EmitsDef,
-          1,
-          _tao_elem,
-          IR_EmitsDef::_tao_any_destructor
-        );
-      return 1;
-    }
-  }
-  ACE_CATCHANY
-  {
-    _tao_elem = IR_EmitsDef::_nil ();
-    return 0;
-  }
-  ACE_ENDTRY;
-  _tao_elem = IR_EmitsDef::_nil ();
-  return 0;
-}
-
-#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
-    defined (ACE_HAS_GNU_REPO)
-    template class TAO_Object_Manager<IR_EmitsDef,IR_EmitsDef_var>;
-  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
-  #  pragma instantiate TAO_Object_Manager<IR_EmitsDef,IR_EmitsDef_var>
-#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
-
-void operator<<= (CORBA::Any &_tao_any, IR_PublishesDef_ptr _tao_elem)
-{
-  TAO_OutputCDR stream;
-  if (stream << _tao_elem)
-  {
-    _tao_any._tao_replace (
-        IR::_tc_PublishesDef, 
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin (),
-        1,
-        IR_PublishesDef::_duplicate (_tao_elem),
-        IR_PublishesDef::_tao_any_destructor
-      );
-  }
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR_PublishesDef_ptr &_tao_elem)
-{
-  ACE_TRY_NEW_ENV
-  {
-    _tao_elem = IR_PublishesDef::_nil ();
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (IR::_tc_PublishesDef, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    TAO_InputCDR stream (
-        _tao_any._tao_get_cdr (),
-        _tao_any._tao_byte_order ()
-      );
-    if (stream >> _tao_elem)
-    {
-      ((CORBA::Any *)&_tao_any)->_tao_replace (
-          IR::_tc_PublishesDef,
-          1,
-          _tao_elem,
-          IR_PublishesDef::_tao_any_destructor
-        );
-      return 1;
-    }
-  }
-  ACE_CATCHANY
-  {
-    _tao_elem = IR_PublishesDef::_nil ();
-    return 0;
-  }
-  ACE_ENDTRY;
-  _tao_elem = IR_PublishesDef::_nil ();
-  return 0;
-}
-
-#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
-    defined (ACE_HAS_GNU_REPO)
-    template class TAO_Object_Manager<IR_PublishesDef,IR_PublishesDef_var>;
-  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
-  #  pragma instantiate TAO_Object_Manager<IR_PublishesDef,IR_PublishesDef_var>
-#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
-
-void operator<<= (CORBA::Any &_tao_any, IR_ConsumesDef_ptr _tao_elem)
-{
-  TAO_OutputCDR stream;
-  if (stream << _tao_elem)
-  {
-    _tao_any._tao_replace (
-        IR::_tc_ConsumesDef, 
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin (),
-        1,
-        IR_ConsumesDef::_duplicate (_tao_elem),
-        IR_ConsumesDef::_tao_any_destructor
-      );
-  }
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR_ConsumesDef_ptr &_tao_elem)
-{
-  ACE_TRY_NEW_ENV
-  {
-    _tao_elem = IR_ConsumesDef::_nil ();
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (IR::_tc_ConsumesDef, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    TAO_InputCDR stream (
-        _tao_any._tao_get_cdr (),
-        _tao_any._tao_byte_order ()
-      );
-    if (stream >> _tao_elem)
-    {
-      ((CORBA::Any *)&_tao_any)->_tao_replace (
-          IR::_tc_ConsumesDef,
-          1,
-          _tao_elem,
-          IR_ConsumesDef::_tao_any_destructor
-        );
-      return 1;
-    }
-  }
-  ACE_CATCHANY
-  {
-    _tao_elem = IR_ConsumesDef::_nil ();
-    return 0;
-  }
-  ACE_ENDTRY;
-  _tao_elem = IR_ConsumesDef::_nil ();
-  return 0;
-}
-
-#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
-    defined (ACE_HAS_GNU_REPO)
-    template class TAO_Object_Manager<IR_ConsumesDef,IR_ConsumesDef_var>;
-  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
-  #  pragma instantiate TAO_Object_Manager<IR_ConsumesDef,IR_ConsumesDef_var>
-#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
-
-void operator<<= (CORBA::Any &_tao_any, IR_ComponentDef_ptr _tao_elem)
-{
-  TAO_OutputCDR stream;
-  if (stream << _tao_elem)
-  {
-    _tao_any._tao_replace (
-        IR::_tc_ComponentDef, 
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin (),
-        1,
-        IR_ComponentDef::_duplicate (_tao_elem),
-        IR_ComponentDef::_tao_any_destructor
-      );
-  }
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR_ComponentDef_ptr &_tao_elem)
-{
-  ACE_TRY_NEW_ENV
-  {
-    _tao_elem = IR_ComponentDef::_nil ();
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (IR::_tc_ComponentDef, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    TAO_InputCDR stream (
-        _tao_any._tao_get_cdr (),
-        _tao_any._tao_byte_order ()
-      );
-    if (stream >> _tao_elem)
-    {
-      ((CORBA::Any *)&_tao_any)->_tao_replace (
-          IR::_tc_ComponentDef,
-          1,
-          _tao_elem,
-          IR_ComponentDef::_tao_any_destructor
-        );
-      return 1;
-    }
-  }
-  ACE_CATCHANY
-  {
-    _tao_elem = IR_ComponentDef::_nil ();
-    return 0;
-  }
-  ACE_ENDTRY;
-  _tao_elem = IR_ComponentDef::_nil ();
-  return 0;
-}
-
-#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
-    defined (ACE_HAS_GNU_REPO)
-    template class TAO_Object_Manager<IR_ComponentDef,IR_ComponentDef_var>;
-  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
-  #  pragma instantiate TAO_Object_Manager<IR_ComponentDef,IR_ComponentDef_var>
-#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
-
-void operator<<= (CORBA::Any &_tao_any, const IR_ComponentDescription &_tao_elem) // copying
-{
-  TAO_OutputCDR stream;
-  stream << _tao_elem;
-  _tao_any._tao_replace (
-      IR::_tc_ComponentDescription,
-      TAO_ENCAP_BYTE_ORDER,
-      stream.begin ()
-    );
-}
-
-void operator<<= (CORBA::Any &_tao_any, IR_ComponentDescription *_tao_elem) // non copying
-{
-  TAO_OutputCDR stream;
-  stream << *_tao_elem;
-  _tao_any._tao_replace (
-      IR::_tc_ComponentDescription,
-      TAO_ENCAP_BYTE_ORDER,
-      stream.begin (),
-      1,
-      _tao_elem,
-      IR_ComponentDescription::_tao_any_destructor
-    );
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR_ComponentDescription *&_tao_elem)
-{
-  return _tao_any >>= ACE_const_cast(const IR_ComponentDescription*&,_tao_elem);
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR_ComponentDescription *&_tao_elem)
-{
-  _tao_elem = 0;
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (IR::_tc_ComponentDescription, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    if (_tao_any.any_owns_data ())
-    {
-      _tao_elem = ACE_static_cast(
-          const IR_ComponentDescription*,
-          _tao_any.value ()
-        );
-      return 1;
-    }
-    else
-    {
-      IR_ComponentDescription *tmp;
-      ACE_NEW_RETURN (tmp, IR_ComponentDescription, 0);
-      TAO_InputCDR stream (
-          _tao_any._tao_get_cdr (),
-          _tao_any._tao_byte_order ()
-        );
-      if (stream >> *tmp)
-      {
-        ((CORBA::Any *)&_tao_any)->_tao_replace (
-            IR::_tc_ComponentDescription,
-            1,
-            ACE_static_cast (void *, tmp),
-            IR_ComponentDescription::_tao_any_destructor
-          );
-        _tao_elem = tmp;
-        return 1;
-      }
-      else
-      {
-        delete tmp;
-      }
-    }
-  }
-  ACE_CATCHANY
-  {
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-void operator<<= (CORBA::Any &_tao_any, IR_PrimaryKeyDef_ptr _tao_elem)
-{
-  TAO_OutputCDR stream;
-  if (stream << _tao_elem)
-  {
-    _tao_any._tao_replace (
-        IR::_tc_PrimaryKeyDef, 
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin (),
-        1,
-        IR_PrimaryKeyDef::_duplicate (_tao_elem),
-        IR_PrimaryKeyDef::_tao_any_destructor
-      );
-  }
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR_PrimaryKeyDef_ptr &_tao_elem)
-{
-  ACE_TRY_NEW_ENV
-  {
-    _tao_elem = IR_PrimaryKeyDef::_nil ();
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (IR::_tc_PrimaryKeyDef, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    TAO_InputCDR stream (
-        _tao_any._tao_get_cdr (),
-        _tao_any._tao_byte_order ()
-      );
-    if (stream >> _tao_elem)
-    {
-      ((CORBA::Any *)&_tao_any)->_tao_replace (
-          IR::_tc_PrimaryKeyDef,
-          1,
-          _tao_elem,
-          IR_PrimaryKeyDef::_tao_any_destructor
-        );
-      return 1;
-    }
-  }
-  ACE_CATCHANY
-  {
-    _tao_elem = IR_PrimaryKeyDef::_nil ();
-    return 0;
-  }
-  ACE_ENDTRY;
-  _tao_elem = IR_PrimaryKeyDef::_nil ();
-  return 0;
-}
-
-#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
-    defined (ACE_HAS_GNU_REPO)
-    template class TAO_Object_Manager<IR_PrimaryKeyDef,IR_PrimaryKeyDef_var>;
-  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
-  #  pragma instantiate TAO_Object_Manager<IR_PrimaryKeyDef,IR_PrimaryKeyDef_var>
-#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
-
-void operator<<= (CORBA::Any &_tao_any, const IR_PrimaryKeyDescription &_tao_elem) // copying
-{
-  TAO_OutputCDR stream;
-  stream << _tao_elem;
-  _tao_any._tao_replace (
-      IR::_tc_PrimaryKeyDescription,
-      TAO_ENCAP_BYTE_ORDER,
-      stream.begin ()
-    );
-}
-
-void operator<<= (CORBA::Any &_tao_any, IR_PrimaryKeyDescription *_tao_elem) // non copying
-{
-  TAO_OutputCDR stream;
-  stream << *_tao_elem;
-  _tao_any._tao_replace (
-      IR::_tc_PrimaryKeyDescription,
-      TAO_ENCAP_BYTE_ORDER,
-      stream.begin (),
-      1,
-      _tao_elem,
-      IR_PrimaryKeyDescription::_tao_any_destructor
-    );
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR_PrimaryKeyDescription *&_tao_elem)
-{
-  return _tao_any >>= ACE_const_cast(const IR_PrimaryKeyDescription*&,_tao_elem);
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR_PrimaryKeyDescription *&_tao_elem)
-{
-  _tao_elem = 0;
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (IR::_tc_PrimaryKeyDescription, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    if (_tao_any.any_owns_data ())
-    {
-      _tao_elem = ACE_static_cast(
-          const IR_PrimaryKeyDescription*,
-          _tao_any.value ()
-        );
-      return 1;
-    }
-    else
-    {
-      IR_PrimaryKeyDescription *tmp;
-      ACE_NEW_RETURN (tmp, IR_PrimaryKeyDescription, 0);
-      TAO_InputCDR stream (
-          _tao_any._tao_get_cdr (),
-          _tao_any._tao_byte_order ()
-        );
-      if (stream >> *tmp)
-      {
-        ((CORBA::Any *)&_tao_any)->_tao_replace (
-            IR::_tc_PrimaryKeyDescription,
-            1,
-            ACE_static_cast (void *, tmp),
-            IR_PrimaryKeyDescription::_tao_any_destructor
-          );
-        _tao_elem = tmp;
-        return 1;
-      }
-      else
-      {
-        delete tmp;
-      }
-    }
-  }
-  ACE_CATCHANY
-  {
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-void operator<<= (CORBA::Any &_tao_any, IR_FactoryDef_ptr _tao_elem)
-{
-  TAO_OutputCDR stream;
-  if (stream << _tao_elem)
-  {
-    _tao_any._tao_replace (
-        IR::_tc_FactoryDef, 
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin (),
-        1,
-        IR_FactoryDef::_duplicate (_tao_elem),
-        IR_FactoryDef::_tao_any_destructor
-      );
-  }
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR_FactoryDef_ptr &_tao_elem)
-{
-  ACE_TRY_NEW_ENV
-  {
-    _tao_elem = IR_FactoryDef::_nil ();
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (IR::_tc_FactoryDef, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    TAO_InputCDR stream (
-        _tao_any._tao_get_cdr (),
-        _tao_any._tao_byte_order ()
-      );
-    if (stream >> _tao_elem)
-    {
-      ((CORBA::Any *)&_tao_any)->_tao_replace (
-          IR::_tc_FactoryDef,
-          1,
-          _tao_elem,
-          IR_FactoryDef::_tao_any_destructor
-        );
-      return 1;
-    }
-  }
-  ACE_CATCHANY
-  {
-    _tao_elem = IR_FactoryDef::_nil ();
-    return 0;
-  }
-  ACE_ENDTRY;
-  _tao_elem = IR_FactoryDef::_nil ();
-  return 0;
-}
-
-#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
-    defined (ACE_HAS_GNU_REPO)
-    template class TAO_Object_Manager<IR_FactoryDef,IR_FactoryDef_var>;
-  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
-  #  pragma instantiate TAO_Object_Manager<IR_FactoryDef,IR_FactoryDef_var>
-#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
-
-void operator<<= (CORBA::Any &_tao_any, IR_FinderDef_ptr _tao_elem)
-{
-  TAO_OutputCDR stream;
-  if (stream << _tao_elem)
-  {
-    _tao_any._tao_replace (
-        IR::_tc_FinderDef, 
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin (),
-        1,
-        IR_FinderDef::_duplicate (_tao_elem),
-        IR_FinderDef::_tao_any_destructor
-      );
-  }
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR_FinderDef_ptr &_tao_elem)
-{
-  ACE_TRY_NEW_ENV
-  {
-    _tao_elem = IR_FinderDef::_nil ();
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (IR::_tc_FinderDef, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    TAO_InputCDR stream (
-        _tao_any._tao_get_cdr (),
-        _tao_any._tao_byte_order ()
-      );
-    if (stream >> _tao_elem)
-    {
-      ((CORBA::Any *)&_tao_any)->_tao_replace (
-          IR::_tc_FinderDef,
-          1,
-          _tao_elem,
-          IR_FinderDef::_tao_any_destructor
-        );
-      return 1;
-    }
-  }
-  ACE_CATCHANY
-  {
-    _tao_elem = IR_FinderDef::_nil ();
-    return 0;
-  }
-  ACE_ENDTRY;
-  _tao_elem = IR_FinderDef::_nil ();
-  return 0;
-}
-
-#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
-    defined (ACE_HAS_GNU_REPO)
-    template class TAO_Object_Manager<IR_FinderDef,IR_FinderDef_var>;
-  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
-  #  pragma instantiate TAO_Object_Manager<IR_FinderDef,IR_FinderDef_var>
-#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
-
-void operator<<= (CORBA::Any &_tao_any, IR_HomeDef_ptr _tao_elem)
-{
-  TAO_OutputCDR stream;
-  if (stream << _tao_elem)
-  {
-    _tao_any._tao_replace (
-        IR::_tc_HomeDef, 
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin (),
-        1,
-        IR_HomeDef::_duplicate (_tao_elem),
-        IR_HomeDef::_tao_any_destructor
-      );
-  }
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR_HomeDef_ptr &_tao_elem)
-{
-  ACE_TRY_NEW_ENV
-  {
-    _tao_elem = IR_HomeDef::_nil ();
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (IR::_tc_HomeDef, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    TAO_InputCDR stream (
-        _tao_any._tao_get_cdr (),
-        _tao_any._tao_byte_order ()
-      );
-    if (stream >> _tao_elem)
-    {
-      ((CORBA::Any *)&_tao_any)->_tao_replace (
-          IR::_tc_HomeDef,
-          1,
-          _tao_elem,
-          IR_HomeDef::_tao_any_destructor
-        );
-      return 1;
-    }
-  }
-  ACE_CATCHANY
-  {
-    _tao_elem = IR_HomeDef::_nil ();
-    return 0;
-  }
-  ACE_ENDTRY;
-  _tao_elem = IR_HomeDef::_nil ();
-  return 0;
-}
-
-#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
-    defined (ACE_HAS_GNU_REPO)
-    template class TAO_Object_Manager<IR_HomeDef,IR_HomeDef_var>;
-  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
-  #  pragma instantiate TAO_Object_Manager<IR_HomeDef,IR_HomeDef_var>
-#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
-
-void operator<<= (CORBA::Any &_tao_any, const IR_HomeDescription &_tao_elem) // copying
-{
-  TAO_OutputCDR stream;
-  stream << _tao_elem;
-  _tao_any._tao_replace (
-      IR::_tc_HomeDescription,
-      TAO_ENCAP_BYTE_ORDER,
-      stream.begin ()
-    );
-}
-
-void operator<<= (CORBA::Any &_tao_any, IR_HomeDescription *_tao_elem) // non copying
-{
-  TAO_OutputCDR stream;
-  stream << *_tao_elem;
-  _tao_any._tao_replace (
-      IR::_tc_HomeDescription,
-      TAO_ENCAP_BYTE_ORDER,
-      stream.begin (),
-      1,
-      _tao_elem,
-      IR_HomeDescription::_tao_any_destructor
-    );
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR_HomeDescription *&_tao_elem)
-{
-  return _tao_any >>= ACE_const_cast(const IR_HomeDescription*&,_tao_elem);
-}
-
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR_HomeDescription *&_tao_elem)
-{
-  _tao_elem = 0;
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (IR::_tc_HomeDescription, ACE_TRY_ENV)) // not equal
-      {
-        return 0;
-      }
-    ACE_TRY_CHECK;
-    if (_tao_any.any_owns_data ())
-    {
-      _tao_elem = ACE_static_cast(
-          const IR_HomeDescription*,
-          _tao_any.value ()
-        );
-      return 1;
-    }
-    else
-    {
-      IR_HomeDescription *tmp;
-      ACE_NEW_RETURN (tmp, IR_HomeDescription, 0);
-      TAO_InputCDR stream (
-          _tao_any._tao_get_cdr (),
-          _tao_any._tao_byte_order ()
-        );
-      if (stream >> *tmp)
-      {
-        ((CORBA::Any *)&_tao_any)->_tao_replace (
-            IR::_tc_HomeDescription,
-            1,
-            ACE_static_cast (void *, tmp),
-            IR_HomeDescription::_tao_any_destructor
-          );
-        _tao_elem = tmp;
-        return 1;
-      }
-      else
-      {
-        delete tmp;
-      }
-    }
-  }
-  ACE_CATCHANY
-  {
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-CORBA::Boolean operator<< (
-    TAO_OutputCDR &strm,
-    const IR_InterfaceDefSeq &_tao_sequence
-  )
-{
-  if (strm << _tao_sequence.length ())
-  {
-    // encode all elements
-    CORBA::Boolean _tao_marshal_flag = 1;
-    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
-    {
-      _tao_marshal_flag = (strm << _tao_sequence[i].in ());
-    }
-    return _tao_marshal_flag;
-  }
-  return 0; // error
-}
-
-CORBA::Boolean operator>> (
-    TAO_InputCDR &strm,
-    IR_InterfaceDefSeq &_tao_sequence
-  )
-{
-  CORBA::ULong _tao_seq_len;
-  if (strm >> _tao_seq_len)
-  {
-    // set the length of the sequence
-    _tao_sequence.length (_tao_seq_len);
-    // If length is 0 we return true.
-    if (0 >= _tao_seq_len) 
-      return 1;
-    // retrieve all the elements
-    CORBA::Boolean _tao_marshal_flag = 1;
-    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
-    {
-      _tao_marshal_flag = (strm >> _tao_sequence[i].out ());
-    }
-    return _tao_marshal_flag;
-  }
-  return 0; // error
-}
-
-CORBA::Boolean operator<< (
-    TAO_OutputCDR &strm,
-    const IR_ValueDefSeq &_tao_sequence
-  )
-{
-  if (strm << _tao_sequence.length ())
-  {
-    // encode all elements
-    CORBA::Boolean _tao_marshal_flag = 1;
-    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
-    {
-      _tao_marshal_flag = (strm << _tao_sequence[i].in ());
-    }
-    return _tao_marshal_flag;
-  }
-  return 0; // error
-}
-
-CORBA::Boolean operator>> (
-    TAO_InputCDR &strm,
-    IR_ValueDefSeq &_tao_sequence
-  )
-{
-  CORBA::ULong _tao_seq_len;
-  if (strm >> _tao_seq_len)
-  {
-    // set the length of the sequence
-    _tao_sequence.length (_tao_seq_len);
-    // If length is 0 we return true.
-    if (0 >= _tao_seq_len) 
-      return 1;
-    // retrieve all the elements
-    CORBA::Boolean _tao_marshal_flag = 1;
-    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
-    {
-      _tao_marshal_flag = (strm >> _tao_sequence[i].out ());
-    }
-    return _tao_marshal_flag;
-  }
-  return 0; // error
-}
-
-CORBA::Boolean operator<< (
-    TAO_OutputCDR &strm,
-    const IR_ComponentDefSeq &_tao_sequence
-  )
-{
-  if (strm << _tao_sequence.length ())
-  {
-    // encode all elements
-    CORBA::Boolean _tao_marshal_flag = 1;
-    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
-    {
-      _tao_marshal_flag = (strm << _tao_sequence[i].in ());
-    }
-    return _tao_marshal_flag;
-  }
-  return 0; // error
-}
-
-CORBA::Boolean operator>> (
-    TAO_InputCDR &strm,
-    IR_ComponentDefSeq &_tao_sequence
-  )
-{
-  CORBA::ULong _tao_seq_len;
-  if (strm >> _tao_seq_len)
-  {
-    // set the length of the sequence
-    _tao_sequence.length (_tao_seq_len);
-    // If length is 0 we return true.
-    if (0 >= _tao_seq_len) 
-      return 1;
-    // retrieve all the elements
-    CORBA::Boolean _tao_marshal_flag = 1;
-    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
-    {
-      _tao_marshal_flag = (strm >> _tao_sequence[i].out ());
-    }
-    return _tao_marshal_flag;
-  }
-  return 0; // error
-}
-
-CORBA::Boolean operator<< (
-    TAO_OutputCDR &strm,
-    const IR_ProvidesDefSeq &_tao_sequence
-  )
-{
-  if (strm << _tao_sequence.length ())
-  {
-    // encode all elements
-    CORBA::Boolean _tao_marshal_flag = 1;
-    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
-    {
-      _tao_marshal_flag = (strm << _tao_sequence[i].in ());
-    }
-    return _tao_marshal_flag;
-  }
-  return 0; // error
-}
-
-CORBA::Boolean operator>> (
-    TAO_InputCDR &strm,
-    IR_ProvidesDefSeq &_tao_sequence
-  )
-{
-  CORBA::ULong _tao_seq_len;
-  if (strm >> _tao_seq_len)
-  {
-    // set the length of the sequence
-    _tao_sequence.length (_tao_seq_len);
-    // If length is 0 we return true.
-    if (0 >= _tao_seq_len) 
-      return 1;
-    // retrieve all the elements
-    CORBA::Boolean _tao_marshal_flag = 1;
-    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
-    {
-      _tao_marshal_flag = (strm >> _tao_sequence[i].out ());
-    }
-    return _tao_marshal_flag;
-  }
-  return 0; // error
-}
-
-CORBA::Boolean operator<< (
-    TAO_OutputCDR &strm,
-    const IR_UsesDefSeq &_tao_sequence
-  )
-{
-  if (strm << _tao_sequence.length ())
-  {
-    // encode all elements
-    CORBA::Boolean _tao_marshal_flag = 1;
-    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
-    {
-      _tao_marshal_flag = (strm << _tao_sequence[i].in ());
-    }
-    return _tao_marshal_flag;
-  }
-  return 0; // error
-}
-
-CORBA::Boolean operator>> (
-    TAO_InputCDR &strm,
-    IR_UsesDefSeq &_tao_sequence
-  )
-{
-  CORBA::ULong _tao_seq_len;
-  if (strm >> _tao_seq_len)
-  {
-    // set the length of the sequence
-    _tao_sequence.length (_tao_seq_len);
-    // If length is 0 we return true.
-    if (0 >= _tao_seq_len) 
-      return 1;
-    // retrieve all the elements
-    CORBA::Boolean _tao_marshal_flag = 1;
-    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
-    {
-      _tao_marshal_flag = (strm >> _tao_sequence[i].out ());
-    }
-    return _tao_marshal_flag;
-  }
-  return 0; // error
-}
-
-CORBA::Boolean operator<< (
-    TAO_OutputCDR &strm,
-    const IR_HomeDefSeq &_tao_sequence
-  )
-{
-  if (strm << _tao_sequence.length ())
-  {
-    // encode all elements
-    CORBA::Boolean _tao_marshal_flag = 1;
-    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
-    {
-      _tao_marshal_flag = (strm << _tao_sequence[i].in ());
-    }
-    return _tao_marshal_flag;
-  }
-  return 0; // error
-}
-
-CORBA::Boolean operator>> (
-    TAO_InputCDR &strm,
-    IR_HomeDefSeq &_tao_sequence
-  )
-{
-  CORBA::ULong _tao_seq_len;
-  if (strm >> _tao_seq_len)
-  {
-    // set the length of the sequence
-    _tao_sequence.length (_tao_seq_len);
-    // If length is 0 we return true.
-    if (0 >= _tao_seq_len) 
-      return 1;
-    // retrieve all the elements
-    CORBA::Boolean _tao_marshal_flag = 1;
-    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
-    {
-      _tao_marshal_flag = (strm >> _tao_sequence[i].out ());
-    }
-    return _tao_marshal_flag;
-  }
-  return 0; // error
-}
-
-CORBA::Boolean operator<< (
-    TAO_OutputCDR &strm,
-    const IR_EmitsDefSeq &_tao_sequence
-  )
-{
-  if (strm << _tao_sequence.length ())
-  {
-    // encode all elements
-    CORBA::Boolean _tao_marshal_flag = 1;
-    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
-    {
-      _tao_marshal_flag = (strm << _tao_sequence[i].in ());
-    }
-    return _tao_marshal_flag;
-  }
-  return 0; // error
-}
-
-CORBA::Boolean operator>> (
-    TAO_InputCDR &strm,
-    IR_EmitsDefSeq &_tao_sequence
-  )
-{
-  CORBA::ULong _tao_seq_len;
-  if (strm >> _tao_seq_len)
-  {
-    // set the length of the sequence
-    _tao_sequence.length (_tao_seq_len);
-    // If length is 0 we return true.
-    if (0 >= _tao_seq_len) 
-      return 1;
-    // retrieve all the elements
-    CORBA::Boolean _tao_marshal_flag = 1;
-    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
-    {
-      _tao_marshal_flag = (strm >> _tao_sequence[i].out ());
-    }
-    return _tao_marshal_flag;
-  }
-  return 0; // error
-}
-
-CORBA::Boolean operator<< (
-    TAO_OutputCDR &strm,
-    const IR_PublishesDefSeq &_tao_sequence
-  )
-{
-  if (strm << _tao_sequence.length ())
-  {
-    // encode all elements
-    CORBA::Boolean _tao_marshal_flag = 1;
-    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
-    {
-      _tao_marshal_flag = (strm << _tao_sequence[i].in ());
-    }
-    return _tao_marshal_flag;
-  }
-  return 0; // error
-}
-
-CORBA::Boolean operator>> (
-    TAO_InputCDR &strm,
-    IR_PublishesDefSeq &_tao_sequence
-  )
-{
-  CORBA::ULong _tao_seq_len;
-  if (strm >> _tao_seq_len)
-  {
-    // set the length of the sequence
-    _tao_sequence.length (_tao_seq_len);
-    // If length is 0 we return true.
-    if (0 >= _tao_seq_len) 
-      return 1;
-    // retrieve all the elements
-    CORBA::Boolean _tao_marshal_flag = 1;
-    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
-    {
-      _tao_marshal_flag = (strm >> _tao_sequence[i].out ());
-    }
-    return _tao_marshal_flag;
-  }
-  return 0; // error
-}
-
-CORBA::Boolean operator<< (
-    TAO_OutputCDR &strm,
-    const IR_ConsumesDefSeq &_tao_sequence
-  )
-{
-  if (strm << _tao_sequence.length ())
-  {
-    // encode all elements
-    CORBA::Boolean _tao_marshal_flag = 1;
-    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
-    {
-      _tao_marshal_flag = (strm << _tao_sequence[i].in ());
-    }
-    return _tao_marshal_flag;
-  }
-  return 0; // error
-}
-
-CORBA::Boolean operator>> (
-    TAO_InputCDR &strm,
-    IR_ConsumesDefSeq &_tao_sequence
-  )
-{
-  CORBA::ULong _tao_seq_len;
-  if (strm >> _tao_seq_len)
-  {
-    // set the length of the sequence
-    _tao_sequence.length (_tao_seq_len);
-    // If length is 0 we return true.
-    if (0 >= _tao_seq_len) 
-      return 1;
-    // retrieve all the elements
-    CORBA::Boolean _tao_marshal_flag = 1;
-    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
-    {
-      _tao_marshal_flag = (strm >> _tao_sequence[i].out ());
-    }
-    return _tao_marshal_flag;
-  }
-  return 0; // error
-}
-
-CORBA::Boolean operator<< (
-    TAO_OutputCDR &strm,
-    const IR_FactoryDefSeq &_tao_sequence
-  )
-{
-  if (strm << _tao_sequence.length ())
-  {
-    // encode all elements
-    CORBA::Boolean _tao_marshal_flag = 1;
-    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
-    {
-      _tao_marshal_flag = (strm << _tao_sequence[i].in ());
-    }
-    return _tao_marshal_flag;
-  }
-  return 0; // error
-}
-
-CORBA::Boolean operator>> (
-    TAO_InputCDR &strm,
-    IR_FactoryDefSeq &_tao_sequence
-  )
-{
-  CORBA::ULong _tao_seq_len;
-  if (strm >> _tao_seq_len)
-  {
-    // set the length of the sequence
-    _tao_sequence.length (_tao_seq_len);
-    // If length is 0 we return true.
-    if (0 >= _tao_seq_len) 
-      return 1;
-    // retrieve all the elements
-    CORBA::Boolean _tao_marshal_flag = 1;
-    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
-    {
-      _tao_marshal_flag = (strm >> _tao_sequence[i].out ());
-    }
-    return _tao_marshal_flag;
-  }
-  return 0; // error
-}
-
-CORBA::Boolean operator<< (
-    TAO_OutputCDR &strm,
-    const IR_FinderDefSeq &_tao_sequence
-  )
-{
-  if (strm << _tao_sequence.length ())
-  {
-    // encode all elements
-    CORBA::Boolean _tao_marshal_flag = 1;
-    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
-    {
-      _tao_marshal_flag = (strm << _tao_sequence[i].in ());
-    }
-    return _tao_marshal_flag;
-  }
-  return 0; // error
-}
-
-CORBA::Boolean operator>> (
-    TAO_InputCDR &strm,
-    IR_FinderDefSeq &_tao_sequence
-  )
-{
-  CORBA::ULong _tao_seq_len;
-  if (strm >> _tao_seq_len)
-  {
-    // set the length of the sequence
-    _tao_sequence.length (_tao_seq_len);
-    // If length is 0 we return true.
-    if (0 >= _tao_seq_len) 
-      return 1;
-    // retrieve all the elements
-    CORBA::Boolean _tao_marshal_flag = 1;
-    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
-    {
-      _tao_marshal_flag = (strm >> _tao_sequence[i].out ());
-    }
-    return _tao_marshal_flag;
-  }
-  return 0; // error
-}
-
-CORBA::Boolean operator<< (
-    TAO_OutputCDR &strm,
-    const IR_ContainedSeq &_tao_sequence
-  )
-{
-  if (strm << _tao_sequence.length ())
-  {
-    // encode all elements
-    CORBA::Boolean _tao_marshal_flag = 1;
-    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
-    {
-      _tao_marshal_flag = (strm << _tao_sequence[i].in ());
-    }
-    return _tao_marshal_flag;
-  }
-  return 0; // error
-}
-
-CORBA::Boolean operator>> (
-    TAO_InputCDR &strm,
-    IR_ContainedSeq &_tao_sequence
-  )
-{
-  CORBA::ULong _tao_seq_len;
-  if (strm >> _tao_seq_len)
-  {
-    // set the length of the sequence
-    _tao_sequence.length (_tao_seq_len);
-    // If length is 0 we return true.
-    if (0 >= _tao_seq_len) 
-      return 1;
-    // retrieve all the elements
-    CORBA::Boolean _tao_marshal_flag = 1;
-    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
-    {
-      _tao_marshal_flag = (strm >> _tao_sequence[i].out ());
-    }
-    return _tao_marshal_flag;
-  }
-  return 0; // error
-}
-
-CORBA::Boolean operator<< (
-    TAO_OutputCDR &strm,
-    const IR_StructMemberSeq &_tao_sequence
-  )
-{
-  if (strm << _tao_sequence.length ())
-  {
-    // encode all elements
-    CORBA::Boolean _tao_marshal_flag = 1;
-    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
-    {
-      _tao_marshal_flag = (strm << _tao_sequence[i]);
-    }
-    return _tao_marshal_flag;
-  }
-  return 0; // error
-}
-
-CORBA::Boolean operator>> (
-    TAO_InputCDR &strm,
-    IR_StructMemberSeq &_tao_sequence
-  )
-{
-  CORBA::ULong _tao_seq_len;
-  if (strm >> _tao_seq_len)
-  {
-    // set the length of the sequence
-    _tao_sequence.length (_tao_seq_len);
-    // If length is 0 we return true.
-    if (0 >= _tao_seq_len) 
-      return 1;
-    // retrieve all the elements
-    CORBA::Boolean _tao_marshal_flag = 1;
-    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
-    {
-      _tao_marshal_flag = (strm >> _tao_sequence[i]);
-    }
-    return _tao_marshal_flag;
-  }
-  return 0; // error
-}
-
-CORBA::Boolean operator<< (
-    TAO_OutputCDR &strm,
-    const IR_InitializerSeq &_tao_sequence
-  )
-{
-  if (strm << _tao_sequence.length ())
-  {
-    // encode all elements
-    CORBA::Boolean _tao_marshal_flag = 1;
-    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
-    {
-      _tao_marshal_flag = (strm << _tao_sequence[i]);
-    }
-    return _tao_marshal_flag;
-  }
-  return 0; // error
-}
-
-CORBA::Boolean operator>> (
-    TAO_InputCDR &strm,
-    IR_InitializerSeq &_tao_sequence
-  )
-{
-  CORBA::ULong _tao_seq_len;
-  if (strm >> _tao_seq_len)
-  {
-    // set the length of the sequence
-    _tao_sequence.length (_tao_seq_len);
-    // If length is 0 we return true.
-    if (0 >= _tao_seq_len) 
-      return 1;
-    // retrieve all the elements
-    CORBA::Boolean _tao_marshal_flag = 1;
-    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
-    {
-      _tao_marshal_flag = (strm >> _tao_sequence[i]);
-    }
-    return _tao_marshal_flag;
-  }
-  return 0; // error
-}
-
-CORBA::Boolean operator<< (
-    TAO_OutputCDR &strm,
-    const IR_UnionMemberSeq &_tao_sequence
-  )
-{
-  if (strm << _tao_sequence.length ())
-  {
-    // encode all elements
-    CORBA::Boolean _tao_marshal_flag = 1;
-    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
-    {
-      _tao_marshal_flag = (strm << _tao_sequence[i]);
-    }
-    return _tao_marshal_flag;
-  }
-  return 0; // error
-}
-
-CORBA::Boolean operator>> (
-    TAO_InputCDR &strm,
-    IR_UnionMemberSeq &_tao_sequence
-  )
-{
-  CORBA::ULong _tao_seq_len;
-  if (strm >> _tao_seq_len)
-  {
-    // set the length of the sequence
-    _tao_sequence.length (_tao_seq_len);
-    // If length is 0 we return true.
-    if (0 >= _tao_seq_len) 
-      return 1;
-    // retrieve all the elements
-    CORBA::Boolean _tao_marshal_flag = 1;
-    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
-    {
-      _tao_marshal_flag = (strm >> _tao_sequence[i]);
-    }
-    return _tao_marshal_flag;
-  }
-  return 0; // error
-}
-
-CORBA::Boolean operator<< (
-    TAO_OutputCDR &strm,
-    const IR_EnumMemberSeq &_tao_sequence
-  )
-{
-  if (strm << _tao_sequence.length ())
-  {
-    // encode all elements
-    CORBA::Boolean _tao_marshal_flag = 1;
-    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
-    {
-      _tao_marshal_flag = (strm << _tao_sequence[i].in ());
-    }
-    return _tao_marshal_flag;
-  }
-  return 0; // error
-}
-
-CORBA::Boolean operator>> (
-    TAO_InputCDR &strm,
-    IR_EnumMemberSeq &_tao_sequence
-  )
-{
-  CORBA::ULong _tao_seq_len;
-  if (strm >> _tao_seq_len)
-  {
-    // set the length of the sequence
-    _tao_sequence.length (_tao_seq_len);
-    // If length is 0 we return true.
-    if (0 >= _tao_seq_len) 
-      return 1;
-    // retrieve all the elements
-    CORBA::Boolean _tao_marshal_flag = 1;
-    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
-    {
-      _tao_marshal_flag = (strm >> _tao_sequence[i].out ());
-    }
-    return _tao_marshal_flag;
-  }
-  return 0; // error
-}
-
-CORBA::Boolean operator<< (
-    TAO_OutputCDR &strm,
-    const IR_Container::DescriptionSeq &_tao_sequence
-  )
-{
-  if (strm << _tao_sequence.length ())
-  {
-    // encode all elements
-    CORBA::Boolean _tao_marshal_flag = 1;
-    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
-    {
-      _tao_marshal_flag = (strm << _tao_sequence[i]);
-    }
-    return _tao_marshal_flag;
-  }
-  return 0; // error
-}
-
-CORBA::Boolean operator>> (
-    TAO_InputCDR &strm,
-    IR_Container::DescriptionSeq &_tao_sequence
-  )
-{
-  CORBA::ULong _tao_seq_len;
-  if (strm >> _tao_seq_len)
-  {
-    // set the length of the sequence
-    _tao_sequence.length (_tao_seq_len);
-    // If length is 0 we return true.
-    if (0 >= _tao_seq_len) 
-      return 1;
-    // retrieve all the elements
-    CORBA::Boolean _tao_marshal_flag = 1;
-    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
-    {
-      _tao_marshal_flag = (strm >> _tao_sequence[i]);
-    }
-    return _tao_marshal_flag;
-  }
-  return 0; // error
-}
-
-CORBA::Boolean operator<< (
-    TAO_OutputCDR &strm,
-    const IR_ExceptionDefSeq &_tao_sequence
-  )
-{
-  if (strm << _tao_sequence.length ())
-  {
-    // encode all elements
-    CORBA::Boolean _tao_marshal_flag = 1;
-    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
-    {
-      _tao_marshal_flag = (strm << _tao_sequence[i].in ());
-    }
-    return _tao_marshal_flag;
-  }
-  return 0; // error
-}
-
-CORBA::Boolean operator>> (
-    TAO_InputCDR &strm,
-    IR_ExceptionDefSeq &_tao_sequence
-  )
-{
-  CORBA::ULong _tao_seq_len;
-  if (strm >> _tao_seq_len)
-  {
-    // set the length of the sequence
-    _tao_sequence.length (_tao_seq_len);
-    // If length is 0 we return true.
-    if (0 >= _tao_seq_len) 
-      return 1;
-    // retrieve all the elements
-    CORBA::Boolean _tao_marshal_flag = 1;
-    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
-    {
-      _tao_marshal_flag = (strm >> _tao_sequence[i].out ());
-    }
-    return _tao_marshal_flag;
-  }
-  return 0; // error
-}
-
-CORBA::Boolean operator<< (
-    TAO_OutputCDR &strm,
-    const IR_ExcDescriptionSeq &_tao_sequence
-  )
-{
-  if (strm << _tao_sequence.length ())
-  {
-    // encode all elements
-    CORBA::Boolean _tao_marshal_flag = 1;
-    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
-    {
-      _tao_marshal_flag = (strm << _tao_sequence[i]);
-    }
-    return _tao_marshal_flag;
-  }
-  return 0; // error
-}
-
-CORBA::Boolean operator>> (
-    TAO_InputCDR &strm,
-    IR_ExcDescriptionSeq &_tao_sequence
-  )
-{
-  CORBA::ULong _tao_seq_len;
-  if (strm >> _tao_seq_len)
-  {
-    // set the length of the sequence
-    _tao_sequence.length (_tao_seq_len);
-    // If length is 0 we return true.
-    if (0 >= _tao_seq_len) 
-      return 1;
-    // retrieve all the elements
-    CORBA::Boolean _tao_marshal_flag = 1;
-    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
-    {
-      _tao_marshal_flag = (strm >> _tao_sequence[i]);
-    }
-    return _tao_marshal_flag;
-  }
-  return 0; // error
-}
-
-CORBA::Boolean operator<< (
-    TAO_OutputCDR &strm,
-    const IR_ParDescriptionSeq &_tao_sequence
-  )
-{
-  if (strm << _tao_sequence.length ())
-  {
-    // encode all elements
-    CORBA::Boolean _tao_marshal_flag = 1;
-    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
-    {
-      _tao_marshal_flag = (strm << _tao_sequence[i]);
-    }
-    return _tao_marshal_flag;
-  }
-  return 0; // error
-}
-
-CORBA::Boolean operator>> (
-    TAO_InputCDR &strm,
-    IR_ParDescriptionSeq &_tao_sequence
-  )
-{
-  CORBA::ULong _tao_seq_len;
-  if (strm >> _tao_seq_len)
-  {
-    // set the length of the sequence
-    _tao_sequence.length (_tao_seq_len);
-    // If length is 0 we return true.
-    if (0 >= _tao_seq_len) 
-      return 1;
-    // retrieve all the elements
-    CORBA::Boolean _tao_marshal_flag = 1;
-    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
-    {
-      _tao_marshal_flag = (strm >> _tao_sequence[i]);
-    }
-    return _tao_marshal_flag;
-  }
-  return 0; // error
-}
-
-CORBA::Boolean operator<< (
-    TAO_OutputCDR &strm,
-    const IR_ContextIdSeq &_tao_sequence
-  )
-{
-  if (strm << _tao_sequence.length ())
-  {
-    // encode all elements
-    CORBA::Boolean _tao_marshal_flag = 1;
-    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
-    {
-      _tao_marshal_flag = (strm << _tao_sequence[i].in ());
-    }
-    return _tao_marshal_flag;
-  }
-  return 0; // error
-}
-
-CORBA::Boolean operator>> (
-    TAO_InputCDR &strm,
-    IR_ContextIdSeq &_tao_sequence
-  )
-{
-  CORBA::ULong _tao_seq_len;
-  if (strm >> _tao_seq_len)
-  {
-    // set the length of the sequence
-    _tao_sequence.length (_tao_seq_len);
-    // If length is 0 we return true.
-    if (0 >= _tao_seq_len) 
-      return 1;
-    // retrieve all the elements
-    CORBA::Boolean _tao_marshal_flag = 1;
-    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
-    {
-      _tao_marshal_flag = (strm >> _tao_sequence[i].out ());
-    }
-    return _tao_marshal_flag;
-  }
-  return 0; // error
-}
-
-CORBA::Boolean operator<< (
-    TAO_OutputCDR &strm,
-    const IR_RepositoryIdSeq &_tao_sequence
-  )
-{
-  if (strm << _tao_sequence.length ())
-  {
-    // encode all elements
-    CORBA::Boolean _tao_marshal_flag = 1;
-    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
-    {
-      _tao_marshal_flag = (strm << _tao_sequence[i].in ());
-    }
-    return _tao_marshal_flag;
-  }
-  return 0; // error
-}
-
-CORBA::Boolean operator>> (
-    TAO_InputCDR &strm,
-    IR_RepositoryIdSeq &_tao_sequence
-  )
-{
-  CORBA::ULong _tao_seq_len;
-  if (strm >> _tao_seq_len)
-  {
-    // set the length of the sequence
-    _tao_sequence.length (_tao_seq_len);
-    // If length is 0 we return true.
-    if (0 >= _tao_seq_len) 
-      return 1;
-    // retrieve all the elements
-    CORBA::Boolean _tao_marshal_flag = 1;
-    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
-    {
-      _tao_marshal_flag = (strm >> _tao_sequence[i].out ());
-    }
-    return _tao_marshal_flag;
-  }
-  return 0; // error
-}
-
-CORBA::Boolean operator<< (
-    TAO_OutputCDR &strm,
-    const IR_OpDescriptionSeq &_tao_sequence
-  )
-{
-  if (strm << _tao_sequence.length ())
-  {
-    // encode all elements
-    CORBA::Boolean _tao_marshal_flag = 1;
-    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
-    {
-      _tao_marshal_flag = (strm << _tao_sequence[i]);
-    }
-    return _tao_marshal_flag;
-  }
-  return 0; // error
-}
-
-CORBA::Boolean operator>> (
-    TAO_InputCDR &strm,
-    IR_OpDescriptionSeq &_tao_sequence
-  )
-{
-  CORBA::ULong _tao_seq_len;
-  if (strm >> _tao_seq_len)
-  {
-    // set the length of the sequence
-    _tao_sequence.length (_tao_seq_len);
-    // If length is 0 we return true.
-    if (0 >= _tao_seq_len) 
-      return 1;
-    // retrieve all the elements
-    CORBA::Boolean _tao_marshal_flag = 1;
-    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
-    {
-      _tao_marshal_flag = (strm >> _tao_sequence[i]);
-    }
-    return _tao_marshal_flag;
-  }
-  return 0; // error
-}
-
-CORBA::Boolean operator<< (
-    TAO_OutputCDR &strm,
-    const IR_AttrDescriptionSeq &_tao_sequence
-  )
-{
-  if (strm << _tao_sequence.length ())
-  {
-    // encode all elements
-    CORBA::Boolean _tao_marshal_flag = 1;
-    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
-    {
-      _tao_marshal_flag = (strm << _tao_sequence[i]);
-    }
-    return _tao_marshal_flag;
-  }
-  return 0; // error
-}
-
-CORBA::Boolean operator>> (
-    TAO_InputCDR &strm,
-    IR_AttrDescriptionSeq &_tao_sequence
-  )
-{
-  CORBA::ULong _tao_seq_len;
-  if (strm >> _tao_seq_len)
-  {
-    // set the length of the sequence
-    _tao_sequence.length (_tao_seq_len);
-    // If length is 0 we return true.
-    if (0 >= _tao_seq_len) 
-      return 1;
-    // retrieve all the elements
-    CORBA::Boolean _tao_marshal_flag = 1;
-    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
-    {
-      _tao_marshal_flag = (strm >> _tao_sequence[i]);
-    }
-    return _tao_marshal_flag;
-  }
-  return 0; // error
-}
-
-CORBA::Boolean operator<< (
-    TAO_OutputCDR &strm,
-    const IR_ValueMemberSeq &_tao_sequence
-  )
-{
-  if (strm << _tao_sequence.length ())
-  {
-    // encode all elements
-    CORBA::Boolean _tao_marshal_flag = 1;
-    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
-    {
-      _tao_marshal_flag = (strm << _tao_sequence[i]);
-    }
-    return _tao_marshal_flag;
-  }
-  return 0; // error
-}
-
-CORBA::Boolean operator>> (
-    TAO_InputCDR &strm,
-    IR_ValueMemberSeq &_tao_sequence
-  )
-{
-  CORBA::ULong _tao_seq_len;
-  if (strm >> _tao_seq_len)
-  {
-    // set the length of the sequence
-    _tao_sequence.length (_tao_seq_len);
-    // If length is 0 we return true.
-    if (0 >= _tao_seq_len) 
-      return 1;
-    // retrieve all the elements
-    CORBA::Boolean _tao_marshal_flag = 1;
-    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
-    {
-      _tao_marshal_flag = (strm >> _tao_sequence[i]);
-    }
-    return _tao_marshal_flag;
-  }
-  return 0; // error
-}
-
-CORBA::Boolean operator<< (
-    TAO_OutputCDR &strm,
-    const IR_ProvidesDescSeq &_tao_sequence
-  )
-{
-  if (strm << _tao_sequence.length ())
-  {
-    // encode all elements
-    CORBA::Boolean _tao_marshal_flag = 1;
-    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
-    {
-      _tao_marshal_flag = (strm << _tao_sequence[i]);
-    }
-    return _tao_marshal_flag;
-  }
-  return 0; // error
-}
-
-CORBA::Boolean operator>> (
-    TAO_InputCDR &strm,
-    IR_ProvidesDescSeq &_tao_sequence
-  )
-{
-  CORBA::ULong _tao_seq_len;
-  if (strm >> _tao_seq_len)
-  {
-    // set the length of the sequence
-    _tao_sequence.length (_tao_seq_len);
-    // If length is 0 we return true.
-    if (0 >= _tao_seq_len) 
-      return 1;
-    // retrieve all the elements
-    CORBA::Boolean _tao_marshal_flag = 1;
-    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
-    {
-      _tao_marshal_flag = (strm >> _tao_sequence[i]);
-    }
-    return _tao_marshal_flag;
-  }
-  return 0; // error
-}
-
-CORBA::Boolean operator<< (
-    TAO_OutputCDR &strm,
-    const IR_UsesDescSeq &_tao_sequence
-  )
-{
-  if (strm << _tao_sequence.length ())
-  {
-    // encode all elements
-    CORBA::Boolean _tao_marshal_flag = 1;
-    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
-    {
-      _tao_marshal_flag = (strm << _tao_sequence[i]);
-    }
-    return _tao_marshal_flag;
-  }
-  return 0; // error
-}
-
-CORBA::Boolean operator>> (
-    TAO_InputCDR &strm,
-    IR_UsesDescSeq &_tao_sequence
-  )
-{
-  CORBA::ULong _tao_seq_len;
-  if (strm >> _tao_seq_len)
-  {
-    // set the length of the sequence
-    _tao_sequence.length (_tao_seq_len);
-    // If length is 0 we return true.
-    if (0 >= _tao_seq_len) 
-      return 1;
-    // retrieve all the elements
-    CORBA::Boolean _tao_marshal_flag = 1;
-    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
-    {
-      _tao_marshal_flag = (strm >> _tao_sequence[i]);
-    }
-    return _tao_marshal_flag;
-  }
-  return 0; // error
-}
-
diff --git a/TAO/tao/IFR_Client/InterfaceC.h b/TAO/tao/IFR_Client/InterfaceC.h
deleted file mode 100644
index 663b79772c9..00000000000
--- a/TAO/tao/IFR_Client/InterfaceC.h
+++ /dev/null
@@ -1,25566 +0,0 @@
-// -*- C++ -*-
-//
-//$Id$
-
-// ****  Code generated by the The ACE ORB (TAO) IDL Compiler ****
-// TAO and the TAO IDL Compiler have been developed by:
-//       Center for Distributed Object Computing
-//       Washington University
-//       St. Louis, MO
-//       USA
-//       http://www.cs.wustl.edu/~schmidt/doc-center.html
-// and
-//       Distributed Object Computing Laboratory
-//       University of California at Irvine
-//       Irvine, CA
-//       USA
-//       http://doc.ece.uci.edu/
-//
-// Information about TAO is available at:
-//     http://www.cs.wustl.edu/~schmidt/TAO.html
-
-#ifndef TAO_IDL_INTERFACEC_H
-#define TAO_IDL_INTERFACEC_H
-#include "ace/pre.h"
-
-#include "ifrfwd.h"
-
-#if !defined (ACE_LACKS_PRAGMA_ONCE)
-# pragma once
-#endif /* ACE_LACKS_PRAGMA_ONCE */
-
-#include "tao/TAO_Singleton.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_INTERCEPTORS == 1)
-  #include "tao/ClientRequestInfo.h"
-#endif /* TAO_HAS_INTERCEPTORS == 1 */
-
-#if defined (TAO_EXPORT_NESTED_CLASSES)
-#  if defined (TAO_EXPORT_NESTED_MACRO)
-#    undef TAO_EXPORT_NESTED_MACRO
-#  endif /* defined (TAO_EXPORT_NESTED_MACRO) */
-#  define TAO_EXPORT_NESTED_MACRO TAO_IFR_Client_Export
-#endif /* TAO_EXPORT_NESTED_CLASSES */
-
-#if defined(_MSC_VER)
-#if (_MSC_VER >= 1200)
-#pragma warning(push)
-#endif /* _MSC_VER >= 1200 */
-#pragma warning(disable:4250)
-#endif /* _MSC_VER */
-
-#if defined (__BORLANDC__)
-#pragma option push -w-rvl -w-rch -w-ccc -w-inl
-#endif /* __BORLANDC__ */
-
-  class TAO_IFR_Client_Export CORBA_IRObject_var : public TAO_Base_var
-  {
-  public:
-    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 CORBA_IRObject_ptr &() const;
-    operator CORBA_IRObject_ptr &();
-    // in, inout, out, _retn
-    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:
-    CORBA_IRObject_ptr ptr_;
-    // Unimplemented - prevents widening assignment.
-    CORBA_IRObject_var (const TAO_Base_var &rhs);
-    CORBA_IRObject_var &operator= (const TAO_Base_var &rhs);
-  };
-
-  class TAO_IFR_Client_Export CORBA_IRObject_out
-  {
-  public:
-    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:
-    CORBA_IRObject_ptr &ptr_;
-  };
-
-  class _TAO_IRObject_Proxy_Impl;
-  class _TAO_IRObject_Remote_Proxy_Impl;
-  class _TAO_IRObject_Proxy_Broker;
-  class _TAO_IRObject_Remote_Proxy_Broker;
-
-  class TAO_IFR_Client_Export CORBA_IRObject : public virtual CORBA_Object
-  {
-  public:
-  #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
-    typedef CORBA_IRObject_ptr _ptr_type;
-    typedef CORBA_IRObject_var _var_type;
-  #endif /* ! __GNUC__ || g++ >= 2.8 */
-
-    // the static operations
-    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 CORBA_IRObject_ptr _unchecked_narrow (
-        CORBA::Object_ptr obj,
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      );
-    static CORBA_IRObject_ptr _nil (void)
-      {
-        return (CORBA_IRObject_ptr)0;
-      }
-
-    static void _tao_any_destructor (void*);
-
-    virtual IR_DefinitionKind def_kind (
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual void destroy (
-        CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual CORBA::Boolean _is_a (
-        const CORBA::Char *type_id,
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      );
-    virtual void *_tao_QueryInterface (ptr_arith_t type);
-
-    virtual const char* _interface_repository_id (void) const;
-
-  private:
-    _TAO_IRObject_Proxy_Broker *the_TAO_IRObject_Proxy_Broker_;
-
-  protected:
-    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 CORBA_IRObject_setup_collocation (int collocated);
-
-    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 ~CORBA_IRObject (void);
-  private:
-    CORBA_IRObject (const CORBA_IRObject &);
-    void operator= (const CORBA_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 (
-          TAO_GIOP_Invocation *_tao_invocation,
-          CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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_destroy (const TAO_ClientRequestInfo_CORBA_IRObject_destroy &);
-    void operator= (const TAO_ClientRequestInfo_CORBA_IRObject_destroy &);
-  
-  };
-
-#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_IFR_Client_Export _TAO_IRObject_Proxy_Impl : public virtual TAO_Object_Proxy_Impl
-{
-public:
-  virtual ~_TAO_IRObject_Proxy_Impl (void) { }
-
-  virtual IR_DefinitionKind def_kind (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  virtual void destroy (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-protected:
-  _TAO_IRObject_Proxy_Impl (void);
-
-};
-
-//
-//                Base  Proxy Impl. Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//                    Remote  Impl. Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_IRObject_Remote_Proxy_Impl :
-  public virtual _TAO_IRObject_Proxy_Impl,
-  public virtual TAO_Remote_Object_Proxy_Impl
-{
-public:
-  _TAO_IRObject_Remote_Proxy_Impl (void);
-
-  virtual ~_TAO_IRObject_Remote_Proxy_Impl (void) { }
-
-  virtual IR_DefinitionKind def_kind (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual void destroy (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-};
-
-//
-//                Base  Proxy Impl. Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-// The Proxy Brokers are used by each interface to get
-// the right proxy for performing a call. In the new
-// collocation scheme, the proxy to be used can vary on
-// a call by call basis.
-
-
-
-///////////////////////////////////////////////////////////////////////
-//                 Base Proxy Broker Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_IRObject_Proxy_Broker
-{
-public:
-  virtual ~_TAO_IRObject_Proxy_Broker (void);
-
-  virtual _TAO_IRObject_Proxy_Impl &select_proxy (
-    CORBA_IRObject *object,
-    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-  ) = 0;
-
-protected:
-  _TAO_IRObject_Proxy_Broker (void);
-
-};
-
-
-//
-//              End Base Proxy Broker Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//                 Remote Proxy Broker Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_IRObject_Remote_Proxy_Broker : public virtual _TAO_IRObject_Proxy_Broker
-{
-public:
-  _TAO_IRObject_Remote_Proxy_Broker (void);
-
-  virtual ~_TAO_IRObject_Remote_Proxy_Broker (void);
-
-  virtual _TAO_IRObject_Proxy_Impl &select_proxy (
-    CORBA_IRObject *object,
-    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-  );
-
-private:
-  _TAO_IRObject_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_IRObject_Remote_Proxy_Broker *the_TAO_IRObject_Remote_Proxy_Broker (void);
-};
-
-//
-//              End Remote Proxy Broker Declaration
-///////////////////////////////////////////////////////////////////////
-
-  class TAO_IFR_Client_Export IR_Contained_var : public TAO_Base_var
-  {
-  public:
-    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 IR_Contained_ptr &() const;
-    operator IR_Contained_ptr &();
-    // in, inout, out, _retn
-    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:
-    IR_Contained_ptr ptr_;
-    // Unimplemented - prevents widening assignment.
-    IR_Contained_var (const TAO_Base_var &rhs);
-    IR_Contained_var &operator= (const TAO_Base_var &rhs);
-  };
-
-  class TAO_IFR_Client_Export IR_Contained_out
-  {
-  public:
-    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:
-    IR_Contained_ptr &ptr_;
-  };
-
-  class TAO_IFR_Client_Export IR_Repository_var : public TAO_Base_var
-  {
-  public:
-    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 IR_Repository_ptr &() const;
-    operator IR_Repository_ptr &();
-    // in, inout, out, _retn
-    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:
-    IR_Repository_ptr ptr_;
-    // Unimplemented - prevents widening assignment.
-    IR_Repository_var (const TAO_Base_var &rhs);
-    IR_Repository_var &operator= (const TAO_Base_var &rhs);
-  };
-
-  class TAO_IFR_Client_Export IR_Repository_out
-  {
-  public:
-    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:
-    IR_Repository_ptr &ptr_;
-  };
-
-  class TAO_IFR_Client_Export IR_Container_var : public TAO_Base_var
-  {
-  public:
-    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 IR_Container_ptr &() const;
-    operator IR_Container_ptr &();
-    // in, inout, out, _retn
-    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:
-    IR_Container_ptr ptr_;
-    // Unimplemented - prevents widening assignment.
-    IR_Container_var (const TAO_Base_var &rhs);
-    IR_Container_var &operator= (const TAO_Base_var &rhs);
-  };
-
-  class TAO_IFR_Client_Export IR_Container_out
-  {
-  public:
-    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:
-    IR_Container_ptr &ptr_;
-  };
-
-// 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_IFR_Client_Export IR_Contained: public virtual CORBA_IRObject
-  {
-  public:
-  #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
-    typedef IR_Contained_ptr _ptr_type;
-    typedef IR_Contained_var _var_type;
-  #endif /* ! __GNUC__ || g++ >= 2.8 */
-
-    // the static operations
-    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 IR_Contained_ptr _unchecked_narrow (
-        CORBA::Object_ptr obj,
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      );
-    static IR_Contained_ptr _nil (void)
-      {
-        return (IR_Contained_ptr)0;
-      }
-
-    static void _tao_any_destructor (void*);
-
-    virtual char * id (
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual void id (
-        const char * id,
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual char * name (
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual void name (
-        const char * name,
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual char * version (
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual void version (
-        const char * version,
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual IR_Container_ptr defined_in (
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual char * absolute_name (
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual IR_Repository_ptr containing_repository (
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    struct Description;
-    class Description_var;
-
-    struct TAO_IFR_Client_Export Description
-    {
-
-#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
-      typedef Description_var _var_type;
-#endif /* ! __GNUC__ || g++ >= 2.8 */
-
-      static void _tao_any_destructor (void*);
-
-      IR_DefinitionKind kind;
-      CORBA::Any value;
-    };
-
-    class TAO_IFR_Client_Export Description_var
-    {
-    public:
-      Description_var (void); // default constructor
-      Description_var (Description *);
-      Description_var (const Description_var &); // copy constructor
-      ~Description_var (void); // destructor
-
-      Description_var &operator= (Description *);
-      Description_var &operator= (const Description_var &);
-      Description *operator-> (void);
-      const Description *operator-> (void) const;
-
-      operator const Description &() const;
-      operator Description &();
-      operator Description &() const;
-      operator Description *&(); // variable-size types only
-
-      // in, inout, out, _retn
-      const Description &in (void) const;
-      Description &inout (void);
-      Description *&out (void);
-      Description *_retn (void);
-      Description *ptr (void) const;
-
-    private:
-      Description *ptr_;
-    };
-
-    class TAO_IFR_Client_Export Description_out
-    {
-    public:
-      Description_out (Description *&);
-      Description_out (Description_var &);
-      Description_out (const Description_out &);
-      Description_out &operator= (const Description_out &);
-      Description_out &operator= (Description *);
-      operator Description *&();
-      Description *&ptr (void);
-      Description *operator-> (void);
-
-    private:
-      Description *&ptr_;
-      // assignment from T_var not allowed
-      void operator= (const Description_var &);
-    };
-
-    static CORBA::TypeCode_ptr _tc_Description;
-
-    virtual IR_Contained::Description * describe     (
-                        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual void move (
-        IR_Container_ptr new_container,
-        const char * new_name,
-        const char * new_version,
-        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_Contained_Proxy_Broker *the_TAO_Contained_Proxy_Broker_;
-
-  protected:
-    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 IR_Contained_setup_collocation (int collocated);
-
-    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 ~IR_Contained (void);
-  private:
-    IR_Contained (const IR_Contained &);
-    void operator= (const IR_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 (
-          TAO_GIOP_Invocation *_tao_invocation,
-          CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-      TAO_GIOP_Invocation *_tao_invocation,
-      CORBA::Object_ptr _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;
-
-    TAO_ClientRequestInfo_IR_Contained_name_set (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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));
-
-    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_;
-  
-  };
-
-  class TAO_ClientRequestInfo_IR_Contained_version_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_version_get (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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_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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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_IFR_Client_Export _TAO_Contained_Proxy_Impl :
-  public virtual _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 void name (
-      CORBA_Object *_collocated_tao_target_,
-      const char * name,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  virtual char * version (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  virtual void version (
-      CORBA_Object *_collocated_tao_target_,
-      const char * version,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  virtual IR_Container_ptr defined_in (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  virtual char * absolute_name (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  virtual IR_Repository_ptr containing_repository (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  virtual IR_Contained::Description * describe (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  virtual void move (
-      CORBA_Object *_collocated_tao_target_,
-      IR_Container_ptr new_container,
-      const char * new_name,
-      const char * new_version,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-protected:
-  _TAO_Contained_Proxy_Impl (void);
-};
-
-//
-//                Base  Proxy Impl. Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//                    Remote  Impl. Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_Contained_Remote_Proxy_Impl :
-  public virtual _TAO_Contained_Proxy_Impl,
-  public virtual TAO_Remote_Object_Proxy_Impl,
-  public virtual _TAO_IRObject_Remote_Proxy_Impl
-
-{
-public:
-  _TAO_Contained_Remote_Proxy_Impl (void);
-
-  virtual ~_TAO_Contained_Remote_Proxy_Impl (void) { }
-
-  virtual char * id (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    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
-    ));
-
-  virtual char * name (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual void name (
-      CORBA_Object *_collocated_tao_target_,
-      const char * name,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual char * version (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual void version (
-      CORBA_Object *_collocated_tao_target_,
-      const char * version,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual IR_Container_ptr defined_in (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual char * absolute_name (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual IR_Repository_ptr containing_repository (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual IR_Contained::Description * describe (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual void move (
-      CORBA_Object *_collocated_tao_target_,
-      IR_Container_ptr new_container,
-      const char * new_name,
-      const char * new_version,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-};
-
-//
-//                Base  Proxy Impl. Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-// The Proxy Brokers are used by each interface to get
-// the right proxy for performing a call. In the new
-// collocation scheme, the proxy to be used can vary on
-// a call by call basis.
-
-
-
-///////////////////////////////////////////////////////////////////////
-//                 Base Proxy Broker Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_Contained_Proxy_Broker
-{
-public:
-  virtual ~_TAO_Contained_Proxy_Broker (void);
-
-  virtual _TAO_Contained_Proxy_Impl &select_proxy (
-    IR_Contained *object,
-    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-  ) = 0;
-
-protected:
-  _TAO_Contained_Proxy_Broker (void);
-
-};
-
-
-//
-//              End Base Proxy Broker Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//                 Remote Proxy Broker Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_Contained_Remote_Proxy_Broker : public virtual _TAO_Contained_Proxy_Broker
-{
-public:
-  _TAO_Contained_Remote_Proxy_Broker (void);
-
-  virtual ~_TAO_Contained_Remote_Proxy_Broker (void);
-
-  virtual _TAO_Contained_Proxy_Impl &select_proxy (
-    IR_Contained *object,
-    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-  );
-
-private:
-  _TAO_Contained_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_Contained_Remote_Proxy_Broker *the_TAO_Contained_Remote_Proxy_Broker (void);
-};
-
-//
-//              End Remote Proxy Broker Declaration
-///////////////////////////////////////////////////////////////////////
-
-class TAO_IFR_Client_Export IR_ModuleDef_var : public TAO_Base_var
-{
-public:
-  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
-
-  IR_ModuleDef_var &operator= (IR_ModuleDef_ptr);
-  IR_ModuleDef_var &operator= (const IR_ModuleDef_var &);
-  IR_ModuleDef_ptr operator-> (void) const;
-
-  operator const IR_ModuleDef_ptr &() const;
-  operator IR_ModuleDef_ptr &();
-  // in, inout, out, _retn
-  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:
-  IR_ModuleDef_ptr ptr_;
-  // Unimplemented - prevents widening assignment.
-  IR_ModuleDef_var (const TAO_Base_var &rhs);
-  IR_ModuleDef_var &operator= (const TAO_Base_var &rhs);
-};
-
-class TAO_IFR_Client_Export IR_ModuleDef_out
-{
-public:
-  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:
-  IR_ModuleDef_ptr &ptr_;
-};
-
-class TAO_IFR_Client_Export IR_ConstantDef_var : public TAO_Base_var
-{
-public:
-  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
-
-  IR_ConstantDef_var &operator= (IR_ConstantDef_ptr);
-  IR_ConstantDef_var &operator= (const IR_ConstantDef_var &);
-  IR_ConstantDef_ptr operator-> (void) const;
-
-  operator const IR_ConstantDef_ptr &() const;
-  operator IR_ConstantDef_ptr &();
-  // in, inout, out, _retn
-  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:
-  IR_ConstantDef_ptr ptr_;
-  // Unimplemented - prevents widening assignment.
-  IR_ConstantDef_var (const TAO_Base_var &rhs);
-  IR_ConstantDef_var &operator= (const TAO_Base_var &rhs);
-};
-
-class TAO_IFR_Client_Export IR_ConstantDef_out
-{
-public:
-  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:
-  IR_ConstantDef_ptr &ptr_;
-};
-
-class TAO_IFR_Client_Export IR_IDLType_var : public TAO_Base_var
-{
-public:
-  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
-
-  IR_IDLType_var &operator= (IR_IDLType_ptr);
-  IR_IDLType_var &operator= (const IR_IDLType_var &);
-  IR_IDLType_ptr operator-> (void) const;
-
-  operator const IR_IDLType_ptr &() const;
-  operator IR_IDLType_ptr &();
-  // in, inout, out, _retn
-  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:
-  IR_IDLType_ptr ptr_;
-  // Unimplemented - prevents widening assignment.
-  IR_IDLType_var (const TAO_Base_var &rhs);
-  IR_IDLType_var &operator= (const TAO_Base_var &rhs);
-};
-
-class TAO_IFR_Client_Export IR_IDLType_out
-{
-public:
-  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:
-  IR_IDLType_ptr &ptr_;
-};
-
-class TAO_IFR_Client_Export IR_StructDef_var : public TAO_Base_var
-{
-public:
-  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
-
-  IR_StructDef_var &operator= (IR_StructDef_ptr);
-  IR_StructDef_var &operator= (const IR_StructDef_var &);
-  IR_StructDef_ptr operator-> (void) const;
-
-  operator const IR_StructDef_ptr &() const;
-  operator IR_StructDef_ptr &();
-  // in, inout, out, _retn
-  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:
-  IR_StructDef_ptr ptr_;
-  // Unimplemented - prevents widening assignment.
-  IR_StructDef_var (const TAO_Base_var &rhs);
-  IR_StructDef_var &operator= (const TAO_Base_var &rhs);
-};
-
-class TAO_IFR_Client_Export IR_StructDef_out
-{
-public:
-  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:
-  IR_StructDef_ptr &ptr_;
-};
-
-class TAO_IFR_Client_Export IR_UnionDef_var : public TAO_Base_var
-{
-public:
-  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
-
-  IR_UnionDef_var &operator= (IR_UnionDef_ptr);
-  IR_UnionDef_var &operator= (const IR_UnionDef_var &);
-  IR_UnionDef_ptr operator-> (void) const;
-
-  operator const IR_UnionDef_ptr &() const;
-  operator IR_UnionDef_ptr &();
-  // in, inout, out, _retn
-  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:
-  IR_UnionDef_ptr ptr_;
-  // Unimplemented - prevents widening assignment.
-  IR_UnionDef_var (const TAO_Base_var &rhs);
-  IR_UnionDef_var &operator= (const TAO_Base_var &rhs);
-};
-
-class TAO_IFR_Client_Export IR_UnionDef_out
-{
-public:
-  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:
-  IR_UnionDef_ptr &ptr_;
-};
-
-class TAO_IFR_Client_Export IR_EnumDef_var : public TAO_Base_var
-{
-public:
-  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
-
-  IR_EnumDef_var &operator= (IR_EnumDef_ptr);
-  IR_EnumDef_var &operator= (const IR_EnumDef_var &);
-  IR_EnumDef_ptr operator-> (void) const;
-
-  operator const IR_EnumDef_ptr &() const;
-  operator IR_EnumDef_ptr &();
-  // in, inout, out, _retn
-  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:
-  IR_EnumDef_ptr ptr_;
-  // Unimplemented - prevents widening assignment.
-  IR_EnumDef_var (const TAO_Base_var &rhs);
-  IR_EnumDef_var &operator= (const TAO_Base_var &rhs);
-};
-
-class TAO_IFR_Client_Export IR_EnumDef_out
-{
-public:
-  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:
-  IR_EnumDef_ptr &ptr_;
-};
-
-class TAO_IFR_Client_Export IR_AliasDef_var : public TAO_Base_var
-{
-public:
-  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
-
-  IR_AliasDef_var &operator= (IR_AliasDef_ptr);
-  IR_AliasDef_var &operator= (const IR_AliasDef_var &);
-  IR_AliasDef_ptr operator-> (void) const;
-
-  operator const IR_AliasDef_ptr &() const;
-  operator IR_AliasDef_ptr &();
-  // in, inout, out, _retn
-  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:
-  IR_AliasDef_ptr ptr_;
-  // Unimplemented - prevents widening assignment.
-  IR_AliasDef_var (const TAO_Base_var &rhs);
-  IR_AliasDef_var &operator= (const TAO_Base_var &rhs);
-};
-
-class TAO_IFR_Client_Export IR_AliasDef_out
-{
-public:
-  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:
-  IR_AliasDef_ptr &ptr_;
-};
-
-class TAO_IFR_Client_Export IR_InterfaceDef_var : public TAO_Base_var
-{
-public:
-  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
-
-  IR_InterfaceDef_var &operator= (IR_InterfaceDef_ptr);
-  IR_InterfaceDef_var &operator= (const IR_InterfaceDef_var &);
-  IR_InterfaceDef_ptr operator-> (void) const;
-
-  operator const IR_InterfaceDef_ptr &() const;
-  operator IR_InterfaceDef_ptr &();
-  // in, inout, out, _retn
-  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:
-  IR_InterfaceDef_ptr ptr_;
-  // Unimplemented - prevents widening assignment.
-  IR_InterfaceDef_var (const TAO_Base_var &rhs);
-  IR_InterfaceDef_var &operator= (const TAO_Base_var &rhs);
-};
-
-class TAO_IFR_Client_Export IR_InterfaceDef_out
-{
-public:
-  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:
-  IR_InterfaceDef_ptr &ptr_;
-};
-
-class TAO_IFR_Client_Export IR_ExceptionDef_var : public TAO_Base_var
-{
-public:
-  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
-
-  IR_ExceptionDef_var &operator= (IR_ExceptionDef_ptr);
-  IR_ExceptionDef_var &operator= (const IR_ExceptionDef_var &);
-  IR_ExceptionDef_ptr operator-> (void) const;
-
-  operator const IR_ExceptionDef_ptr &() const;
-  operator IR_ExceptionDef_ptr &();
-  // in, inout, out, _retn
-  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:
-  IR_ExceptionDef_ptr ptr_;
-  // Unimplemented - prevents widening assignment.
-  IR_ExceptionDef_var (const TAO_Base_var &rhs);
-  IR_ExceptionDef_var &operator= (const TAO_Base_var &rhs);
-};
-
-class TAO_IFR_Client_Export IR_ExceptionDef_out
-{
-public:
-  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:
-  IR_ExceptionDef_ptr &ptr_;
-};
-
-class TAO_IFR_Client_Export IR_NativeDef_var : public TAO_Base_var
-{
-public:
-  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
-
-  IR_NativeDef_var &operator= (IR_NativeDef_ptr);
-  IR_NativeDef_var &operator= (const IR_NativeDef_var &);
-  IR_NativeDef_ptr operator-> (void) const;
-
-  operator const IR_NativeDef_ptr &() const;
-  operator IR_NativeDef_ptr &();
-  // in, inout, out, _retn
-  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:
-  IR_NativeDef_ptr ptr_;
-  // Unimplemented - prevents widening assignment.
-  IR_NativeDef_var (const TAO_Base_var &rhs);
-  IR_NativeDef_var &operator= (const TAO_Base_var &rhs);
-};
-
-class TAO_IFR_Client_Export IR_NativeDef_out
-{
-public:
-  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:
-  IR_NativeDef_ptr &ptr_;
-};
-
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-
-  class _TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq : public TAO_Unbounded_Base_Sequence
-  {
-  public:
-    // = Initialization and termination methods.
-
-    _TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq (void);
-    _TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq (CORBA::ULong maximum);
-    _TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq (CORBA::ULong maximum,
-      CORBA::ULong length,
-      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 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);
-    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,
-        CORBA_Object *src,
-        CORBA_Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      );
-    virtual CORBA_Object* _upcast (void *src) const;
-
-  };
-
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
-
-// *************************************************************
-// IR_InterfaceDefSeq
-// *************************************************************
-
-class TAO_IFR_Client_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<IR_InterfaceDef,IR_InterfaceDef_var>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
-{
-public:
-  IR_InterfaceDefSeq (void); // default ctor
-  IR_InterfaceDefSeq (CORBA::ULong max); // uses max size
-  IR_InterfaceDefSeq (
-    CORBA::ULong max,
-    CORBA::ULong length,
-    IR_InterfaceDef_ptr *buffer,
-    CORBA::Boolean release = 0
-  );
-  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 IR_InterfaceDefSeq_var _var_type;
-#endif /* ! __GNUC__ || g++ >= 2.8 */
-
-};
-
-// *************************************************************
-// class IR_InterfaceDefSeq_var
-// *************************************************************
-
-class TAO_IFR_Client_Export IR_InterfaceDefSeq_var
-{
-public:
-  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
-
-  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 IR_InterfaceDefSeq &() const;
-  operator IR_InterfaceDefSeq &();
-  operator IR_InterfaceDefSeq &() const;
-  operator IR_InterfaceDefSeq *&(); // variable-size base types only
-
-  TAO_Object_Manager<IR_InterfaceDef, IR_InterfaceDef_var> operator[] (CORBA::ULong index);
-
-  // in, inout, out, _retn
-  const IR_InterfaceDefSeq &in (void) const;
-  IR_InterfaceDefSeq &inout (void);
-  IR_InterfaceDefSeq *&out (void);
-  IR_InterfaceDefSeq *_retn (void);
-  IR_InterfaceDefSeq *ptr (void) const;
-
-private:
-  IR_InterfaceDefSeq *ptr_;
-};
-
-class TAO_IFR_Client_Export IR_InterfaceDefSeq_out
-{
-public:
-  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:
-  IR_InterfaceDefSeq *&ptr_;
-  // assignment from T_var not allowed
-  void operator= (const IR_InterfaceDefSeq_var &);
-};
-
-class TAO_IFR_Client_Export IR_ValueDef_var : public TAO_Base_var
-{
-public:
-  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
-
-  IR_ValueDef_var &operator= (IR_ValueDef_ptr);
-  IR_ValueDef_var &operator= (const IR_ValueDef_var &);
-  IR_ValueDef_ptr operator-> (void) const;
-
-  operator const IR_ValueDef_ptr &() const;
-  operator IR_ValueDef_ptr &();
-  // in, inout, out, _retn
-  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:
-  IR_ValueDef_ptr ptr_;
-  // Unimplemented - prevents widening assignment.
-  IR_ValueDef_var (const TAO_Base_var &rhs);
-  IR_ValueDef_var &operator= (const TAO_Base_var &rhs);
-};
-
-class TAO_IFR_Client_Export IR_ValueDef_out
-{
-public:
-  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:
-  IR_ValueDef_ptr &ptr_;
-};
-
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-
-  class _TAO_Unbounded_Object_Sequence_IR_ValueDefSeq : public TAO_Unbounded_Base_Sequence
-  {
-  public:
-    // = Initialization and termination methods.
-
-    _TAO_Unbounded_Object_Sequence_IR_ValueDefSeq (void);
-    _TAO_Unbounded_Object_Sequence_IR_ValueDefSeq (CORBA::ULong maximum);
-    _TAO_Unbounded_Object_Sequence_IR_ValueDefSeq (CORBA::ULong maximum,
-      CORBA::ULong length,
-      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 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);
-    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,
-        CORBA_Object *src,
-        CORBA_Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      );
-    virtual CORBA_Object* _upcast (void *src) const;
-
-  };
-
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
-
-// *************************************************************
-// IR_ValueDefSeq
-// *************************************************************
-
-class TAO_IFR_Client_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<IR_ValueDef,IR_ValueDef_var>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
-{
-public:
-  IR_ValueDefSeq (void); // default ctor
-  IR_ValueDefSeq (CORBA::ULong max); // uses max size
-  IR_ValueDefSeq (
-    CORBA::ULong max,
-    CORBA::ULong length,
-    IR_ValueDef_ptr *buffer,
-    CORBA::Boolean release = 0
-  );
-  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 IR_ValueDefSeq_var _var_type;
-#endif /* ! __GNUC__ || g++ >= 2.8 */
-
-};
-
-// *************************************************************
-// class IR_ValueDefSeq_var
-// *************************************************************
-
-class TAO_IFR_Client_Export IR_ValueDefSeq_var
-{
-public:
-  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
-
-  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 IR_ValueDefSeq &() const;
-  operator IR_ValueDefSeq &();
-  operator IR_ValueDefSeq &() const;
-  operator IR_ValueDefSeq *&(); // variable-size base types only
-
-  TAO_Object_Manager<IR_ValueDef, IR_ValueDef_var> operator[] (CORBA::ULong index);
-
-  // in, inout, out, _retn
-  const IR_ValueDefSeq &in (void) const;
-  IR_ValueDefSeq &inout (void);
-  IR_ValueDefSeq *&out (void);
-  IR_ValueDefSeq *_retn (void);
-  IR_ValueDefSeq *ptr (void) const;
-
-private:
-  IR_ValueDefSeq *ptr_;
-};
-
-class TAO_IFR_Client_Export IR_ValueDefSeq_out
-{
-public:
-  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:
-  IR_ValueDefSeq *&ptr_;
-  // assignment from T_var not allowed
-  void operator= (const IR_ValueDefSeq_var &);
-};
-
-class TAO_IFR_Client_Export IR_ValueBoxDef_var : public TAO_Base_var
-{
-public:
-  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
-
-  IR_ValueBoxDef_var &operator= (IR_ValueBoxDef_ptr);
-  IR_ValueBoxDef_var &operator= (const IR_ValueBoxDef_var &);
-  IR_ValueBoxDef_ptr operator-> (void) const;
-
-  operator const IR_ValueBoxDef_ptr &() const;
-  operator IR_ValueBoxDef_ptr &();
-  // in, inout, out, _retn
-  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:
-  IR_ValueBoxDef_ptr ptr_;
-  // Unimplemented - prevents widening assignment.
-  IR_ValueBoxDef_var (const TAO_Base_var &rhs);
-  IR_ValueBoxDef_var &operator= (const TAO_Base_var &rhs);
-};
-
-class TAO_IFR_Client_Export IR_ValueBoxDef_out
-{
-public:
-  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:
-  IR_ValueBoxDef_ptr &ptr_;
-};
-
-class TAO_IFR_Client_Export IR_ComponentDef_var : public TAO_Base_var
-{
-public:
-  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
-
-  IR_ComponentDef_var &operator= (IR_ComponentDef_ptr);
-  IR_ComponentDef_var &operator= (const IR_ComponentDef_var &);
-  IR_ComponentDef_ptr operator-> (void) const;
-
-  operator const IR_ComponentDef_ptr &() const;
-  operator IR_ComponentDef_ptr &();
-  // in, inout, out, _retn
-  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:
-  IR_ComponentDef_ptr ptr_;
-  // Unimplemented - prevents widening assignment.
-  IR_ComponentDef_var (const TAO_Base_var &rhs);
-  IR_ComponentDef_var &operator= (const TAO_Base_var &rhs);
-};
-
-class TAO_IFR_Client_Export IR_ComponentDef_out
-{
-public:
-  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:
-  IR_ComponentDef_ptr &ptr_;
-};
-
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-
-  class _TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq : public TAO_Unbounded_Base_Sequence
-  {
-  public:
-    // = Initialization and termination methods.
-
-    _TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq (void);
-    _TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq (CORBA::ULong maximum);
-    _TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq (CORBA::ULong maximum,
-      CORBA::ULong length,
-      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 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);
-    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,
-        CORBA_Object *src,
-        CORBA_Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      );
-    virtual CORBA_Object* _upcast (void *src) const;
-
-  };
-
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
-
-// *************************************************************
-// IR_ComponentDefSeq
-// *************************************************************
-
-class TAO_IFR_Client_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<IR_ComponentDef,IR_ComponentDef_var>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
-{
-public:
-  IR_ComponentDefSeq (void); // default ctor
-  IR_ComponentDefSeq (CORBA::ULong max); // uses max size
-  IR_ComponentDefSeq (
-    CORBA::ULong max,
-    CORBA::ULong length,
-    IR_ComponentDef_ptr *buffer,
-    CORBA::Boolean release = 0
-  );
-  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 IR_ComponentDefSeq_var _var_type;
-#endif /* ! __GNUC__ || g++ >= 2.8 */
-
-};
-
-// *************************************************************
-// class IR_ComponentDefSeq_var
-// *************************************************************
-
-class TAO_IFR_Client_Export IR_ComponentDefSeq_var
-{
-public:
-  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
-
-  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 IR_ComponentDefSeq &() const;
-  operator IR_ComponentDefSeq &();
-  operator IR_ComponentDefSeq &() const;
-  operator IR_ComponentDefSeq *&(); // variable-size base types only
-
-  TAO_Object_Manager<IR_ComponentDef, IR_ComponentDef_var> operator[] (CORBA::ULong index);
-
-  // in, inout, out, _retn
-  const IR_ComponentDefSeq &in (void) const;
-  IR_ComponentDefSeq &inout (void);
-  IR_ComponentDefSeq *&out (void);
-  IR_ComponentDefSeq *_retn (void);
-  IR_ComponentDefSeq *ptr (void) const;
-
-private:
-  IR_ComponentDefSeq *ptr_;
-};
-
-class TAO_IFR_Client_Export IR_ComponentDefSeq_out
-{
-public:
-  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:
-  IR_ComponentDefSeq *&ptr_;
-  // assignment from T_var not allowed
-  void operator= (const IR_ComponentDefSeq_var &);
-};
-
-class TAO_IFR_Client_Export IR_ProvidesDef_var : public TAO_Base_var
-{
-public:
-  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
-
-  IR_ProvidesDef_var &operator= (IR_ProvidesDef_ptr);
-  IR_ProvidesDef_var &operator= (const IR_ProvidesDef_var &);
-  IR_ProvidesDef_ptr operator-> (void) const;
-
-  operator const IR_ProvidesDef_ptr &() const;
-  operator IR_ProvidesDef_ptr &();
-  // in, inout, out, _retn
-  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:
-  IR_ProvidesDef_ptr ptr_;
-  // Unimplemented - prevents widening assignment.
-  IR_ProvidesDef_var (const TAO_Base_var &rhs);
-  IR_ProvidesDef_var &operator= (const TAO_Base_var &rhs);
-};
-
-class TAO_IFR_Client_Export IR_ProvidesDef_out
-{
-public:
-  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:
-  IR_ProvidesDef_ptr &ptr_;
-};
-
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-
-  class _TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq : public TAO_Unbounded_Base_Sequence
-  {
-  public:
-    // = Initialization and termination methods.
-
-    _TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq (void);
-    _TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq (CORBA::ULong maximum);
-    _TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq (CORBA::ULong maximum,
-      CORBA::ULong length,
-      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 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);
-    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,
-        CORBA_Object *src,
-        CORBA_Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      );
-    virtual CORBA_Object* _upcast (void *src) const;
-
-  };
-
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
-
-// *************************************************************
-// IR_ProvidesDefSeq
-// *************************************************************
-
-class TAO_IFR_Client_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<IR_ProvidesDef,IR_ProvidesDef_var>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
-{
-public:
-  IR_ProvidesDefSeq (void); // default ctor
-  IR_ProvidesDefSeq (CORBA::ULong max); // uses max size
-  IR_ProvidesDefSeq (
-    CORBA::ULong max,
-    CORBA::ULong length,
-    IR_ProvidesDef_ptr *buffer,
-    CORBA::Boolean release = 0
-  );
-  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 IR_ProvidesDefSeq_var _var_type;
-#endif /* ! __GNUC__ || g++ >= 2.8 */
-
-};
-
-// *************************************************************
-// class IR_ProvidesDefSeq_var
-// *************************************************************
-
-class TAO_IFR_Client_Export IR_ProvidesDefSeq_var
-{
-public:
-  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
-
-  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 IR_ProvidesDefSeq &() const;
-  operator IR_ProvidesDefSeq &();
-  operator IR_ProvidesDefSeq &() const;
-  operator IR_ProvidesDefSeq *&(); // variable-size base types only
-
-  TAO_Object_Manager<IR_ProvidesDef, IR_ProvidesDef_var> operator[] (CORBA::ULong index);
-
-  // in, inout, out, _retn
-  const IR_ProvidesDefSeq &in (void) const;
-  IR_ProvidesDefSeq &inout (void);
-  IR_ProvidesDefSeq *&out (void);
-  IR_ProvidesDefSeq *_retn (void);
-  IR_ProvidesDefSeq *ptr (void) const;
-
-private:
-  IR_ProvidesDefSeq *ptr_;
-};
-
-class TAO_IFR_Client_Export IR_ProvidesDefSeq_out
-{
-public:
-  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:
-  IR_ProvidesDefSeq *&ptr_;
-  // assignment from T_var not allowed
-  void operator= (const IR_ProvidesDefSeq_var &);
-};
-
-class TAO_IFR_Client_Export IR_UsesDef_var : public TAO_Base_var
-{
-public:
-  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
-
-  IR_UsesDef_var &operator= (IR_UsesDef_ptr);
-  IR_UsesDef_var &operator= (const IR_UsesDef_var &);
-  IR_UsesDef_ptr operator-> (void) const;
-
-  operator const IR_UsesDef_ptr &() const;
-  operator IR_UsesDef_ptr &();
-  // in, inout, out, _retn
-  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:
-  IR_UsesDef_ptr ptr_;
-  // Unimplemented - prevents widening assignment.
-  IR_UsesDef_var (const TAO_Base_var &rhs);
-  IR_UsesDef_var &operator= (const TAO_Base_var &rhs);
-};
-
-class TAO_IFR_Client_Export IR_UsesDef_out
-{
-public:
-  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:
-  IR_UsesDef_ptr &ptr_;
-};
-
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-
-  class _TAO_Unbounded_Object_Sequence_IR_UsesDefSeq : public TAO_Unbounded_Base_Sequence
-  {
-  public:
-    // = Initialization and termination methods.
-
-    _TAO_Unbounded_Object_Sequence_IR_UsesDefSeq (void);
-    _TAO_Unbounded_Object_Sequence_IR_UsesDefSeq (CORBA::ULong maximum);
-    _TAO_Unbounded_Object_Sequence_IR_UsesDefSeq (CORBA::ULong maximum,
-      CORBA::ULong length,
-      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 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);
-    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,
-        CORBA_Object *src,
-        CORBA_Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      );
-    virtual CORBA_Object* _upcast (void *src) const;
-
-  };
-
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
-
-// *************************************************************
-// IR_UsesDefSeq
-// *************************************************************
-
-class TAO_IFR_Client_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<IR_UsesDef,IR_UsesDef_var>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
-{
-public:
-  IR_UsesDefSeq (void); // default ctor
-  IR_UsesDefSeq (CORBA::ULong max); // uses max size
-  IR_UsesDefSeq (
-    CORBA::ULong max,
-    CORBA::ULong length,
-    IR_UsesDef_ptr *buffer,
-    CORBA::Boolean release = 0
-  );
-  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 IR_UsesDefSeq_var _var_type;
-#endif /* ! __GNUC__ || g++ >= 2.8 */
-
-};
-
-// *************************************************************
-// class IR_UsesDefSeq_var
-// *************************************************************
-
-class TAO_IFR_Client_Export IR_UsesDefSeq_var
-{
-public:
-  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
-
-  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 IR_UsesDefSeq &() const;
-  operator IR_UsesDefSeq &();
-  operator IR_UsesDefSeq &() const;
-  operator IR_UsesDefSeq *&(); // variable-size base types only
-
-  TAO_Object_Manager<IR_UsesDef, IR_UsesDef_var> operator[] (CORBA::ULong index);
-
-  // in, inout, out, _retn
-  const IR_UsesDefSeq &in (void) const;
-  IR_UsesDefSeq &inout (void);
-  IR_UsesDefSeq *&out (void);
-  IR_UsesDefSeq *_retn (void);
-  IR_UsesDefSeq *ptr (void) const;
-
-private:
-  IR_UsesDefSeq *ptr_;
-};
-
-class TAO_IFR_Client_Export IR_UsesDefSeq_out
-{
-public:
-  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:
-  IR_UsesDefSeq *&ptr_;
-  // assignment from T_var not allowed
-  void operator= (const IR_UsesDefSeq_var &);
-};
-
-class TAO_IFR_Client_Export IR_HomeDef_var : public TAO_Base_var
-{
-public:
-  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
-
-  IR_HomeDef_var &operator= (IR_HomeDef_ptr);
-  IR_HomeDef_var &operator= (const IR_HomeDef_var &);
-  IR_HomeDef_ptr operator-> (void) const;
-
-  operator const IR_HomeDef_ptr &() const;
-  operator IR_HomeDef_ptr &();
-  // in, inout, out, _retn
-  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:
-  IR_HomeDef_ptr ptr_;
-  // Unimplemented - prevents widening assignment.
-  IR_HomeDef_var (const TAO_Base_var &rhs);
-  IR_HomeDef_var &operator= (const TAO_Base_var &rhs);
-};
-
-class TAO_IFR_Client_Export IR_HomeDef_out
-{
-public:
-  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:
-  IR_HomeDef_ptr &ptr_;
-};
-
-
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-
-  class _TAO_Unbounded_Object_Sequence_IR_HomeDefSeq : public TAO_Unbounded_Base_Sequence
-  {
-  public:
-    // = Initialization and termination methods.
-
-    _TAO_Unbounded_Object_Sequence_IR_HomeDefSeq (void);
-    _TAO_Unbounded_Object_Sequence_IR_HomeDefSeq (CORBA::ULong maximum);
-    _TAO_Unbounded_Object_Sequence_IR_HomeDefSeq (CORBA::ULong maximum,
-      CORBA::ULong length,
-      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 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);
-    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,
-        CORBA_Object *src,
-        CORBA_Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      );
-    virtual CORBA_Object* _upcast (void *src) const;
-
-  };
-
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
-
-// *************************************************************
-// IR_HomeDefSeq
-// *************************************************************
-
-class TAO_IFR_Client_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<IR_HomeDef,IR_HomeDef_var>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
-{
-public:
-  IR_HomeDefSeq (void); // default ctor
-  IR_HomeDefSeq (CORBA::ULong max); // uses max size
-  IR_HomeDefSeq (
-    CORBA::ULong max,
-    CORBA::ULong length,
-    IR_HomeDef_ptr *buffer,
-    CORBA::Boolean release = 0
-  );
-  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 IR_HomeDefSeq_var _var_type;
-#endif /* ! __GNUC__ || g++ >= 2.8 */
-
-};
-
-// *************************************************************
-// class IR_HomeDefSeq_var
-// *************************************************************
-
-class TAO_IFR_Client_Export IR_HomeDefSeq_var
-{
-public:
-  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
-
-  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 IR_HomeDefSeq &() const;
-  operator IR_HomeDefSeq &();
-  operator IR_HomeDefSeq &() const;
-  operator IR_HomeDefSeq *&(); // variable-size base types only
-
-  TAO_Object_Manager<IR_HomeDef, IR_HomeDef_var> operator[] (CORBA::ULong index);
-
-  // in, inout, out, _retn
-  const IR_HomeDefSeq &in (void) const;
-  IR_HomeDefSeq &inout (void);
-  IR_HomeDefSeq *&out (void);
-  IR_HomeDefSeq *_retn (void);
-  IR_HomeDefSeq *ptr (void) const;
-
-private:
-  IR_HomeDefSeq *ptr_;
-};
-
-class TAO_IFR_Client_Export IR_HomeDefSeq_out
-{
-public:
-  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:
-  IR_HomeDefSeq *&ptr_;
-  // assignment from T_var not allowed
-  void operator= (const IR_HomeDefSeq_var &);
-};
-
-class TAO_IFR_Client_Export IR_EventDef_var : public TAO_Base_var
-{
-public:
-  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
-
-  IR_EventDef_var &operator= (IR_EventDef_ptr);
-  IR_EventDef_var &operator= (const IR_EventDef_var &);
-  IR_EventDef_ptr operator-> (void) const;
-
-  operator const IR_EventDef_ptr &() const;
-  operator IR_EventDef_ptr &();
-  // in, inout, out, _retn
-  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:
-  IR_EventDef_ptr ptr_;
-  // Unimplemented - prevents widening assignment.
-  IR_EventDef_var (const TAO_Base_var &rhs);
-  IR_EventDef_var &operator= (const TAO_Base_var &rhs);
-};
-
-class TAO_IFR_Client_Export IR_EventDef_out
-{
-public:
-  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:
-  IR_EventDef_ptr &ptr_;
-};
-
-class TAO_IFR_Client_Export IR_EmitsDef_var : public TAO_Base_var
-{
-public:
-  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
-
-  IR_EmitsDef_var &operator= (IR_EmitsDef_ptr);
-  IR_EmitsDef_var &operator= (const IR_EmitsDef_var &);
-  IR_EmitsDef_ptr operator-> (void) const;
-
-  operator const IR_EmitsDef_ptr &() const;
-  operator IR_EmitsDef_ptr &();
-  // in, inout, out, _retn
-  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:
-  IR_EmitsDef_ptr ptr_;
-  // Unimplemented - prevents widening assignment.
-  IR_EmitsDef_var (const TAO_Base_var &rhs);
-  IR_EmitsDef_var &operator= (const TAO_Base_var &rhs);
-};
-
-class TAO_IFR_Client_Export IR_EmitsDef_out
-{
-public:
-  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:
-  IR_EmitsDef_ptr &ptr_;
-};
-
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-
-  class _TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq : public TAO_Unbounded_Base_Sequence
-  {
-  public:
-    // = Initialization and termination methods.
-
-    _TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq (void);
-    _TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq (CORBA::ULong maximum);
-    _TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq (CORBA::ULong maximum,
-      CORBA::ULong length,
-      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 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);
-    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,
-        CORBA_Object *src,
-        CORBA_Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      );
-    virtual CORBA_Object* _upcast (void *src) const;
-
-  };
-
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
-
-// *************************************************************
-// IR_EmitsDefSeq
-// *************************************************************
-
-class TAO_IFR_Client_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<IR_EmitsDef,IR_EmitsDef_var>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
-{
-public:
-  IR_EmitsDefSeq (void); // default ctor
-  IR_EmitsDefSeq (CORBA::ULong max); // uses max size
-  IR_EmitsDefSeq (
-    CORBA::ULong max,
-    CORBA::ULong length,
-    IR_EmitsDef_ptr *buffer,
-    CORBA::Boolean release = 0
-  );
-  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 IR_EmitsDefSeq_var _var_type;
-#endif /* ! __GNUC__ || g++ >= 2.8 */
-
-};
-
-// *************************************************************
-// class IR_EmitsDefSeq_var
-// *************************************************************
-
-class TAO_IFR_Client_Export IR_EmitsDefSeq_var
-{
-public:
-  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
-
-  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 IR_EmitsDefSeq &() const;
-  operator IR_EmitsDefSeq &();
-  operator IR_EmitsDefSeq &() const;
-  operator IR_EmitsDefSeq *&(); // variable-size base types only
-
-  TAO_Object_Manager<IR_EmitsDef, IR_EmitsDef_var> operator[] (CORBA::ULong index);
-
-  // in, inout, out, _retn
-  const IR_EmitsDefSeq &in (void) const;
-  IR_EmitsDefSeq &inout (void);
-  IR_EmitsDefSeq *&out (void);
-  IR_EmitsDefSeq *_retn (void);
-  IR_EmitsDefSeq *ptr (void) const;
-
-private:
-  IR_EmitsDefSeq *ptr_;
-};
-
-class TAO_IFR_Client_Export IR_EmitsDefSeq_out
-{
-public:
-  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:
-  IR_EmitsDefSeq *&ptr_;
-  // assignment from T_var not allowed
-  void operator= (const IR_EmitsDefSeq_var &);
-};
-
-class TAO_IFR_Client_Export IR_PublishesDef_var : public TAO_Base_var
-{
-public:
-  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
-
-  IR_PublishesDef_var &operator= (IR_PublishesDef_ptr);
-  IR_PublishesDef_var &operator= (const IR_PublishesDef_var &);
-  IR_PublishesDef_ptr operator-> (void) const;
-
-  operator const IR_PublishesDef_ptr &() const;
-  operator IR_PublishesDef_ptr &();
-  // in, inout, out, _retn
-  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:
-  IR_PublishesDef_ptr ptr_;
-  // Unimplemented - prevents widening assignment.
-  IR_PublishesDef_var (const TAO_Base_var &rhs);
-  IR_PublishesDef_var &operator= (const TAO_Base_var &rhs);
-};
-
-class TAO_IFR_Client_Export IR_PublishesDef_out
-{
-public:
-  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:
-  IR_PublishesDef_ptr &ptr_;
-};
-
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-
-  class _TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq : public TAO_Unbounded_Base_Sequence
-  {
-  public:
-    // = Initialization and termination methods.
-
-    _TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq (void);
-    _TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq (CORBA::ULong maximum);
-    _TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq (CORBA::ULong maximum,
-      CORBA::ULong length,
-      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 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);
-    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,
-        CORBA_Object *src,
-        CORBA_Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      );
-    virtual CORBA_Object* _upcast (void *src) const;
-
-  };
-
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
-
-// *************************************************************
-// IR_PublishesDefSeq
-// *************************************************************
-
-class TAO_IFR_Client_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<IR_PublishesDef,IR_PublishesDef_var>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
-{
-public:
-  IR_PublishesDefSeq (void); // default ctor
-  IR_PublishesDefSeq (CORBA::ULong max); // uses max size
-  IR_PublishesDefSeq (
-    CORBA::ULong max,
-    CORBA::ULong length,
-    IR_PublishesDef_ptr *buffer,
-    CORBA::Boolean release = 0
-  );
-  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 IR_PublishesDefSeq_var _var_type;
-#endif /* ! __GNUC__ || g++ >= 2.8 */
-
-};
-
-// *************************************************************
-// class IR_PublishesDefSeq_var
-// *************************************************************
-
-class TAO_IFR_Client_Export IR_PublishesDefSeq_var
-{
-public:
-  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
-
-  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 IR_PublishesDefSeq &() const;
-  operator IR_PublishesDefSeq &();
-  operator IR_PublishesDefSeq &() const;
-  operator IR_PublishesDefSeq *&(); // variable-size base types only
-
-  TAO_Object_Manager<IR_PublishesDef, IR_PublishesDef_var> operator[] (CORBA::ULong index);
-
-  // in, inout, out, _retn
-  const IR_PublishesDefSeq &in (void) const;
-  IR_PublishesDefSeq &inout (void);
-  IR_PublishesDefSeq *&out (void);
-  IR_PublishesDefSeq *_retn (void);
-  IR_PublishesDefSeq *ptr (void) const;
-
-private:
-  IR_PublishesDefSeq *ptr_;
-};
-
-class TAO_IFR_Client_Export IR_PublishesDefSeq_out
-{
-public:
-  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:
-  IR_PublishesDefSeq *&ptr_;
-  // assignment from T_var not allowed
-  void operator= (const IR_PublishesDefSeq_var &);
-};
-
-class TAO_IFR_Client_Export IR_ConsumesDef_var : public TAO_Base_var
-{
-public:
-  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
-
-  IR_ConsumesDef_var &operator= (IR_ConsumesDef_ptr);
-  IR_ConsumesDef_var &operator= (const IR_ConsumesDef_var &);
-  IR_ConsumesDef_ptr operator-> (void) const;
-
-  operator const IR_ConsumesDef_ptr &() const;
-  operator IR_ConsumesDef_ptr &();
-  // in, inout, out, _retn
-  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:
-  IR_ConsumesDef_ptr ptr_;
-  // Unimplemented - prevents widening assignment.
-  IR_ConsumesDef_var (const TAO_Base_var &rhs);
-  IR_ConsumesDef_var &operator= (const TAO_Base_var &rhs);
-};
-
-class TAO_IFR_Client_Export IR_ConsumesDef_out
-{
-public:
-  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:
-  IR_ConsumesDef_ptr &ptr_;
-};
-
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-
-  class _TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq : public TAO_Unbounded_Base_Sequence
-  {
-  public:
-    // = Initialization and termination methods.
-
-    _TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq (void);
-    _TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq (CORBA::ULong maximum);
-    _TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq (CORBA::ULong maximum,
-      CORBA::ULong length,
-      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 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);
-    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,
-        CORBA_Object *src,
-        CORBA_Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      );
-    virtual CORBA_Object* _upcast (void *src) const;
-
-  };
-
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
-
-// *************************************************************
-// IR_ConsumesDefSeq
-// *************************************************************
-
-class TAO_IFR_Client_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<IR_ConsumesDef,IR_ConsumesDef_var>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
-{
-public:
-  IR_ConsumesDefSeq (void); // default ctor
-  IR_ConsumesDefSeq (CORBA::ULong max); // uses max size
-  IR_ConsumesDefSeq (
-    CORBA::ULong max,
-    CORBA::ULong length,
-    IR_ConsumesDef_ptr *buffer,
-    CORBA::Boolean release = 0
-  );
-  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 IR_ConsumesDefSeq_var _var_type;
-#endif /* ! __GNUC__ || g++ >= 2.8 */
-
-};
-
-// *************************************************************
-// class IR_ConsumesDefSeq_var
-// *************************************************************
-
-class TAO_IFR_Client_Export IR_ConsumesDefSeq_var
-{
-public:
-  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
-
-  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 IR_ConsumesDefSeq &() const;
-  operator IR_ConsumesDefSeq &();
-  operator IR_ConsumesDefSeq &() const;
-  operator IR_ConsumesDefSeq *&(); // variable-size base types only
-
-  TAO_Object_Manager<IR_ConsumesDef, IR_ConsumesDef_var> operator[] (CORBA::ULong index);
-
-  // in, inout, out, _retn
-  const IR_ConsumesDefSeq &in (void) const;
-  IR_ConsumesDefSeq &inout (void);
-  IR_ConsumesDefSeq *&out (void);
-  IR_ConsumesDefSeq *_retn (void);
-  IR_ConsumesDefSeq *ptr (void) const;
-
-private:
-  IR_ConsumesDefSeq *ptr_;
-};
-
-class TAO_IFR_Client_Export IR_ConsumesDefSeq_out
-{
-public:
-  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:
-  IR_ConsumesDefSeq *&ptr_;
-  // assignment from T_var not allowed
-  void operator= (const IR_ConsumesDefSeq_var &);
-};
-
-class TAO_IFR_Client_Export IR_FactoryDef_var : public TAO_Base_var
-{
-public:
-  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
-
-  IR_FactoryDef_var &operator= (IR_FactoryDef_ptr);
-  IR_FactoryDef_var &operator= (const IR_FactoryDef_var &);
-  IR_FactoryDef_ptr operator-> (void) const;
-
-  operator const IR_FactoryDef_ptr &() const;
-  operator IR_FactoryDef_ptr &();
-  // in, inout, out, _retn
-  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:
-  IR_FactoryDef_ptr ptr_;
-  // Unimplemented - prevents widening assignment.
-  IR_FactoryDef_var (const TAO_Base_var &rhs);
-  IR_FactoryDef_var &operator= (const TAO_Base_var &rhs);
-};
-
-class TAO_IFR_Client_Export IR_FactoryDef_out
-{
-public:
-  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:
-  IR_FactoryDef_ptr &ptr_;
-};
-
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-
-  class _TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq : public TAO_Unbounded_Base_Sequence
-  {
-  public:
-    // = Initialization and termination methods.
-
-    _TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq (void);
-    _TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq (CORBA::ULong maximum);
-    _TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq (CORBA::ULong maximum,
-      CORBA::ULong length,
-      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 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);
-    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,
-        CORBA_Object *src,
-        CORBA_Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      );
-    virtual CORBA_Object* _upcast (void *src) const;
-
-  };
-
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
-
-// *************************************************************
-// IR_FactoryDefSeq
-// *************************************************************
-
-class TAO_IFR_Client_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<IR_FactoryDef,IR_FactoryDef_var>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
-{
-public:
-  IR_FactoryDefSeq (void); // default ctor
-  IR_FactoryDefSeq (CORBA::ULong max); // uses max size
-  IR_FactoryDefSeq (
-    CORBA::ULong max,
-    CORBA::ULong length,
-    IR_FactoryDef_ptr *buffer,
-    CORBA::Boolean release = 0
-  );
-  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 IR_FactoryDefSeq_var _var_type;
-#endif /* ! __GNUC__ || g++ >= 2.8 */
-
-};
-
-// *************************************************************
-// class IR_FactoryDefSeq_var
-// *************************************************************
-
-class TAO_IFR_Client_Export IR_FactoryDefSeq_var
-{
-public:
-  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
-
-  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 IR_FactoryDefSeq &() const;
-  operator IR_FactoryDefSeq &();
-  operator IR_FactoryDefSeq &() const;
-  operator IR_FactoryDefSeq *&(); // variable-size base types only
-
-  TAO_Object_Manager<IR_FactoryDef, IR_FactoryDef_var> operator[] (CORBA::ULong index);
-
-  // in, inout, out, _retn
-  const IR_FactoryDefSeq &in (void) const;
-  IR_FactoryDefSeq &inout (void);
-  IR_FactoryDefSeq *&out (void);
-  IR_FactoryDefSeq *_retn (void);
-  IR_FactoryDefSeq *ptr (void) const;
-
-private:
-  IR_FactoryDefSeq *ptr_;
-};
-
-class TAO_IFR_Client_Export IR_FactoryDefSeq_out
-{
-public:
-  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:
-  IR_FactoryDefSeq *&ptr_;
-  // assignment from T_var not allowed
-  void operator= (const IR_FactoryDefSeq_var &);
-};
-
-class TAO_IFR_Client_Export IR_FinderDef_var : public TAO_Base_var
-{
-public:
-  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
-
-  IR_FinderDef_var &operator= (IR_FinderDef_ptr);
-  IR_FinderDef_var &operator= (const IR_FinderDef_var &);
-  IR_FinderDef_ptr operator-> (void) const;
-
-  operator const IR_FinderDef_ptr &() const;
-  operator IR_FinderDef_ptr &();
-  // in, inout, out, _retn
-  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:
-  IR_FinderDef_ptr ptr_;
-  // Unimplemented - prevents widening assignment.
-  IR_FinderDef_var (const TAO_Base_var &rhs);
-  IR_FinderDef_var &operator= (const TAO_Base_var &rhs);
-};
-
-class TAO_IFR_Client_Export IR_FinderDef_out
-{
-public:
-  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:
-  IR_FinderDef_ptr &ptr_;
-};
-
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-
-  class _TAO_Unbounded_Object_Sequence_IR_FinderDefSeq : public TAO_Unbounded_Base_Sequence
-  {
-  public:
-    // = Initialization and termination methods.
-
-    _TAO_Unbounded_Object_Sequence_IR_FinderDefSeq (void);
-    _TAO_Unbounded_Object_Sequence_IR_FinderDefSeq (CORBA::ULong maximum);
-    _TAO_Unbounded_Object_Sequence_IR_FinderDefSeq (CORBA::ULong maximum,
-      CORBA::ULong length,
-      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 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);
-    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,
-        CORBA_Object *src,
-        CORBA_Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      );
-    virtual CORBA_Object* _upcast (void *src) const;
-
-  };
-
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
-
-// *************************************************************
-// IR_FinderDefSeq
-// *************************************************************
-
-class TAO_IFR_Client_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<IR_FinderDef,IR_FinderDef_var>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
-{
-public:
-  IR_FinderDefSeq (void); // default ctor
-  IR_FinderDefSeq (CORBA::ULong max); // uses max size
-  IR_FinderDefSeq (
-    CORBA::ULong max,
-    CORBA::ULong length,
-    IR_FinderDef_ptr *buffer,
-    CORBA::Boolean release = 0
-  );
-  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 IR_FinderDefSeq_var _var_type;
-#endif /* ! __GNUC__ || g++ >= 2.8 */
-
-};
-
-// *************************************************************
-// class IR_FinderDefSeq_var
-// *************************************************************
-
-class TAO_IFR_Client_Export IR_FinderDefSeq_var
-{
-public:
-  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
-
-  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 IR_FinderDefSeq &() const;
-  operator IR_FinderDefSeq &();
-  operator IR_FinderDefSeq &() const;
-  operator IR_FinderDefSeq *&(); // variable-size base types only
-
-  TAO_Object_Manager<IR_FinderDef, IR_FinderDef_var> operator[] (CORBA::ULong index);
-
-  // in, inout, out, _retn
-  const IR_FinderDefSeq &in (void) const;
-  IR_FinderDefSeq &inout (void);
-  IR_FinderDefSeq *&out (void);
-  IR_FinderDefSeq *_retn (void);
-  IR_FinderDefSeq *ptr (void) const;
-
-private:
-  IR_FinderDefSeq *ptr_;
-};
-
-class TAO_IFR_Client_Export IR_FinderDefSeq_out
-{
-public:
-  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:
-  IR_FinderDefSeq *&ptr_;
-  // assignment from T_var not allowed
-  void operator= (const IR_FinderDefSeq_var &);
-};
-
-class TAO_IFR_Client_Export IR_PrimaryKeyDef_var : public TAO_Base_var
-{
-public:
-  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
-
-  IR_PrimaryKeyDef_var &operator= (IR_PrimaryKeyDef_ptr);
-  IR_PrimaryKeyDef_var &operator= (const IR_PrimaryKeyDef_var &);
-  IR_PrimaryKeyDef_ptr operator-> (void) const;
-
-  operator const IR_PrimaryKeyDef_ptr &() const;
-  operator IR_PrimaryKeyDef_ptr &();
-  // in, inout, out, _retn
-  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:
-  IR_PrimaryKeyDef_ptr ptr_;
-  // Unimplemented - prevents widening assignment.
-  IR_PrimaryKeyDef_var (const TAO_Base_var &rhs);
-  IR_PrimaryKeyDef_var &operator= (const TAO_Base_var &rhs);
-};
-
-class TAO_IFR_Client_Export IR_PrimaryKeyDef_out
-{
-public:
-  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:
-  IR_PrimaryKeyDef_ptr &ptr_;
-};
-
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-
-  class _TAO_Unbounded_Object_Sequence_IR_ContainedSeq : public TAO_Unbounded_Base_Sequence
-  {
-  public:
-    // = Initialization and termination methods.
-
-    _TAO_Unbounded_Object_Sequence_IR_ContainedSeq (void);
-    _TAO_Unbounded_Object_Sequence_IR_ContainedSeq (CORBA::ULong maximum);
-    _TAO_Unbounded_Object_Sequence_IR_ContainedSeq (CORBA::ULong maximum,
-      CORBA::ULong length,
-      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 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);
-    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,
-        CORBA_Object *src,
-        CORBA_Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      );
-    virtual CORBA_Object* _upcast (void *src) const;
-
-  };
-
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
-
-// *************************************************************
-// IR_ContainedSeq
-// *************************************************************
-
-class TAO_IFR_Client_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<IR_Contained,IR_Contained_var>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
-{
-public:
-  IR_ContainedSeq (void); // default ctor
-  IR_ContainedSeq (CORBA::ULong max); // uses max size
-  IR_ContainedSeq (
-    CORBA::ULong max,
-    CORBA::ULong length,
-    IR_Contained_ptr *buffer,
-    CORBA::Boolean release = 0
-  );
-  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 IR_ContainedSeq_var _var_type;
-#endif /* ! __GNUC__ || g++ >= 2.8 */
-
-};
-
-// *************************************************************
-// class IR_ContainedSeq_var
-// *************************************************************
-
-class TAO_IFR_Client_Export IR_ContainedSeq_var
-{
-public:
-  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
-
-  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 IR_ContainedSeq &() const;
-  operator IR_ContainedSeq &();
-  operator IR_ContainedSeq &() const;
-  operator IR_ContainedSeq *&(); // variable-size base types only
-
-  TAO_Object_Manager<IR_Contained, IR_Contained_var> operator[] (CORBA::ULong index);
-
-  // in, inout, out, _retn
-  const IR_ContainedSeq &in (void) const;
-  IR_ContainedSeq &inout (void);
-  IR_ContainedSeq *&out (void);
-  IR_ContainedSeq *_retn (void);
-  IR_ContainedSeq *ptr (void) const;
-
-private:
-  IR_ContainedSeq *ptr_;
-};
-
-
-class TAO_IFR_Client_Export IR_ContainedSeq_out
-{
-public:
-  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:
-  IR_ContainedSeq *&ptr_;
-  // assignment from T_var not allowed
-  void operator= (const IR_ContainedSeq_var &);
-};
-
-struct TAO_IFR_Client_Export IR_StructMember
-{
-
-#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
-  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;
-  IR_IDLType_var type_def;
-};
-
-class TAO_IFR_Client_Export IR_StructMember_var
-{
-public:
-  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
-
-  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 IR_StructMember &() const;
-  operator IR_StructMember &();
-  operator IR_StructMember &() const;
-  operator IR_StructMember *&(); // variable-size types only
-
-  // in, inout, out, _retn
-  const IR_StructMember &in (void) const;
-  IR_StructMember &inout (void);
-  IR_StructMember *&out (void);
-  IR_StructMember *_retn (void);
-  IR_StructMember *ptr (void) const;
-
-private:
-  IR_StructMember *ptr_;
-};
-
-class TAO_IFR_Client_Export IR_StructMember_out
-{
-public:
-  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:
-  IR_StructMember *&ptr_;
-  // assignment from T_var not allowed
-  void operator= (const IR_StructMember_var &);
-};
-
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-
-  class TAO_EXPORT_NESTED_MACRO _TAO_Unbounded_Sequence_IR_StructMemberSeq : public TAO_Unbounded_Base_Sequence
-  {
-  public:
-    // = Initialization and termination methods.
-
-    _TAO_Unbounded_Sequence_IR_StructMemberSeq (void); // Default constructor.
-    _TAO_Unbounded_Sequence_IR_StructMemberSeq (CORBA::ULong maximum);
-    _TAO_Unbounded_Sequence_IR_StructMemberSeq (CORBA::ULong maximum,
-      CORBA::ULong length,
-      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.
-    IR_StructMember &operator[] (CORBA::ULong i);
-    const IR_StructMember &operator[] (CORBA::ULong i) const;
-    // = Static operations.
-    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)
-
-    IR_StructMember *get_buffer (CORBA::Boolean orphan = 0);
-    const IR_StructMember *get_buffer (void) const;
-    void replace (CORBA::ULong max,
-      CORBA::ULong length,
-      IR_StructMember *data,
-      CORBA::Boolean release);
-  };
-
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
-
-// *************************************************************
-// IR_StructMemberSeq
-// *************************************************************
-
-class TAO_IFR_Client_Export IR_StructMemberSeq : public
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Sequence_IR_StructMemberSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Sequence<IR_StructMember>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
-{
-public:
-  IR_StructMemberSeq (void); // default ctor
-  IR_StructMemberSeq (CORBA::ULong max); // uses max size
-  IR_StructMemberSeq (
-    CORBA::ULong max,
-    CORBA::ULong length,
-    IR_StructMember *buffer,
-    CORBA::Boolean release = 0
-  );
-  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 IR_StructMemberSeq_var _var_type;
-#endif /* ! __GNUC__ || g++ >= 2.8 */
-
-};
-
-// *************************************************************
-// class IR_StructMemberSeq_var
-// *************************************************************
-
-class TAO_IFR_Client_Export IR_StructMemberSeq_var
-{
-public:
-  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
-
-  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 IR_StructMemberSeq &() const;
-  operator IR_StructMemberSeq &();
-  operator IR_StructMemberSeq &() const;
-  operator IR_StructMemberSeq *&(); // variable-size base types only
-
-  IR_StructMember & operator[] (CORBA::ULong index);
-  const IR_StructMember & operator[] (CORBA::ULong index) const;
-
-  // in, inout, out, _retn
-  const IR_StructMemberSeq &in (void) const;
-  IR_StructMemberSeq &inout (void);
-  IR_StructMemberSeq *&out (void);
-  IR_StructMemberSeq *_retn (void);
-  IR_StructMemberSeq *ptr (void) const;
-
-private:
-  IR_StructMemberSeq *ptr_;
-};
-
-class TAO_IFR_Client_Export IR_StructMemberSeq_out
-{
-public:
-  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:
-  IR_StructMemberSeq *&ptr_;
-  // assignment from T_var not allowed
-  void operator= (const IR_StructMemberSeq_var &);
-};
-
-struct TAO_IFR_Client_Export IR_Initializer
-{
-
-#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
-  typedef IR_Initializer_var _var_type;
-#endif /* ! __GNUC__ || g++ >= 2.8 */
-
-  static void _tao_any_destructor (void*);
-
-  IR_StructMemberSeq members;
-  TAO_String_Manager name;
-};
-
-class TAO_IFR_Client_Export IR_Initializer_var
-{
-public:
-  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 IR_Initializer &in (void) const;
-  IR_Initializer &inout (void);
-  IR_Initializer *&out (void);
-  IR_Initializer *_retn (void);
-  IR_Initializer *ptr (void) const;
-
-private:
-  IR_Initializer *ptr_;
-};
-
-class TAO_IFR_Client_Export IR_Initializer_out
-{
-public:
-  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:
-  IR_Initializer *&ptr_;
-  // assignment from T_var not allowed
-  void operator= (const IR_Initializer_var &);
-};
-
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-
-  class TAO_EXPORT_NESTED_MACRO _TAO_Unbounded_Sequence_IR_InitializerSeq : public TAO_Unbounded_Base_Sequence
-  {
-  public:
-    // = Initialization and termination methods.
-
-    _TAO_Unbounded_Sequence_IR_InitializerSeq (void); // Default constructor.
-    _TAO_Unbounded_Sequence_IR_InitializerSeq (CORBA::ULong maximum);
-    _TAO_Unbounded_Sequence_IR_InitializerSeq (CORBA::ULong maximum,
-      CORBA::ULong length,
-      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.
-    IR_Initializer &operator[] (CORBA::ULong i);
-    const IR_Initializer &operator[] (CORBA::ULong i) const;
-    // = Static operations.
-    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)
-
-    IR_Initializer *get_buffer (CORBA::Boolean orphan = 0);
-    const IR_Initializer *get_buffer (void) const;
-    void replace (CORBA::ULong max,
-      CORBA::ULong length,
-      IR_Initializer *data,
-      CORBA::Boolean release);
-  };
-
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
-
-// *************************************************************
-// IR_InitializerSeq
-// *************************************************************
-
-class TAO_IFR_Client_Export IR_InitializerSeq : public
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Sequence_IR_InitializerSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Sequence<IR_Initializer>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
-{
-public:
-  IR_InitializerSeq (void); // default ctor
-  IR_InitializerSeq (CORBA::ULong max); // uses max size
-  IR_InitializerSeq (
-    CORBA::ULong max,
-    CORBA::ULong length,
-    IR_Initializer *buffer,
-    CORBA::Boolean release = 0
-  );
-  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 IR_InitializerSeq_var _var_type;
-#endif /* ! __GNUC__ || g++ >= 2.8 */
-
-};
-
-// *************************************************************
-// class IR_InitializerSeq_var
-// *************************************************************
-
-class TAO_IFR_Client_Export IR_InitializerSeq_var
-{
-public:
-  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
-
-  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 IR_InitializerSeq &() const;
-  operator IR_InitializerSeq &();
-  operator IR_InitializerSeq &() const;
-  operator IR_InitializerSeq *&(); // variable-size base types only
-
-  IR_Initializer & operator[] (CORBA::ULong index);
-  const IR_Initializer & operator[] (CORBA::ULong index) const;
-
-  // in, inout, out, _retn
-  const IR_InitializerSeq &in (void) const;
-  IR_InitializerSeq &inout (void);
-  IR_InitializerSeq *&out (void);
-  IR_InitializerSeq *_retn (void);
-  IR_InitializerSeq *ptr (void) const;
-
-private:
-  IR_InitializerSeq *ptr_;
-};
-
-class TAO_IFR_Client_Export IR_InitializerSeq_out
-{
-public:
-  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:
-  IR_InitializerSeq *&ptr_;
-  // assignment from T_var not allowed
-  void operator= (const IR_InitializerSeq_var &);
-};
-
-struct TAO_IFR_Client_Export IR_UnionMember
-{
-
-#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
-  typedef IR_UnionMember_var _var_type;
-#endif /* ! __GNUC__ || g++ >= 2.8 */
-
-  static void _tao_any_destructor (void*);
-
-  TAO_String_Manager name;
-  CORBA::Any label;
-  CORBA::TypeCode_var type;
-  IR_IDLType_var type_def;
-};
-
-class TAO_IFR_Client_Export IR_UnionMember_var
-{
-public:
-  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
-
-  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 IR_UnionMember &() const;
-  operator IR_UnionMember &();
-  operator IR_UnionMember &() const;
-  operator IR_UnionMember *&(); // variable-size types only
-
-  // in, inout, out, _retn
-  const IR_UnionMember &in (void) const;
-  IR_UnionMember &inout (void);
-  IR_UnionMember *&out (void);
-  IR_UnionMember *_retn (void);
-  IR_UnionMember *ptr (void) const;
-
-private:
-  IR_UnionMember *ptr_;
-};
-
-class TAO_IFR_Client_Export IR_UnionMember_out
-{
-public:
-  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:
-  IR_UnionMember *&ptr_;
-  // assignment from T_var not allowed
-  void operator= (const IR_UnionMember_var &);
-};
-
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-
-  class TAO_EXPORT_NESTED_MACRO _TAO_Unbounded_Sequence_IR_UnionMemberSeq : public TAO_Unbounded_Base_Sequence
-  {
-  public:
-    // = Initialization and termination methods.
-
-    _TAO_Unbounded_Sequence_IR_UnionMemberSeq (void); // Default constructor.
-    _TAO_Unbounded_Sequence_IR_UnionMemberSeq (CORBA::ULong maximum);
-    _TAO_Unbounded_Sequence_IR_UnionMemberSeq (CORBA::ULong maximum,
-      CORBA::ULong length,
-      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.
-    IR_UnionMember &operator[] (CORBA::ULong i);
-    const IR_UnionMember &operator[] (CORBA::ULong i) const;
-    // = Static operations.
-    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)
-
-    IR_UnionMember *get_buffer (CORBA::Boolean orphan = 0);
-    const IR_UnionMember *get_buffer (void) const;
-    void replace (CORBA::ULong max,
-      CORBA::ULong length,
-      IR_UnionMember *data,
-      CORBA::Boolean release);
-  };
-
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
-
-// *************************************************************
-// IR_UnionMemberSeq
-// *************************************************************
-
-class TAO_IFR_Client_Export IR_UnionMemberSeq : public
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Sequence_IR_UnionMemberSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Sequence<IR_UnionMember>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
-{
-public:
-  IR_UnionMemberSeq (void); // default ctor
-  IR_UnionMemberSeq (CORBA::ULong max); // uses max size
-  IR_UnionMemberSeq (
-    CORBA::ULong max,
-    CORBA::ULong length,
-    IR_UnionMember *buffer,
-    CORBA::Boolean release = 0
-  );
-  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 IR_UnionMemberSeq_var _var_type;
-#endif /* ! __GNUC__ || g++ >= 2.8 */
-
-};
-
-// *************************************************************
-// class IR_UnionMemberSeq_var
-// *************************************************************
-
-class TAO_IFR_Client_Export IR_UnionMemberSeq_var
-{
-public:
-  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
-
-  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 IR_UnionMemberSeq &() const;
-  operator IR_UnionMemberSeq &();
-  operator IR_UnionMemberSeq &() const;
-  operator IR_UnionMemberSeq *&(); // variable-size base types only
-
-  IR_UnionMember & operator[] (CORBA::ULong index);
-  const IR_UnionMember & operator[] (CORBA::ULong index) const;
-
-  // in, inout, out, _retn
-  const IR_UnionMemberSeq &in (void) const;
-  IR_UnionMemberSeq &inout (void);
-  IR_UnionMemberSeq *&out (void);
-  IR_UnionMemberSeq *_retn (void);
-  IR_UnionMemberSeq *ptr (void) const;
-
-private:
-  IR_UnionMemberSeq *ptr_;
-};
-
-class TAO_IFR_Client_Export IR_UnionMemberSeq_out
-{
-public:
-  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:
-  IR_UnionMemberSeq *&ptr_;
-  // assignment from T_var not allowed
-  void operator= (const IR_UnionMemberSeq_var &);
-};
-
-// *************************************************************
-// IR_EnumMemberSeq
-// *************************************************************
-
-class TAO_IFR_Client_Export IR_EnumMemberSeq : public
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  TAO_Unbounded_String_Sequence
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_String_Sequence
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
-{
-public:
-  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
-  );
-  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 IR_EnumMemberSeq_var _var_type;
-#endif /* ! __GNUC__ || g++ >= 2.8 */
-
-};
-
-// *************************************************************
-// class IR_EnumMemberSeq_var
-// *************************************************************
-
-class TAO_IFR_Client_Export IR_EnumMemberSeq_var
-{
-public:
-  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
-
-  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 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 IR_EnumMemberSeq &in (void) const;
-  IR_EnumMemberSeq &inout (void);
-  IR_EnumMemberSeq *&out (void);
-  IR_EnumMemberSeq *_retn (void);
-  IR_EnumMemberSeq *ptr (void) const;
-
-private:
-  IR_EnumMemberSeq *ptr_;
-};
-
-class TAO_IFR_Client_Export IR_EnumMemberSeq_out
-{
-public:
-  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:
-  IR_EnumMemberSeq *&ptr_;
-  // assignment from T_var not allowed
-  void operator= (const IR_EnumMemberSeq_var &);
-};
-
-// 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_IFR_Client_Export IR_Container: public virtual CORBA_IRObject
-{
-public:
-#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
-  typedef IR_Container_ptr _ptr_type;
-  typedef IR_Container_var _var_type;
-#endif /* ! __GNUC__ || g++ >= 2.8 */
-
-  // the static operations
-  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 IR_Container_ptr _unchecked_narrow (
-      CORBA::Object_ptr obj,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    );
-  static IR_Container_ptr _nil (void)
-    {
-      return (IR_Container_ptr)0;
-    }
-
-  static void _tao_any_destructor (void*);
-
-  virtual IR_Contained_ptr lookup (
-      const char * search_name,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual IR_ContainedSeq * contents (
-      IR_DefinitionKind limit_type,
-      CORBA::Boolean exclude_inherited,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual IR_ContainedSeq * lookup_name (
-      const char * search_name,
-      CORBA::Long levels_to_search,
-      IR_DefinitionKind limit_type,
-      CORBA::Boolean exclude_inherited,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  struct Description;
-  class Description_var;
-
-  struct TAO_IFR_Client_Export Description
-  {
-
-#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
-    typedef Description_var _var_type;
-#endif /* ! __GNUC__ || g++ >= 2.8 */
-
-    static void _tao_any_destructor (void*);
-
-    IR_Contained_var contained_object;
-    IR_DefinitionKind kind;
-    CORBA::Any value;
-  };
-
-  class TAO_IFR_Client_Export Description_var
-  {
-  public:
-    Description_var (void); // default constructor
-    Description_var (Description *);
-    Description_var (const Description_var &); // copy constructor
-    ~Description_var (void); // destructor
-
-    Description_var &operator= (Description *);
-    Description_var &operator= (const Description_var &);
-    Description *operator-> (void);
-    const Description *operator-> (void) const;
-
-    operator const Description &() const;
-    operator Description &();
-    operator Description &() const;
-    operator Description *&(); // variable-size types only
-
-    // in, inout, out, _retn
-    const Description &in (void) const;
-    Description &inout (void);
-    Description *&out (void);
-    Description *_retn (void);
-    Description *ptr (void) const;
-
-  private:
-    Description *ptr_;
-  };
-
-  class TAO_IFR_Client_Export Description_out
-  {
-  public:
-    Description_out (Description *&);
-    Description_out (Description_var &);
-    Description_out (const Description_out &);
-    Description_out &operator= (const Description_out &);
-    Description_out &operator= (Description *);
-    operator Description *&();
-    Description *&ptr (void);
-    Description *operator-> (void);
-
-  private:
-    Description *&ptr_;
-    // assignment from T_var not allowed
-    void operator= (const Description_var &);
-  };
-
-  static CORBA::TypeCode_ptr _tc_Description;
-
-
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-
-    class TAO_EXPORT_NESTED_MACRO _TAO_Unbounded_Sequence_IR_Container_DescriptionSeq : public TAO_Unbounded_Base_Sequence
-    {
-    public:
-      // = Initialization and termination methods.
-
-      _TAO_Unbounded_Sequence_IR_Container_DescriptionSeq (void); // Default constructor.
-      _TAO_Unbounded_Sequence_IR_Container_DescriptionSeq (CORBA::ULong maximum);
-      _TAO_Unbounded_Sequence_IR_Container_DescriptionSeq (CORBA::ULong maximum,
-        CORBA::ULong length,
-        Description *data,
-        CORBA::Boolean release = 0);
-      _TAO_Unbounded_Sequence_IR_Container_DescriptionSeq (const _TAO_Unbounded_Sequence_IR_Container_DescriptionSeq &rhs);
-      _TAO_Unbounded_Sequence_IR_Container_DescriptionSeq &operator= (const _TAO_Unbounded_Sequence_IR_Container_DescriptionSeq &rhs);
-      virtual ~_TAO_Unbounded_Sequence_IR_Container_DescriptionSeq (void); // Dtor.
-      // = Accessors.
-      Description &operator[] (CORBA::ULong i);
-      const Description &operator[] (CORBA::ULong i) const;
-      // = Static operations.
-      static Description *allocbuf (CORBA::ULong size);
-      static void freebuf (Description *buffer);
-      virtual void _allocate_buffer (CORBA::ULong length);
-      virtual void _deallocate_buffer (void);
-      // Implement the TAO_Base_Sequence methods (see Sequence.h)
-
-      Description *get_buffer (CORBA::Boolean orphan = 0);
-      const Description *get_buffer (void) const;
-      void replace (CORBA::ULong max,
-        CORBA::ULong length,
-        Description *data,
-        CORBA::Boolean release);
-    };
-
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
-
-  class DescriptionSeq_var;
-
-  // *************************************************************
-  // DescriptionSeq
-  // *************************************************************
-
-  class TAO_IFR_Client_Export DescriptionSeq : public
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-    _TAO_Unbounded_Sequence_IR_Container_DescriptionSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-    TAO_Unbounded_Sequence<Description>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
-  {
-  public:
-    DescriptionSeq (void); // default ctor
-    DescriptionSeq (CORBA::ULong max); // uses max size
-    DescriptionSeq (
-      CORBA::ULong max,
-      CORBA::ULong length,
-      Description *buffer,
-      CORBA::Boolean release = 0
-    );
-    DescriptionSeq (const DescriptionSeq &); // copy ctor
-    ~DescriptionSeq (void);
-    static void _tao_any_destructor (void*);
-
-#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
-    typedef DescriptionSeq_var _var_type;
-#endif /* ! __GNUC__ || g++ >= 2.8 */
-
-  };
-
-  // *************************************************************
-  // class IR_Container::DescriptionSeq_var
-  // *************************************************************
-
-  class TAO_IFR_Client_Export DescriptionSeq_var
-  {
-  public:
-    DescriptionSeq_var (void); // default constructor
-    DescriptionSeq_var (DescriptionSeq *);
-    DescriptionSeq_var (const DescriptionSeq_var &); // copy constructor
-    ~DescriptionSeq_var (void); // destructor
-
-    DescriptionSeq_var &operator= (DescriptionSeq *);
-    DescriptionSeq_var &operator= (const DescriptionSeq_var &);
-    DescriptionSeq *operator-> (void);
-    const DescriptionSeq *operator-> (void) const;
-
-    operator const DescriptionSeq &() const;
-    operator DescriptionSeq &();
-    operator DescriptionSeq &() const;
-    operator DescriptionSeq *&(); // variable-size base types only
-
-    Description & operator[] (CORBA::ULong index);
-    const Description & operator[] (CORBA::ULong index) const;
-
-    // in, inout, out, _retn
-    const DescriptionSeq &in (void) const;
-    DescriptionSeq &inout (void);
-    DescriptionSeq *&out (void);
-    DescriptionSeq *_retn (void);
-    DescriptionSeq *ptr (void) const;
-
-  private:
-    DescriptionSeq *ptr_;
-  };
-
-  class TAO_IFR_Client_Export DescriptionSeq_out
-  {
-  public:
-    DescriptionSeq_out (DescriptionSeq *&);
-    DescriptionSeq_out (DescriptionSeq_var &);
-    DescriptionSeq_out (const DescriptionSeq_out &);
-    DescriptionSeq_out &operator= (const DescriptionSeq_out &);
-    DescriptionSeq_out &operator= (DescriptionSeq *);
-    operator DescriptionSeq *&();
-    DescriptionSeq *&ptr (void);
-    DescriptionSeq *operator-> (void);
-    Description & operator[] (CORBA::ULong index);
-
-  private:
-    DescriptionSeq *&ptr_;
-    // assignment from T_var not allowed
-    void operator= (const DescriptionSeq_var &);
-  };
-
-  static CORBA::TypeCode_ptr _tc_DescriptionSeq;
-
-  virtual IR_Container::DescriptionSeq * describe_contents (
-      IR_DefinitionKind limit_type,
-      CORBA::Boolean exclude_inherited,
-      CORBA::Long max_returned_objs,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual IR_ModuleDef_ptr create_module (
-      const char * id,
-      const char * name,
-      const char * version,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual IR_ConstantDef_ptr create_constant (
-      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 ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual IR_StructDef_ptr create_struct (
-      const char * id,
-      const char * name,
-      const char * version,
-      const IR_StructMemberSeq & members,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual IR_UnionDef_ptr create_union (
-      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 ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual IR_EnumDef_ptr create_enum (
-      const char * id,
-      const char * name,
-      const char * version,
-      const IR_EnumMemberSeq & members,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual IR_AliasDef_ptr create_alias (
-      const char * id,
-      const char * name,
-      const char * version,
-      IR_IDLType_ptr original_type,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual IR_InterfaceDef_ptr create_interface (
-      const char * id,
-      const char * name,
-      const char * version,
-      const IR_InterfaceDefSeq & base_interfaces,
-      CORBA::Boolean is_abstract,
-      CORBA::Boolean is_local,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  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,
-      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 ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual IR_ValueBoxDef_ptr create_value_box (
-      const char * id,
-      const char * name,
-      const char * version,
-      IR_IDLType_ptr original_type_def,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual IR_ExceptionDef_ptr create_exception (
-      const char * id,
-      const char * name,
-      const char * version,
-      const IR_StructMemberSeq & members,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual IR_NativeDef_ptr create_native (
-      const char * id,
-      const char * name,
-      const char * version,
-      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_Container_Proxy_Broker *the_TAO_Container_Proxy_Broker_;
-
-protected:
-  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 IR_Container_setup_collocation (int collocated);
-
-  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 ~IR_Container (void);
-private:
-  IR_Container (const IR_Container &);
-  void operator= (const IR_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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _tao_target,
-        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_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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 */
-
-};
-
-
-// The Proxy Implementations are used by each interface to
-// perform a call. Each different implementation encapsulate
-// an invocation logics.
-
-
-///////////////////////////////////////////////////////////////////////
-//                    Base  Impl. Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_Container_Proxy_Impl :
-  public virtual _TAO_IRObject_Proxy_Impl
-{
-public:
-  virtual ~_TAO_Container_Proxy_Impl (void) { }
-
-  virtual IR_Contained_ptr lookup (
-      CORBA_Object *_collocated_tao_target_,
-      const char * search_name,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  virtual IR_ContainedSeq * contents (
-      CORBA_Object *_collocated_tao_target_,
-      IR_DefinitionKind limit_type,
-      CORBA::Boolean exclude_inherited,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  virtual IR_ContainedSeq * lookup_name (
-      CORBA_Object *_collocated_tao_target_,
-      const char * search_name,
-      CORBA::Long levels_to_search,
-      IR_DefinitionKind limit_type,
-      CORBA::Boolean exclude_inherited,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  virtual IR_Container::DescriptionSeq * describe_contents (
-      CORBA_Object *_collocated_tao_target_,
-      IR_DefinitionKind limit_type,
-      CORBA::Boolean exclude_inherited,
-      CORBA::Long max_returned_objs,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  virtual IR_ModuleDef_ptr create_module (
-      CORBA_Object *_collocated_tao_target_,
-      const char * id,
-      const char * name,
-      const char * version,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  virtual IR_ConstantDef_ptr create_constant (
-      CORBA_Object *_collocated_tao_target_,
-      const char * id,
-      const char * name,
-      const char * version,
-      IR_IDLType_ptr type,
-      const CORBA::Any & value,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  virtual IR_StructDef_ptr create_struct (
-      CORBA_Object *_collocated_tao_target_,
-      const char * id,
-      const char * name,
-      const char * version,
-      const IR_StructMemberSeq & members,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  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,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  virtual IR_EnumDef_ptr create_enum (
-      CORBA_Object *_collocated_tao_target_,
-      const char * id,
-      const char * name,
-      const char * version,
-      const IR_EnumMemberSeq & members,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  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,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  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,
-      CORBA::Boolean is_abstract,
-      CORBA::Boolean is_local,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  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,
-      CORBA::Boolean is_truncatable,
-      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 (
-      CORBA_Object *_collocated_tao_target_,
-      const char * id,
-      const char * name,
-      const char * version,
-      IR_IDLType_ptr original_type_def,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  virtual IR_ExceptionDef_ptr create_exception (
-      CORBA_Object *_collocated_tao_target_,
-      const char * id,
-      const char * name,
-      const char * version,
-      const IR_StructMemberSeq & members,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  virtual IR_NativeDef_ptr create_native (
-      CORBA_Object *_collocated_tao_target_,
-      const char * id,
-      const char * name,
-      const char * version,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-protected:
-  _TAO_Container_Proxy_Impl (void);
-
-};
-
-//
-//                Base  Proxy Impl. Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//                    Remote  Impl. Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_Container_Remote_Proxy_Impl :
-  public virtual _TAO_Container_Proxy_Impl,
-  public virtual TAO_Remote_Object_Proxy_Impl,
-  public virtual _TAO_IRObject_Remote_Proxy_Impl
-
-{
-public:
-  _TAO_Container_Remote_Proxy_Impl (void);
-
-  virtual ~_TAO_Container_Remote_Proxy_Impl (void) { }
-
-  virtual IR_Contained_ptr lookup (
-      CORBA_Object *_collocated_tao_target_,
-      const char * search_name,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual IR_ContainedSeq * contents (
-      CORBA_Object *_collocated_tao_target_,
-      IR_DefinitionKind limit_type,
-      CORBA::Boolean exclude_inherited,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual IR_ContainedSeq * lookup_name (
-      CORBA_Object *_collocated_tao_target_,
-      const char * search_name,
-      CORBA::Long levels_to_search,
-      IR_DefinitionKind limit_type,
-      CORBA::Boolean exclude_inherited,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual IR_Container::DescriptionSeq * describe_contents (
-      CORBA_Object *_collocated_tao_target_,
-      IR_DefinitionKind limit_type,
-      CORBA::Boolean exclude_inherited,
-      CORBA::Long max_returned_objs,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual IR_ModuleDef_ptr create_module (
-      CORBA_Object *_collocated_tao_target_,
-      const char * id,
-      const char * name,
-      const char * version,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual IR_ConstantDef_ptr create_constant (
-      CORBA_Object *_collocated_tao_target_,
-      const char * id,
-      const char * name,
-      const char * version,
-      IR_IDLType_ptr type,
-      const CORBA::Any & value,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual IR_StructDef_ptr create_struct (
-      CORBA_Object *_collocated_tao_target_,
-      const char * id,
-      const char * name,
-      const char * version,
-      const IR_StructMemberSeq & members,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  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,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual IR_EnumDef_ptr create_enum (
-      CORBA_Object *_collocated_tao_target_,
-      const char * id,
-      const char * name,
-      const char * version,
-      const IR_EnumMemberSeq & members,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  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,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  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,
-      CORBA::Boolean is_abstract,
-      CORBA::Boolean is_local,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  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,
-      CORBA::Boolean is_truncatable,
-      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 (
-      CORBA_Object *_collocated_tao_target_,
-      const char * id,
-      const char * name,
-      const char * version,
-      IR_IDLType_ptr original_type_def,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual IR_ExceptionDef_ptr create_exception (
-      CORBA_Object *_collocated_tao_target_,
-      const char * id,
-      const char * name,
-      const char * version,
-      const IR_StructMemberSeq & members,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual IR_NativeDef_ptr create_native (
-      CORBA_Object *_collocated_tao_target_,
-      const char * id,
-      const char * name,
-      const char * version,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-};
-
-//
-//                Base  Proxy Impl. Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-// The Proxy Brokers are used by each interface to get
-// the right proxy for performing a call. In the new
-// collocation scheme, the proxy to be used can vary on
-// a call by call basis.
-
-
-
-///////////////////////////////////////////////////////////////////////
-//                 Base Proxy Broker Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_Container_Proxy_Broker
-{
-public:
-  virtual ~_TAO_Container_Proxy_Broker (void);
-
-  virtual _TAO_Container_Proxy_Impl &select_proxy (
-    IR_Container *object,
-    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-  ) = 0;
-
-protected:
-  _TAO_Container_Proxy_Broker (void);
-
-};
-
-
-//
-//              End Base Proxy Broker Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//                 Remote Proxy Broker Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_Container_Remote_Proxy_Broker : public virtual _TAO_Container_Proxy_Broker
-{
-public:
-  _TAO_Container_Remote_Proxy_Broker (void);
-
-  virtual ~_TAO_Container_Remote_Proxy_Broker (void);
-
-  virtual _TAO_Container_Proxy_Impl &select_proxy (
-    IR_Container *object,
-    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-  );
-
-private:
-  _TAO_Container_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_Container_Remote_Proxy_Broker *the_TAO_Container_Remote_Proxy_Broker (void);
-};
-
-//
-//              End Remote Proxy Broker Declaration
-///////////////////////////////////////////////////////////////////////
-
-// 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_IFR_Client_Export IR_IDLType : public virtual CORBA_IRObject
-{
-public:
-#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
-  typedef IR_IDLType_ptr _ptr_type;
-  typedef IR_IDLType_var _var_type;
-#endif /* ! __GNUC__ || g++ >= 2.8 */
-
-  // the static operations
-  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 IR_IDLType_ptr _unchecked_narrow (
-      CORBA::Object_ptr obj,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    );
-  static IR_IDLType_ptr _nil (void)
-    {
-      return (IR_IDLType_ptr)0;
-    }
-
-  static void _tao_any_destructor (void*);
-
-  virtual CORBA::TypeCode_ptr type   (
-                  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_IDLType_Proxy_Broker *the_TAO_IDLType_Proxy_Broker_;
-
-protected:
-  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 IR_IDLType_setup_collocation (int collocated);
-
-  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 ~IR_IDLType (void);
-private:
-  IR_IDLType (const IR_IDLType &);
-  void operator= (const IR_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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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;
-  };
-
-#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_IFR_Client_Export _TAO_IDLType_Proxy_Impl :
-  public virtual _TAO_IRObject_Proxy_Impl
-{
-public:
-  virtual ~_TAO_IDLType_Proxy_Impl (void) { }
-
-  virtual CORBA::TypeCode_ptr type (
-      CORBA_Object *_collocated_tao_target_,
-       CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-protected:
-  _TAO_IDLType_Proxy_Impl (void);
-
-};
-
-//
-//                Base  Proxy Impl. Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//                    Remote  Impl. Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_IDLType_Remote_Proxy_Impl :
-  public virtual _TAO_IDLType_Proxy_Impl,
-  public virtual TAO_Remote_Object_Proxy_Impl,
-  public virtual _TAO_IRObject_Remote_Proxy_Impl
-
-{
-public:
-  _TAO_IDLType_Remote_Proxy_Impl (void);
-
-  virtual ~_TAO_IDLType_Remote_Proxy_Impl (void) { }
-
-  virtual CORBA::TypeCode_ptr type   (
-      CORBA_Object *_collocated_tao_target_,
-            CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-};
-
-//
-//                Base  Proxy Impl. Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-// The Proxy Brokers are used by each interface to get
-// the right proxy for performing a call. In the new
-// collocation scheme, the proxy to be used can vary on
-// a call by call basis.
-
-
-
-///////////////////////////////////////////////////////////////////////
-//                 Base Proxy Broker Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_IDLType_Proxy_Broker
-{
-public:
-  virtual ~_TAO_IDLType_Proxy_Broker (void);
-
-  virtual _TAO_IDLType_Proxy_Impl &select_proxy (
-    IR_IDLType *object,
-    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-  ) = 0;
-
-protected:
-  _TAO_IDLType_Proxy_Broker (void);
-
-};
-
-
-//
-//              End Base Proxy Broker Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//                 Remote Proxy Broker Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_IDLType_Remote_Proxy_Broker : public virtual _TAO_IDLType_Proxy_Broker
-{
-public:
-  _TAO_IDLType_Remote_Proxy_Broker (void);
-
-  virtual ~_TAO_IDLType_Remote_Proxy_Broker (void);
-
-  virtual _TAO_IDLType_Proxy_Impl &select_proxy (
-    IR_IDLType *object,
-    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-  );
-
-private:
-  _TAO_IDLType_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_IDLType_Remote_Proxy_Broker *the_TAO_IDLType_Remote_Proxy_Broker (void);
-};
-
-//
-//              End Remote Proxy Broker Declaration
-///////////////////////////////////////////////////////////////////////
-
-class TAO_IFR_Client_Export IR_PrimitiveDef_var : public TAO_Base_var
-{
-public:
-  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
-
-  IR_PrimitiveDef_var &operator= (IR_PrimitiveDef_ptr);
-  IR_PrimitiveDef_var &operator= (const IR_PrimitiveDef_var &);
-  IR_PrimitiveDef_ptr operator-> (void) const;
-
-  operator const IR_PrimitiveDef_ptr &() const;
-  operator IR_PrimitiveDef_ptr &();
-  // in, inout, out, _retn
-  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:
-  IR_PrimitiveDef_ptr ptr_;
-  // Unimplemented - prevents widening assignment.
-  IR_PrimitiveDef_var (const TAO_Base_var &rhs);
-  IR_PrimitiveDef_var &operator= (const TAO_Base_var &rhs);
-};
-
-
-class TAO_IFR_Client_Export IR_PrimitiveDef_out
-{
-public:
-  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:
-  IR_PrimitiveDef_ptr &ptr_;
-};
-
-class TAO_IFR_Client_Export IR_StringDef_var : public TAO_Base_var
-{
-public:
-  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
-
-  IR_StringDef_var &operator= (IR_StringDef_ptr);
-  IR_StringDef_var &operator= (const IR_StringDef_var &);
-  IR_StringDef_ptr operator-> (void) const;
-
-  operator const IR_StringDef_ptr &() const;
-  operator IR_StringDef_ptr &();
-  // in, inout, out, _retn
-  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:
-  IR_StringDef_ptr ptr_;
-  // Unimplemented - prevents widening assignment.
-  IR_StringDef_var (const TAO_Base_var &rhs);
-  IR_StringDef_var &operator= (const TAO_Base_var &rhs);
-};
-
-class TAO_IFR_Client_Export IR_StringDef_out
-{
-public:
-  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:
-  IR_StringDef_ptr &ptr_;
-};
-
-class TAO_IFR_Client_Export IR_SequenceDef_var : public TAO_Base_var
-{
-public:
-  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
-
-  IR_SequenceDef_var &operator= (IR_SequenceDef_ptr);
-  IR_SequenceDef_var &operator= (const IR_SequenceDef_var &);
-  IR_SequenceDef_ptr operator-> (void) const;
-
-  operator const IR_SequenceDef_ptr &() const;
-  operator IR_SequenceDef_ptr &();
-  // in, inout, out, _retn
-  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:
-  IR_SequenceDef_ptr ptr_;
-  // Unimplemented - prevents widening assignment.
-  IR_SequenceDef_var (const TAO_Base_var &rhs);
-  IR_SequenceDef_var &operator= (const TAO_Base_var &rhs);
-};
-
-class TAO_IFR_Client_Export IR_SequenceDef_out
-{
-public:
-  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:
-  IR_SequenceDef_ptr &ptr_;
-};
-
-class TAO_IFR_Client_Export IR_ArrayDef_var : public TAO_Base_var
-{
-public:
-  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
-
-  IR_ArrayDef_var &operator= (IR_ArrayDef_ptr);
-  IR_ArrayDef_var &operator= (const IR_ArrayDef_var &);
-  IR_ArrayDef_ptr operator-> (void) const;
-
-  operator const IR_ArrayDef_ptr &() const;
-  operator IR_ArrayDef_ptr &();
-  // in, inout, out, _retn
-  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:
-  IR_ArrayDef_ptr ptr_;
-  // Unimplemented - prevents widening assignment.
-  IR_ArrayDef_var (const TAO_Base_var &rhs);
-  IR_ArrayDef_var &operator= (const TAO_Base_var &rhs);
-};
-
-class TAO_IFR_Client_Export IR_ArrayDef_out
-{
-public:
-  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:
-  IR_ArrayDef_ptr &ptr_;
-};
-
-class TAO_IFR_Client_Export IR_WstringDef_var : public TAO_Base_var
-{
-public:
-  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
-
-  IR_WstringDef_var &operator= (IR_WstringDef_ptr);
-  IR_WstringDef_var &operator= (const IR_WstringDef_var &);
-  IR_WstringDef_ptr operator-> (void) const;
-
-  operator const IR_WstringDef_ptr &() const;
-  operator IR_WstringDef_ptr &();
-  // in, inout, out, _retn
-  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:
-  IR_WstringDef_ptr ptr_;
-  // Unimplemented - prevents widening assignment.
-  IR_WstringDef_var (const TAO_Base_var &rhs);
-  IR_WstringDef_var &operator= (const TAO_Base_var &rhs);
-};
-
-class TAO_IFR_Client_Export IR_WstringDef_out
-{
-public:
-  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:
-  IR_WstringDef_ptr &ptr_;
-};
-
-class TAO_IFR_Client_Export IR_FixedDef_var : public TAO_Base_var
-{
-public:
-  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
-
-  IR_FixedDef_var &operator= (IR_FixedDef_ptr);
-  IR_FixedDef_var &operator= (const IR_FixedDef_var &);
-  IR_FixedDef_ptr operator-> (void) const;
-
-  operator const IR_FixedDef_ptr &() const;
-  operator IR_FixedDef_ptr &();
-  // in, inout, out, _retn
-  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:
-  IR_FixedDef_ptr ptr_;
-  // Unimplemented - prevents widening assignment.
-  IR_FixedDef_var (const TAO_Base_var &rhs);
-  IR_FixedDef_var &operator= (const TAO_Base_var &rhs);
-};
-
-class TAO_IFR_Client_Export IR_FixedDef_out
-{
-public:
-  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:
-  IR_FixedDef_ptr &ptr_;
-};
-
-// Forward Classes Declaration
-class _TAO_Repository_Proxy_Impl;
-class _TAO_Repository_Remote_Proxy_Impl;
-class _TAO_Repository_Proxy_Broker;
-class _TAO_Repository_Remote_Proxy_Broker;
-
-class TAO_IFR_Client_Export IR_Repository: public virtual IR_Container
-{
-public:
-#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
-  typedef IR_Repository_ptr _ptr_type;
-  typedef IR_Repository_var _var_type;
-#endif /* ! __GNUC__ || g++ >= 2.8 */
-
-  // the static operations
-  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 IR_Repository_ptr _unchecked_narrow (
-      CORBA::Object_ptr obj,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    );
-  static IR_Repository_ptr _nil (void)
-    {
-      return (IR_Repository_ptr)0;
-    }
-
-  static void _tao_any_destructor (void*);
-
-  virtual IR_Contained_ptr lookup_id (
-      const char * search_id,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual CORBA::TypeCode_ptr get_canonical_typecode (
-      CORBA::TypeCode_ptr tc,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual IR_PrimitiveDef_ptr get_primitive (
-      IR_PrimitiveKind kind,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual IR_StringDef_ptr create_string (
-      CORBA::ULong bound,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual IR_WstringDef_ptr create_wstring (
-      CORBA::ULong bound,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual IR_SequenceDef_ptr create_sequence (
-      CORBA::ULong bound,
-      IR_IDLType_ptr element_type,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual IR_ArrayDef_ptr create_array (
-      CORBA::ULong length,
-      IR_IDLType_ptr element_type,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual IR_FixedDef_ptr create_fixed (
-      CORBA::UShort digits,
-      CORBA::Short scale,
-      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_Repository_Proxy_Broker *the_TAO_Repository_Proxy_Broker_;
-
-protected:
-  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 IR_Repository_setup_collocation (int collocated);
-
-  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 ~IR_Repository (void);
-private:
-  IR_Repository (const IR_Repository &);
-  void operator= (const IR_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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 */
-
-};
-
-
-// The Proxy Implementations are used by each interface to
-// perform a call. Each different implementation encapsulate
-// an invocation logics.
-
-
-///////////////////////////////////////////////////////////////////////
-//                    Base  Impl. Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_Repository_Proxy_Impl :
-  public virtual _TAO_Container_Proxy_Impl
-{
-public:
-  virtual ~_TAO_Repository_Proxy_Impl (void) { }
-
-  virtual IR_Contained_ptr lookup_id (
-      CORBA_Object *_collocated_tao_target_,
-      const char * search_id,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  virtual CORBA::TypeCode_ptr get_canonical_typecode (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::TypeCode_ptr tc,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  virtual IR_PrimitiveDef_ptr get_primitive (
-      CORBA_Object *_collocated_tao_target_,
-      IR_PrimitiveKind kind,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  virtual IR_StringDef_ptr create_string (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::ULong bound,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  virtual IR_WstringDef_ptr create_wstring (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::ULong bound,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  virtual IR_SequenceDef_ptr create_sequence (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::ULong bound,
-      IR_IDLType_ptr element_type,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  virtual IR_ArrayDef_ptr create_array (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::ULong length,
-      IR_IDLType_ptr element_type,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  virtual IR_FixedDef_ptr create_fixed (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::UShort digits,
-      CORBA::Short scale,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-protected:
-  _TAO_Repository_Proxy_Impl (void);
-
-};
-
-//
-//                Base  Proxy Impl. Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//                    Remote  Impl. Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_Repository_Remote_Proxy_Impl :
-  public virtual _TAO_Repository_Proxy_Impl,
-  public virtual TAO_Remote_Object_Proxy_Impl,
-  public virtual _TAO_Container_Remote_Proxy_Impl
-
-{
-public:
-  _TAO_Repository_Remote_Proxy_Impl (void);
-
-  virtual ~_TAO_Repository_Remote_Proxy_Impl (void) { }
-
-  virtual IR_Contained_ptr lookup_id (
-      CORBA_Object *_collocated_tao_target_,
-      const char * search_id,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual CORBA::TypeCode_ptr get_canonical_typecode (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::TypeCode_ptr tc,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual IR_PrimitiveDef_ptr get_primitive (
-      CORBA_Object *_collocated_tao_target_,
-      IR_PrimitiveKind kind,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual IR_StringDef_ptr create_string (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::ULong bound,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual IR_WstringDef_ptr create_wstring (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::ULong bound,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual IR_SequenceDef_ptr create_sequence (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::ULong bound,
-      IR_IDLType_ptr element_type,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual IR_ArrayDef_ptr create_array (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::ULong length,
-      IR_IDLType_ptr element_type,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual IR_FixedDef_ptr create_fixed (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::UShort digits,
-      CORBA::Short scale,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-};
-
-//
-//                Base  Proxy Impl. Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-// The Proxy Brokers are used by each interface to get
-// the right proxy for performing a call. In the new
-// collocation scheme, the proxy to be used can vary on
-// a call by call basis.
-
-
-
-///////////////////////////////////////////////////////////////////////
-//                 Base Proxy Broker Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_Repository_Proxy_Broker
-{
-public:
-  virtual ~_TAO_Repository_Proxy_Broker (void);
-
-  virtual _TAO_Repository_Proxy_Impl &select_proxy (
-    IR_Repository *object,
-    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-  ) = 0;
-
-protected:
-  _TAO_Repository_Proxy_Broker (void);
-
-};
-
-
-//
-//              End Base Proxy Broker Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//                 Remote Proxy Broker Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_Repository_Remote_Proxy_Broker : public virtual _TAO_Repository_Proxy_Broker
-{
-public:
-  _TAO_Repository_Remote_Proxy_Broker (void);
-
-  virtual ~_TAO_Repository_Remote_Proxy_Broker (void);
-
-  virtual _TAO_Repository_Proxy_Impl &select_proxy (
-    IR_Repository *object,
-    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-  );
-
-private:
-  _TAO_Repository_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_Repository_Remote_Proxy_Broker *the_TAO_Repository_Remote_Proxy_Broker (void);
-};
-
-//
-//              End Remote Proxy Broker Declaration
-///////////////////////////////////////////////////////////////////////
-
-class TAO_IFR_Client_Export IR_ComponentRepository_var : public TAO_Base_var
-{
-public:
-  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
-
-  IR_ComponentRepository_var &operator= (IR_ComponentRepository_ptr);
-  IR_ComponentRepository_var &operator= (const IR_ComponentRepository_var &);
-  IR_ComponentRepository_ptr operator-> (void) const;
-
-  operator const IR_ComponentRepository_ptr &() const;
-  operator IR_ComponentRepository_ptr &();
-  // in, inout, out, _retn
-  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:
-  IR_ComponentRepository_ptr ptr_;
-  // Unimplemented - prevents widening assignment.
-  IR_ComponentRepository_var (const TAO_Base_var &rhs);
-  IR_ComponentRepository_var &operator= (const TAO_Base_var &rhs);
-};
-
-class TAO_IFR_Client_Export IR_ComponentRepository_out
-{
-public:
-  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:
-  IR_ComponentRepository_ptr &ptr_;
-};
-
-// 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_IFR_Client_Export IR_ComponentRepository: public virtual IR_Repository
-{
-public:
-#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
-  typedef IR_ComponentRepository_ptr _ptr_type;
-  typedef IR_ComponentRepository_var _var_type;
-#endif /* ! __GNUC__ || g++ >= 2.8 */
-
-  // the static operations
-  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 IR_ComponentRepository_ptr _unchecked_narrow (
-      CORBA::Object_ptr obj,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    );
-  static IR_ComponentRepository_ptr _nil (void)
-    {
-      return (IR_ComponentRepository_ptr)0;
-    }
-
-  static void _tao_any_destructor (void*);
-
-  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,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  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,
-      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_ComponentRepository_Proxy_Broker *the_TAO_ComponentRepository_Proxy_Broker_;
-
-protected:
-  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 IR_ComponentRepository_setup_collocation (int collocated);
-
-  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 ~IR_ComponentRepository (void);
-private:
-  IR_ComponentRepository (const IR_ComponentRepository &);
-  void operator= (const IR_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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 ()
-      );
-
-    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_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 */
-
-};
-
-
-// The Proxy Implementations are used by each interface to
-// perform a call. Each different implementation encapsulate
-// an invocation logics.
-
-
-///////////////////////////////////////////////////////////////////////
-//                    Base  Impl. Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_ComponentRepository_Proxy_Impl :
-  public virtual _TAO_Repository_Proxy_Impl
-{
-public:
-  virtual ~_TAO_ComponentRepository_Proxy_Impl (void) { }
-
-  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,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  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,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-protected:
-  _TAO_ComponentRepository_Proxy_Impl (void);
-
-};
-
-//
-//                Base  Proxy Impl. Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//                    Remote  Impl. Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_ComponentRepository_Remote_Proxy_Impl :
-  public virtual _TAO_ComponentRepository_Proxy_Impl,
-  public virtual TAO_Remote_Object_Proxy_Impl,
-  public virtual _TAO_Repository_Remote_Proxy_Impl
-
-{
-public:
-  _TAO_ComponentRepository_Remote_Proxy_Impl (void);
-
-  virtual ~_TAO_ComponentRepository_Remote_Proxy_Impl (void) { }
-
-  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,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  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,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-};
-
-//
-//                Base  Proxy Impl. Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-// The Proxy Brokers are used by each interface to get
-// the right proxy for performing a call. In the new
-// collocation scheme, the proxy to be used can vary on
-// a call by call basis.
-
-
-
-///////////////////////////////////////////////////////////////////////
-//                 Base Proxy Broker Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_ComponentRepository_Proxy_Broker
-{
-public:
-  virtual ~_TAO_ComponentRepository_Proxy_Broker (void);
-
-  virtual _TAO_ComponentRepository_Proxy_Impl &select_proxy (
-    IR_ComponentRepository *object,
-    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-  ) = 0;
-
-protected:
-  _TAO_ComponentRepository_Proxy_Broker (void);
-
-};
-
-
-//
-//              End Base Proxy Broker Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//                 Remote Proxy Broker Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_ComponentRepository_Remote_Proxy_Broker : public virtual _TAO_ComponentRepository_Proxy_Broker
-{
-public:
-  _TAO_ComponentRepository_Remote_Proxy_Broker (void);
-
-  virtual ~_TAO_ComponentRepository_Remote_Proxy_Broker (void);
-
-  virtual _TAO_ComponentRepository_Proxy_Impl &select_proxy (
-    IR_ComponentRepository *object,
-    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-  );
-
-private:
-  _TAO_ComponentRepository_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_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;
-
-class TAO_IFR_Client_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 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 IR_ModuleDef_ptr _unchecked_narrow (
-      CORBA::Object_ptr obj,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    );
-  static IR_ModuleDef_ptr _nil (void)
-    {
-      return (IR_ModuleDef_ptr)0;
-    }
-
-  static void _tao_any_destructor (void*);
-
-  virtual CORBA::Boolean _is_a (
-      const CORBA::Char *type_id,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    );
-  virtual void *_tao_QueryInterface (ptr_arith_t type);
-
-  virtual const char* _interface_repository_id (void) const;
-
-private:
-  _TAO_ModuleDef_Proxy_Broker *the_TAO_ModuleDef_Proxy_Broker_;
-
-protected:
-  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 IR_ModuleDef_setup_collocation (int collocated);
-
-  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;
-
-  virtual ~IR_ModuleDef (void);
-private:
-  IR_ModuleDef (const IR_ModuleDef &);
-  void operator= (const IR_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 */
-
-};
-
-
-// The Proxy Implementations are used by each interface to
-// perform a call. Each different implementation encapsulate
-// an invocation logics.
-
-
-  ///////////////////////////////////////////////////////////////////////
-  //                    Base  Impl. Declaration
-  //
-
-  class TAO_IFR_Client_Export _TAO_ModuleDef_Proxy_Impl :
-    public virtual _TAO_Container_Proxy_Impl,
-    public virtual _TAO_Contained_Proxy_Impl
-  {
-  public:
-    virtual ~_TAO_ModuleDef_Proxy_Impl (void) { }
-
-  protected:
-    _TAO_ModuleDef_Proxy_Impl (void);
-
-  };
-
-  //
-  //                Base  Proxy Impl. Declaration
-  ///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//                    Remote  Impl. Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_ModuleDef_Remote_Proxy_Impl :
-  public virtual _TAO_ModuleDef_Proxy_Impl,
-  public virtual TAO_Remote_Object_Proxy_Impl,
-  public virtual _TAO_Container_Remote_Proxy_Impl,
-  public virtual _TAO_Contained_Remote_Proxy_Impl
-
-{
-public:
-  _TAO_ModuleDef_Remote_Proxy_Impl (void);
-
-  virtual ~_TAO_ModuleDef_Remote_Proxy_Impl (void) { }
-
-};
-
-//
-//                Base  Proxy Impl. Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-// The Proxy Brokers are used by each interface to get
-// the right proxy for performing a call. In the new
-// collocation scheme, the proxy to be used can vary on
-// a call by call basis.
-
-
-
-///////////////////////////////////////////////////////////////////////
-//                 Base Proxy Broker Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_ModuleDef_Proxy_Broker
-{
-public:
-  virtual ~_TAO_ModuleDef_Proxy_Broker (void);
-
-  virtual _TAO_ModuleDef_Proxy_Impl &select_proxy (
-    IR_ModuleDef *object,
-    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-  ) = 0;
-
-protected:
-  _TAO_ModuleDef_Proxy_Broker (void);
-
-};
-
-
-//
-//              End Base Proxy Broker Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//                 Remote Proxy Broker Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_ModuleDef_Remote_Proxy_Broker : public virtual _TAO_ModuleDef_Proxy_Broker
-{
-public:
-  _TAO_ModuleDef_Remote_Proxy_Broker (void);
-
-  virtual ~_TAO_ModuleDef_Remote_Proxy_Broker (void);
-
-  virtual _TAO_ModuleDef_Proxy_Impl &select_proxy (
-    IR_ModuleDef *object,
-    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-  );
-
-private:
-  _TAO_ModuleDef_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_ModuleDef_Remote_Proxy_Broker *the_TAO_ModuleDef_Remote_Proxy_Broker (void);
-};
-
-//
-//              End Remote Proxy Broker Declaration
-///////////////////////////////////////////////////////////////////////
-
-struct TAO_IFR_Client_Export IR_ModuleDescription
-{
-
-#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
-  typedef IR_ModuleDescription_var _var_type;
-#endif /* ! __GNUC__ || g++ >= 2.8 */
-
-  static void _tao_any_destructor (void*);
-
-  TAO_String_Manager name;
-  TAO_String_Manager id;
-  TAO_String_Manager defined_in;
-  TAO_String_Manager version;
-};
-
-class TAO_IFR_Client_Export IR_ModuleDescription_var
-{
-public:
-  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
-
-  IR_ModuleDescription_var &operator= (IR_ModuleDescription *);
-  IR_ModuleDescription_var &operator= (const IR_ModuleDescription_var &);
-  IR_ModuleDescription *operator-> (void);
-  const IR_ModuleDescription *operator-> (void) const;
-
-  operator const IR_ModuleDescription &() const;
-  operator IR_ModuleDescription &();
-  operator IR_ModuleDescription &() const;
-  operator IR_ModuleDescription *&(); // variable-size types only
-
-  // in, inout, out, _retn
-  const IR_ModuleDescription &in (void) const;
-  IR_ModuleDescription &inout (void);
-  IR_ModuleDescription *&out (void);
-  IR_ModuleDescription *_retn (void);
-  IR_ModuleDescription *ptr (void) const;
-
-private:
-  IR_ModuleDescription *ptr_;
-};
-
-class TAO_IFR_Client_Export IR_ModuleDescription_out
-{
-public:
-  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:
-  IR_ModuleDescription *&ptr_;
-  // assignment from T_var not allowed
-  void operator= (const IR_ModuleDescription_var &);
-};
-
-// 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_IFR_Client_Export IR_ConstantDef: public virtual IR_Contained
-{
-public:
-#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
-  typedef IR_ConstantDef_ptr _ptr_type;
-  typedef IR_ConstantDef_var _var_type;
-#endif /* ! __GNUC__ || g++ >= 2.8 */
-
-  // the static operations
-  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 IR_ConstantDef_ptr _unchecked_narrow (
-      CORBA::Object_ptr obj,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    );
-  static IR_ConstantDef_ptr _nil (void)
-    {
-      return (IR_ConstantDef_ptr)0;
-    }
-
-  static void _tao_any_destructor (void*);
-
-  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 =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual void type_def (
-      IR_IDLType_ptr type_def,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual CORBA::Any * value (
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual void value (
-      const CORBA::Any & 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_ConstantDef_Proxy_Broker *the_TAO_ConstantDef_Proxy_Broker_;
-
-protected:
-  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 IR_ConstantDef_setup_collocation (int collocated);
-
-  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 ~IR_ConstantDef (void);
-private:
-  IR_ConstantDef (const IR_ConstantDef &);
-  void operator= (const IR_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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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));
-
-  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 */
-
-};
-
-
-// The Proxy Implementations are used by each interface to
-// perform a call. Each different implementation encapsulate
-// an invocation logics.
-
-
-///////////////////////////////////////////////////////////////////////
-//                    Base  Impl. Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_ConstantDef_Proxy_Impl :
-  public virtual _TAO_Contained_Proxy_Impl
-{
-public:
-  virtual ~_TAO_ConstantDef_Proxy_Impl (void) { }
-
-  virtual CORBA::TypeCode_ptr type (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  virtual IR_IDLType_ptr type_def (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  virtual void type_def (
-      CORBA_Object *_collocated_tao_target_,
-      IR_IDLType_ptr type_def,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  virtual CORBA::Any * value (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  virtual void value (
-      CORBA_Object *_collocated_tao_target_,
-      const CORBA::Any & value,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-protected:
-  _TAO_ConstantDef_Proxy_Impl (void);
-
-};
-
-//
-//                Base  Proxy Impl. Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//                    Remote  Impl. Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_ConstantDef_Remote_Proxy_Impl :
-  public virtual _TAO_ConstantDef_Proxy_Impl,
-  public virtual TAO_Remote_Object_Proxy_Impl,
-  public virtual _TAO_Contained_Remote_Proxy_Impl
-
-{
-public:
-  _TAO_ConstantDef_Remote_Proxy_Impl (void);
-
-  virtual ~_TAO_ConstantDef_Remote_Proxy_Impl (void) { }
-
-  virtual CORBA::TypeCode_ptr type (
-      CORBA_Object *_collocated_tao_target_,
-       CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual IR_IDLType_ptr type_def (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual void type_def (
-      CORBA_Object *_collocated_tao_target_,
-      IR_IDLType_ptr type_def,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual CORBA::Any * value   (
-      CORBA_Object *_collocated_tao_target_,
-            CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual void value   (
-      CORBA_Object *_collocated_tao_target_,
-      const CORBA::Any & value,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-};
-
-//
-//                Base  Proxy Impl. Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-// The Proxy Brokers are used by each interface to get
-// the right proxy for performing a call. In the new
-// collocation scheme, the proxy to be used can vary on
-// a call by call basis.
-
-
-
-///////////////////////////////////////////////////////////////////////
-//                 Base Proxy Broker Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_ConstantDef_Proxy_Broker
-{
-public:
-  virtual ~_TAO_ConstantDef_Proxy_Broker (void);
-  virtual _TAO_ConstantDef_Proxy_Impl &select_proxy (
-    IR_ConstantDef *object,
-    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-  ) = 0;
-
-protected:
-  _TAO_ConstantDef_Proxy_Broker (void);
-
-};
-
-
-//
-//              End Base Proxy Broker Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//                 Remote Proxy Broker Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_ConstantDef_Remote_Proxy_Broker : public virtual _TAO_ConstantDef_Proxy_Broker
-{
-public:
-  _TAO_ConstantDef_Remote_Proxy_Broker (void);
-
-  virtual ~_TAO_ConstantDef_Remote_Proxy_Broker (void);
-
-  virtual _TAO_ConstantDef_Proxy_Impl &select_proxy (
-    IR_ConstantDef *object,
-    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-  );
-
-private:
-  _TAO_ConstantDef_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_ConstantDef_Remote_Proxy_Broker *the_TAO_ConstantDef_Remote_Proxy_Broker (void);
-};
-
-//
-//              End Remote Proxy Broker Declaration
-///////////////////////////////////////////////////////////////////////
-
-struct TAO_IFR_Client_Export IR_ConstantDescription
-{
-
-#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
-  typedef IR_ConstantDescription_var _var_type;
-#endif /* ! __GNUC__ || g++ >= 2.8 */
-
-  static void _tao_any_destructor (void*);
-
-  TAO_String_Manager name;
-  TAO_String_Manager id;
-  TAO_String_Manager defined_in;
-  TAO_String_Manager version;
-  CORBA::TypeCode_var type;
-  CORBA::Any value;
-};
-
-class TAO_IFR_Client_Export IR_ConstantDescription_var
-{
-public:
-  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 IR_ConstantDescription &in (void) const;
-  IR_ConstantDescription &inout (void);
-  IR_ConstantDescription *&out (void);
-  IR_ConstantDescription *_retn (void);
-  IR_ConstantDescription *ptr (void) const;
-
-private:
-  IR_ConstantDescription *ptr_;
-};
-
-class TAO_IFR_Client_Export IR_ConstantDescription_out
-{
-public:
-  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:
-  IR_ConstantDescription *&ptr_;
-  // assignment from T_var not allowed
-  void operator= (const IR_ConstantDescription_var &);
-};
-
-class TAO_IFR_Client_Export IR_TypedefDef_var : public TAO_Base_var
-{
-public:
-  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
-
-  IR_TypedefDef_var &operator= (IR_TypedefDef_ptr);
-  IR_TypedefDef_var &operator= (const IR_TypedefDef_var &);
-  IR_TypedefDef_ptr operator-> (void) const;
-
-  operator const IR_TypedefDef_ptr &() const;
-  operator IR_TypedefDef_ptr &();
-  // in, inout, out, _retn
-  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:
-  IR_TypedefDef_ptr ptr_;
-  // Unimplemented - prevents widening assignment.
-  IR_TypedefDef_var (const TAO_Base_var &rhs);
-  IR_TypedefDef_var &operator= (const TAO_Base_var &rhs);
-};
-
-class TAO_IFR_Client_Export IR_TypedefDef_out
-{
-public:
-  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:
-  IR_TypedefDef_ptr &ptr_;
-};
-
-// 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_IFR_Client_Export IR_TypedefDef: public virtual IR_Contained, public virtual IR_IDLType
-{
-public:
-#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
-  typedef IR_TypedefDef_ptr _ptr_type;
-  typedef IR_TypedefDef_var _var_type;
-#endif /* ! __GNUC__ || g++ >= 2.8 */
-
-  // the static operations
-  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 IR_TypedefDef_ptr _unchecked_narrow (
-      CORBA::Object_ptr obj,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    );
-  static IR_TypedefDef_ptr _nil (void)
-    {
-      return (IR_TypedefDef_ptr)0;
-    }
-
-  static void _tao_any_destructor (void*);
-
-  virtual CORBA::Boolean _is_a (
-      const CORBA::Char *type_id,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    );
-  virtual void *_tao_QueryInterface (ptr_arith_t type);
-
-  virtual const char* _interface_repository_id (void) const;
-
-private:
-  _TAO_TypedefDef_Proxy_Broker *the_TAO_TypedefDef_Proxy_Broker_;
-
-protected:
-  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 IR_TypedefDef_setup_collocation (int collocated);
-
-  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;
-
-  virtual ~IR_TypedefDef (void);
-private:
-  IR_TypedefDef (const IR_TypedefDef &);
-  void operator= (const IR_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 */
-
-};
-
-
-// The Proxy Implementations are used by each interface to
-// perform a call. Each different implementation encapsulate
-// an invocation logics.
-
-
-  ///////////////////////////////////////////////////////////////////////
-  //                    Base  Impl. Declaration
-  //
-
-  class TAO_IFR_Client_Export _TAO_TypedefDef_Proxy_Impl :
-    public virtual _TAO_Contained_Proxy_Impl,
-    public virtual _TAO_IDLType_Proxy_Impl
-  {
-  public:
-    virtual ~_TAO_TypedefDef_Proxy_Impl (void) { }
-
-  protected:
-    _TAO_TypedefDef_Proxy_Impl (void);
-
-  };
-
-//
-//                Base  Proxy Impl. Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//                    Remote  Impl. Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_TypedefDef_Remote_Proxy_Impl :
-  public virtual _TAO_TypedefDef_Proxy_Impl,
-  public virtual TAO_Remote_Object_Proxy_Impl,
-  public virtual _TAO_Contained_Remote_Proxy_Impl,
-  public virtual _TAO_IDLType_Remote_Proxy_Impl
-
-{
-public:
-  _TAO_TypedefDef_Remote_Proxy_Impl (void);
-
-  virtual ~_TAO_TypedefDef_Remote_Proxy_Impl (void) { }
-
-};
-
-//
-//                Base  Proxy Impl. Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-// The Proxy Brokers are used by each interface to get
-// the right proxy for performing a call. In the new
-// collocation scheme, the proxy to be used can vary on
-// a call by call basis.
-
-
-
-///////////////////////////////////////////////////////////////////////
-//                 Base Proxy Broker Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_TypedefDef_Proxy_Broker
-{
-public:
-  virtual ~_TAO_TypedefDef_Proxy_Broker (void);
-  virtual _TAO_TypedefDef_Proxy_Impl &select_proxy (
-    IR_TypedefDef *object,
-    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-  ) = 0;
-
-protected:
-  _TAO_TypedefDef_Proxy_Broker (void);
-
-};
-
-
-//
-//              End Base Proxy Broker Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//                 Remote Proxy Broker Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_TypedefDef_Remote_Proxy_Broker : public virtual _TAO_TypedefDef_Proxy_Broker
-{
-public:
-  _TAO_TypedefDef_Remote_Proxy_Broker (void);
-
-  virtual ~_TAO_TypedefDef_Remote_Proxy_Broker (void);
-
-  virtual _TAO_TypedefDef_Proxy_Impl &select_proxy (
-    IR_TypedefDef *object,
-    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-  );
-
-private:
-  _TAO_TypedefDef_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_TypedefDef_Remote_Proxy_Broker *the_TAO_TypedefDef_Remote_Proxy_Broker (void);
-};
-
-//
-//              End Remote Proxy Broker Declaration
-///////////////////////////////////////////////////////////////////////
-
-struct TAO_IFR_Client_Export IR_TypeDescription
-{
-
-#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
-  typedef IR_TypeDescription_var _var_type;
-#endif /* ! __GNUC__ || g++ >= 2.8 */
-
-  static void _tao_any_destructor (void*);
-
-  TAO_String_Manager name;
-  TAO_String_Manager id;
-  TAO_String_Manager defined_in;
-  TAO_String_Manager version;
-  CORBA::TypeCode_var type;
-};
-
-class TAO_IFR_Client_Export IR_TypeDescription_var
-{
-public:
-  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
-
-  IR_TypeDescription_var &operator= (IR_TypeDescription *);
-  IR_TypeDescription_var &operator= (const IR_TypeDescription_var &);
-  IR_TypeDescription *operator-> (void);
-  const IR_TypeDescription *operator-> (void) const;
-
-  operator const IR_TypeDescription &() const;
-  operator IR_TypeDescription &();
-  operator IR_TypeDescription &() const;
-  operator IR_TypeDescription *&(); // variable-size types only
-
-  // in, inout, out, _retn
-  const IR_TypeDescription &in (void) const;
-  IR_TypeDescription &inout (void);
-  IR_TypeDescription *&out (void);
-  IR_TypeDescription *_retn (void);
-  IR_TypeDescription *ptr (void) const;
-
-private:
-  IR_TypeDescription *ptr_;
-};
-
-class TAO_IFR_Client_Export IR_TypeDescription_out
-{
-public:
-  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:
-  IR_TypeDescription *&ptr_;
-  // assignment from T_var not allowed
-  void operator= (const IR_TypeDescription_var &);
-};
-
-// 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_IFR_Client_Export IR_StructDef: public virtual IR_TypedefDef, public virtual IR_Container
-{
-public:
-#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
-  typedef IR_StructDef_ptr _ptr_type;
-  typedef IR_StructDef_var _var_type;
-#endif /* ! __GNUC__ || g++ >= 2.8 */
-
-  // the static operations
-  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 IR_StructDef_ptr _unchecked_narrow (
-      CORBA::Object_ptr obj,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    );
-  static IR_StructDef_ptr _nil (void)
-    {
-      return (IR_StructDef_ptr)0;
-    }
-
-  static void _tao_any_destructor (void*);
-
-  virtual IR_StructMemberSeq * members   (
-                  CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual void members   (
-            const IR_StructMemberSeq & members,
-      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_StructDef_Proxy_Broker *the_TAO_StructDef_Proxy_Broker_;
-
-protected:
-  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 IR_StructDef_setup_collocation (int collocated);
-
-  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 ~IR_StructDef (void);
-private:
-  IR_StructDef (const IR_StructDef &);
-  void operator= (const IR_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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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_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 */
-
-};
-
-
-// The Proxy Implementations are used by each interface to
-// perform a call. Each different implementation encapsulate
-// an invocation logics.
-
-
-///////////////////////////////////////////////////////////////////////
-//                    Base  Impl. Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_StructDef_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 (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  virtual void members (
-      CORBA_Object *_collocated_tao_target_,
-      const IR_StructMemberSeq & members,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-protected:
-  _TAO_StructDef_Proxy_Impl (void);
-
-};
-
-//
-//                Base  Proxy Impl. Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//                    Remote  Impl. Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_StructDef_Remote_Proxy_Impl :
-  public virtual _TAO_StructDef_Proxy_Impl,
-  public virtual TAO_Remote_Object_Proxy_Impl,
-  public virtual _TAO_TypedefDef_Remote_Proxy_Impl,
-  public virtual _TAO_Container_Remote_Proxy_Impl
-
-{
-public:
-  _TAO_StructDef_Remote_Proxy_Impl (void);
-
-  virtual ~_TAO_StructDef_Remote_Proxy_Impl (void) { }
-
-  virtual IR_StructMemberSeq * members (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual void members (
-      CORBA_Object *_collocated_tao_target_,
-      const IR_StructMemberSeq & members,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-};
-
-//
-//                Base  Proxy Impl. Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-// The Proxy Brokers are used by each interface to get
-// the right proxy for performing a call. In the new
-// collocation scheme, the proxy to be used can vary on
-// a call by call basis.
-
-
-
-///////////////////////////////////////////////////////////////////////
-//                 Base Proxy Broker Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_StructDef_Proxy_Broker
-{
-public:
-  virtual ~_TAO_StructDef_Proxy_Broker (void);
-
-  virtual _TAO_StructDef_Proxy_Impl &select_proxy (
-    IR_StructDef *object,
-    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-  ) = 0;
-
-protected:
-  _TAO_StructDef_Proxy_Broker (void);
-
-};
-
-
-//
-//              End Base Proxy Broker Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//                 Remote Proxy Broker Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_StructDef_Remote_Proxy_Broker : public virtual _TAO_StructDef_Proxy_Broker
-{
-public:
-  _TAO_StructDef_Remote_Proxy_Broker (void);
-
-  virtual ~_TAO_StructDef_Remote_Proxy_Broker (void);
-
-  virtual _TAO_StructDef_Proxy_Impl &select_proxy (
-    IR_StructDef *object,
-    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-  );
-
-private:
-  _TAO_StructDef_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_StructDef_Remote_Proxy_Broker *the_TAO_StructDef_Remote_Proxy_Broker (void);
-};
-
-//
-//              End Remote Proxy Broker Declaration
-///////////////////////////////////////////////////////////////////////
-
-// 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_IFR_Client_Export IR_UnionDef: public virtual IR_TypedefDef, public virtual IR_Container
-{
-public:
-#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
-  typedef IR_UnionDef_ptr _ptr_type;
-  typedef IR_UnionDef_var _var_type;
-#endif /* ! __GNUC__ || g++ >= 2.8 */
-
-  // the static operations
-  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 IR_UnionDef_ptr _unchecked_narrow (
-      CORBA::Object_ptr obj,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    );
-  static IR_UnionDef_ptr _nil (void)
-    {
-      return (IR_UnionDef_ptr)0;
-    }
-
-  static void _tao_any_destructor (void*);
-
-  virtual CORBA::TypeCode_ptr discriminator_type (
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual IR_IDLType_ptr discriminator_type_def (
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual void discriminator_type_def (
-      IR_IDLType_ptr discriminator_type_def,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual IR_UnionMemberSeq * members (
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual void members (
-      const IR_UnionMemberSeq & members,
-      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_UnionDef_Proxy_Broker *the_TAO_UnionDef_Proxy_Broker_;
-
-protected:
-  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 IR_UnionDef_setup_collocation (int collocated);
-
-  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 ~IR_UnionDef (void);
-private:
- IR_UnionDef (const IR_UnionDef &);
-  void operator= (const IR_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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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));
-
-  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 */
-
-};
-
-
-// The Proxy Implementations are used by each interface to
-// perform a call. Each different implementation encapsulate
-// an invocation logics.
-
-
-///////////////////////////////////////////////////////////////////////
-//                    Base  Impl. Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_UnionDef_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 (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  virtual IR_IDLType_ptr discriminator_type_def (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  virtual void discriminator_type_def (
-      CORBA_Object *_collocated_tao_target_,
-      IR_IDLType_ptr discriminator_type_def,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  virtual IR_UnionMemberSeq * members (
-      CORBA_Object *_collocated_tao_target_,
-            CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  virtual void members   (
-      CORBA_Object *_collocated_tao_target_,
-      const IR_UnionMemberSeq & members,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-protected:
-  _TAO_UnionDef_Proxy_Impl (void);
-
-};
-
-//
-//                Base  Proxy Impl. Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//                    Remote  Impl. Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_UnionDef_Remote_Proxy_Impl :
-  public virtual _TAO_UnionDef_Proxy_Impl,
-  public virtual TAO_Remote_Object_Proxy_Impl,
-  public virtual _TAO_TypedefDef_Remote_Proxy_Impl,
-  public virtual _TAO_Container_Remote_Proxy_Impl
-
-{
-public:
-  _TAO_UnionDef_Remote_Proxy_Impl (void);
-
-  virtual ~_TAO_UnionDef_Remote_Proxy_Impl (void) { }
-
-  virtual CORBA::TypeCode_ptr discriminator_type (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual IR_IDLType_ptr discriminator_type_def (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual void discriminator_type_def (
-      CORBA_Object *_collocated_tao_target_,
-      IR_IDLType_ptr discriminator_type_def,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual IR_UnionMemberSeq * members (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual void members (
-      CORBA_Object *_collocated_tao_target_,
-      const IR_UnionMemberSeq & members,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-};
-
-//
-//                Base  Proxy Impl. Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-// The Proxy Brokers are used by each interface to get
-// the right proxy for performing a call. In the new
-// collocation scheme, the proxy to be used can vary on
-// a call by call basis.
-
-
-
-///////////////////////////////////////////////////////////////////////
-//                 Base Proxy Broker Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_UnionDef_Proxy_Broker
-{
-public:
-  virtual ~_TAO_UnionDef_Proxy_Broker (void);
-
-  virtual _TAO_UnionDef_Proxy_Impl &select_proxy (
-    IR_UnionDef *object,
-    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-  ) = 0;
-
-protected:
-  _TAO_UnionDef_Proxy_Broker (void);
-
-};
-
-
-//
-//              End Base Proxy Broker Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//                 Remote Proxy Broker Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_UnionDef_Remote_Proxy_Broker : public virtual _TAO_UnionDef_Proxy_Broker
-{
-public:
-  _TAO_UnionDef_Remote_Proxy_Broker (void);
-
-  virtual ~_TAO_UnionDef_Remote_Proxy_Broker (void);
-
-  virtual _TAO_UnionDef_Proxy_Impl &select_proxy (
-    IR_UnionDef *object,
-    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-  );
-
-private:
-  _TAO_UnionDef_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_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;
-
-class TAO_IFR_Client_Export IR_EnumDef: public virtual IR_TypedefDef
-{
-public:
-#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
-  typedef IR_EnumDef_ptr _ptr_type;
-  typedef IR_EnumDef_var _var_type;
-#endif /* ! __GNUC__ || g++ >= 2.8 */
-
-  // the static operations
-  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 IR_EnumDef_ptr _unchecked_narrow (
-      CORBA::Object_ptr obj,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    );
-  static IR_EnumDef_ptr _nil (void)
-    {
-      return (IR_EnumDef_ptr)0;
-    }
-
-  static void _tao_any_destructor (void*);
-
-  virtual IR_EnumMemberSeq * members (
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual void members (
-      const IR_EnumMemberSeq & members,
-      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_EnumDef_Proxy_Broker *the_TAO_EnumDef_Proxy_Broker_;
-
-protected:
-  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 IR_EnumDef_setup_collocation (int collocated);
-
-  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 ~IR_EnumDef (void);
-private:
-  IR_EnumDef (const IR_EnumDef &);
-  void operator= (const IR_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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _tao_target,
-        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_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 */
-
-};
-
-
-// The Proxy Implementations are used by each interface to
-// perform a call. Each different implementation encapsulate
-// an invocation logics.
-
-
-///////////////////////////////////////////////////////////////////////
-//                    Base  Impl. Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_EnumDef_Proxy_Impl :
-  public virtual _TAO_TypedefDef_Proxy_Impl
-{
-public:
-  virtual ~_TAO_EnumDef_Proxy_Impl (void) { }
-
-  virtual IR_EnumMemberSeq * members (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  virtual void members   (
-      CORBA_Object *_collocated_tao_target_,
-      const IR_EnumMemberSeq & members,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-protected:
-  _TAO_EnumDef_Proxy_Impl (void);
-
-};
-
-//
-//                Base  Proxy Impl. Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//                    Remote  Impl. Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_EnumDef_Remote_Proxy_Impl :
-  public virtual _TAO_EnumDef_Proxy_Impl,
-  public virtual TAO_Remote_Object_Proxy_Impl,
-  public virtual _TAO_TypedefDef_Remote_Proxy_Impl
-
-{
-public:
-  _TAO_EnumDef_Remote_Proxy_Impl (void);
-
-  virtual ~_TAO_EnumDef_Remote_Proxy_Impl (void) { }
-
-  virtual IR_EnumMemberSeq * members (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual void members (
-      CORBA_Object *_collocated_tao_target_,
-      const IR_EnumMemberSeq & members,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-};
-
-//
-//                Base  Proxy Impl. Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-// The Proxy Brokers are used by each interface to get
-// the right proxy for performing a call. In the new
-// collocation scheme, the proxy to be used can vary on
-// a call by call basis.
-
-
-
-///////////////////////////////////////////////////////////////////////
-//                 Base Proxy Broker Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_EnumDef_Proxy_Broker
-{
-public:
-  virtual ~_TAO_EnumDef_Proxy_Broker (void);
-
-  virtual _TAO_EnumDef_Proxy_Impl &select_proxy (
-    IR_EnumDef *object,
-    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-  ) = 0;
-
-protected:
-  _TAO_EnumDef_Proxy_Broker (void);
-
-};
-
-
-//
-//              End Base Proxy Broker Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//                 Remote Proxy Broker Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_EnumDef_Remote_Proxy_Broker : public virtual _TAO_EnumDef_Proxy_Broker
-{
-public:
-  _TAO_EnumDef_Remote_Proxy_Broker (void);
-
-  virtual ~_TAO_EnumDef_Remote_Proxy_Broker (void);
-
-  virtual _TAO_EnumDef_Proxy_Impl &select_proxy (
-    IR_EnumDef *object,
-    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-  );
-
-private:
-  _TAO_EnumDef_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_EnumDef_Remote_Proxy_Broker *the_TAO_EnumDef_Remote_Proxy_Broker (void);
-};
-
-//
-//              End Remote Proxy Broker Declaration
-///////////////////////////////////////////////////////////////////////
-
-// 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_IFR_Client_Export IR_AliasDef: public virtual IR_TypedefDef
-{
-public:
-#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
-  typedef IR_AliasDef_ptr _ptr_type;
-  typedef IR_AliasDef_var _var_type;
-#endif /* ! __GNUC__ || g++ >= 2.8 */
-
-  // the static operations
-  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 IR_AliasDef_ptr _unchecked_narrow (
-      CORBA::Object_ptr obj,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    );
-  static IR_AliasDef_ptr _nil (void)
-    {
-      return (IR_AliasDef_ptr)0;
-    }
-
-  static void _tao_any_destructor (void*);
-
-  virtual IR_IDLType_ptr original_type_def (
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual void original_type_def   (
-      IR_IDLType_ptr original_type_def,
-      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_AliasDef_Proxy_Broker *the_TAO_AliasDef_Proxy_Broker_;
-
-protected:
-  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 IR_AliasDef_setup_collocation (int collocated);
-
-  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 ~IR_AliasDef (void);
-private:
-  IR_AliasDef (const IR_AliasDef &);
-  void operator= (const IR_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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _tao_target,
-        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_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 */
-
-};
-
-
-// The Proxy Implementations are used by each interface to
-// perform a call. Each different implementation encapsulate
-// an invocation logics.
-
-
-///////////////////////////////////////////////////////////////////////
-//                    Base  Impl. Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_AliasDef_Proxy_Impl :
-  public virtual _TAO_TypedefDef_Proxy_Impl
-{
-public:
-  virtual ~_TAO_AliasDef_Proxy_Impl (void) { }
-
-  virtual IR_IDLType_ptr original_type_def (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  virtual void original_type_def (
-      CORBA_Object *_collocated_tao_target_,
-      IR_IDLType_ptr original_type_def,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-protected:
-  _TAO_AliasDef_Proxy_Impl (void);
-
-};
-
-//
-//                Base  Proxy Impl. Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//                    Remote  Impl. Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_AliasDef_Remote_Proxy_Impl :
-  public virtual _TAO_AliasDef_Proxy_Impl,
-  public virtual TAO_Remote_Object_Proxy_Impl,
-  public virtual _TAO_TypedefDef_Remote_Proxy_Impl
-
-{
-public:
-  _TAO_AliasDef_Remote_Proxy_Impl (void);
-
-  virtual ~_TAO_AliasDef_Remote_Proxy_Impl (void) { }
-
-  virtual IR_IDLType_ptr original_type_def (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual void original_type_def (
-      CORBA_Object *_collocated_tao_target_,
-      IR_IDLType_ptr original_type_def,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-};
-
-//
-//                Base  Proxy Impl. Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-// The Proxy Brokers are used by each interface to get
-// the right proxy for performing a call. In the new
-// collocation scheme, the proxy to be used can vary on
-// a call by call basis.
-
-
-
-///////////////////////////////////////////////////////////////////////
-//                 Base Proxy Broker Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_AliasDef_Proxy_Broker
-{
-public:
-  virtual ~_TAO_AliasDef_Proxy_Broker (void);
-
-  virtual _TAO_AliasDef_Proxy_Impl &select_proxy (
-    IR_AliasDef *object,
-    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-  ) = 0;
-
-protected:
-  _TAO_AliasDef_Proxy_Broker (void);
-
-};
-
-
-//
-//              End Base Proxy Broker Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//                 Remote Proxy Broker Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_AliasDef_Remote_Proxy_Broker : public virtual _TAO_AliasDef_Proxy_Broker
-{
-public:
-  _TAO_AliasDef_Remote_Proxy_Broker (void);
-
-  virtual ~_TAO_AliasDef_Remote_Proxy_Broker (void);
-
-  virtual _TAO_AliasDef_Proxy_Impl &select_proxy (
-    IR_AliasDef *object,
-    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-  );
-
-private:
-  _TAO_AliasDef_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_AliasDef_Remote_Proxy_Broker *the_TAO_AliasDef_Remote_Proxy_Broker (void);
-};
-
-//
-//              End Remote Proxy Broker Declaration
-///////////////////////////////////////////////////////////////////////
-
-// 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_IFR_Client_Export IR_NativeDef: public virtual IR_TypedefDef
-{
-public:
-#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
-  typedef IR_NativeDef_ptr _ptr_type;
-  typedef IR_NativeDef_var _var_type;
-#endif /* ! __GNUC__ || g++ >= 2.8 */
-
-  // the static operations
-  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 IR_NativeDef_ptr _unchecked_narrow (
-      CORBA::Object_ptr obj,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    );
-  static IR_NativeDef_ptr _nil (void)
-    {
-      return (IR_NativeDef_ptr)0;
-    }
-
-  static void _tao_any_destructor (void*);
-
-  virtual CORBA::Boolean _is_a (
-      const CORBA::Char *type_id,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    );
-  virtual void *_tao_QueryInterface (ptr_arith_t type);
-
-  virtual const char* _interface_repository_id (void) const;
-
-private:
-  _TAO_NativeDef_Proxy_Broker *the_TAO_NativeDef_Proxy_Broker_;
-
-protected:
-  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 IR_NativeDef_setup_collocation (int collocated);
-
-  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;
-
-  virtual ~IR_NativeDef (void);
-private:
-  IR_NativeDef (const IR_NativeDef &);
-  void operator= (const IR_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 */
-
-};
-
-
-// The Proxy Implementations are used by each interface to
-// perform a call. Each different implementation encapsulate
-// an invocation logics.
-
-
-///////////////////////////////////////////////////////////////////////
-//                    Base  Impl. Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_NativeDef_Proxy_Impl :
-  public virtual _TAO_TypedefDef_Proxy_Impl
-{
-public:
-  virtual ~_TAO_NativeDef_Proxy_Impl (void) { }
-
-protected:
-  _TAO_NativeDef_Proxy_Impl (void);
-
-};
-
-//
-//                Base  Proxy Impl. Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//                    Remote  Impl. Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_NativeDef_Remote_Proxy_Impl :
-  public virtual _TAO_NativeDef_Proxy_Impl,
-  public virtual TAO_Remote_Object_Proxy_Impl,
-  public virtual _TAO_TypedefDef_Remote_Proxy_Impl
-
-{
-public:
-  _TAO_NativeDef_Remote_Proxy_Impl (void);
-
-  virtual ~_TAO_NativeDef_Remote_Proxy_Impl (void) { }
-
-};
-
-//
-//                Base  Proxy Impl. Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-// The Proxy Brokers are used by each interface to get
-// the right proxy for performing a call. In the new
-// collocation scheme, the proxy to be used can vary on
-// a call by call basis.
-
-
-
-///////////////////////////////////////////////////////////////////////
-//                 Base Proxy Broker Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_NativeDef_Proxy_Broker
-{
-public:
-  virtual ~_TAO_NativeDef_Proxy_Broker (void);
-
-  virtual _TAO_NativeDef_Proxy_Impl &select_proxy (
-    IR_NativeDef *object,
-    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-  ) = 0;
-
-protected:
-  _TAO_NativeDef_Proxy_Broker (void);
-
-};
-
-
-//
-//              End Base Proxy Broker Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//                 Remote Proxy Broker Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_NativeDef_Remote_Proxy_Broker : public virtual _TAO_NativeDef_Proxy_Broker
-{
-public:
-  _TAO_NativeDef_Remote_Proxy_Broker (void);
-
-  virtual ~_TAO_NativeDef_Remote_Proxy_Broker (void);
-
-  virtual _TAO_NativeDef_Proxy_Impl &select_proxy (
-    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);
-};
-
-//
-//              End Remote Proxy Broker Declaration
-///////////////////////////////////////////////////////////////////////
-
-// 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_IFR_Client_Export IR_PrimitiveDef: public virtual IR_IDLType
-{
-public:
-#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
-  typedef IR_PrimitiveDef_ptr _ptr_type;
-  typedef IR_PrimitiveDef_var _var_type;
-#endif /* ! __GNUC__ || g++ >= 2.8 */
-
-  // the static operations
-  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 IR_PrimitiveDef_ptr _unchecked_narrow (
-      CORBA::Object_ptr obj,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    );
-  static IR_PrimitiveDef_ptr _nil (void)
-    {
-      return (IR_PrimitiveDef_ptr)0;
-    }
-
-  static void _tao_any_destructor (void*);
-
-  virtual IR_PrimitiveKind kind (
-      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_PrimitiveDef_Proxy_Broker *the_TAO_PrimitiveDef_Proxy_Broker_;
-
-protected:
-  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 IR_PrimitiveDef_setup_collocation (int collocated);
-
-  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 ~IR_PrimitiveDef (void);
-private:
-  IR_PrimitiveDef (const IR_PrimitiveDef &);
-  void operator= (const IR_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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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;
-  };
-
-#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_IFR_Client_Export _TAO_PrimitiveDef_Proxy_Impl :
-  public virtual _TAO_IDLType_Proxy_Impl
-{
-public:
-  virtual ~_TAO_PrimitiveDef_Proxy_Impl (void) { }
-
-  virtual IR_PrimitiveKind kind (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-protected:
-  _TAO_PrimitiveDef_Proxy_Impl (void);
-
-};
-
-//
-//                Base  Proxy Impl. Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//                    Remote  Impl. Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_PrimitiveDef_Remote_Proxy_Impl :
-  public virtual _TAO_PrimitiveDef_Proxy_Impl,
-  public virtual TAO_Remote_Object_Proxy_Impl,
-  public virtual _TAO_IDLType_Remote_Proxy_Impl
-
-{
-public:
-  _TAO_PrimitiveDef_Remote_Proxy_Impl (void);
-
-  virtual ~_TAO_PrimitiveDef_Remote_Proxy_Impl (void) { }
-
-  virtual IR_PrimitiveKind kind (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-};
-
-//
-//                Base  Proxy Impl. Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-// The Proxy Brokers are used by each interface to get
-// the right proxy for performing a call. In the new
-// collocation scheme, the proxy to be used can vary on
-// a call by call basis.
-
-
-
-///////////////////////////////////////////////////////////////////////
-//                 Base Proxy Broker Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_PrimitiveDef_Proxy_Broker
-{
-public:
-  virtual ~_TAO_PrimitiveDef_Proxy_Broker (void);
-
-  virtual _TAO_PrimitiveDef_Proxy_Impl &select_proxy (
-    IR_PrimitiveDef *object,
-    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-  ) = 0;
-
-protected:
-  _TAO_PrimitiveDef_Proxy_Broker (void);
-
-};
-
-
-//
-//              End Base Proxy Broker Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//                 Remote Proxy Broker Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_PrimitiveDef_Remote_Proxy_Broker : public virtual _TAO_PrimitiveDef_Proxy_Broker
-{
-public:
-  _TAO_PrimitiveDef_Remote_Proxy_Broker (void);
-
-  virtual ~_TAO_PrimitiveDef_Remote_Proxy_Broker (void);
-
-  virtual _TAO_PrimitiveDef_Proxy_Impl &select_proxy (
-    IR_PrimitiveDef *object,
-    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-  );
-
-private:
-  _TAO_PrimitiveDef_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_PrimitiveDef_Remote_Proxy_Broker *the_TAO_PrimitiveDef_Remote_Proxy_Broker (void);
-};
-
-//
-//              End Remote Proxy Broker Declaration
-///////////////////////////////////////////////////////////////////////
-
-// 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_IFR_Client_Export IR_StringDef: public virtual IR_IDLType
-{
-public:
-#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
-  typedef IR_StringDef_ptr _ptr_type;
-  typedef IR_StringDef_var _var_type;
-#endif /* ! __GNUC__ || g++ >= 2.8 */
-
-  // the static operations
-  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 IR_StringDef_ptr _unchecked_narrow (
-      CORBA::Object_ptr obj,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    );
-  static IR_StringDef_ptr _nil (void)
-    {
-      return (IR_StringDef_ptr)0;
-    }
-
-  static void _tao_any_destructor (void*);
-
-  virtual CORBA::ULong bound (
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual void bound (
-      CORBA::ULong bound,
-      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_StringDef_Proxy_Broker *the_TAO_StringDef_Proxy_Broker_;
-
-protected:
-  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 IR_StringDef_setup_collocation (int collocated);
-
-  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 ~IR_StringDef (void);
-private:
-  IR_StringDef (const IR_StringDef &);
-  void operator= (const IR_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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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_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 */
-
-};
-
-
-// The Proxy Implementations are used by each interface to
-// perform a call. Each different implementation encapsulate
-// an invocation logics.
-
-
-///////////////////////////////////////////////////////////////////////
-//                    Base  Impl. Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_StringDef_Proxy_Impl :
-  public virtual _TAO_IDLType_Proxy_Impl
-{
-public:
-  virtual ~_TAO_StringDef_Proxy_Impl (void) { }
-
-  virtual CORBA::ULong bound (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  virtual void bound (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::ULong bound,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-protected:
-  _TAO_StringDef_Proxy_Impl (void);
-
-};
-
-//
-//                Base  Proxy Impl. Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//                    Remote  Impl. Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_StringDef_Remote_Proxy_Impl :
-  public virtual _TAO_StringDef_Proxy_Impl,
-  public virtual TAO_Remote_Object_Proxy_Impl,
-  public virtual _TAO_IDLType_Remote_Proxy_Impl
-
-{
-public:
-  _TAO_StringDef_Remote_Proxy_Impl (void);
-
-  virtual ~_TAO_StringDef_Remote_Proxy_Impl (void) { }
-
-  virtual CORBA::ULong bound (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual void bound (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::ULong bound,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-};
-
-//
-//                Base  Proxy Impl. Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-// The Proxy Brokers are used by each interface to get
-// the right proxy for performing a call. In the new
-// collocation scheme, the proxy to be used can vary on
-// a call by call basis.
-
-
-
-///////////////////////////////////////////////////////////////////////
-//                 Base Proxy Broker Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_StringDef_Proxy_Broker
-{
-public:
-  virtual ~_TAO_StringDef_Proxy_Broker (void);
-
-  virtual _TAO_StringDef_Proxy_Impl &select_proxy (
-    IR_StringDef *object,
-    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-  ) = 0;
-
-protected:
-  _TAO_StringDef_Proxy_Broker (void);
-
-};
-
-
-//
-//              End Base Proxy Broker Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//                 Remote Proxy Broker Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_StringDef_Remote_Proxy_Broker : public virtual _TAO_StringDef_Proxy_Broker
-{
-public:
-  _TAO_StringDef_Remote_Proxy_Broker (void);
-
-  virtual ~_TAO_StringDef_Remote_Proxy_Broker (void);
-
-  virtual _TAO_StringDef_Proxy_Impl &select_proxy (
-    IR_StringDef *object,
-    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-  );
-
-private:
-  _TAO_StringDef_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_StringDef_Remote_Proxy_Broker *the_TAO_StringDef_Remote_Proxy_Broker (void);
-};
-
-//
-//              End Remote Proxy Broker Declaration
-///////////////////////////////////////////////////////////////////////
-
-// 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_IFR_Client_Export IR_WstringDef: public virtual IR_IDLType
-{
-public:
-#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
-  typedef IR_WstringDef_ptr _ptr_type;
-  typedef IR_WstringDef_var _var_type;
-#endif /* ! __GNUC__ || g++ >= 2.8 */
-
-  // the static operations
-  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 IR_WstringDef_ptr _unchecked_narrow (
-      CORBA::Object_ptr obj,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    );
-  static IR_WstringDef_ptr _nil (void)
-    {
-      return (IR_WstringDef_ptr)0;
-    }
-
-  static void _tao_any_destructor (void*);
-
-  virtual CORBA::ULong bound (
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual void bound (
-      CORBA::ULong bound,
-      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_WstringDef_Proxy_Broker *the_TAO_WstringDef_Proxy_Broker_;
-
-protected:
-  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 IR_WstringDef_setup_collocation (int collocated);
-
-  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;
-
-  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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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;
-
-    TAO_ClientRequestInfo_IR_WstringDef_bound_set (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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_IFR_Client_Export _TAO_WstringDef_Proxy_Impl :
-  public virtual _TAO_IDLType_Proxy_Impl
-{
-public:
-  virtual ~_TAO_WstringDef_Proxy_Impl (void) { }
-
-  virtual CORBA::ULong bound (
-      CORBA_Object *_collocated_tao_target_,
-            CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  virtual void bound (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::ULong bound,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-protected:
-  _TAO_WstringDef_Proxy_Impl (void);
-
-};
-
-//
-//                Base  Proxy Impl. Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//                    Remote  Impl. Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_WstringDef_Remote_Proxy_Impl :
-  public virtual _TAO_WstringDef_Proxy_Impl,
-  public virtual TAO_Remote_Object_Proxy_Impl,
-  public virtual _TAO_IDLType_Remote_Proxy_Impl
-
-{
-public:
-  _TAO_WstringDef_Remote_Proxy_Impl (void);
-
-  virtual ~_TAO_WstringDef_Remote_Proxy_Impl (void) { }
-
-  virtual CORBA::ULong bound (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual void bound (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::ULong bound,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-};
-
-//
-//                Base  Proxy Impl. Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-// The Proxy Brokers are used by each interface to get
-// the right proxy for performing a call. In the new
-// collocation scheme, the proxy to be used can vary on
-// a call by call basis.
-
-
-
-///////////////////////////////////////////////////////////////////////
-//                 Base Proxy Broker Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_WstringDef_Proxy_Broker
-{
-public:
-  virtual ~_TAO_WstringDef_Proxy_Broker (void);
-
-  virtual _TAO_WstringDef_Proxy_Impl &select_proxy (
-    IR_WstringDef *object,
-    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-  ) = 0;
-
-protected:
-  _TAO_WstringDef_Proxy_Broker (void);
-
-};
-
-
-//
-//              End Base Proxy Broker Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//                 Remote Proxy Broker Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_WstringDef_Remote_Proxy_Broker : public virtual _TAO_WstringDef_Proxy_Broker
-{
-public:
-  _TAO_WstringDef_Remote_Proxy_Broker (void);
-
-  virtual ~_TAO_WstringDef_Remote_Proxy_Broker (void);
-
-  virtual _TAO_WstringDef_Proxy_Impl &select_proxy (
-    IR_WstringDef *object,
-    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-  );
-
-private:
-  _TAO_WstringDef_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_WstringDef_Remote_Proxy_Broker *the_TAO_WstringDef_Remote_Proxy_Broker (void);
-};
-
-//
-//              End Remote Proxy Broker Declaration
-///////////////////////////////////////////////////////////////////////
-
-// 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_IFR_Client_Export IR_FixedDef: public virtual IR_IDLType
-{
-public:
-#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
-  typedef IR_FixedDef_ptr _ptr_type;
-  typedef IR_FixedDef_var _var_type;
-#endif /* ! __GNUC__ || g++ >= 2.8 */
-
-  // the static operations
-  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 IR_FixedDef_ptr _unchecked_narrow (
-      CORBA::Object_ptr obj,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    );
-  static IR_FixedDef_ptr _nil (void)
-    {
-      return (IR_FixedDef_ptr)0;
-    }
-
-  static void _tao_any_destructor (void*);
-
-  virtual CORBA::UShort digits   (
-                  CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual void digits (
-      CORBA::UShort digits,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual CORBA::Short scale (
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual void scale (
-      CORBA::Short scale,
-      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_FixedDef_Proxy_Broker *the_TAO_FixedDef_Proxy_Broker_;
-
-protected:
-  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 IR_FixedDef_setup_collocation (int collocated);
-
-  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 ~IR_FixedDef (void);
-private:
-  IR_FixedDef (const IR_FixedDef &);
-  void operator= (const IR_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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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));
-
-  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 */
-
-};
-
-
-// The Proxy Implementations are used by each interface to
-// perform a call. Each different implementation encapsulate
-// an invocation logics.
-
-
-///////////////////////////////////////////////////////////////////////
-//                    Base  Impl. Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_FixedDef_Proxy_Impl :
-  public virtual _TAO_IDLType_Proxy_Impl
-{
-public:
-  virtual ~_TAO_FixedDef_Proxy_Impl (void) { }
-
-  virtual CORBA::UShort digits (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  virtual void digits (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::UShort digits,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  virtual CORBA::Short scale (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  virtual void scale (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Short scale,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-protected:
-  _TAO_FixedDef_Proxy_Impl (void);
-
-};
-
-//
-//                Base  Proxy Impl. Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//                    Remote  Impl. Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_FixedDef_Remote_Proxy_Impl :
-  public virtual _TAO_FixedDef_Proxy_Impl,
-  public virtual TAO_Remote_Object_Proxy_Impl,
-  public virtual _TAO_IDLType_Remote_Proxy_Impl
-
-{
-public:
-  _TAO_FixedDef_Remote_Proxy_Impl (void);
-
-  virtual ~_TAO_FixedDef_Remote_Proxy_Impl (void) { }
-
-  virtual CORBA::UShort digits (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual void digits (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::UShort digits,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual CORBA::Short scale (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual void scale (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Short scale,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-};
-
-//
-//                Base  Proxy Impl. Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-// The Proxy Brokers are used by each interface to get
-// the right proxy for performing a call. In the new
-// collocation scheme, the proxy to be used can vary on
-// a call by call basis.
-
-
-
-///////////////////////////////////////////////////////////////////////
-//                 Base Proxy Broker Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_FixedDef_Proxy_Broker
-{
-public:
-  virtual ~_TAO_FixedDef_Proxy_Broker (void);
-
-  virtual _TAO_FixedDef_Proxy_Impl &select_proxy (
-    IR_FixedDef *object,
-    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-  ) = 0;
-
-protected:
-  _TAO_FixedDef_Proxy_Broker (void);
-
-};
-
-
-//
-//              End Base Proxy Broker Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//                 Remote Proxy Broker Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_FixedDef_Remote_Proxy_Broker : public virtual _TAO_FixedDef_Proxy_Broker
-{
-public:
-  _TAO_FixedDef_Remote_Proxy_Broker (void);
-
-  virtual ~_TAO_FixedDef_Remote_Proxy_Broker (void);
-
-  virtual _TAO_FixedDef_Proxy_Impl &select_proxy (
-    IR_FixedDef *object,
-    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-  );
-
-private:
-  _TAO_FixedDef_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_FixedDef_Remote_Proxy_Broker *the_TAO_FixedDef_Remote_Proxy_Broker (void);
-};
-
-//
-//              End Remote Proxy Broker Declaration
-///////////////////////////////////////////////////////////////////////
-
-// 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_IFR_Client_Export IR_SequenceDef: public virtual IR_IDLType
-{
-public:
-#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
-  typedef IR_SequenceDef_ptr _ptr_type;
-  typedef IR_SequenceDef_var _var_type;
-#endif /* ! __GNUC__ || g++ >= 2.8 */
-
-  // the static operations
-  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 IR_SequenceDef_ptr _unchecked_narrow (
-      CORBA::Object_ptr obj,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    );
-  static IR_SequenceDef_ptr _nil (void)
-    {
-      return (IR_SequenceDef_ptr)0;
-    }
-
-  static void _tao_any_destructor (void*);
-
-  virtual CORBA::ULong bound (
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual void bound (
-      CORBA::ULong bound,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual CORBA::TypeCode_ptr element_type (
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual IR_IDLType_ptr element_type_def (
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual void element_type_def (
-      IR_IDLType_ptr element_type_def,
-      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_SequenceDef_Proxy_Broker *the_TAO_SequenceDef_Proxy_Broker_;
-
-protected:
-  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 IR_SequenceDef_setup_collocation (int collocated);
-
-  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;
-
-  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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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;
-
-    TAO_ClientRequestInfo_IR_SequenceDef_bound_set (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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_IFR_Client_Export _TAO_SequenceDef_Proxy_Impl :
-  public virtual _TAO_IDLType_Proxy_Impl
-{
-public:
-  virtual ~_TAO_SequenceDef_Proxy_Impl (void) { }
-
-  virtual CORBA::ULong bound (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  virtual void bound (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::ULong bound,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  virtual CORBA::TypeCode_ptr element_type (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  virtual IR_IDLType_ptr element_type_def (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  virtual void element_type_def   (
-      CORBA_Object *_collocated_tao_target_,
-      IR_IDLType_ptr element_type_def,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-protected:
-  _TAO_SequenceDef_Proxy_Impl (void);
-
-};
-
-
-//
-//                Base  Proxy Impl. Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//                    Remote  Impl. Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_SequenceDef_Remote_Proxy_Impl :
-  public virtual _TAO_SequenceDef_Proxy_Impl,
-  public virtual TAO_Remote_Object_Proxy_Impl,
-  public virtual _TAO_IDLType_Remote_Proxy_Impl
-
-{
-public:
-  _TAO_SequenceDef_Remote_Proxy_Impl (void);
-
-  virtual ~_TAO_SequenceDef_Remote_Proxy_Impl (void) { }
-
-  virtual CORBA::ULong bound (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual void bound (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::ULong bound,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual CORBA::TypeCode_ptr element_type(
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual IR_IDLType_ptr element_type_def (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual void element_type_def (
-      CORBA_Object *_collocated_tao_target_,
-      IR_IDLType_ptr element_type_def,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-};
-
-//
-//                Base  Proxy Impl. Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-// The Proxy Brokers are used by each interface to get
-// the right proxy for performing a call. In the new
-// collocation scheme, the proxy to be used can vary on
-// a call by call basis.
-
-
-
-///////////////////////////////////////////////////////////////////////
-//                 Base Proxy Broker Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_SequenceDef_Proxy_Broker
-{
-public:
-  virtual ~_TAO_SequenceDef_Proxy_Broker (void);
-
-  virtual _TAO_SequenceDef_Proxy_Impl &select_proxy (
-    IR_SequenceDef *object,
-    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-  ) = 0;
-
-protected:
-  _TAO_SequenceDef_Proxy_Broker (void);
-
-};
-
-
-//
-//              End Base Proxy Broker Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//                 Remote Proxy Broker Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_SequenceDef_Remote_Proxy_Broker : public virtual _TAO_SequenceDef_Proxy_Broker
-{
-public:
-  _TAO_SequenceDef_Remote_Proxy_Broker (void);
-
-  virtual ~_TAO_SequenceDef_Remote_Proxy_Broker (void);
-
-  virtual _TAO_SequenceDef_Proxy_Impl &select_proxy (
-    IR_SequenceDef *object,
-    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-  );
-
-private:
-  _TAO_SequenceDef_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_SequenceDef_Remote_Proxy_Broker *the_TAO_SequenceDef_Remote_Proxy_Broker (void);
-};
-
-//
-//              End Remote Proxy Broker Declaration
-///////////////////////////////////////////////////////////////////////
-
-// 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_IFR_Client_Export IR_ArrayDef: public virtual IR_IDLType
-{
-public:
-#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
-  typedef IR_ArrayDef_ptr _ptr_type;
-  typedef IR_ArrayDef_var _var_type;
-#endif /* ! __GNUC__ || g++ >= 2.8 */
-
-  // the static operations
-  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 IR_ArrayDef_ptr _unchecked_narrow (
-      CORBA::Object_ptr obj,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    );
-  static IR_ArrayDef_ptr _nil (void)
-    {
-      return (IR_ArrayDef_ptr)0;
-    }
-
-  static void _tao_any_destructor (void*);
-
-  virtual CORBA::ULong length (
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual void length (
-      CORBA::ULong length,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual CORBA::TypeCode_ptr element_type (
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual IR_IDLType_ptr element_type_def (
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual void element_type_def (
-      IR_IDLType_ptr element_type_def,
-      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_ArrayDef_Proxy_Broker *the_TAO_ArrayDef_Proxy_Broker_;
-
-protected:
-  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 IR_ArrayDef_setup_collocation (int collocated);
-
-  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 ~IR_ArrayDef (void);
-private:
-  IR_ArrayDef (const IR_ArrayDef &);
-  void operator= (const IR_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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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_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 */
-
-};
-
-
-// The Proxy Implementations are used by each interface to
-// perform a call. Each different implementation encapsulate
-// an invocation logics.
-
-
-///////////////////////////////////////////////////////////////////////
-//                    Base  Impl. Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_ArrayDef_Proxy_Impl :
-  public virtual _TAO_IDLType_Proxy_Impl
-{
-public:
-  virtual ~_TAO_ArrayDef_Proxy_Impl (void) { }
-
-  virtual CORBA::ULong length (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  virtual void length (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::ULong length,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  virtual CORBA::TypeCode_ptr element_type (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  virtual IR_IDLType_ptr element_type_def (
-      CORBA_Object *_collocated_tao_target_,
-            CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  virtual void element_type_def (
-      CORBA_Object *_collocated_tao_target_,
-      IR_IDLType_ptr element_type_def,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-protected:
-  _TAO_ArrayDef_Proxy_Impl (void);
-
-};
-
-//
-//                Base  Proxy Impl. Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//                    Remote  Impl. Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_ArrayDef_Remote_Proxy_Impl :
-  public virtual _TAO_ArrayDef_Proxy_Impl,
-  public virtual TAO_Remote_Object_Proxy_Impl,
-  public virtual _TAO_IDLType_Remote_Proxy_Impl
-
-{
-public:
-  _TAO_ArrayDef_Remote_Proxy_Impl (void);
-
-  virtual ~_TAO_ArrayDef_Remote_Proxy_Impl (void) { }
-
-  virtual CORBA::ULong length (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual void length (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::ULong length,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual CORBA::TypeCode_ptr element_type   (
-      CORBA_Object *_collocated_tao_target_,
-            CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual IR_IDLType_ptr element_type_def   (
-      CORBA_Object *_collocated_tao_target_,
-            CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual void element_type_def   (
-      CORBA_Object *_collocated_tao_target_,
-      IR_IDLType_ptr element_type_def,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-};
-
-//
-//                Base  Proxy Impl. Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-// The Proxy Brokers are used by each interface to get
-// the right proxy for performing a call. In the new
-// collocation scheme, the proxy to be used can vary on
-// a call by call basis.
-
-
-
-///////////////////////////////////////////////////////////////////////
-//                 Base Proxy Broker Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_ArrayDef_Proxy_Broker
-{
-public:
-  virtual ~_TAO_ArrayDef_Proxy_Broker (void);
-
-  virtual _TAO_ArrayDef_Proxy_Impl &select_proxy (
-    IR_ArrayDef *object,
-    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-  ) = 0;
-
-protected:
-  _TAO_ArrayDef_Proxy_Broker (void);
-
-};
-
-
-//
-//              End Base Proxy Broker Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//                 Remote Proxy Broker Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_ArrayDef_Remote_Proxy_Broker : public virtual _TAO_ArrayDef_Proxy_Broker
-{
-public:
-  _TAO_ArrayDef_Remote_Proxy_Broker (void);
-
-  virtual ~_TAO_ArrayDef_Remote_Proxy_Broker (void);
-
-  virtual _TAO_ArrayDef_Proxy_Impl &select_proxy (
-    IR_ArrayDef *object,
-    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-  );
-
-private:
-  _TAO_ArrayDef_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_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;
-
-class TAO_IFR_Client_Export IR_ExceptionDef
-  : public virtual IR_Contained,
-    public virtual IR_Container
-{
-public:
-#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 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 IR_ExceptionDef_ptr _unchecked_narrow (
-      CORBA::Object_ptr obj,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    );
-  static IR_ExceptionDef_ptr _nil (void)
-    {
-      return (IR_ExceptionDef_ptr)0;
-    }
-
-  static void _tao_any_destructor (void*);
-
-  virtual CORBA::TypeCode_ptr type (
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual IR_StructMemberSeq * members (
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual void members (
-      const IR_StructMemberSeq & members,
-      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_ExceptionDef_Proxy_Broker *the_TAO_ExceptionDef_Proxy_Broker_;
-
-protected:
-  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 IR_ExceptionDef_setup_collocation (int collocated);
-
-  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 ~IR_ExceptionDef (void);
-private:
-  IR_ExceptionDef (const IR_ExceptionDef &);
-  void operator= (const IR_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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 */
-
-};
-
-
-// The Proxy Implementations are used by each interface to
-// perform a call. Each different implementation encapsulate
-// an invocation logics.
-
-
-///////////////////////////////////////////////////////////////////////
-//                    Base  Impl. Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_ExceptionDef_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 (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  virtual IR_StructMemberSeq * members   (
-      CORBA_Object *_collocated_tao_target_,
-            CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  virtual void members   (
-      CORBA_Object *_collocated_tao_target_,
-      const IR_StructMemberSeq & members,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-protected:
-  _TAO_ExceptionDef_Proxy_Impl (void);
-
-};
-
-//
-//                Base  Proxy Impl. Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//                    Remote  Impl. Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_ExceptionDef_Remote_Proxy_Impl :
-  public virtual _TAO_ExceptionDef_Proxy_Impl,
-  public virtual TAO_Remote_Object_Proxy_Impl,
-  public virtual _TAO_Contained_Remote_Proxy_Impl,
-  public virtual _TAO_Container_Remote_Proxy_Impl
-
-{
-public:
-  _TAO_ExceptionDef_Remote_Proxy_Impl (void);
-
-  virtual ~_TAO_ExceptionDef_Remote_Proxy_Impl (void) { }
-
-  virtual CORBA::TypeCode_ptr type (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual IR_StructMemberSeq * members (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual void members (
-      CORBA_Object *_collocated_tao_target_,
-      const IR_StructMemberSeq & members,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-};
-
-//
-//                Base  Proxy Impl. Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-// The Proxy Brokers are used by each interface to get
-// the right proxy for performing a call. In the new
-// collocation scheme, the proxy to be used can vary on
-// a call by call basis.
-
-
-
-///////////////////////////////////////////////////////////////////////
-//                 Base Proxy Broker Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_ExceptionDef_Proxy_Broker
-{
-public:
-  virtual ~_TAO_ExceptionDef_Proxy_Broker (void);
-
-  virtual _TAO_ExceptionDef_Proxy_Impl &select_proxy (
-    IR_ExceptionDef *object,
-    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-  ) = 0;
-
-protected:
-  _TAO_ExceptionDef_Proxy_Broker (void);
-
-};
-
-
-//
-//              End Base Proxy Broker Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//                 Remote Proxy Broker Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_ExceptionDef_Remote_Proxy_Broker : public virtual _TAO_ExceptionDef_Proxy_Broker
-{
-public:
-  _TAO_ExceptionDef_Remote_Proxy_Broker (void);
-
-  virtual ~_TAO_ExceptionDef_Remote_Proxy_Broker (void);
-
-  virtual _TAO_ExceptionDef_Proxy_Impl &select_proxy (
-    IR_ExceptionDef *object,
-    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-  );
-
-private:
-  _TAO_ExceptionDef_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_ExceptionDef_Remote_Proxy_Broker *the_TAO_ExceptionDef_Remote_Proxy_Broker (void);
-};
-
-//
-//              End Remote Proxy Broker Declaration
-///////////////////////////////////////////////////////////////////////
-
-struct TAO_IFR_Client_Export IR_ExceptionDescription
-{
-
-#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
-  typedef IR_ExceptionDescription_var _var_type;
-#endif /* ! __GNUC__ || g++ >= 2.8 */
-
-  static void _tao_any_destructor (void*);
-
-  TAO_String_Manager name;
-  TAO_String_Manager id;
-  TAO_String_Manager defined_in;
-  TAO_String_Manager version;
-  CORBA::TypeCode_var type;
-};
-
-class TAO_IFR_Client_Export IR_ExceptionDescription_var
-{
-public:
-  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 IR_ExceptionDescription &in (void) const;
-  IR_ExceptionDescription &inout (void);
-  IR_ExceptionDescription *&out (void);
-  IR_ExceptionDescription *_retn (void);
-  IR_ExceptionDescription *ptr (void) const;
-
-private:
-  IR_ExceptionDescription *ptr_;
-};
-
-class TAO_IFR_Client_Export IR_ExceptionDescription_out
-{
-public:
-  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:
-  IR_ExceptionDescription *&ptr_;
-  // assignment from T_var not allowed
-  void operator= (const IR_ExceptionDescription_var &);
-};
-
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-
-  class _TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq : public TAO_Unbounded_Base_Sequence
-  {
-  public:
-    // = Initialization and termination methods.
-
-    _TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq (void);
-    _TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq (CORBA::ULong maximum);
-    _TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq (CORBA::ULong maximum,
-      CORBA::ULong length,
-      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 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);
-    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,
-        CORBA_Object *src,
-        CORBA_Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      );
-    virtual CORBA_Object* _upcast (void *src) const;
-
-  };
-
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
-
-// *************************************************************
-// IR_ExceptionDefSeq
-// *************************************************************
-
-class TAO_IFR_Client_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<IR_ExceptionDef,IR_ExceptionDef_var>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
-{
-public:
-  IR_ExceptionDefSeq (void); // default ctor
-  IR_ExceptionDefSeq (CORBA::ULong max); // uses max size
-  IR_ExceptionDefSeq (
-    CORBA::ULong max,
-    CORBA::ULong length,
-    IR_ExceptionDef_ptr *buffer,
-    CORBA::Boolean release = 0
-  );
-  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 IR_ExceptionDefSeq_var _var_type;
-#endif /* ! __GNUC__ || g++ >= 2.8 */
-
-};
-
-// *************************************************************
-// class IR_ExceptionDefSeq_var
-// *************************************************************
-
-class TAO_IFR_Client_Export IR_ExceptionDefSeq_var
-{
-public:
-  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
-
-  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 IR_ExceptionDefSeq &() const;
-  operator IR_ExceptionDefSeq &();
-  operator IR_ExceptionDefSeq &() const;
-  operator IR_ExceptionDefSeq *&(); // variable-size base types only
-
-  TAO_Object_Manager<IR_ExceptionDef, IR_ExceptionDef_var> operator[] (CORBA::ULong index);
-
-  // in, inout, out, _retn
-  const IR_ExceptionDefSeq &in (void) const;
-  IR_ExceptionDefSeq &inout (void);
-  IR_ExceptionDefSeq *&out (void);
-  IR_ExceptionDefSeq *_retn (void);
-  IR_ExceptionDefSeq *ptr (void) const;
-
-private:
-  IR_ExceptionDefSeq *ptr_;
-};
-
-class TAO_IFR_Client_Export IR_ExceptionDefSeq_out
-{
-public:
-  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:
-  IR_ExceptionDefSeq *&ptr_;
-  // assignment from T_var not allowed
-  void operator= (const IR_ExceptionDefSeq_var &);
-};
-
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-
-  class TAO_EXPORT_NESTED_MACRO _TAO_Unbounded_Sequence_IR_ExcDescriptionSeq : public TAO_Unbounded_Base_Sequence
-  {
-  public:
-    // = Initialization and termination methods.
-
-    _TAO_Unbounded_Sequence_IR_ExcDescriptionSeq (void); // Default constructor.
-    _TAO_Unbounded_Sequence_IR_ExcDescriptionSeq (CORBA::ULong maximum);
-    _TAO_Unbounded_Sequence_IR_ExcDescriptionSeq (CORBA::ULong maximum,
-      CORBA::ULong length,
-      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.
-    IR_ExceptionDescription &operator[] (CORBA::ULong i);
-    const IR_ExceptionDescription &operator[] (CORBA::ULong i) const;
-    // = Static operations.
-    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)
-
-    IR_ExceptionDescription *get_buffer (CORBA::Boolean orphan = 0);
-    const IR_ExceptionDescription *get_buffer (void) const;
-    void replace (CORBA::ULong max,
-      CORBA::ULong length,
-      IR_ExceptionDescription *data,
-      CORBA::Boolean release);
-  };
-
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
-
-// *************************************************************
-// IR_ExcDescriptionSeq
-// *************************************************************
-
-class TAO_IFR_Client_Export IR_ExcDescriptionSeq : public
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Sequence_IR_ExcDescriptionSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Sequence<IR_ExceptionDescription>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
-{
-public:
-  IR_ExcDescriptionSeq (void); // default ctor
-  IR_ExcDescriptionSeq (CORBA::ULong max); // uses max size
-  IR_ExcDescriptionSeq (
-    CORBA::ULong max,
-    CORBA::ULong length,
-    IR_ExceptionDescription *buffer,
-    CORBA::Boolean release = 0
-  );
-  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 IR_ExcDescriptionSeq_var _var_type;
-#endif /* ! __GNUC__ || g++ >= 2.8 */
-
-};
-
-// *************************************************************
-// class IR_ExcDescriptionSeq_var
-// *************************************************************
-
-class TAO_IFR_Client_Export IR_ExcDescriptionSeq_var
-{
-public:
-  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
-
-  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 IR_ExcDescriptionSeq &() const;
-  operator IR_ExcDescriptionSeq &();
-  operator IR_ExcDescriptionSeq &() const;
-  operator IR_ExcDescriptionSeq *&(); // variable-size base types only
-
-  IR_ExceptionDescription & operator[] (CORBA::ULong index);
-  const IR_ExceptionDescription & operator[] (CORBA::ULong index) const;
-
-  // in, inout, out, _retn
-  const IR_ExcDescriptionSeq &in (void) const;
-  IR_ExcDescriptionSeq &inout (void);
-  IR_ExcDescriptionSeq *&out (void);
-  IR_ExcDescriptionSeq *_retn (void);
-  IR_ExcDescriptionSeq *ptr (void) const;
-
-private:
-  IR_ExcDescriptionSeq *ptr_;
-};
-
-class TAO_IFR_Client_Export IR_ExcDescriptionSeq_out
-{
-public:
-  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:
-  IR_ExcDescriptionSeq *&ptr_;
-  // assignment from T_var not allowed
-  void operator= (const IR_ExcDescriptionSeq_var &);
-};
-
-class TAO_IFR_Client_Export IR_AttributeDef_var : public TAO_Base_var
-{
-public:
-  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
-
-  IR_AttributeDef_var &operator= (IR_AttributeDef_ptr);
-  IR_AttributeDef_var &operator= (const IR_AttributeDef_var &);
-  IR_AttributeDef_ptr operator-> (void) const;
-
-  operator const IR_AttributeDef_ptr &() const;
-  operator IR_AttributeDef_ptr &();
-  // in, inout, out, _retn
-  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:
-  IR_AttributeDef_ptr ptr_;
-  // Unimplemented - prevents widening assignment.
-  IR_AttributeDef_var (const TAO_Base_var &rhs);
-  IR_AttributeDef_var &operator= (const TAO_Base_var &rhs);
-};
-
-class TAO_IFR_Client_Export IR_AttributeDef_out
-{
-public:
-  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:
-  IR_AttributeDef_ptr &ptr_;
-};
-
-// 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_IFR_Client_Export IR_AttributeDef: public virtual IR_Contained
-{
-public:
-#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
-  typedef IR_AttributeDef_ptr _ptr_type;
-  typedef IR_AttributeDef_var _var_type;
-#endif /* ! __GNUC__ || g++ >= 2.8 */
-
-  // the static operations
-  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 IR_AttributeDef_ptr _unchecked_narrow (
-      CORBA::Object_ptr obj,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    );
-  static IR_AttributeDef_ptr _nil (void)
-    {
-      return (IR_AttributeDef_ptr)0;
-    }
-
-  static void _tao_any_destructor (void*);
-
-  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 =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual void type_def (
-      IR_IDLType_ptr type_def,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual IR_AttributeMode mode (
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual void mode (
-      IR_AttributeMode mode,
-      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_AttributeDef_Proxy_Broker *the_TAO_AttributeDef_Proxy_Broker_;
-
-protected:
-  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 IR_AttributeDef_setup_collocation (int collocated);
-
-  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 ~IR_AttributeDef (void);
-private:
-  IR_AttributeDef (const IR_AttributeDef &);
-  void operator= (const IR_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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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));
-
-  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 */
-
-};
-
-
-// The Proxy Implementations are used by each interface to
-// perform a call. Each different implementation encapsulate
-// an invocation logics.
-
-
-///////////////////////////////////////////////////////////////////////
-//                    Base  Impl. Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_AttributeDef_Proxy_Impl :
-  public virtual _TAO_Contained_Proxy_Impl
-{
-public:
-  virtual ~_TAO_AttributeDef_Proxy_Impl (void) { }
-
-  virtual CORBA::TypeCode_ptr type (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  virtual IR_IDLType_ptr type_def (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  virtual void type_def (
-      CORBA_Object *_collocated_tao_target_,
-      IR_IDLType_ptr type_def,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  virtual IR_AttributeMode 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_AttributeMode mode,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-protected:
-  _TAO_AttributeDef_Proxy_Impl (void);
-
-};
-
-//
-//                Base  Proxy Impl. Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//                    Remote  Impl. Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_AttributeDef_Remote_Proxy_Impl :
-  public virtual _TAO_AttributeDef_Proxy_Impl,
-  public virtual TAO_Remote_Object_Proxy_Impl,
-  public virtual _TAO_Contained_Remote_Proxy_Impl
-
-{
-public:
-  _TAO_AttributeDef_Remote_Proxy_Impl (void);
-
-  virtual ~_TAO_AttributeDef_Remote_Proxy_Impl (void) { }
-
-  virtual CORBA::TypeCode_ptr type (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual IR_IDLType_ptr type_def (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual void type_def (
-      CORBA_Object *_collocated_tao_target_,
-      IR_IDLType_ptr type_def,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual IR_AttributeMode mode (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual void mode (
-      CORBA_Object *_collocated_tao_target_,
-      IR_AttributeMode mode,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-};
-
-//
-//                Base  Proxy Impl. Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-// The Proxy Brokers are used by each interface to get
-// the right proxy for performing a call. In the new
-// collocation scheme, the proxy to be used can vary on
-// a call by call basis.
-
-
-
-///////////////////////////////////////////////////////////////////////
-//                 Base Proxy Broker Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_AttributeDef_Proxy_Broker
-{
-public:
-  virtual ~_TAO_AttributeDef_Proxy_Broker (void);
-
-  virtual _TAO_AttributeDef_Proxy_Impl &select_proxy (
-    IR_AttributeDef *object,
-    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-  ) = 0;
-
-protected:
-  _TAO_AttributeDef_Proxy_Broker (void);
-
-};
-
-
-//
-//              End Base Proxy Broker Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//                 Remote Proxy Broker Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_AttributeDef_Remote_Proxy_Broker : public virtual _TAO_AttributeDef_Proxy_Broker
-{
-public:
-  _TAO_AttributeDef_Remote_Proxy_Broker (void);
-
-  virtual ~_TAO_AttributeDef_Remote_Proxy_Broker (void);
-
-  virtual _TAO_AttributeDef_Proxy_Impl &select_proxy (
-    IR_AttributeDef *object,
-    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-  );
-
-private:
-  _TAO_AttributeDef_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_AttributeDef_Remote_Proxy_Broker *the_TAO_AttributeDef_Remote_Proxy_Broker (void);
-};
-
-//
-//              End Remote Proxy Broker Declaration
-///////////////////////////////////////////////////////////////////////
-
-struct TAO_IFR_Client_Export IR_AttributeDescription
-{
-
-#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
-  typedef IR_AttributeDescription_var _var_type;
-#endif /* ! __GNUC__ || g++ >= 2.8 */
-
-  static void _tao_any_destructor (void*);
-
-  TAO_String_Manager name;
-  TAO_String_Manager id;
-  TAO_String_Manager defined_in;
-  TAO_String_Manager version;
-  CORBA::TypeCode_var type;
-  IR_AttributeMode mode;
-  IR_ExcDescriptionSeq get_exceptions;
-  IR_ExcDescriptionSeq put_exceptions;
-};
-
-class TAO_IFR_Client_Export IR_AttributeDescription_var
-{
-public:
-  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
-
-  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 IR_AttributeDescription &() const;
-  operator IR_AttributeDescription &();
-  operator IR_AttributeDescription &() const;
-  operator IR_AttributeDescription *&(); // variable-size types only
-
-  // in, inout, out, _retn
-  const IR_AttributeDescription &in (void) const;
-  IR_AttributeDescription &inout (void);
-  IR_AttributeDescription *&out (void);
-  IR_AttributeDescription *_retn (void);
-  IR_AttributeDescription *ptr (void) const;
-
-private:
-  IR_AttributeDescription *ptr_;
-};
-
-class TAO_IFR_Client_Export IR_AttributeDescription_out
-{
-public:
-  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:
-  IR_AttributeDescription *&ptr_;
-  // assignment from T_var not allowed
-  void operator= (const IR_AttributeDescription_var &);
-};
-
-struct TAO_IFR_Client_Export IR_ParameterDescription
-{
-
-#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
-  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;
-  IR_IDLType_var type_def;
-  IR_ParameterMode mode;
-};
-
-class TAO_IFR_Client_Export IR_ParameterDescription_var
-{
-public:
-  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
-
-  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 IR_ParameterDescription &() const;
-  operator IR_ParameterDescription &();
-  operator IR_ParameterDescription &() const;
-  operator IR_ParameterDescription *&(); // variable-size types only
-
-  // in, inout, out, _retn
-  const IR_ParameterDescription &in (void) const;
-  IR_ParameterDescription &inout (void);
-  IR_ParameterDescription *&out (void);
-  IR_ParameterDescription *_retn (void);
-  IR_ParameterDescription *ptr (void) const;
-
-private:
-  IR_ParameterDescription *ptr_;
-};
-
-class TAO_IFR_Client_Export IR_ParameterDescription_out
-{
-public:
-  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:
-  IR_ParameterDescription *&ptr_;
-  // assignment from T_var not allowed
-  void operator= (const IR_ParameterDescription_var &);
-};
-
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-
-  class TAO_EXPORT_NESTED_MACRO _TAO_Unbounded_Sequence_IR_ParDescriptionSeq : public TAO_Unbounded_Base_Sequence
-  {
-  public:
-    // = Initialization and termination methods.
-
-    _TAO_Unbounded_Sequence_IR_ParDescriptionSeq (void); // Default constructor.
-    _TAO_Unbounded_Sequence_IR_ParDescriptionSeq (CORBA::ULong maximum);
-    _TAO_Unbounded_Sequence_IR_ParDescriptionSeq (CORBA::ULong maximum,
-      CORBA::ULong length,
-      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.
-    IR_ParameterDescription &operator[] (CORBA::ULong i);
-    const IR_ParameterDescription &operator[] (CORBA::ULong i) const;
-    // = Static operations.
-    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)
-
-    IR_ParameterDescription *get_buffer (CORBA::Boolean orphan = 0);
-    const IR_ParameterDescription *get_buffer (void) const;
-    void replace (CORBA::ULong max,
-      CORBA::ULong length,
-      IR_ParameterDescription *data,
-      CORBA::Boolean release);
-  };
-
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
-
-// *************************************************************
-// IR_ParDescriptionSeq
-// *************************************************************
-
-class TAO_IFR_Client_Export IR_ParDescriptionSeq : public
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Sequence_IR_ParDescriptionSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Sequence<IR_ParameterDescription>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
-{
-public:
-  IR_ParDescriptionSeq (void); // default ctor
-  IR_ParDescriptionSeq (CORBA::ULong max); // uses max size
-  IR_ParDescriptionSeq (
-    CORBA::ULong max,
-    CORBA::ULong length,
-    IR_ParameterDescription *buffer,
-    CORBA::Boolean release = 0
-  );
-  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 IR_ParDescriptionSeq_var _var_type;
-#endif /* ! __GNUC__ || g++ >= 2.8 */
-
-};
-
-// *************************************************************
-// class IR_ParDescriptionSeq_var
-// *************************************************************
-
-class TAO_IFR_Client_Export IR_ParDescriptionSeq_var
-{
-public:
-  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
-
-  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 IR_ParDescriptionSeq &() const;
-  operator IR_ParDescriptionSeq &();
-  operator IR_ParDescriptionSeq &() const;
-  operator IR_ParDescriptionSeq *&(); // variable-size base types only
-
-  IR_ParameterDescription & operator[] (CORBA::ULong index);
-  const IR_ParameterDescription & operator[] (CORBA::ULong index) const;
-
-  // in, inout, out, _retn
-  const IR_ParDescriptionSeq &in (void) const;
-  IR_ParDescriptionSeq &inout (void);
-  IR_ParDescriptionSeq *&out (void);
-  IR_ParDescriptionSeq *_retn (void);
-  IR_ParDescriptionSeq *ptr (void) const;
-
-private:
-  IR_ParDescriptionSeq *ptr_;
-};
-
-class TAO_IFR_Client_Export IR_ParDescriptionSeq_out
-{
-public:
-  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:
-  IR_ParDescriptionSeq *&ptr_;
-  // assignment from T_var not allowed
-  void operator= (const IR_ParDescriptionSeq_var &);
-};
-
-// *************************************************************
-// IR_ContextIdSeq
-// *************************************************************
-
-class TAO_IFR_Client_Export IR_ContextIdSeq : public
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  TAO_Unbounded_String_Sequence
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_String_Sequence
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
-{
-public:
-  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
-  );
-  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 IR_ContextIdSeq_var _var_type;
-#endif /* ! __GNUC__ || g++ >= 2.8 */
-
-};
-
-// *************************************************************
-// class IR_ContextIdSeq_var
-// *************************************************************
-
-class TAO_IFR_Client_Export IR_ContextIdSeq_var
-{
-public:
-  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
-
-  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 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 IR_ContextIdSeq &in (void) const;
-  IR_ContextIdSeq &inout (void);
-  IR_ContextIdSeq *&out (void);
-  IR_ContextIdSeq *_retn (void);
-  IR_ContextIdSeq *ptr (void) const;
-
-private:
-  IR_ContextIdSeq *ptr_;
-};
-
-class TAO_IFR_Client_Export IR_ContextIdSeq_out
-{
-public:
-  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:
-  IR_ContextIdSeq *&ptr_;
-  // assignment from T_var not allowed
-  void operator= (const IR_ContextIdSeq_var &);
-};
-
-class TAO_IFR_Client_Export IR_OperationDef_var : public TAO_Base_var
-{
-public:
-  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
-
-  IR_OperationDef_var &operator= (IR_OperationDef_ptr);
-  IR_OperationDef_var &operator= (const IR_OperationDef_var &);
-  IR_OperationDef_ptr operator-> (void) const;
-
-  operator const IR_OperationDef_ptr &() const;
-  operator IR_OperationDef_ptr &();
-  // in, inout, out, _retn
-  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:
-  IR_OperationDef_ptr ptr_;
-  // Unimplemented - prevents widening assignment.
-  IR_OperationDef_var (const TAO_Base_var &rhs);
-  IR_OperationDef_var &operator= (const TAO_Base_var &rhs);
-};
-
-class TAO_IFR_Client_Export IR_OperationDef_out
-{
-public:
-  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:
-  IR_OperationDef_ptr &ptr_;
-};
-
-// 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_IFR_Client_Export IR_OperationDef: public virtual IR_Contained
-{
-public:
-#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
-  typedef IR_OperationDef_ptr _ptr_type;
-  typedef IR_OperationDef_var _var_type;
-#endif /* ! __GNUC__ || g++ >= 2.8 */
-
-  // the static operations
-  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 IR_OperationDef_ptr _unchecked_narrow (
-      CORBA::Object_ptr obj,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    );
-  static IR_OperationDef_ptr _nil (void)
-    {
-      return (IR_OperationDef_ptr)0;
-    }
-
-  static void _tao_any_destructor (void*);
-
-  virtual CORBA::TypeCode_ptr result   (
-                  CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual IR_IDLType_ptr result_def (
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual void result_def (
-      IR_IDLType_ptr result_def,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual IR_ParDescriptionSeq * params (
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual void params (
-      const IR_ParDescriptionSeq & params,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual IR_OperationMode mode (
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual void mode (
-      IR_OperationMode mode,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual IR_ContextIdSeq * contexts (
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual void contexts (
-      const IR_ContextIdSeq & contexts,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual IR_ExceptionDefSeq * exceptions (
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual void exceptions (
-      const IR_ExceptionDefSeq & exceptions,
-      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_OperationDef_Proxy_Broker *the_TAO_OperationDef_Proxy_Broker_;
-
-protected:
-  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 IR_OperationDef_setup_collocation (int collocated);
-
-  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 ~IR_OperationDef (void);
-private:
-  IR_OperationDef (const IR_OperationDef &);
-  void operator= (const IR_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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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;
-
-    TAO_ClientRequestInfo_IR_OperationDef_result_def_set (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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));
-
-    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_;
-  
-  };
-
-  class TAO_ClientRequestInfo_IR_OperationDef_params_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_params_get (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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_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;
-  };
-
-  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;
-
-    TAO_ClientRequestInfo_IR_OperationDef_params_set (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _tao_target,
-        const IR_ParDescriptionSeq & params,
-        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_params_set (const TAO_ClientRequestInfo_IR_OperationDef_params_set &);
-    void operator= (const TAO_ClientRequestInfo_IR_OperationDef_params_set &);
-    const IR_ParDescriptionSeq & params_;
-  
-  };
-
-  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;
-
-    TAO_ClientRequestInfo_IR_OperationDef_mode_get (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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_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;
-  };
-
-  class TAO_ClientRequestInfo_IR_OperationDef_mode_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_mode_set (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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_IFR_Client_Export _TAO_OperationDef_Proxy_Impl :
-  public virtual _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_IFR_Client_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:
-  _TAO_OperationDef_Remote_Proxy_Impl (void);
-
-  virtual ~_TAO_OperationDef_Remote_Proxy_Impl (void) { }
-
-  virtual CORBA::TypeCode_ptr result (
-      CORBA_Object *_collocated_tao_target_,
-            CORBA::Environment &ACE_TRY_ENV
-    )
-    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
-    ));
-
-  virtual void result_def (
-      CORBA_Object *_collocated_tao_target_,
-      IR_IDLType_ptr result_def,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual IR_ParDescriptionSeq * params (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual void params (
-      CORBA_Object *_collocated_tao_target_,
-      const IR_ParDescriptionSeq & params,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual IR_OperationMode mode (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    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
-    ));
-
-  virtual IR_ContextIdSeq * contexts (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    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
-    ));
-
-  virtual IR_ExceptionDefSeq * exceptions (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual void exceptions (
-      CORBA_Object *_collocated_tao_target_,
-      const IR_ExceptionDefSeq & exceptions,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-};
-
-//
-//                Base  Proxy Impl. Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-// The Proxy Brokers are used by each interface to get
-// the right proxy for performing a call. In the new
-// collocation scheme, the proxy to be used can vary on
-// a call by call basis.
-
-
-
-///////////////////////////////////////////////////////////////////////
-//                 Base Proxy Broker Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_OperationDef_Proxy_Broker
-{
-public:
-  virtual ~_TAO_OperationDef_Proxy_Broker (void);
-
-  virtual _TAO_OperationDef_Proxy_Impl &select_proxy (
-    IR_OperationDef *object,
-    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-  ) = 0;
-
-protected:
-  _TAO_OperationDef_Proxy_Broker (void);
-
-};
-
-
-//
-//              End Base Proxy Broker Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//                 Remote Proxy Broker Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_OperationDef_Remote_Proxy_Broker : public virtual _TAO_OperationDef_Proxy_Broker
-{
-public:
-  _TAO_OperationDef_Remote_Proxy_Broker (void);
-
-  virtual ~_TAO_OperationDef_Remote_Proxy_Broker (void);
-
-  virtual _TAO_OperationDef_Proxy_Impl &select_proxy (
-    IR_OperationDef *object,
-    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-  );
-
-private:
-  _TAO_OperationDef_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_OperationDef_Remote_Proxy_Broker *the_TAO_OperationDef_Remote_Proxy_Broker (void);
-};
-
-//
-//              End Remote Proxy Broker Declaration
-///////////////////////////////////////////////////////////////////////
-
-struct TAO_IFR_Client_Export IR_OperationDescription
-{
-
-#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
-  typedef IR_OperationDescription_var _var_type;
-#endif /* ! __GNUC__ || g++ >= 2.8 */
-
-  static void _tao_any_destructor (void*);
-
-  TAO_String_Manager name;
-  TAO_String_Manager id;
-  TAO_String_Manager defined_in;
-  TAO_String_Manager version;
-  CORBA::TypeCode_var result;
-  IR_OperationMode mode;
-  IR_ContextIdSeq contexts;
-  IR_ParDescriptionSeq parameters;
-  IR_ExcDescriptionSeq exceptions;
-};
-
-class TAO_IFR_Client_Export IR_OperationDescription_var
-{
-public:
-  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
-
-  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 IR_OperationDescription &() const;
-  operator IR_OperationDescription &();
-  operator IR_OperationDescription &() const;
-  operator IR_OperationDescription *&(); // variable-size types only
-
-  // in, inout, out, _retn
-  const IR_OperationDescription &in (void) const;
-  IR_OperationDescription &inout (void);
-  IR_OperationDescription *&out (void);
-  IR_OperationDescription *_retn (void);
-  IR_OperationDescription *ptr (void) const;
-
-private:
-  IR_OperationDescription *ptr_;
-};
-
-class TAO_IFR_Client_Export IR_OperationDescription_out
-{
-public:
-  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:
-  IR_OperationDescription *&ptr_;
-  // assignment from T_var not allowed
-  void operator= (const IR_OperationDescription_var &);
-};
-
-// *************************************************************
-// IR_RepositoryIdSeq
-// *************************************************************
-
-class TAO_IFR_Client_Export IR_RepositoryIdSeq : public
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  TAO_Unbounded_String_Sequence
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_String_Sequence
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
-{
-public:
-  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
-  );
-  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 IR_RepositoryIdSeq_var _var_type;
-#endif /* ! __GNUC__ || g++ >= 2.8 */
-
-};
-
-// *************************************************************
-// class IR_RepositoryIdSeq_var
-// *************************************************************
-
-class TAO_IFR_Client_Export IR_RepositoryIdSeq_var
-{
-public:
-  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
-
-  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 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 IR_RepositoryIdSeq &in (void) const;
-  IR_RepositoryIdSeq &inout (void);
-  IR_RepositoryIdSeq *&out (void);
-  IR_RepositoryIdSeq *_retn (void);
-  IR_RepositoryIdSeq *ptr (void) const;
-
-private:
-  IR_RepositoryIdSeq *ptr_;
-};
-
-class TAO_IFR_Client_Export IR_RepositoryIdSeq_out
-{
-public:
-  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:
-  IR_RepositoryIdSeq *&ptr_;
-  // assignment from T_var not allowed
-  void operator= (const IR_RepositoryIdSeq_var &);
-};
-
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-
-  class TAO_EXPORT_NESTED_MACRO _TAO_Unbounded_Sequence_IR_OpDescriptionSeq : public TAO_Unbounded_Base_Sequence
-  {
-  public:
-    // = Initialization and termination methods.
-
-    _TAO_Unbounded_Sequence_IR_OpDescriptionSeq (void); // Default constructor.
-    _TAO_Unbounded_Sequence_IR_OpDescriptionSeq (CORBA::ULong maximum);
-    _TAO_Unbounded_Sequence_IR_OpDescriptionSeq (CORBA::ULong maximum,
-      CORBA::ULong length,
-      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.
-    IR_OperationDescription &operator[] (CORBA::ULong i);
-    const IR_OperationDescription &operator[] (CORBA::ULong i) const;
-    // = Static operations.
-    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)
-
-    IR_OperationDescription *get_buffer (CORBA::Boolean orphan = 0);
-    const IR_OperationDescription *get_buffer (void) const;
-    void replace (CORBA::ULong max,
-      CORBA::ULong length,
-      IR_OperationDescription *data,
-      CORBA::Boolean release);
-  };
-
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
-
-// *************************************************************
-// IR_OpDescriptionSeq
-// *************************************************************
-
-class TAO_IFR_Client_Export IR_OpDescriptionSeq : public
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Sequence_IR_OpDescriptionSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Sequence<IR_OperationDescription>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
-{
-public:
-  IR_OpDescriptionSeq (void); // default ctor
-  IR_OpDescriptionSeq (CORBA::ULong max); // uses max size
-  IR_OpDescriptionSeq (
-    CORBA::ULong max,
-    CORBA::ULong length,
-    IR_OperationDescription *buffer,
-    CORBA::Boolean release = 0
-  );
-  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 IR_OpDescriptionSeq_var _var_type;
-#endif /* ! __GNUC__ || g++ >= 2.8 */
-
-};
-
-// *************************************************************
-// class IR_OpDescriptionSeq_var
-// *************************************************************
-
-class TAO_IFR_Client_Export IR_OpDescriptionSeq_var
-{
-public:
-  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
-
-  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 IR_OpDescriptionSeq &() const;
-  operator IR_OpDescriptionSeq &();
-  operator IR_OpDescriptionSeq &() const;
-  operator IR_OpDescriptionSeq *&(); // variable-size base types only
-
-  IR_OperationDescription & operator[] (CORBA::ULong index);
-  const IR_OperationDescription & operator[] (CORBA::ULong index) const;
-
-  // in, inout, out, _retn
-  const IR_OpDescriptionSeq &in (void) const;
-  IR_OpDescriptionSeq &inout (void);
-  IR_OpDescriptionSeq *&out (void);
-  IR_OpDescriptionSeq *_retn (void);
-  IR_OpDescriptionSeq *ptr (void) const;
-
-private:
-  IR_OpDescriptionSeq *ptr_;
-};
-
-class TAO_IFR_Client_Export IR_OpDescriptionSeq_out
-{
-public:
-  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:
-  IR_OpDescriptionSeq *&ptr_;
-  // assignment from T_var not allowed
-  void operator= (const IR_OpDescriptionSeq_var &);
-};
-
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-
-  class TAO_EXPORT_NESTED_MACRO _TAO_Unbounded_Sequence_IR_AttrDescriptionSeq : public TAO_Unbounded_Base_Sequence
-  {
-  public:
-    // = Initialization and termination methods.
-
-    _TAO_Unbounded_Sequence_IR_AttrDescriptionSeq (void); // Default constructor.
-    _TAO_Unbounded_Sequence_IR_AttrDescriptionSeq (CORBA::ULong maximum);
-    _TAO_Unbounded_Sequence_IR_AttrDescriptionSeq (CORBA::ULong maximum,
-      CORBA::ULong length,
-      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.
-    IR_AttributeDescription &operator[] (CORBA::ULong i);
-    const IR_AttributeDescription &operator[] (CORBA::ULong i) const;
-    // = Static operations.
-    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)
-
-    IR_AttributeDescription *get_buffer (CORBA::Boolean orphan = 0);
-    const IR_AttributeDescription *get_buffer (void) const;
-    void replace (CORBA::ULong max,
-      CORBA::ULong length,
-      IR_AttributeDescription *data,
-      CORBA::Boolean release);
-  };
-
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
-
-// *************************************************************
-// IR_AttrDescriptionSeq
-// *************************************************************
-
-class TAO_IFR_Client_Export IR_AttrDescriptionSeq : public
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Sequence_IR_AttrDescriptionSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Sequence<IR_AttributeDescription>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
-{
-public:
-  IR_AttrDescriptionSeq (void); // default ctor
-  IR_AttrDescriptionSeq (CORBA::ULong max); // uses max size
-  IR_AttrDescriptionSeq (
-    CORBA::ULong max,
-    CORBA::ULong length,
-    IR_AttributeDescription *buffer,
-    CORBA::Boolean release = 0
-  );
-  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 IR_AttrDescriptionSeq_var _var_type;
-#endif /* ! __GNUC__ || g++ >= 2.8 */
-
-};
-
-
-// *************************************************************
-// class IR_AttrDescriptionSeq_var
-// *************************************************************
-
-class TAO_IFR_Client_Export IR_AttrDescriptionSeq_var
-{
-public:
-  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
-
-  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 IR_AttrDescriptionSeq &() const;
-  operator IR_AttrDescriptionSeq &();
-  operator IR_AttrDescriptionSeq &() const;
-  operator IR_AttrDescriptionSeq *&(); // variable-size base types only
-
-  IR_AttributeDescription & operator[] (CORBA::ULong index);
-  const IR_AttributeDescription & operator[] (CORBA::ULong index) const;
-
-  // in, inout, out, _retn
-  const IR_AttrDescriptionSeq &in (void) const;
-  IR_AttrDescriptionSeq &inout (void);
-  IR_AttrDescriptionSeq *&out (void);
-  IR_AttrDescriptionSeq *_retn (void);
-  IR_AttrDescriptionSeq *ptr (void) const;
-
-private:
-  IR_AttrDescriptionSeq *ptr_;
-};
-
-class TAO_IFR_Client_Export IR_AttrDescriptionSeq_out
-{
-public:
-  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:
-  IR_AttrDescriptionSeq *&ptr_;
-  // assignment from T_var not allowed
-  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;
-
-class TAO_IFR_Client_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 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 IR_InterfaceDef_ptr _unchecked_narrow (
-      CORBA::Object_ptr obj,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    );
-  static IR_InterfaceDef_ptr _nil (void)
-    {
-      return (IR_InterfaceDef_ptr)0;
-    }
-
-  static void _tao_any_destructor (void*);
-
-  virtual IR_InterfaceDefSeq * base_interfaces (
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual void base_interfaces (
-      const IR_InterfaceDefSeq & base_interfaces,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual CORBA::Boolean is_abstract (
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual void is_abstract (
-      CORBA::Boolean is_abstract,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual CORBA::Boolean is_local (
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual void is_local (
-      CORBA::Boolean is_local,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual CORBA::Boolean is_a (
-      const char * interface_id,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  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,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  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,
-      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_InterfaceDef_Proxy_Broker *the_TAO_InterfaceDef_Proxy_Broker_;
-
-protected:
-  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 IR_InterfaceDef_setup_collocation (int collocated);
-
-  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 ~IR_InterfaceDef (void);
-private:
-  IR_InterfaceDef (const IR_InterfaceDef &);
-  void operator= (const IR_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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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));
-
-  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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 */
-
-};
-
-
-// The Proxy Implementations are used by each interface to
-// perform a call. Each different implementation encapsulate
-// an invocation logics.
-
-
-///////////////////////////////////////////////////////////////////////
-//                    Base  Impl. Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_InterfaceDef_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 (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  virtual void base_interfaces (
-      CORBA_Object *_collocated_tao_target_,
-      const IR_InterfaceDefSeq & base_interfaces,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  virtual CORBA::Boolean is_abstract (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  virtual void is_abstract (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Boolean is_abstract,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  virtual CORBA::Boolean is_local (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  virtual void is_local (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Boolean is_local,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  virtual CORBA::Boolean is_a (
-      CORBA_Object *_collocated_tao_target_,
-      const char * interface_id,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  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,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  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,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-protected:
-  _TAO_InterfaceDef_Proxy_Impl (void);
-
-};
-
-//
-//                Base  Proxy Impl. Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//                    Remote  Impl. Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_InterfaceDef_Remote_Proxy_Impl :
-  public virtual _TAO_InterfaceDef_Proxy_Impl,
-  public virtual TAO_Remote_Object_Proxy_Impl,
-  public virtual _TAO_Container_Remote_Proxy_Impl,
-  public virtual _TAO_Contained_Remote_Proxy_Impl,
-  public virtual _TAO_IDLType_Remote_Proxy_Impl
-
-{
-public:
-  _TAO_InterfaceDef_Remote_Proxy_Impl (void);
-
-  virtual ~_TAO_InterfaceDef_Remote_Proxy_Impl (void) { }
-
-  virtual IR_InterfaceDefSeq * base_interfaces (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual void base_interfaces (
-      CORBA_Object *_collocated_tao_target_,
-      const IR_InterfaceDefSeq & base_interfaces,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual CORBA::Boolean is_abstract (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual void is_abstract (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Boolean is_abstract,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual CORBA::Boolean is_local (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual void is_local (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Boolean is_local,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual CORBA::Boolean is_a (
-      CORBA_Object *_collocated_tao_target_,
-      const char * interface_id,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  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,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  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,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-};
-
-//
-//                Base  Proxy Impl. Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-// The Proxy Brokers are used by each interface to get
-// the right proxy for performing a call. In the new
-// collocation scheme, the proxy to be used can vary on
-// a call by call basis.
-
-
-
-///////////////////////////////////////////////////////////////////////
-//                 Base Proxy Broker Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_InterfaceDef_Proxy_Broker
-{
-public:
-  virtual ~_TAO_InterfaceDef_Proxy_Broker (void);
-
-  virtual _TAO_InterfaceDef_Proxy_Impl &select_proxy (
-    IR_InterfaceDef *object,
-    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-  ) = 0;
-
-protected:
-  _TAO_InterfaceDef_Proxy_Broker (void);
-
-};
-
-
-//
-//              End Base Proxy Broker Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//                 Remote Proxy Broker Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_InterfaceDef_Remote_Proxy_Broker : public virtual _TAO_InterfaceDef_Proxy_Broker
-{
-public:
-  _TAO_InterfaceDef_Remote_Proxy_Broker (void);
-
-  virtual ~_TAO_InterfaceDef_Remote_Proxy_Broker (void);
-
-  virtual _TAO_InterfaceDef_Proxy_Impl &select_proxy (
-    IR_InterfaceDef *object,
-    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-  );
-
-private:
-  _TAO_InterfaceDef_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_InterfaceDef_Remote_Proxy_Broker *the_TAO_InterfaceDef_Remote_Proxy_Broker (void);
-};
-
-//
-//              End Remote Proxy Broker Declaration
-///////////////////////////////////////////////////////////////////////
-
-struct TAO_IFR_Client_Export IR_InterfaceDescription
-{
-
-#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
-  typedef IR_InterfaceDescription_var _var_type;
-#endif /* ! __GNUC__ || g++ >= 2.8 */
-
-  static void _tao_any_destructor (void*);
-
-  TAO_String_Manager name;
-  TAO_String_Manager id;
-  TAO_String_Manager defined_in;
-  TAO_String_Manager version;
-  IR_OpDescriptionSeq operations;
-  IR_AttrDescriptionSeq attributes;
-  IR_RepositoryIdSeq base_interfaces;
-  CORBA::TypeCode_var type;
-  CORBA::Boolean is_abstract;
-  CORBA::Boolean is_local;
-};
-
-class TAO_IFR_Client_Export IR_InterfaceDescription_var
-{
-public:
-  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 IR_InterfaceDescription &in (void) const;
-  IR_InterfaceDescription &inout (void);
-  IR_InterfaceDescription *&out (void);
-  IR_InterfaceDescription *_retn (void);
-  IR_InterfaceDescription *ptr (void) const;
-
-private:
-  IR_InterfaceDescription *ptr_;
-};
-
-class TAO_IFR_Client_Export IR_InterfaceDescription_out
-{
-public:
-  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:
-  IR_InterfaceDescription *&ptr_;
-  // assignment from T_var not allowed
-  void operator= (const IR_InterfaceDescription_var &);
-};
-
-struct TAO_IFR_Client_Export IR_ValueMember
-{
-
-#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
-  typedef IR_ValueMember_var _var_type;
-#endif /* ! __GNUC__ || g++ >= 2.8 */
-
-  static void _tao_any_destructor (void*);
-
-  TAO_String_Manager name;
-  TAO_String_Manager id;
-  TAO_String_Manager defined_in;
-  TAO_String_Manager version;
-  CORBA::TypeCode_var type;
-  IR_IDLType_var type_def;
-  CORBA::Visibility access;
-};
-
-class TAO_IFR_Client_Export IR_ValueMember_var
-{
-public:
-  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 IR_ValueMember &in (void) const;
-  IR_ValueMember &inout (void);
-  IR_ValueMember *&out (void);
-  IR_ValueMember *_retn (void);
-  IR_ValueMember *ptr (void) const;
-
-private:
-  IR_ValueMember *ptr_;
-};
-
-class TAO_IFR_Client_Export IR_ValueMember_out
-{
-public:
-  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:
-  IR_ValueMember *&ptr_;
-  // assignment from T_var not allowed
-  void operator= (const IR_ValueMember_var &);
-};
-
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-
-  class TAO_EXPORT_NESTED_MACRO _TAO_Unbounded_Sequence_IR_ValueMemberSeq : public TAO_Unbounded_Base_Sequence
-  {
-  public:
-    // = Initialization and termination methods.
-
-    _TAO_Unbounded_Sequence_IR_ValueMemberSeq (void); // Default constructor.
-    _TAO_Unbounded_Sequence_IR_ValueMemberSeq (CORBA::ULong maximum);
-    _TAO_Unbounded_Sequence_IR_ValueMemberSeq (CORBA::ULong maximum,
-      CORBA::ULong length,
-      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.
-    IR_ValueMember &operator[] (CORBA::ULong i);
-    const IR_ValueMember &operator[] (CORBA::ULong i) const;
-    // = Static operations.
-    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)
-
-    IR_ValueMember *get_buffer (CORBA::Boolean orphan = 0);
-    const IR_ValueMember *get_buffer (void) const;
-    void replace (CORBA::ULong max,
-      CORBA::ULong length,
-      IR_ValueMember *data,
-      CORBA::Boolean release);
-  };
-
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
-
-// *************************************************************
-// IR_ValueMemberSeq
-// *************************************************************
-
-class TAO_IFR_Client_Export IR_ValueMemberSeq : public
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Sequence_IR_ValueMemberSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Sequence<IR_ValueMember>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
-{
-public:
-  IR_ValueMemberSeq (void); // default ctor
-  IR_ValueMemberSeq (CORBA::ULong max); // uses max size
-  IR_ValueMemberSeq (
-    CORBA::ULong max,
-    CORBA::ULong length,
-    IR_ValueMember *buffer,
-    CORBA::Boolean release = 0
-  );
-  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 IR_ValueMemberSeq_var _var_type;
-#endif /* ! __GNUC__ || g++ >= 2.8 */
-
-};
-
-// *************************************************************
-// class IR_ValueMemberSeq_var
-// *************************************************************
-
-class TAO_IFR_Client_Export IR_ValueMemberSeq_var
-{
-public:
-  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
-
-  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 IR_ValueMemberSeq &() const;
-  operator IR_ValueMemberSeq &();
-  operator IR_ValueMemberSeq &() const;
-  operator IR_ValueMemberSeq *&(); // variable-size base types only
-
-  IR_ValueMember & operator[] (CORBA::ULong index);
-  const IR_ValueMember & operator[] (CORBA::ULong index) const;
-
-  // in, inout, out, _retn
-  const IR_ValueMemberSeq &in (void) const;
-  IR_ValueMemberSeq &inout (void);
-  IR_ValueMemberSeq *&out (void);
-  IR_ValueMemberSeq *_retn (void);
-  IR_ValueMemberSeq *ptr (void) const;
-
-private:
-  IR_ValueMemberSeq *ptr_;
-};
-
-class TAO_IFR_Client_Export IR_ValueMemberSeq_out
-{
-public:
-  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:
-  IR_ValueMemberSeq *&ptr_;
-  // assignment from T_var not allowed
-  void operator= (const IR_ValueMemberSeq_var &);
-};
-
-class TAO_IFR_Client_Export IR_ValueMemberDef_var : public TAO_Base_var
-{
-public:
-  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
-
-  IR_ValueMemberDef_var &operator= (IR_ValueMemberDef_ptr);
-  IR_ValueMemberDef_var &operator= (const IR_ValueMemberDef_var &);
-  IR_ValueMemberDef_ptr operator-> (void) const;
-
-  operator const IR_ValueMemberDef_ptr &() const;
-  operator IR_ValueMemberDef_ptr &();
-  // in, inout, out, _retn
-  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:
-  IR_ValueMemberDef_ptr ptr_;
-  // Unimplemented - prevents widening assignment.
-  IR_ValueMemberDef_var (const TAO_Base_var &rhs);
-  IR_ValueMemberDef_var &operator= (const TAO_Base_var &rhs);
-};
-
-class TAO_IFR_Client_Export IR_ValueMemberDef_out
-{
-public:
-  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:
-  IR_ValueMemberDef_ptr &ptr_;
-};
-
-// 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_IFR_Client_Export IR_ValueMemberDef: public virtual IR_Contained
-{
-public:
-#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
-  typedef IR_ValueMemberDef_ptr _ptr_type;
-  typedef IR_ValueMemberDef_var _var_type;
-#endif /* ! __GNUC__ || g++ >= 2.8 */
-
-  // the static operations
-  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 IR_ValueMemberDef_ptr _unchecked_narrow (
-      CORBA::Object_ptr obj,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    );
-  static IR_ValueMemberDef_ptr _nil (void)
-    {
-      return (IR_ValueMemberDef_ptr)0;
-    }
-
-  static void _tao_any_destructor (void*);
-
-  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 =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual void type_def (
-      IR_IDLType_ptr type_def,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual CORBA::Visibility access (
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual void access (
-      CORBA::Visibility access,
-      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_ValueMemberDef_Proxy_Broker *the_TAO_ValueMemberDef_Proxy_Broker_;
-
-protected:
-  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 IR_ValueMemberDef_setup_collocation (int collocated);
-
-  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;
-
-  virtual ~IR_ValueMemberDef (void);
-private:
-  IR_ValueMemberDef (const IR_ValueMemberDef &);
-  void operator= (const IR_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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 */
-
-};
-
-
-// The Proxy Implementations are used by each interface to
-// perform a call. Each different implementation encapsulate
-// an invocation logics.
-
-
-///////////////////////////////////////////////////////////////////////
-//                    Base  Impl. Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_ValueMemberDef_Proxy_Impl :
-  public virtual _TAO_Contained_Proxy_Impl
-{
-public:
-  virtual ~_TAO_ValueMemberDef_Proxy_Impl (void) { }
-
-  virtual CORBA::TypeCode_ptr type (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  virtual IR_IDLType_ptr type_def (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  virtual void type_def (
-      CORBA_Object *_collocated_tao_target_,
-      IR_IDLType_ptr type_def,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  virtual CORBA::Visibility access (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  virtual void access (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Visibility access,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-protected:
-  _TAO_ValueMemberDef_Proxy_Impl (void);
-
-};
-
-//
-//                Base  Proxy Impl. Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//                    Remote  Impl. Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_ValueMemberDef_Remote_Proxy_Impl :
-  public virtual _TAO_ValueMemberDef_Proxy_Impl,
-  public virtual TAO_Remote_Object_Proxy_Impl,
-  public virtual _TAO_Contained_Remote_Proxy_Impl
-
-{
-public:
-  _TAO_ValueMemberDef_Remote_Proxy_Impl (void);
-
-  virtual ~_TAO_ValueMemberDef_Remote_Proxy_Impl (void) { }
-
-  virtual CORBA::TypeCode_ptr type (
-      CORBA_Object *_collocated_tao_target_,
-            CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual IR_IDLType_ptr type_def (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual void type_def (
-      CORBA_Object *_collocated_tao_target_,
-      IR_IDLType_ptr type_def,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual CORBA::Visibility access (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual void access (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Visibility access,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-};
-
-//
-//                Base  Proxy Impl. Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-// The Proxy Brokers are used by each interface to get
-// the right proxy for performing a call. In the new
-// collocation scheme, the proxy to be used can vary on
-// a call by call basis.
-
-
-
-///////////////////////////////////////////////////////////////////////
-//                 Base Proxy Broker Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_ValueMemberDef_Proxy_Broker
-{
-public:
-  virtual ~_TAO_ValueMemberDef_Proxy_Broker (void);
-
-  virtual _TAO_ValueMemberDef_Proxy_Impl &select_proxy (
-    IR_ValueMemberDef *object,
-    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-  ) = 0;
-
-protected:
-  _TAO_ValueMemberDef_Proxy_Broker (void);
-
-};
-
-
-//
-//              End Base Proxy Broker Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//                 Remote Proxy Broker Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_ValueMemberDef_Remote_Proxy_Broker : public virtual _TAO_ValueMemberDef_Proxy_Broker
-{
-public:
-  _TAO_ValueMemberDef_Remote_Proxy_Broker (void);
-
-  virtual ~_TAO_ValueMemberDef_Remote_Proxy_Broker (void);
-
-  virtual _TAO_ValueMemberDef_Proxy_Impl &select_proxy (
-    IR_ValueMemberDef *object,
-    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-  );
-
-private:
-  _TAO_ValueMemberDef_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_ValueMemberDef_Remote_Proxy_Broker *the_TAO_ValueMemberDef_Remote_Proxy_Broker (void);
-};
-
-//
-//              End Remote Proxy Broker Declaration
-///////////////////////////////////////////////////////////////////////
-
-// 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_IFR_Client_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 IR_ValueDef_ptr _ptr_type;
-  typedef IR_ValueDef_var _var_type;
-#endif /* ! __GNUC__ || g++ >= 2.8 */
-
-  // the static operations
-  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 IR_ValueDef_ptr _unchecked_narrow (
-      CORBA::Object_ptr obj,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    );
-  static IR_ValueDef_ptr _nil (void)
-    {
-      return (IR_ValueDef_ptr)0;
-    }
-
-  static void _tao_any_destructor (void*);
-
-  virtual IR_InterfaceDefSeq * supported_interfaces (
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual void supported_interfaces (
-      const IR_InterfaceDefSeq & supported_interfaces,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual IR_InitializerSeq * initializers (
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual void initializers (
-      const IR_InitializerSeq & initializers,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual IR_ValueDef_ptr base_value (
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual void base_value (
-      IR_ValueDef_ptr base_value,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual IR_ValueDefSeq * abstract_base_values (
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual void abstract_base_values (
-      const IR_ValueDefSeq & abstract_base_values,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual CORBA::Boolean is_abstract (
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual void is_abstract (
-      CORBA::Boolean is_abstract,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual CORBA::Boolean is_custom (
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual void is_custom (
-      CORBA::Boolean is_custom,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual CORBA::Boolean is_truncatable (
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual void is_truncatable (
-      CORBA::Boolean is_truncatable,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual CORBA::Boolean is_a (
-      const char * id,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual IR_ValueMemberDef_ptr create_value_member (
-      const char * id,
-      const char * name,
-      const char * version,
-      IR_IDLType_ptr type,
-      CORBA::Visibility access,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  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,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  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,
-      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_ValueDef_Proxy_Broker *the_TAO_ValueDef_Proxy_Broker_;
-
-protected:
-  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 IR_ValueDef_setup_collocation (int collocated);
-
-  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 ~IR_ValueDef (void);
-private:
-  IR_ValueDef (const IR_ValueDef &);
-  void operator= (const IR_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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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_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;
-  };
-
-  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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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));
-
-    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_;
-  
-  };
-
-  class TAO_ClientRequestInfo_IR_ValueDef_base_value_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_base_value_get (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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_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;
-  };
-
-  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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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_IFR_Client_Export _TAO_ValueDef_Proxy_Impl :
-  public virtual _TAO_Container_Proxy_Impl,
-  public virtual _TAO_Contained_Proxy_Impl,
-  public virtual _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 (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  virtual void abstract_base_values (
-      CORBA_Object *_collocated_tao_target_,
-      const IR_ValueDefSeq & abstract_base_values,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  virtual CORBA::Boolean is_abstract (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  virtual void is_abstract (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Boolean is_abstract,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  virtual CORBA::Boolean is_custom (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  virtual void is_custom (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Boolean is_custom,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  virtual CORBA::Boolean is_truncatable (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  virtual void is_truncatable (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Boolean is_truncatable,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  virtual CORBA::Boolean is_a (
-      CORBA_Object *_collocated_tao_target_,
-      const char * id,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  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,
-      CORBA::Visibility access,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  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,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  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,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-protected:
-  _TAO_ValueDef_Proxy_Impl (void);
-
-};
-
-//
-//                Base  Proxy Impl. Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//                    Remote  Impl. Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_ValueDef_Remote_Proxy_Impl :
-  public virtual _TAO_ValueDef_Proxy_Impl,
-  public virtual TAO_Remote_Object_Proxy_Impl,
-  public virtual _TAO_Container_Remote_Proxy_Impl,
-  public virtual _TAO_Contained_Remote_Proxy_Impl,
-  public virtual _TAO_IDLType_Remote_Proxy_Impl
-
-{
-public:
-  _TAO_ValueDef_Remote_Proxy_Impl (void);
-
-  virtual ~_TAO_ValueDef_Remote_Proxy_Impl (void) { }
-
-  virtual IR_InterfaceDefSeq * supported_interfaces (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual void supported_interfaces (
-      CORBA_Object *_collocated_tao_target_,
-      const IR_InterfaceDefSeq & supported_interfaces,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual IR_InitializerSeq * initializers (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    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
-    ));
-
-  virtual IR_ValueDef_ptr base_value (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual void base_value (
-      CORBA_Object *_collocated_tao_target_,
-      IR_ValueDef_ptr base_value,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual IR_ValueDefSeq * abstract_base_values (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual void abstract_base_values (
-      CORBA_Object *_collocated_tao_target_,
-      const IR_ValueDefSeq & abstract_base_values,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual CORBA::Boolean is_abstract (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual void is_abstract (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Boolean is_abstract,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual CORBA::Boolean is_custom (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual void is_custom (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Boolean is_custom,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual CORBA::Boolean is_truncatable (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual void is_truncatable (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Boolean is_truncatable,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual CORBA::Boolean is_a (
-      CORBA_Object *_collocated_tao_target_,
-      const char * id,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  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,
-      CORBA::Visibility access,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  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,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  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,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-};
-
-//
-//                Base  Proxy Impl. Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-// The Proxy Brokers are used by each interface to get
-// the right proxy for performing a call. In the new
-// collocation scheme, the proxy to be used can vary on
-// a call by call basis.
-
-
-
-///////////////////////////////////////////////////////////////////////
-//                 Base Proxy Broker Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_ValueDef_Proxy_Broker
-{
-public:
-  virtual ~_TAO_ValueDef_Proxy_Broker (void);
-
-  virtual _TAO_ValueDef_Proxy_Impl &select_proxy (
-    IR_ValueDef *object,
-    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-  ) = 0;
-
-protected:
-  _TAO_ValueDef_Proxy_Broker (void);
-
-};
-
-
-//
-//              End Base Proxy Broker Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//                 Remote Proxy Broker Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_ValueDef_Remote_Proxy_Broker : public virtual _TAO_ValueDef_Proxy_Broker
-{
-public:
-  _TAO_ValueDef_Remote_Proxy_Broker (void);
-
-  virtual ~_TAO_ValueDef_Remote_Proxy_Broker (void);
-
-  virtual _TAO_ValueDef_Proxy_Impl &select_proxy (
-    IR_ValueDef *object,
-    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-  );
-
-private:
-  _TAO_ValueDef_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_ValueDef_Remote_Proxy_Broker *the_TAO_ValueDef_Remote_Proxy_Broker (void);
-};
-
-//
-//              End Remote Proxy Broker Declaration
-///////////////////////////////////////////////////////////////////////
-
-struct TAO_IFR_Client_Export IR_ValueDescription
-{
-
-#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
-  typedef IR_ValueDescription_var _var_type;
-#endif /* ! __GNUC__ || g++ >= 2.8 */
-
-  static void _tao_any_destructor (void*);
-
-  TAO_String_Manager name;
-  TAO_String_Manager id;
-  CORBA::Boolean is_abstract;
-  CORBA::Boolean is_custom;
-  TAO_String_Manager defined_in;
-  TAO_String_Manager version;
-  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_IFR_Client_Export IR_ValueDescription_var
-{
-public:
-  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 IR_ValueDescription &in (void) const;
-  IR_ValueDescription &inout (void);
-  IR_ValueDescription *&out (void);
-  IR_ValueDescription *_retn (void);
-  IR_ValueDescription *ptr (void) const;
-
-private:
-  IR_ValueDescription *ptr_;
-};
-
-class TAO_IFR_Client_Export IR_ValueDescription_out
-{
-public:
-  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:
-  IR_ValueDescription *&ptr_;
-  // assignment from T_var not allowed
-  void operator= (const IR_ValueDescription_var &);
-};
-
-// 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_IFR_Client_Export IR_ValueBoxDef: public virtual IR_TypedefDef
-{
-public:
-#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
-  typedef IR_ValueBoxDef_ptr _ptr_type;
-  typedef IR_ValueBoxDef_var _var_type;
-#endif /* ! __GNUC__ || g++ >= 2.8 */
-
-  // the static operations
-  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 IR_ValueBoxDef_ptr _unchecked_narrow (
-      CORBA::Object_ptr obj,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    );
-  static IR_ValueBoxDef_ptr _nil (void)
-    {
-      return (IR_ValueBoxDef_ptr)0;
-    }
-
-  static void _tao_any_destructor (void*);
-
-  virtual IR_IDLType_ptr original_type_def (
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual void original_type_def (
-      IR_IDLType_ptr original_type_def,
-      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_ValueBoxDef_Proxy_Broker *the_TAO_ValueBoxDef_Proxy_Broker_;
-
-protected:
-  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 IR_ValueBoxDef_setup_collocation (int collocated);
-
-  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 ~IR_ValueBoxDef (void);
-private:
-  IR_ValueBoxDef (const IR_ValueBoxDef &);
-  void operator= (const IR_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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _tao_target,
-        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_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 */
-
-};
-
-
-// The Proxy Implementations are used by each interface to
-// perform a call. Each different implementation encapsulate
-// an invocation logics.
-
-
-///////////////////////////////////////////////////////////////////////
-//                    Base  Impl. Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_ValueBoxDef_Proxy_Impl :
-  public virtual _TAO_TypedefDef_Proxy_Impl
-{
-public:
-  virtual ~_TAO_ValueBoxDef_Proxy_Impl (void) { }
-
-  virtual IR_IDLType_ptr original_type_def (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  virtual void original_type_def (
-      CORBA_Object *_collocated_tao_target_,
-      IR_IDLType_ptr original_type_def,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-protected:
-  _TAO_ValueBoxDef_Proxy_Impl (void);
-
-};
-
-//
-//                Base  Proxy Impl. Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//                    Remote  Impl. Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_ValueBoxDef_Remote_Proxy_Impl :
-  public virtual _TAO_ValueBoxDef_Proxy_Impl,
-  public virtual TAO_Remote_Object_Proxy_Impl,
-  public virtual _TAO_TypedefDef_Remote_Proxy_Impl
-
-{
-public:
-  _TAO_ValueBoxDef_Remote_Proxy_Impl (void);
-
-  virtual ~_TAO_ValueBoxDef_Remote_Proxy_Impl (void) { }
-
-  virtual IR_IDLType_ptr original_type_def (
-      CORBA_Object *_collocated_tao_target_,
-            CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual void original_type_def (
-      CORBA_Object *_collocated_tao_target_,
-      IR_IDLType_ptr original_type_def,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-};
-
-//
-//                Base  Proxy Impl. Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-// The Proxy Brokers are used by each interface to get
-// the right proxy for performing a call. In the new
-// collocation scheme, the proxy to be used can vary on
-// a call by call basis.
-
-
-
-///////////////////////////////////////////////////////////////////////
-//                 Base Proxy Broker Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_ValueBoxDef_Proxy_Broker
-{
-public:
-  virtual ~_TAO_ValueBoxDef_Proxy_Broker (void);
-
-  virtual _TAO_ValueBoxDef_Proxy_Impl &select_proxy (
-    IR_ValueBoxDef *object,
-    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-  ) = 0;
-
-protected:
-  _TAO_ValueBoxDef_Proxy_Broker (void);
-
-};
-
-
-//
-//              End Base Proxy Broker Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//                 Remote Proxy Broker Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_ValueBoxDef_Remote_Proxy_Broker : public virtual _TAO_ValueBoxDef_Proxy_Broker
-{
-public:
-  _TAO_ValueBoxDef_Remote_Proxy_Broker (void);
-
-  virtual ~_TAO_ValueBoxDef_Remote_Proxy_Broker (void);
-
-  virtual _TAO_ValueBoxDef_Proxy_Impl &select_proxy (
-    IR_ValueBoxDef *object,
-    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-  );
-
-private:
-  _TAO_ValueBoxDef_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_ValueBoxDef_Remote_Proxy_Broker *the_TAO_ValueBoxDef_Remote_Proxy_Broker (void);
-};
-
-//
-//              End Remote Proxy Broker Declaration
-///////////////////////////////////////////////////////////////////////
-
-// 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_IFR_Client_Export IR_ProvidesDef: public virtual IR_Contained
-{
-public:
-#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
-  typedef IR_ProvidesDef_ptr _ptr_type;
-  typedef IR_ProvidesDef_var _var_type;
-#endif /* ! __GNUC__ || g++ >= 2.8 */
-
-  // the static operations
-  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 IR_ProvidesDef_ptr _unchecked_narrow (
-      CORBA::Object_ptr obj,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    );
-  static IR_ProvidesDef_ptr _nil (void)
-    {
-      return (IR_ProvidesDef_ptr)0;
-    }
-
-  static void _tao_any_destructor (void*);
-
-  virtual IR_InterfaceDef_ptr interface_type (
-      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_ProvidesDef_Proxy_Broker *the_TAO_ProvidesDef_Proxy_Broker_;
-
-protected:
-  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 IR_ProvidesDef_setup_collocation (int collocated);
-
-  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 ~IR_ProvidesDef (void);
-private:
-  IR_ProvidesDef (const IR_ProvidesDef &);
-  void operator= (const IR_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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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;
-  };
-
-#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_IFR_Client_Export _TAO_ProvidesDef_Proxy_Impl :
-  public virtual _TAO_Contained_Proxy_Impl
-{
-public:
-  virtual ~_TAO_ProvidesDef_Proxy_Impl (void) { }
-
-  virtual IR_InterfaceDef_ptr interface_type (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-protected:
-  _TAO_ProvidesDef_Proxy_Impl (void);
-
-};
-
-//
-//                Base  Proxy Impl. Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//                    Remote  Impl. Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_ProvidesDef_Remote_Proxy_Impl :
-  public virtual _TAO_ProvidesDef_Proxy_Impl,
-  public virtual TAO_Remote_Object_Proxy_Impl,
-  public virtual _TAO_Contained_Remote_Proxy_Impl
-
-{
-public:
-  _TAO_ProvidesDef_Remote_Proxy_Impl (void);
-
-  virtual ~_TAO_ProvidesDef_Remote_Proxy_Impl (void) { }
-
-  virtual IR_InterfaceDef_ptr interface_type (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-};
-
-//
-//                Base  Proxy Impl. Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-// The Proxy Brokers are used by each interface to get
-// the right proxy for performing a call. In the new
-// collocation scheme, the proxy to be used can vary on
-// a call by call basis.
-
-
-
-///////////////////////////////////////////////////////////////////////
-//                 Base Proxy Broker Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_ProvidesDef_Proxy_Broker
-{
-public:
-  virtual ~_TAO_ProvidesDef_Proxy_Broker (void);
-
-  virtual _TAO_ProvidesDef_Proxy_Impl &select_proxy (
-    IR_ProvidesDef *object,
-    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-  ) = 0;
-
-protected:
-  _TAO_ProvidesDef_Proxy_Broker (void);
-
-};
-
-
-//
-//              End Base Proxy Broker Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//                 Remote Proxy Broker Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_ProvidesDef_Remote_Proxy_Broker : public virtual _TAO_ProvidesDef_Proxy_Broker
-{
-public:
-  _TAO_ProvidesDef_Remote_Proxy_Broker (void);
-
-  virtual ~_TAO_ProvidesDef_Remote_Proxy_Broker (void);
-
-  virtual _TAO_ProvidesDef_Proxy_Impl &select_proxy (
-    IR_ProvidesDef *object,
-    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-  );
-
-private:
-  _TAO_ProvidesDef_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_ProvidesDef_Remote_Proxy_Broker *the_TAO_ProvidesDef_Remote_Proxy_Broker (void);
-};
-
-//
-//              End Remote Proxy Broker Declaration
-///////////////////////////////////////////////////////////////////////
-
-struct TAO_IFR_Client_Export IR_ProvidesDescription
-{
-
-#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
-  typedef IR_ProvidesDescription_var _var_type;
-#endif /* ! __GNUC__ || g++ >= 2.8 */
-
-  static void _tao_any_destructor (void*);
-
-  TAO_String_Manager name;
-  TAO_String_Manager id;
-  TAO_String_Manager defined_in;
-  TAO_String_Manager version;
-  IR_InterfaceDef_var interface_type;
-};
-
-class TAO_IFR_Client_Export IR_ProvidesDescription_var
-{
-public:
-  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
-
-  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 IR_ProvidesDescription &() const;
-  operator IR_ProvidesDescription &();
-  operator IR_ProvidesDescription &() const;
-  operator IR_ProvidesDescription *&(); // variable-size types only
-
-  // in, inout, out, _retn
-  const IR_ProvidesDescription &in (void) const;
-  IR_ProvidesDescription &inout (void);
-  IR_ProvidesDescription *&out (void);
-  IR_ProvidesDescription *_retn (void);
-  IR_ProvidesDescription *ptr (void) const;
-
-private:
-  IR_ProvidesDescription *ptr_;
-};
-
-class TAO_IFR_Client_Export IR_ProvidesDescription_out
-{
-public:
-  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:
-  IR_ProvidesDescription *&ptr_;
-  // assignment from T_var not allowed
-  void operator= (const IR_ProvidesDescription_var &);
-};
-
-// 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_IFR_Client_Export IR_UsesDef: public virtual IR_Contained
-{
-public:
-#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
-  typedef IR_UsesDef_ptr _ptr_type;
-  typedef IR_UsesDef_var _var_type;
-#endif /* ! __GNUC__ || g++ >= 2.8 */
-
-  // the static operations
-  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 IR_UsesDef_ptr _unchecked_narrow (
-      CORBA::Object_ptr obj,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    );
-  static IR_UsesDef_ptr _nil (void)
-    {
-      return (IR_UsesDef_ptr)0;
-    }
-
-  static void _tao_any_destructor (void*);
-
-  virtual IR_InterfaceDef_ptr interface_type (
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual CORBA::Boolean is_multiple (
-      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_UsesDef_Proxy_Broker *the_TAO_UsesDef_Proxy_Broker_;
-
-protected:
-  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 IR_UsesDef_setup_collocation (int collocated);
-
-  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 ~IR_UsesDef (void);
-private:
-  IR_UsesDef (const IR_UsesDef &);
-  void operator= (const IR_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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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_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 */
-
-};
-
-
-// The Proxy Implementations are used by each interface to
-// perform a call. Each different implementation encapsulate
-// an invocation logics.
-
-
-///////////////////////////////////////////////////////////////////////
-//                    Base  Impl. Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_UsesDef_Proxy_Impl :
-  public virtual _TAO_Contained_Proxy_Impl
-{
-public:
-  virtual ~_TAO_UsesDef_Proxy_Impl (void) { }
-
-  virtual IR_InterfaceDef_ptr interface_type (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  virtual CORBA::Boolean is_multiple (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-protected:
-  _TAO_UsesDef_Proxy_Impl (void);
-
-};
-
-//
-//                Base  Proxy Impl. Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//                    Remote  Impl. Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_UsesDef_Remote_Proxy_Impl :
-  public virtual _TAO_UsesDef_Proxy_Impl,
-  public virtual TAO_Remote_Object_Proxy_Impl,
-  public virtual _TAO_Contained_Remote_Proxy_Impl
-
-{
-public:
-  _TAO_UsesDef_Remote_Proxy_Impl (void);
-
-  virtual ~_TAO_UsesDef_Remote_Proxy_Impl (void) { }
-
-  virtual IR_InterfaceDef_ptr interface_type (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual CORBA::Boolean is_multiple (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-};
-
-//
-//                Base  Proxy Impl. Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-// The Proxy Brokers are used by each interface to get
-// the right proxy for performing a call. In the new
-// collocation scheme, the proxy to be used can vary on
-// a call by call basis.
-
-
-
-///////////////////////////////////////////////////////////////////////
-//                 Base Proxy Broker Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_UsesDef_Proxy_Broker
-{
-public:
-  virtual ~_TAO_UsesDef_Proxy_Broker (void);
-
-  virtual _TAO_UsesDef_Proxy_Impl &select_proxy (
-    IR_UsesDef *object,
-    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-  ) = 0;
-
-protected:
-  _TAO_UsesDef_Proxy_Broker (void);
-
-};
-
-
-//
-//              End Base Proxy Broker Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//                 Remote Proxy Broker Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_UsesDef_Remote_Proxy_Broker : public virtual _TAO_UsesDef_Proxy_Broker
-{
-public:
-  _TAO_UsesDef_Remote_Proxy_Broker (void);
-
-  virtual ~_TAO_UsesDef_Remote_Proxy_Broker (void);
-
-  virtual _TAO_UsesDef_Proxy_Impl &select_proxy (
-    IR_UsesDef *object,
-    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-  );
-
-private:
-  _TAO_UsesDef_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_UsesDef_Remote_Proxy_Broker *the_TAO_UsesDef_Remote_Proxy_Broker (void);
-};
-
-//
-//              End Remote Proxy Broker Declaration
-///////////////////////////////////////////////////////////////////////
-
-struct TAO_IFR_Client_Export IR_UsesDescription
-{
-
-#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
-  typedef IR_UsesDescription_var _var_type;
-#endif /* ! __GNUC__ || g++ >= 2.8 */
-
-  static void _tao_any_destructor (void*);
-
-  TAO_String_Manager name;
-  TAO_String_Manager id;
-  TAO_String_Manager defined_in;
-  TAO_String_Manager version;
-  IR_InterfaceDef_var interface_type;
-  CORBA::Boolean is_multiple;
-};
-
-class TAO_IFR_Client_Export IR_UsesDescription_var
-{
-public:
-  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 IR_UsesDescription &in (void) const;
-  IR_UsesDescription &inout (void);
-  IR_UsesDescription *&out (void);
-  IR_UsesDescription *_retn (void);
-  IR_UsesDescription *ptr (void) const;
-
-private:
-  IR_UsesDescription *ptr_;
-};
-
-class TAO_IFR_Client_Export IR_UsesDescription_out
-{
-public:
-  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:
-  IR_UsesDescription *&ptr_;
-  // assignment from T_var not allowed
-  void operator= (const IR_UsesDescription_var &);
-};
-
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-
-  class TAO_EXPORT_NESTED_MACRO _TAO_Unbounded_Sequence_IR_ProvidesDescSeq : public TAO_Unbounded_Base_Sequence
-  {
-  public:
-    // = Initialization and termination methods.
-
-    _TAO_Unbounded_Sequence_IR_ProvidesDescSeq (void); // Default constructor.
-    _TAO_Unbounded_Sequence_IR_ProvidesDescSeq (CORBA::ULong maximum);
-    _TAO_Unbounded_Sequence_IR_ProvidesDescSeq (CORBA::ULong maximum,
-      CORBA::ULong length,
-      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.
-    IR_ProvidesDescription &operator[] (CORBA::ULong i);
-    const IR_ProvidesDescription &operator[] (CORBA::ULong i) const;
-    // = Static operations.
-    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)
-
-    IR_ProvidesDescription *get_buffer (CORBA::Boolean orphan = 0);
-    const IR_ProvidesDescription *get_buffer (void) const;
-    void replace (CORBA::ULong max,
-      CORBA::ULong length,
-      IR_ProvidesDescription *data,
-      CORBA::Boolean release);
-  };
-
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
-
-// *************************************************************
-// IR_ProvidesDescSeq
-// *************************************************************
-
-class TAO_IFR_Client_Export IR_ProvidesDescSeq : public
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Sequence_IR_ProvidesDescSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Sequence<IR_ProvidesDescription>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
-{
-public:
-  IR_ProvidesDescSeq (void); // default ctor
-  IR_ProvidesDescSeq (CORBA::ULong max); // uses max size
-  IR_ProvidesDescSeq (
-    CORBA::ULong max,
-    CORBA::ULong length,
-    IR_ProvidesDescription *buffer,
-    CORBA::Boolean release = 0
-  );
-  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 IR_ProvidesDescSeq_var _var_type;
-#endif /* ! __GNUC__ || g++ >= 2.8 */
-
-};
-
-// *************************************************************
-// class IR_ProvidesDescSeq_var
-// *************************************************************
-
-class TAO_IFR_Client_Export IR_ProvidesDescSeq_var
-{
-public:
-  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
-
-  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 IR_ProvidesDescSeq &() const;
-  operator IR_ProvidesDescSeq &();
-  operator IR_ProvidesDescSeq &() const;
-  operator IR_ProvidesDescSeq *&(); // variable-size base types only
-
-  IR_ProvidesDescription & operator[] (CORBA::ULong index);
-  const IR_ProvidesDescription & operator[] (CORBA::ULong index) const;
-
-  // in, inout, out, _retn
-  const IR_ProvidesDescSeq &in (void) const;
-  IR_ProvidesDescSeq &inout (void);
-  IR_ProvidesDescSeq *&out (void);
-  IR_ProvidesDescSeq *_retn (void);
-  IR_ProvidesDescSeq *ptr (void) const;
-
-private:
-  IR_ProvidesDescSeq *ptr_;
-};
-
-class TAO_IFR_Client_Export IR_ProvidesDescSeq_out
-{
-public:
-  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:
-  IR_ProvidesDescSeq *&ptr_;
-  // assignment from T_var not allowed
-  void operator= (const IR_ProvidesDescSeq_var &);
-};
-
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-
-  class TAO_EXPORT_NESTED_MACRO _TAO_Unbounded_Sequence_IR_UsesDescSeq : public TAO_Unbounded_Base_Sequence
-  {
-  public:
-    // = Initialization and termination methods.
-
-    _TAO_Unbounded_Sequence_IR_UsesDescSeq (void); // Default constructor.
-    _TAO_Unbounded_Sequence_IR_UsesDescSeq (CORBA::ULong maximum);
-    _TAO_Unbounded_Sequence_IR_UsesDescSeq (CORBA::ULong maximum,
-      CORBA::ULong length,
-      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.
-    IR_UsesDescription &operator[] (CORBA::ULong i);
-    const IR_UsesDescription &operator[] (CORBA::ULong i) const;
-    // = Static operations.
-    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)
-
-    IR_UsesDescription *get_buffer (CORBA::Boolean orphan = 0);
-    const IR_UsesDescription *get_buffer (void) const;
-    void replace (CORBA::ULong max,
-      CORBA::ULong length,
-      IR_UsesDescription *data,
-      CORBA::Boolean release);
-  };
-
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
-
-// *************************************************************
-// IR_UsesDescSeq
-// *************************************************************
-
-class TAO_IFR_Client_Export IR_UsesDescSeq : public
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Sequence_IR_UsesDescSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Sequence<IR_UsesDescription>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
-{
-public:
-  IR_UsesDescSeq (void); // default ctor
-  IR_UsesDescSeq (CORBA::ULong max); // uses max size
-  IR_UsesDescSeq (
-    CORBA::ULong max,
-    CORBA::ULong length,
-    IR_UsesDescription *buffer,
-    CORBA::Boolean release = 0
-  );
-  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 IR_UsesDescSeq_var _var_type;
-#endif /* ! __GNUC__ || g++ >= 2.8 */
-
-};
-
-// *************************************************************
-// class IR_UsesDescSeq_var
-// *************************************************************
-
-class TAO_IFR_Client_Export IR_UsesDescSeq_var
-{
-public:
-  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
-
-  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 IR_UsesDescSeq &() const;
-  operator IR_UsesDescSeq &();
-  operator IR_UsesDescSeq &() const;
-  operator IR_UsesDescSeq *&(); // variable-size base types only
-
-  IR_UsesDescription & operator[] (CORBA::ULong index);
-  const IR_UsesDescription & operator[] (CORBA::ULong index) const;
-
-  // in, inout, out, _retn
-  const IR_UsesDescSeq &in (void) const;
-  IR_UsesDescSeq &inout (void);
-  IR_UsesDescSeq *&out (void);
-  IR_UsesDescSeq *_retn (void);
-  IR_UsesDescSeq *ptr (void) const;
-
-private:
-  IR_UsesDescSeq *ptr_;
-};
-
-class TAO_IFR_Client_Export IR_UsesDescSeq_out
-{
-public:
-  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:
-  IR_UsesDescSeq *&ptr_;
-  // assignment from T_var not allowed
-  void operator= (const IR_UsesDescSeq_var &);
-};
-
-// 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_IFR_Client_Export IR_EventDef: public virtual IR_Contained
-{
-public:
-#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
-  typedef IR_EventDef_ptr _ptr_type;
-  typedef IR_EventDef_var _var_type;
-#endif /* ! __GNUC__ || g++ >= 2.8 */
-
-  // the static operations
-  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 IR_EventDef_ptr _unchecked_narrow (
-      CORBA::Object_ptr obj,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    );
-  static IR_EventDef_ptr _nil (void)
-    {
-      return (IR_EventDef_ptr)0;
-    }
-
-  static void _tao_any_destructor (void*);
-
-  virtual CORBA::Boolean is_a (
-      const char * event_id,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual IR_ValueDef_ptr event (
-      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_EventDef_Proxy_Broker *the_TAO_EventDef_Proxy_Broker_;
-
-protected:
-  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 IR_EventDef_setup_collocation (int collocated);
-
-  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 ~IR_EventDef (void);
-private:
-  IR_EventDef (const IR_EventDef &);
-  void operator= (const IR_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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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_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 */
-
-};
-
-
-// The Proxy Implementations are used by each interface to
-// perform a call. Each different implementation encapsulate
-// an invocation logics.
-
-
-///////////////////////////////////////////////////////////////////////
-//                    Base  Impl. Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_EventDef_Proxy_Impl :
-  public virtual _TAO_Contained_Proxy_Impl
-{
-public:
-  virtual ~_TAO_EventDef_Proxy_Impl (void) { }
-
-  virtual CORBA::Boolean is_a (
-      CORBA_Object *_collocated_tao_target_,
-      const char * event_id,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  virtual IR_ValueDef_ptr event (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-protected:
-  _TAO_EventDef_Proxy_Impl (void);
-
-};
-
-//
-//                Base  Proxy Impl. Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//                    Remote  Impl. Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_EventDef_Remote_Proxy_Impl :
-  public virtual _TAO_EventDef_Proxy_Impl,
-  public virtual TAO_Remote_Object_Proxy_Impl,
-  public virtual _TAO_Contained_Remote_Proxy_Impl
-
-{
-public:
-  _TAO_EventDef_Remote_Proxy_Impl (void);
-
-  virtual ~_TAO_EventDef_Remote_Proxy_Impl (void) { }
-
-  virtual CORBA::Boolean is_a (
-      CORBA_Object *_collocated_tao_target_,
-      const char * event_id,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual IR_ValueDef_ptr event (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-};
-
-//
-//                Base  Proxy Impl. Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-// The Proxy Brokers are used by each interface to get
-// the right proxy for performing a call. In the new
-// collocation scheme, the proxy to be used can vary on
-// a call by call basis.
-
-
-
-///////////////////////////////////////////////////////////////////////
-//                 Base Proxy Broker Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_EventDef_Proxy_Broker
-{
-public:
-  virtual ~_TAO_EventDef_Proxy_Broker (void);
-
-  virtual _TAO_EventDef_Proxy_Impl &select_proxy (
-    IR_EventDef *object,
-    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-  ) = 0;
-
-protected:
-  _TAO_EventDef_Proxy_Broker (void);
-
-};
-
-
-//
-//              End Base Proxy Broker Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//                 Remote Proxy Broker Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_EventDef_Remote_Proxy_Broker : public virtual _TAO_EventDef_Proxy_Broker
-{
-public:
-  _TAO_EventDef_Remote_Proxy_Broker (void);
-
-  virtual ~_TAO_EventDef_Remote_Proxy_Broker (void);
-
-  virtual _TAO_EventDef_Proxy_Impl &select_proxy (
-    IR_EventDef *object,
-    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-  );
-
-private:
-  _TAO_EventDef_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_EventDef_Remote_Proxy_Broker *the_TAO_EventDef_Remote_Proxy_Broker (void);
-};
-
-//
-//              End Remote Proxy Broker Declaration
-///////////////////////////////////////////////////////////////////////
-
-struct TAO_IFR_Client_Export IR_EventDescription
-{
-
-#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
-  typedef IR_EventDescription_var _var_type;
-#endif /* ! __GNUC__ || g++ >= 2.8 */
-
-  static void _tao_any_destructor (void*);
-
-  TAO_String_Manager name;
-  TAO_String_Manager id;
-  TAO_String_Manager defined_in;
-  TAO_String_Manager version;
-  IR_ValueDef_var value;
-};
-
-class TAO_IFR_Client_Export IR_EventDescription_var
-{
-public:
-  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
-
-  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 IR_EventDescription &() const;
-  operator IR_EventDescription &();
-  operator IR_EventDescription &() const;
-  operator IR_EventDescription *&(); // variable-size types only
-
-  // in, inout, out, _retn
-  const IR_EventDescription &in (void) const;
-  IR_EventDescription &inout (void);
-  IR_EventDescription *&out (void);
-  IR_EventDescription *_retn (void);
-  IR_EventDescription *ptr (void) const;
-
-private:
-  IR_EventDescription *ptr_;
-};
-
-class TAO_IFR_Client_Export IR_EventDescription_out
-{
-public:
-  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:
-  IR_EventDescription *&ptr_;
-  // assignment from T_var not allowed
-  void operator= (const IR_EventDescription_var &);
-};
-
-// 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_IFR_Client_Export IR_EmitsDef: public virtual IR_EventDef
-{
-public:
-#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
-  typedef IR_EmitsDef_ptr _ptr_type;
-  typedef IR_EmitsDef_var _var_type;
-#endif /* ! __GNUC__ || g++ >= 2.8 */
-
-  // the static operations
-  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 IR_EmitsDef_ptr _unchecked_narrow (
-      CORBA::Object_ptr obj,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    );
-  static IR_EmitsDef_ptr _nil (void)
-    {
-      return (IR_EmitsDef_ptr)0;
-    }
-
-  static void _tao_any_destructor (void*);
-
-  virtual CORBA::Boolean _is_a (
-      const CORBA::Char *type_id,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    );
-  virtual void *_tao_QueryInterface (ptr_arith_t type);
-
-  virtual const char* _interface_repository_id (void) const;
-
-private:
-  _TAO_EmitsDef_Proxy_Broker *the_TAO_EmitsDef_Proxy_Broker_;
-
-protected:
-  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 IR_EmitsDef_setup_collocation (int collocated);
-
-  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;
-
-  virtual ~IR_EmitsDef (void);
-private:
-  IR_EmitsDef (const IR_EmitsDef &);
-  void operator= (const IR_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 */
-
-};
-
-
-// The Proxy Implementations are used by each interface to
-// perform a call. Each different implementation encapsulate
-// an invocation logics.
-
-
-///////////////////////////////////////////////////////////////////////
-//                    Base  Impl. Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_EmitsDef_Proxy_Impl
-  : public virtual _TAO_EventDef_Proxy_Impl
-{
-public:
-  virtual ~_TAO_EmitsDef_Proxy_Impl (void) { }
-
-protected:
-  _TAO_EmitsDef_Proxy_Impl (void);
-
-};
-
-//
-//                Base  Proxy Impl. Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//                    Remote  Impl. Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_EmitsDef_Remote_Proxy_Impl :
-  public virtual _TAO_EmitsDef_Proxy_Impl,
-  public virtual TAO_Remote_Object_Proxy_Impl,
-  public virtual _TAO_EventDef_Remote_Proxy_Impl
-
-{
-public:
-  _TAO_EmitsDef_Remote_Proxy_Impl (void);
-
-  virtual ~_TAO_EmitsDef_Remote_Proxy_Impl (void) { }
-
-};
-
-//
-//                Base  Proxy Impl. Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-// The Proxy Brokers are used by each interface to get
-// the right proxy for performing a call. In the new
-// collocation scheme, the proxy to be used can vary on
-// a call by call basis.
-
-
-
-///////////////////////////////////////////////////////////////////////
-//                 Base Proxy Broker Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_EmitsDef_Proxy_Broker
-{
-public:
-  virtual ~_TAO_EmitsDef_Proxy_Broker (void);
-
-  virtual _TAO_EmitsDef_Proxy_Impl &select_proxy (
-    IR_EmitsDef *object,
-    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-  ) = 0;
-
-protected:
-  _TAO_EmitsDef_Proxy_Broker (void);
-
-};
-
-
-//
-//              End Base Proxy Broker Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//                 Remote Proxy Broker Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_EmitsDef_Remote_Proxy_Broker : public virtual _TAO_EmitsDef_Proxy_Broker
-{
-public:
-  _TAO_EmitsDef_Remote_Proxy_Broker (void);
-
-  virtual ~_TAO_EmitsDef_Remote_Proxy_Broker (void);
-
-  virtual _TAO_EmitsDef_Proxy_Impl &select_proxy (
-    IR_EmitsDef *object,
-    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-  );
-
-private:
-  _TAO_EmitsDef_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_EmitsDef_Remote_Proxy_Broker *the_TAO_EmitsDef_Remote_Proxy_Broker (void);
-};
-
-//
-//              End Remote Proxy Broker 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_IFR_Client_Export IR_PublishesDef: public virtual IR_EventDef
-{
-public:
-#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
-  typedef IR_PublishesDef_ptr _ptr_type;
-  typedef IR_PublishesDef_var _var_type;
-#endif /* ! __GNUC__ || g++ >= 2.8 */
-
-  // the static operations
-  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 IR_PublishesDef_ptr _unchecked_narrow (
-      CORBA::Object_ptr obj,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    );
-  static IR_PublishesDef_ptr _nil (void)
-    {
-      return (IR_PublishesDef_ptr)0;
-    }
-
-  static void _tao_any_destructor (void*);
-
-  virtual CORBA::Boolean _is_a (
-      const CORBA::Char *type_id,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    );
-  virtual void *_tao_QueryInterface (ptr_arith_t type);
-
-  virtual const char* _interface_repository_id (void) const;
-
-private:
-  _TAO_PublishesDef_Proxy_Broker *the_TAO_PublishesDef_Proxy_Broker_;
-
-protected:
-  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 IR_PublishesDef_setup_collocation (int collocated);
-
-  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;
-
-  virtual ~IR_PublishesDef (void);
-private:
-  IR_PublishesDef (const IR_PublishesDef &);
-  void operator= (const IR_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 */
-
-};
-
-
-// The Proxy Implementations are used by each interface to
-// perform a call. Each different implementation encapsulate
-// an invocation logics.
-
-
-///////////////////////////////////////////////////////////////////////
-//                    Base  Impl. Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_PublishesDef_Proxy_Impl
-  : public virtual _TAO_EventDef_Proxy_Impl
-{
-public:
-  virtual ~_TAO_PublishesDef_Proxy_Impl (void) { }
-
-protected:
-  _TAO_PublishesDef_Proxy_Impl (void);
-
-};
-
-//
-//                Base  Proxy Impl. Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//                    Remote  Impl. Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_PublishesDef_Remote_Proxy_Impl :
-  public virtual _TAO_PublishesDef_Proxy_Impl,
-  public virtual TAO_Remote_Object_Proxy_Impl,
-  public virtual _TAO_EventDef_Remote_Proxy_Impl
-
-{
-public:
-  _TAO_PublishesDef_Remote_Proxy_Impl (void);
-
-  virtual ~_TAO_PublishesDef_Remote_Proxy_Impl (void) { }
-
-};
-
-//
-//                Base  Proxy Impl. Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-// The Proxy Brokers are used by each interface to get
-// the right proxy for performing a call. In the new
-// collocation scheme, the proxy to be used can vary on
-// a call by call basis.
-
-
-
-///////////////////////////////////////////////////////////////////////
-//                 Base Proxy Broker Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_PublishesDef_Proxy_Broker
-{
-public:
-  virtual ~_TAO_PublishesDef_Proxy_Broker (void);
-
-  virtual _TAO_PublishesDef_Proxy_Impl &select_proxy (
-    IR_PublishesDef *object,
-    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-  ) = 0;
-
-protected:
-  _TAO_PublishesDef_Proxy_Broker (void);
-
-};
-
-
-//
-//              End Base Proxy Broker Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//                 Remote Proxy Broker Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_PublishesDef_Remote_Proxy_Broker : public virtual _TAO_PublishesDef_Proxy_Broker
-{
-public:
-  _TAO_PublishesDef_Remote_Proxy_Broker (void);
-
-  virtual ~_TAO_PublishesDef_Remote_Proxy_Broker (void);
-
-  virtual _TAO_PublishesDef_Proxy_Impl &select_proxy (
-    IR_PublishesDef *object,
-    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-  );
-
-private:
-  _TAO_PublishesDef_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_PublishesDef_Remote_Proxy_Broker *the_TAO_PublishesDef_Remote_Proxy_Broker (void);
-};
-
-//
-//              End Remote Proxy Broker Declaration
-///////////////////////////////////////////////////////////////////////
-
-// 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_IFR_Client_Export IR_ConsumesDef: public virtual IR_EventDef
-{
-public:
-#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
-  typedef IR_ConsumesDef_ptr _ptr_type;
-  typedef IR_ConsumesDef_var _var_type;
-#endif /* ! __GNUC__ || g++ >= 2.8 */
-
-  // the static operations
-  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 IR_ConsumesDef_ptr _unchecked_narrow (
-      CORBA::Object_ptr obj,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    );
-  static IR_ConsumesDef_ptr _nil (void)
-    {
-      return (IR_ConsumesDef_ptr)0;
-    }
-
-  static void _tao_any_destructor (void*);
-
-  virtual CORBA::Boolean _is_a (
-      const CORBA::Char *type_id,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    );
-  virtual void *_tao_QueryInterface (ptr_arith_t type);
-
-  virtual const char* _interface_repository_id (void) const;
-
-private:
-  _TAO_ConsumesDef_Proxy_Broker *the_TAO_ConsumesDef_Proxy_Broker_;
-
-protected:
-  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 IR_ConsumesDef_setup_collocation (int collocated);
-
-  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;
-
-  virtual ~IR_ConsumesDef (void);
-private:
-  IR_ConsumesDef (const IR_ConsumesDef &);
-  void operator= (const IR_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 */
-
-};
-
-
-// The Proxy Implementations are used by each interface to
-// perform a call. Each different implementation encapsulate
-// an invocation logics.
-
-
-///////////////////////////////////////////////////////////////////////
-//                    Base  Impl. Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_ConsumesDef_Proxy_Impl
-  : public virtual _TAO_EventDef_Proxy_Impl
-{
-public:
-  virtual ~_TAO_ConsumesDef_Proxy_Impl (void) { }
-
-protected:
-  _TAO_ConsumesDef_Proxy_Impl (void);
-
-};
-
-//
-//                Base  Proxy Impl. Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//                    Remote  Impl. Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_ConsumesDef_Remote_Proxy_Impl :
-  public virtual _TAO_ConsumesDef_Proxy_Impl,
-  public virtual TAO_Remote_Object_Proxy_Impl,
-  public virtual _TAO_EventDef_Remote_Proxy_Impl
-
-{
-public:
-  _TAO_ConsumesDef_Remote_Proxy_Impl (void);
-
-  virtual ~_TAO_ConsumesDef_Remote_Proxy_Impl (void) { }
-
-};
-
-//
-//                Base  Proxy Impl. Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-// The Proxy Brokers are used by each interface to get
-// the right proxy for performing a call. In the new
-// collocation scheme, the proxy to be used can vary on
-// a call by call basis.
-
-
-
-///////////////////////////////////////////////////////////////////////
-//                 Base Proxy Broker Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_ConsumesDef_Proxy_Broker
-{
-public:
-  virtual ~_TAO_ConsumesDef_Proxy_Broker (void);
-
-  virtual _TAO_ConsumesDef_Proxy_Impl &select_proxy (
-    IR_ConsumesDef *object,
-    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-  ) = 0;
-
-protected:
-  _TAO_ConsumesDef_Proxy_Broker (void);
-
-};
-
-
-//
-//              End Base Proxy Broker Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//                 Remote Proxy Broker Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_ConsumesDef_Remote_Proxy_Broker : public virtual _TAO_ConsumesDef_Proxy_Broker
-{
-public:
-  _TAO_ConsumesDef_Remote_Proxy_Broker (void);
-
-  virtual ~_TAO_ConsumesDef_Remote_Proxy_Broker (void);
-
-  virtual _TAO_ConsumesDef_Proxy_Impl &select_proxy (
-    IR_ConsumesDef *object,
-    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-  );
-
-private:
-  _TAO_ConsumesDef_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_ConsumesDef_Remote_Proxy_Broker *the_TAO_ConsumesDef_Remote_Proxy_Broker (void);
-};
-
-//
-//              End Remote Proxy Broker Declaration
-///////////////////////////////////////////////////////////////////////
-
-// 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_IFR_Client_Export IR_ComponentDef: public virtual IR_InterfaceDef
-{
-public:
-#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
-  typedef IR_ComponentDef_ptr _ptr_type;
-  typedef IR_ComponentDef_var _var_type;
-#endif /* ! __GNUC__ || g++ >= 2.8 */
-
-  // the static operations
-  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 IR_ComponentDef_ptr _unchecked_narrow (
-      CORBA::Object_ptr obj,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    );
-  static IR_ComponentDef_ptr _nil (void)
-    {
-      return (IR_ComponentDef_ptr)0;
-    }
-
-  static void _tao_any_destructor (void*);
-
-  virtual IR_InterfaceDefSeq * supported_interfaces (
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  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 (
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual IR_PublishesDefSeq * publishes_events (
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual IR_ConsumesDefSeq * consumes_events (
-      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 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:
-  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 IR_ComponentDef_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;
-
-  virtual ~IR_ComponentDef (void);
-private:
-  IR_ComponentDef (const IR_ComponentDef &);
-  void operator= (const IR_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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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;
-  };
-
-  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;
-
-    TAO_ClientRequestInfo_IR_ComponentDef_is_basic_get (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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_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;
-  };
-
-  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;
-
-    TAO_ClientRequestInfo_IR_ComponentDef_create_provides (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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;
-  };
-
-  class TAO_ClientRequestInfo_IR_ComponentDef_create_uses : 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_uses (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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;
-  };
-
-  class TAO_ClientRequestInfo_IR_ComponentDef_create_emits : 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_emits (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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;
-  
-    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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 */
-
-};
-
-// The Proxy Implementations are used by each interface to
-// perform a call. Each different implementation encapsulate
-// an invocation logics.
-
-
-///////////////////////////////////////////////////////////////////////
-//                    Base  Impl. Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_ComponentDef_Proxy_Impl :
-  public virtual _TAO_InterfaceDef_Proxy_Impl
-{
-public:
-  virtual ~_TAO_ComponentDef_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_ComponentDef_ptr base_component (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  virtual IR_ProvidesDefSeq * provides_interfaces (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  virtual IR_UsesDefSeq * uses_interfaces (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  virtual IR_EmitsDefSeq * emits_events (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  virtual IR_PublishesDefSeq * publishes_events (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  virtual IR_ConsumesDefSeq * consumes_events (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  virtual CORBA::Boolean is_basic (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  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,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  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,
-      CORBA::Boolean is_multiple,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  virtual IR_EmitsDef_ptr create_emits (
-      CORBA_Object *_collocated_tao_target_,
-      const char * id,
-      const char * name,
-      const char * version,
-      IR_ValueDef_ptr value,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  virtual IR_PublishesDef_ptr create_publishes (
-      CORBA_Object *_collocated_tao_target_,
-      const char * id,
-      const char * name,
-      const char * version,
-      IR_ValueDef_ptr value,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  virtual IR_ConsumesDef_ptr create_consumes (
-      CORBA_Object *_collocated_tao_target_,
-      const char * id,
-      const char * name,
-      const char * version,
-      IR_ValueDef_ptr value,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-protected:
-  _TAO_ComponentDef_Proxy_Impl (void);
-
-};
-
-//
-//                Base  Proxy Impl. Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//                    Remote  Impl. Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_ComponentDef_Remote_Proxy_Impl :
-  public virtual _TAO_ComponentDef_Proxy_Impl,
-  public virtual TAO_Remote_Object_Proxy_Impl,
-  public virtual _TAO_InterfaceDef_Remote_Proxy_Impl
-
-{
-public:
-  _TAO_ComponentDef_Remote_Proxy_Impl (void);
-
-  virtual ~_TAO_ComponentDef_Remote_Proxy_Impl (void) { }
-
-  virtual IR_InterfaceDefSeq * supported_interfaces (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual void supported_interfaces (
-      CORBA_Object *_collocated_tao_target_,
-      const IR_InterfaceDefSeq & supported_interfaces,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual IR_ComponentDef_ptr base_component (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual IR_ProvidesDefSeq * provides_interfaces (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual IR_UsesDefSeq * uses_interfaces (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual IR_EmitsDefSeq * emits_events (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual IR_PublishesDefSeq * publishes_events (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual IR_ConsumesDefSeq * consumes_events (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual CORBA::Boolean is_basic (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  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,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  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,
-      CORBA::Boolean is_multiple,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual IR_EmitsDef_ptr create_emits (
-      CORBA_Object *_collocated_tao_target_,
-      const char * id,
-      const char * name,
-      const char * version,
-      IR_ValueDef_ptr value,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual IR_PublishesDef_ptr create_publishes (
-      CORBA_Object *_collocated_tao_target_,
-      const char * id,
-      const char * name,
-      const char * version,
-      IR_ValueDef_ptr value,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual IR_ConsumesDef_ptr create_consumes (
-      CORBA_Object *_collocated_tao_target_,
-      const char * id,
-      const char * name,
-      const char * version,
-      IR_ValueDef_ptr value,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-};
-
-//
-//                Base  Proxy Impl. Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-// The Proxy Brokers are used by each interface to get
-// the right proxy for performing a call. In the new
-// collocation scheme, the proxy to be used can vary on
-// a call by call basis.
-
-
-
-///////////////////////////////////////////////////////////////////////
-//                 Base Proxy Broker Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_ComponentDef_Proxy_Broker
-{
-public:
-  virtual ~_TAO_ComponentDef_Proxy_Broker (void);
-
-  virtual _TAO_ComponentDef_Proxy_Impl &select_proxy (
-    IR_ComponentDef *object,
-    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-  ) = 0;
-
-protected:
-  _TAO_ComponentDef_Proxy_Broker (void);
-
-};
-
-
-//
-//              End Base Proxy Broker Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//                 Remote Proxy Broker Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_ComponentDef_Remote_Proxy_Broker : public virtual _TAO_ComponentDef_Proxy_Broker
-{
-public:
-  _TAO_ComponentDef_Remote_Proxy_Broker (void);
-
-  virtual ~_TAO_ComponentDef_Remote_Proxy_Broker (void);
-
-  virtual _TAO_ComponentDef_Proxy_Impl &select_proxy (
-    IR_ComponentDef *object,
-    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-  );
-
-private:
-  _TAO_ComponentDef_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_ComponentDef_Remote_Proxy_Broker *the_TAO_ComponentDef_Remote_Proxy_Broker (void);
-};
-
-//
-//              End Remote Proxy Broker Declaration
-///////////////////////////////////////////////////////////////////////
-
-struct TAO_IFR_Client_Export IR_ComponentDescription
-{
-
-#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
-  typedef IR_ComponentDescription_var _var_type;
-#endif /* ! __GNUC__ || g++ >= 2.8 */
-
-  static void _tao_any_destructor (void*);
-
-  TAO_String_Manager name;
-  TAO_String_Manager id;
-  TAO_String_Manager defined_in;
-  TAO_String_Manager version;
-  TAO_String_Manager base_component;
-  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_IFR_Client_Export IR_ComponentDescription_var
-{
-public:
-  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
-
-  IR_ComponentDescription_var &operator= (IR_ComponentDescription *);
-  IR_ComponentDescription_var &operator= (const IR_ComponentDescription_var &);
-  IR_ComponentDescription *operator-> (void);
-  const IR_ComponentDescription *operator-> (void) const;
-
-  operator const IR_ComponentDescription &() const;
-  operator IR_ComponentDescription &();
-  operator IR_ComponentDescription &() const;
-  operator IR_ComponentDescription *&(); // variable-size types only
-
-  // in, inout, out, _retn
-  const IR_ComponentDescription &in (void) const;
-  IR_ComponentDescription &inout (void);
-  IR_ComponentDescription *&out (void);
-  IR_ComponentDescription *_retn (void);
-  IR_ComponentDescription *ptr (void) const;
-
-private:
-  IR_ComponentDescription *ptr_;
-};
-
-class TAO_IFR_Client_Export IR_ComponentDescription_out
-{
-public:
-  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:
-  IR_ComponentDescription *&ptr_;
-  // assignment from T_var not allowed
-  void operator= (const IR_ComponentDescription_var &);
-};
-
-// 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_IFR_Client_Export IR_PrimaryKeyDef: public virtual IR_Contained
-{
-public:
-#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
-  typedef IR_PrimaryKeyDef_ptr _ptr_type;
-  typedef IR_PrimaryKeyDef_var _var_type;
-#endif /* ! __GNUC__ || g++ >= 2.8 */
-
-  // the static operations
-  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 IR_PrimaryKeyDef_ptr _unchecked_narrow (
-      CORBA::Object_ptr obj,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    );
-  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 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:
-  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 IR_PrimaryKeyDef_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 &);
-
-#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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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_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 */
-
-};
-
-
-// The Proxy Implementations are used by each interface to
-// perform a call. Each different implementation encapsulate
-// an invocation logics.
-
-
-///////////////////////////////////////////////////////////////////////
-//                    Base  Impl. Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_PrimaryKeyDef_Proxy_Impl :
-  public virtual _TAO_Contained_Proxy_Impl
-{
-public:
-  virtual ~_TAO_PrimaryKeyDef_Proxy_Impl (void) { }
-
-  virtual CORBA::Boolean is_a (
-      CORBA_Object *_collocated_tao_target_,
-      const char * primary_key_id,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  virtual IR_ValueDef_ptr primary_key (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-protected:
-  _TAO_PrimaryKeyDef_Proxy_Impl (void);
-
-};
-
-//
-//                Base  Proxy Impl. Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//                    Remote  Impl. Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_PrimaryKeyDef_Remote_Proxy_Impl :
-  public virtual _TAO_PrimaryKeyDef_Proxy_Impl,
-  public virtual TAO_Remote_Object_Proxy_Impl,
-  public virtual _TAO_Contained_Remote_Proxy_Impl
-
-{
-public:
-  _TAO_PrimaryKeyDef_Remote_Proxy_Impl (void);
-
-  virtual ~_TAO_PrimaryKeyDef_Remote_Proxy_Impl (void) { }
-
-  virtual CORBA::Boolean is_a (
-      CORBA_Object *_collocated_tao_target_,
-      const char * primary_key_id,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual IR_ValueDef_ptr primary_key (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-};
-
-//
-//                Base  Proxy Impl. Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-// The Proxy Brokers are used by each interface to get
-// the right proxy for performing a call. In the new
-// collocation scheme, the proxy to be used can vary on
-// a call by call basis.
-
-
-
-///////////////////////////////////////////////////////////////////////
-//                 Base Proxy Broker Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_PrimaryKeyDef_Proxy_Broker
-{
-public:
-  virtual ~_TAO_PrimaryKeyDef_Proxy_Broker (void);
-
-  virtual _TAO_PrimaryKeyDef_Proxy_Impl &select_proxy (
-    IR_PrimaryKeyDef *object,
-    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-  ) = 0;
-
-protected:
-  _TAO_PrimaryKeyDef_Proxy_Broker (void);
-
-};
-
-
-//
-//              End Base Proxy Broker Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//                 Remote Proxy Broker Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_PrimaryKeyDef_Remote_Proxy_Broker : public virtual _TAO_PrimaryKeyDef_Proxy_Broker
-{
-public:
-  _TAO_PrimaryKeyDef_Remote_Proxy_Broker (void);
-
-  virtual ~_TAO_PrimaryKeyDef_Remote_Proxy_Broker (void);
-
-  virtual _TAO_PrimaryKeyDef_Proxy_Impl &select_proxy (
-    IR_PrimaryKeyDef *object,
-    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-  );
-
-private:
-  _TAO_PrimaryKeyDef_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_PrimaryKeyDef_Remote_Proxy_Broker *the_TAO_PrimaryKeyDef_Remote_Proxy_Broker (void);
-};
-
-//
-//              End Remote Proxy Broker Declaration
-///////////////////////////////////////////////////////////////////////
-
-struct TAO_IFR_Client_Export IR_PrimaryKeyDescription
-{
-
-#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
-  typedef IR_PrimaryKeyDescription_var _var_type;
-#endif /* ! __GNUC__ || g++ >= 2.8 */
-
-  static void _tao_any_destructor (void*);
-
-  TAO_String_Manager name;
-  TAO_String_Manager id;
-  TAO_String_Manager defined_in;
-  TAO_String_Manager version;
-  IR_ValueDef_var primary_key;
-};
-
-class TAO_IFR_Client_Export IR_PrimaryKeyDescription_var
-{
-public:
-  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
-
-  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 IR_PrimaryKeyDescription &() const;
-  operator IR_PrimaryKeyDescription &();
-  operator IR_PrimaryKeyDescription &() const;
-  operator IR_PrimaryKeyDescription *&(); // variable-size types only
-
-  // in, inout, out, _retn
-  const IR_PrimaryKeyDescription &in (void) const;
-  IR_PrimaryKeyDescription &inout (void);
-  IR_PrimaryKeyDescription *&out (void);
-  IR_PrimaryKeyDescription *_retn (void);
-  IR_PrimaryKeyDescription *ptr (void) const;
-
-private:
-  IR_PrimaryKeyDescription *ptr_;
-};
-
-class TAO_IFR_Client_Export IR_PrimaryKeyDescription_out
-{
-public:
-  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:
-  IR_PrimaryKeyDescription *&ptr_;
-  // assignment from T_var not allowed
-  void operator= (const IR_PrimaryKeyDescription_var &);
-};
-
-// 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_IFR_Client_Export IR_FactoryDef: public virtual IR_OperationDef
-{
-public:
-#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
-  typedef IR_FactoryDef_ptr _ptr_type;
-  typedef IR_FactoryDef_var _var_type;
-#endif /* ! __GNUC__ || g++ >= 2.8 */
-
-  // the static operations
-  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 IR_FactoryDef_ptr _unchecked_narrow (
-      CORBA::Object_ptr obj,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    );
-  static IR_FactoryDef_ptr _nil (void)
-    {
-      return (IR_FactoryDef_ptr)0;
-    }
-
-  static void _tao_any_destructor (void*);
-
-  virtual CORBA::Boolean _is_a (
-      const CORBA::Char *type_id,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    );
-  virtual void *_tao_QueryInterface (ptr_arith_t type);
-
-  virtual const char* _interface_repository_id (void) const;
-
-private:
-  _TAO_FactoryDef_Proxy_Broker *the_TAO_FactoryDef_Proxy_Broker_;
-
-protected:
-  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 IR_FactoryDef_setup_collocation (int collocated);
-
-  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;
-
-  virtual ~IR_FactoryDef (void);
-private:
-  IR_FactoryDef (const IR_FactoryDef &);
-  void operator= (const IR_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 */
-
-};
-
-
-// The Proxy Implementations are used by each interface to
-// perform a call. Each different implementation encapsulate
-// an invocation logics.
-
-
-///////////////////////////////////////////////////////////////////////
-//                    Base  Impl. Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_FactoryDef_Proxy_Impl
-  : public virtual _TAO_OperationDef_Proxy_Impl
-{
-public:
-  virtual ~_TAO_FactoryDef_Proxy_Impl (void) { }
-
-protected:
-  _TAO_FactoryDef_Proxy_Impl (void);
-
-};
-
-//
-//                Base  Proxy Impl. Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//                    Remote  Impl. Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_FactoryDef_Remote_Proxy_Impl :
-  public virtual _TAO_FactoryDef_Proxy_Impl,
-  public virtual TAO_Remote_Object_Proxy_Impl,
-  public virtual _TAO_OperationDef_Remote_Proxy_Impl
-
-{
-public:
-  _TAO_FactoryDef_Remote_Proxy_Impl (void);
-
-  virtual ~_TAO_FactoryDef_Remote_Proxy_Impl (void) { }
-
-};
-
-//
-//                Base  Proxy Impl. Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-// The Proxy Brokers are used by each interface to get
-// the right proxy for performing a call. In the new
-// collocation scheme, the proxy to be used can vary on
-// a call by call basis.
-
-
-
-///////////////////////////////////////////////////////////////////////
-//                 Base Proxy Broker Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_FactoryDef_Proxy_Broker
-{
-public:
-  virtual ~_TAO_FactoryDef_Proxy_Broker (void);
-
-  virtual _TAO_FactoryDef_Proxy_Impl &select_proxy (
-    IR_FactoryDef *object,
-    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-  ) = 0;
-
-protected:
-  _TAO_FactoryDef_Proxy_Broker (void);
-
-};
-
-
-//
-//              End Base Proxy Broker Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//                 Remote Proxy Broker Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_FactoryDef_Remote_Proxy_Broker : public virtual _TAO_FactoryDef_Proxy_Broker
-{
-public:
-  _TAO_FactoryDef_Remote_Proxy_Broker (void);
-
-  virtual ~_TAO_FactoryDef_Remote_Proxy_Broker (void);
-
-  virtual _TAO_FactoryDef_Proxy_Impl &select_proxy (
-    IR_FactoryDef *object,
-    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-  );
-
-private:
-  _TAO_FactoryDef_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_FactoryDef_Remote_Proxy_Broker *the_TAO_FactoryDef_Remote_Proxy_Broker (void);
-};
-
-//
-//              End Remote Proxy Broker Declaration
-///////////////////////////////////////////////////////////////////////
-
-// 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_IFR_Client_Export IR_FinderDef: public virtual IR_OperationDef
-{
-public:
-#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
-  typedef IR_FinderDef_ptr _ptr_type;
-  typedef IR_FinderDef_var _var_type;
-#endif /* ! __GNUC__ || g++ >= 2.8 */
-
-  // the static operations
-  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 IR_FinderDef_ptr _unchecked_narrow (
-      CORBA::Object_ptr obj,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    );
-  static IR_FinderDef_ptr _nil (void)
-    {
-      return (IR_FinderDef_ptr)0;
-    }
-
-  static void _tao_any_destructor (void*);
-
-  virtual CORBA::Boolean _is_a (
-      const CORBA::Char *type_id,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    );
-  virtual void *_tao_QueryInterface (ptr_arith_t type);
-
-  virtual const char* _interface_repository_id (void) const;
-
-private:
-  _TAO_FinderDef_Proxy_Broker *the_TAO_FinderDef_Proxy_Broker_;
-
-protected:
-  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 IR_FinderDef_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;
-
-  virtual ~IR_FinderDef (void);
-private:
-  IR_FinderDef (const IR_FinderDef &);
-  void operator= (const IR_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 */
-
-};
-
-
-// The Proxy Implementations are used by each interface to
-// perform a call. Each different implementation encapsulate
-// an invocation logics.
-
-
-///////////////////////////////////////////////////////////////////////
-//                    Base  Impl. Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_FinderDef_Proxy_Impl
-  : public virtual _TAO_OperationDef_Proxy_Impl
-{
-public:
-  virtual ~_TAO_FinderDef_Proxy_Impl (void) { }
-
-protected:
-  _TAO_FinderDef_Proxy_Impl (void);
-
-};
-
-//
-//                Base  Proxy Impl. Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//                    Remote  Impl. Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_FinderDef_Remote_Proxy_Impl :
-  public virtual _TAO_FinderDef_Proxy_Impl,
-  public virtual TAO_Remote_Object_Proxy_Impl,
-  public virtual _TAO_OperationDef_Remote_Proxy_Impl
-
-{
-public:
-  _TAO_FinderDef_Remote_Proxy_Impl (void);
-
-  virtual ~_TAO_FinderDef_Remote_Proxy_Impl (void) { }
-
-};
-
-//
-//                Base  Proxy Impl. Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-// The Proxy Brokers are used by each interface to get
-// the right proxy for performing a call. In the new
-// collocation scheme, the proxy to be used can vary on
-// a call by call basis.
-
-
-
-///////////////////////////////////////////////////////////////////////
-//                 Base Proxy Broker Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_FinderDef_Proxy_Broker
-{
-public:
-  virtual ~_TAO_FinderDef_Proxy_Broker (void);
-
-  virtual _TAO_FinderDef_Proxy_Impl &select_proxy (
-    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_IFR_Client_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 (
-    IR_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
-///////////////////////////////////////////////////////////////////////
-
-// Forward Classes Declaration
-class _TAO_HomeDef_Proxy_Impl;
-class _TAO_HomeDef_Remote_Proxy_Impl;
-class _TAO_HomeDef_Proxy_Broker;
-class _TAO_HomeDef_Remote_Proxy_Broker;
-
-class TAO_IFR_Client_Export IR_HomeDef: public virtual IR_InterfaceDef
-{
-public:
-#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
-  typedef IR_HomeDef_ptr _ptr_type;
-  typedef IR_HomeDef_var _var_type;
-#endif /* ! __GNUC__ || g++ >= 2.8 */
-
-  // the static operations
-  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 IR_HomeDef_ptr _unchecked_narrow (
-      CORBA::Object_ptr obj,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    );
-  static IR_HomeDef_ptr _nil (void)
-    {
-      return (IR_HomeDef_ptr)0;
-    }
-
-  static void _tao_any_destructor (void*);
-
-  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 (
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual IR_PrimaryKeyDef_ptr primary_key (
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual IR_FactoryDefSeq * factories (
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual IR_FinderDefSeq * finders (
-      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 IR_PrimaryKeyDef_ptr create_primary_key (
-      const char * id,
-      const char * name,
-      const char * version,
-      IR_ValueDef_ptr primary_key,
-      CORBA::Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual IR_FactoryDef_ptr create_factory (
-      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 ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual IR_FinderDef_ptr create_finder (
-      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 ()
-    )
-    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_HomeDef_Proxy_Broker *the_TAO_HomeDef_Proxy_Broker_;
-
-protected:
-  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 IR_HomeDef_setup_collocation (int collocated);
-
-  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 ~IR_HomeDef (void);
-private:
-  IR_HomeDef (const IR_HomeDef &);
-  void operator= (const IR_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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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_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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 (
-        TAO_GIOP_Invocation *_tao_invocation,
-        CORBA::Object_ptr _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 */
-
-};
-
-
-// The Proxy Implementations are used by each interface to
-// perform a call. Each different implementation encapsulate
-// an invocation logics.
-
-
-///////////////////////////////////////////////////////////////////////
-//                    Base  Impl. Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_HomeDef_Proxy_Impl :
-  public virtual _TAO_InterfaceDef_Proxy_Impl
-{
-public:
-  virtual ~_TAO_HomeDef_Proxy_Impl (void) { }
-
-  virtual IR_HomeDef_ptr base_home (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  virtual IR_ComponentDef_ptr managed_component (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  virtual IR_PrimaryKeyDef_ptr primary_key (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  virtual IR_FactoryDefSeq * factories (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  virtual IR_FinderDefSeq * finders   (
-      CORBA_Object *_collocated_tao_target_,
-            CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  virtual CORBA::Boolean is_basic   (
-      CORBA_Object *_collocated_tao_target_,
-            CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  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,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  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,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  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,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-protected:
-  _TAO_HomeDef_Proxy_Impl (void);
-
-};
-
-//
-//                Base  Proxy Impl. Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//                    Remote  Impl. Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_HomeDef_Remote_Proxy_Impl :
-  public virtual _TAO_HomeDef_Proxy_Impl,
-  public virtual TAO_Remote_Object_Proxy_Impl,
-  public virtual _TAO_InterfaceDef_Remote_Proxy_Impl
-
-{
-public:
-  _TAO_HomeDef_Remote_Proxy_Impl (void);
-
-  virtual ~_TAO_HomeDef_Remote_Proxy_Impl (void) { }
-
-  virtual IR_HomeDef_ptr base_home (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual IR_ComponentDef_ptr managed_component (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual IR_PrimaryKeyDef_ptr primary_key (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual IR_FactoryDefSeq * factories (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual IR_FinderDefSeq * finders (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  virtual CORBA::Boolean is_basic (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  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,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  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,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-  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,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
-
-};
-
-//
-//                Base  Proxy Impl. Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-// The Proxy Brokers are used by each interface to get
-// the right proxy for performing a call. In the new
-// collocation scheme, the proxy to be used can vary on
-// a call by call basis.
-
-
-
-///////////////////////////////////////////////////////////////////////
-//                 Base Proxy Broker Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_HomeDef_Proxy_Broker
-{
-public:
-  virtual ~_TAO_HomeDef_Proxy_Broker (void);
-
-  virtual _TAO_HomeDef_Proxy_Impl &select_proxy (
-    IR_HomeDef *object,
-    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-  ) = 0;
-
-protected:
-  _TAO_HomeDef_Proxy_Broker (void);
-
-};
-
-
-//
-//              End Base Proxy Broker Declaration
-///////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////
-//                 Remote Proxy Broker Declaration
-//
-
-class TAO_IFR_Client_Export _TAO_HomeDef_Remote_Proxy_Broker : public virtual _TAO_HomeDef_Proxy_Broker
-{
-public:
-  _TAO_HomeDef_Remote_Proxy_Broker (void);
-
-  virtual ~_TAO_HomeDef_Remote_Proxy_Broker (void);
-
-  virtual _TAO_HomeDef_Proxy_Impl &select_proxy (
-    IR_HomeDef *object,
-    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-  );
-
-private:
-  _TAO_HomeDef_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_HomeDef_Remote_Proxy_Broker *the_TAO_HomeDef_Remote_Proxy_Broker (void);
-};
-
-//
-//              End Remote Proxy Broker Declaration
-///////////////////////////////////////////////////////////////////////
-
-struct TAO_IFR_Client_Export IR_HomeDescription
-{
-
-#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
-  typedef IR_HomeDescription_var _var_type;
-#endif /* ! __GNUC__ || g++ >= 2.8 */
-
-  static void _tao_any_destructor (void*);
-
-  TAO_String_Manager name;
-  TAO_String_Manager id;
-  TAO_String_Manager defined_in;
-  TAO_String_Manager version;
-  TAO_String_Manager base_home;
-  TAO_String_Manager managed_component;
-  IR_PrimaryKeyDef_var primary_key_def;
-  IR_FactoryDefSeq factories;
-  IR_FinderDefSeq finders;
-  IR_OpDescriptionSeq operations;
-  IR_AttrDescriptionSeq attributes;
-  CORBA::Boolean is_basic;
-};
-
-class TAO_IFR_Client_Export IR_HomeDescription_var
-{
-public:
-  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 IR_HomeDescription &in (void) const;
-  IR_HomeDescription &inout (void);
-  IR_HomeDescription *&out (void);
-  IR_HomeDescription *_retn (void);
-  IR_HomeDescription *ptr (void) const;
-
-private:
-  IR_HomeDescription *ptr_;
-};
-
-class TAO_IFR_Client_Export IR_HomeDescription_out
-{
-public:
-  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:
-  IR_HomeDescription *&ptr_;
-  // assignment from T_var not allowed
-  void operator= (const IR_HomeDescription_var &);
-};
-
-// Proxy Broker Factory function pointer declarations.
-
-extern TAO_IFR_Client_Export _TAO_IRObject_Proxy_Broker * (*_TAO_IRObject_Proxy_Broker_Factory_function_pointer) (
-    CORBA::Object_ptr obj
-  );
-
-extern TAO_IFR_Client_Export _TAO_Contained_Proxy_Broker * (*_TAO_Contained_Proxy_Broker_Factory_function_pointer) (
-    CORBA::Object_ptr obj
-  );
-
-extern TAO_IFR_Client_Export _TAO_Container_Proxy_Broker * (*_TAO_Container_Proxy_Broker_Factory_function_pointer) (
-    CORBA::Object_ptr obj
-  );
-
-extern TAO_IFR_Client_Export _TAO_IDLType_Proxy_Broker * (*_TAO_IDLType_Proxy_Broker_Factory_function_pointer) (
-    CORBA::Object_ptr obj
-  );
-
-extern TAO_IFR_Client_Export _TAO_Repository_Proxy_Broker * (*_TAO_Repository_Proxy_Broker_Factory_function_pointer) (
-    CORBA::Object_ptr obj
-  );
-
-extern TAO_IFR_Client_Export _TAO_ComponentRepository_Proxy_Broker * (*_TAO_ComponentRepository_Proxy_Broker_Factory_function_pointer) (
-    CORBA::Object_ptr obj
-  );
-
-extern TAO_IFR_Client_Export _TAO_ModuleDef_Proxy_Broker * (*_TAO_ModuleDef_Proxy_Broker_Factory_function_pointer) (
-    CORBA::Object_ptr obj
-  );
-
-extern TAO_IFR_Client_Export _TAO_ConstantDef_Proxy_Broker * (*_TAO_ConstantDef_Proxy_Broker_Factory_function_pointer) (
-    CORBA::Object_ptr obj
-  );
-
-extern TAO_IFR_Client_Export _TAO_TypedefDef_Proxy_Broker * (*_TAO_TypedefDef_Proxy_Broker_Factory_function_pointer) (
-    CORBA::Object_ptr obj
-  );
-
-extern TAO_IFR_Client_Export _TAO_StructDef_Proxy_Broker * (*_TAO_StructDef_Proxy_Broker_Factory_function_pointer) (
-    CORBA::Object_ptr obj
-  );
-
-extern TAO_IFR_Client_Export _TAO_UnionDef_Proxy_Broker * (*_TAO_UnionDef_Proxy_Broker_Factory_function_pointer) (
-    CORBA::Object_ptr obj
-  );
-
-extern TAO_IFR_Client_Export _TAO_EnumDef_Proxy_Broker * (*_TAO_EnumDef_Proxy_Broker_Factory_function_pointer) (
-    CORBA::Object_ptr obj
-  );
-
-extern TAO_IFR_Client_Export _TAO_AliasDef_Proxy_Broker * (*_TAO_AliasDef_Proxy_Broker_Factory_function_pointer) (
-    CORBA::Object_ptr obj
-  );
-
-extern TAO_IFR_Client_Export _TAO_NativeDef_Proxy_Broker * (*_TAO_NativeDef_Proxy_Broker_Factory_function_pointer) (
-    CORBA::Object_ptr obj
-  );
-
-extern TAO_IFR_Client_Export _TAO_PrimitiveDef_Proxy_Broker * (*_TAO_PrimitiveDef_Proxy_Broker_Factory_function_pointer) (
-    CORBA::Object_ptr obj
-  );
-
-extern TAO_IFR_Client_Export _TAO_StringDef_Proxy_Broker * (*_TAO_StringDef_Proxy_Broker_Factory_function_pointer) (
-    CORBA::Object_ptr obj
-  );
-
-extern TAO_IFR_Client_Export _TAO_WstringDef_Proxy_Broker * (*_TAO_WstringDef_Proxy_Broker_Factory_function_pointer) (
-    CORBA::Object_ptr obj
-  );
-
-extern TAO_IFR_Client_Export _TAO_FixedDef_Proxy_Broker * (*_TAO_FixedDef_Proxy_Broker_Factory_function_pointer) (
-    CORBA::Object_ptr obj
-  );
-
-extern TAO_IFR_Client_Export _TAO_SequenceDef_Proxy_Broker * (*_TAO_SequenceDef_Proxy_Broker_Factory_function_pointer) (
-    CORBA::Object_ptr obj
-  );
-
-extern TAO_IFR_Client_Export _TAO_ArrayDef_Proxy_Broker * (*_TAO_ArrayDef_Proxy_Broker_Factory_function_pointer) (
-    CORBA::Object_ptr obj
-  );
-
-extern TAO_IFR_Client_Export _TAO_ExceptionDef_Proxy_Broker * (*_TAO_ExceptionDef_Proxy_Broker_Factory_function_pointer) (
-    CORBA::Object_ptr obj
-  );
-
-extern TAO_IFR_Client_Export _TAO_AttributeDef_Proxy_Broker * (*_TAO_AttributeDef_Proxy_Broker_Factory_function_pointer) (
-    CORBA::Object_ptr obj
-  );
-
-extern TAO_IFR_Client_Export _TAO_OperationDef_Proxy_Broker * (*_TAO_OperationDef_Proxy_Broker_Factory_function_pointer) (
-    CORBA::Object_ptr obj
-  );
-
-extern TAO_IFR_Client_Export _TAO_InterfaceDef_Proxy_Broker * (*_TAO_InterfaceDef_Proxy_Broker_Factory_function_pointer) (
-    CORBA::Object_ptr obj
-  );
-
-extern TAO_IFR_Client_Export _TAO_ValueMemberDef_Proxy_Broker * (*_TAO_ValueMemberDef_Proxy_Broker_Factory_function_pointer) (
-    CORBA::Object_ptr obj
-  );
-
-extern TAO_IFR_Client_Export _TAO_ValueDef_Proxy_Broker * (*_TAO_ValueDef_Proxy_Broker_Factory_function_pointer) (
-    CORBA::Object_ptr obj
-  );
-
-extern TAO_IFR_Client_Export _TAO_ValueBoxDef_Proxy_Broker * (*_TAO_ValueBoxDef_Proxy_Broker_Factory_function_pointer) (
-    CORBA::Object_ptr obj
-  );
-
-extern TAO_IFR_Client_Export _TAO_ProvidesDef_Proxy_Broker * (*_TAO_ProvidesDef_Proxy_Broker_Factory_function_pointer) (
-    CORBA::Object_ptr obj
-  );
-
-extern TAO_IFR_Client_Export _TAO_UsesDef_Proxy_Broker * (*_TAO_UsesDef_Proxy_Broker_Factory_function_pointer) (
-    CORBA::Object_ptr obj
-  );
-
-extern TAO_IFR_Client_Export _TAO_EventDef_Proxy_Broker * (*_TAO_EventDef_Proxy_Broker_Factory_function_pointer) (
-    CORBA::Object_ptr obj
-  );
-
-extern TAO_IFR_Client_Export _TAO_EmitsDef_Proxy_Broker * (*_TAO_EmitsDef_Proxy_Broker_Factory_function_pointer) (
-    CORBA::Object_ptr obj
-  );
-
-extern TAO_IFR_Client_Export _TAO_PublishesDef_Proxy_Broker * (*_TAO_PublishesDef_Proxy_Broker_Factory_function_pointer) (
-    CORBA::Object_ptr obj
-  );
-
-extern TAO_IFR_Client_Export _TAO_ConsumesDef_Proxy_Broker * (*_TAO_ConsumesDef_Proxy_Broker_Factory_function_pointer) (
-    CORBA::Object_ptr obj
-  );
-
-extern TAO_IFR_Client_Export _TAO_ComponentDef_Proxy_Broker * (*_TAO_ComponentDef_Proxy_Broker_Factory_function_pointer) (
-    CORBA::Object_ptr obj
-  );
-
-extern TAO_IFR_Client_Export _TAO_PrimaryKeyDef_Proxy_Broker * (*_TAO_PrimaryKeyDef_Proxy_Broker_Factory_function_pointer) (
-    CORBA::Object_ptr obj
-  );
-
-extern TAO_IFR_Client_Export _TAO_FactoryDef_Proxy_Broker * (*_TAO_FactoryDef_Proxy_Broker_Factory_function_pointer) (
-    CORBA::Object_ptr obj
-  );
-
-extern TAO_IFR_Client_Export _TAO_FinderDef_Proxy_Broker * (*_TAO_FinderDef_Proxy_Broker_Factory_function_pointer) (
-    CORBA::Object_ptr obj
-  );
-
-extern TAO_IFR_Client_Export _TAO_HomeDef_Proxy_Broker * (*_TAO_HomeDef_Proxy_Broker_Factory_function_pointer) (
-    CORBA::Object_ptr obj
-  );
-
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR_DefinitionKind);
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_DefinitionKind &);
-// Any operators for interface CORBA_IRObject
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, CORBA_IRObject_ptr);
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA_IRObject *&);
-// Any operators for interface IR_Contained
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR_Contained_ptr);
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_Contained *&);
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const IR_Contained::Description &); // copying version
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR_Contained::Description*); // noncopying version
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_Contained::Description *&); // deprecated
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_Contained::Description *&);
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const IR_InterfaceDefSeq &); // copying version
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR_InterfaceDefSeq*); // noncopying version
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_InterfaceDefSeq *&); // deprecated
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_InterfaceDefSeq *&);
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const IR_ValueDefSeq &); // copying version
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR_ValueDefSeq*); // noncopying version
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_ValueDefSeq *&); // deprecated
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_ValueDefSeq *&);
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const IR_ComponentDefSeq &); // copying version
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR_ComponentDefSeq*); // noncopying version
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_ComponentDefSeq *&); // deprecated
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_ComponentDefSeq *&);
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const IR_ProvidesDefSeq &); // copying version
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR_ProvidesDefSeq*); // noncopying version
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_ProvidesDefSeq *&); // deprecated
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_ProvidesDefSeq *&);
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const IR_UsesDefSeq &); // copying version
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR_UsesDefSeq*); // noncopying version
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_UsesDefSeq *&); // deprecated
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_UsesDefSeq *&);
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const IR_HomeDefSeq &); // copying version
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR_HomeDefSeq*); // noncopying version
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_HomeDefSeq *&); // deprecated
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_HomeDefSeq *&);
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const IR_EmitsDefSeq &); // copying version
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR_EmitsDefSeq*); // noncopying version
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_EmitsDefSeq *&); // deprecated
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_EmitsDefSeq *&);
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const IR_PublishesDefSeq &); // copying version
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR_PublishesDefSeq*); // noncopying version
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_PublishesDefSeq *&); // deprecated
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_PublishesDefSeq *&);
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const IR_ConsumesDefSeq &); // copying version
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR_ConsumesDefSeq*); // noncopying version
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_ConsumesDefSeq *&); // deprecated
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_ConsumesDefSeq *&);
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const IR_FactoryDefSeq &); // copying version
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR_FactoryDefSeq*); // noncopying version
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_FactoryDefSeq *&); // deprecated
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_FactoryDefSeq *&);
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const IR_FinderDefSeq &); // copying version
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR_FinderDefSeq*); // noncopying version
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_FinderDefSeq *&); // deprecated
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_FinderDefSeq *&);
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const IR_ContainedSeq &); // copying version
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR_ContainedSeq*); // noncopying version
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_ContainedSeq *&); // deprecated
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_ContainedSeq *&);
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const IR_StructMember &); // copying version
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR_StructMember*); // noncopying version
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_StructMember *&); // deprecated
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_StructMember *&);
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const IR_StructMemberSeq &); // copying version
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR_StructMemberSeq*); // noncopying version
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_StructMemberSeq *&); // deprecated
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_StructMemberSeq *&);
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const IR_Initializer &); // copying version
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR_Initializer*); // noncopying version
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_Initializer *&); // deprecated
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_Initializer *&);
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const IR_InitializerSeq &); // copying version
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR_InitializerSeq*); // noncopying version
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_InitializerSeq *&); // deprecated
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_InitializerSeq *&);
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const IR_UnionMember &); // copying version
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR_UnionMember*); // noncopying version
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_UnionMember *&); // deprecated
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_UnionMember *&);
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const IR_UnionMemberSeq &); // copying version
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR_UnionMemberSeq*); // noncopying version
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_UnionMemberSeq *&); // deprecated
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_UnionMemberSeq *&);
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const IR_EnumMemberSeq &); // copying version
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR_EnumMemberSeq*); // noncopying version
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_EnumMemberSeq *&); // deprecated
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_EnumMemberSeq *&);
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR_Container_ptr);
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_Container *&);
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const IR_Container::Description &); // copying version
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR_Container::Description*); // noncopying version
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_Container::Description *&); // deprecated
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_Container::Description *&);
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const IR_Container::DescriptionSeq &); // copying version
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR_Container::DescriptionSeq*); // noncopying version
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_Container::DescriptionSeq *&); // deprecated
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_Container::DescriptionSeq *&);
-// Any operators for interface IR_IDLType
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR_IDLType_ptr);
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_IDLType *&);
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR_PrimitiveKind);
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_PrimitiveKind &);
-// Any operators for interface IR_Repository
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR_Repository_ptr);
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_Repository *&);
-// Any operators for interface IR_ComponentRepository
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR_ComponentRepository_ptr);
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_ComponentRepository *&);
-// Any operators for interface IR_ModuleDef
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR_ModuleDef_ptr);
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_ModuleDef *&);
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const IR_ModuleDescription &); // copying version
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR_ModuleDescription*); // noncopying version
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_ModuleDescription *&); // deprecated
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_ModuleDescription *&);
-// Any operators for interface IR_ConstantDef
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR_ConstantDef_ptr);
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_ConstantDef *&);
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const IR_ConstantDescription &); // copying version
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR_ConstantDescription*); // noncopying version
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_ConstantDescription *&); // deprecated
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_ConstantDescription *&);
-// Any operators for interface IR_TypedefDef
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR_TypedefDef_ptr);
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_TypedefDef *&);
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const IR_TypeDescription &); // copying version
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR_TypeDescription*); // noncopying version
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_TypeDescription *&); // deprecated
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_TypeDescription *&);
-// Any operators for interface IR_StructDef
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR_StructDef_ptr);
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_StructDef *&);
-// Any operators for interface IR_UnionDef
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR_UnionDef_ptr);
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_UnionDef *&);
-// Any operators for interface IR_EnumDef
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR_EnumDef_ptr);
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_EnumDef *&);
-// Any operators for interface IR_AliasDef
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR_AliasDef_ptr);
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_AliasDef *&);
-// Any operators for interface IR_NativeDef
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR_NativeDef_ptr);
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_NativeDef *&);
-// Any operators for interface IR_PrimitiveDef
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR_PrimitiveDef_ptr);
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_PrimitiveDef *&);
-// Any operators for interface IR_StringDef
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR_StringDef_ptr);
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_StringDef *&);
-// Any operators for interface IR_WstringDef
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR_WstringDef_ptr);
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_WstringDef *&);
-// Any operators for interface IR_FixedDef
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR_FixedDef_ptr);
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_FixedDef *&);
-// Any operators for interface IR_SequenceDef
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR_SequenceDef_ptr);
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_SequenceDef *&);
-// Any operators for interface IR_ArrayDef
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR_ArrayDef_ptr);
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_ArrayDef *&);
-// Any operators for interface IR_ExceptionDef
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR_ExceptionDef_ptr);
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_ExceptionDef *&);
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const IR_ExceptionDescription &); // copying version
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR_ExceptionDescription*); // noncopying version
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_ExceptionDescription *&); // deprecated
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_ExceptionDescription *&);
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const IR_ExceptionDefSeq &); // copying version
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR_ExceptionDefSeq*); // noncopying version
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_ExceptionDefSeq *&); // deprecated
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_ExceptionDefSeq *&);
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const IR_ExcDescriptionSeq &); // copying version
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR_ExcDescriptionSeq*); // noncopying version
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_ExcDescriptionSeq *&); // deprecated
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_ExcDescriptionSeq *&);
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR_AttributeMode);
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_AttributeMode &);
-// Any operators for interface IR_AttributeDef
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR_AttributeDef_ptr);
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_AttributeDef *&);
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const IR_AttributeDescription &); // copying version
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR_AttributeDescription*); // noncopying version
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_AttributeDescription *&); // deprecated
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_AttributeDescription *&);
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR_OperationMode);
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_OperationMode &);
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR_ParameterMode);
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_ParameterMode &);
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const IR_ParameterDescription &); // copying version
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR_ParameterDescription*); // noncopying version
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_ParameterDescription *&); // deprecated
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_ParameterDescription *&);
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const IR_ParDescriptionSeq &); // copying version
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR_ParDescriptionSeq*); // noncopying version
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_ParDescriptionSeq *&); // deprecated
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_ParDescriptionSeq *&);
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const IR_ContextIdSeq &); // copying version
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR_ContextIdSeq*); // noncopying version
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_ContextIdSeq *&); // deprecated
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_ContextIdSeq *&);
-// Any operators for interface IR_OperationDef
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR_OperationDef_ptr);
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_OperationDef *&);
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const IR_OperationDescription &); // copying version
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR_OperationDescription*); // noncopying version
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_OperationDescription *&); // deprecated
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_OperationDescription *&);
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const IR_RepositoryIdSeq &); // copying version
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR_RepositoryIdSeq*); // noncopying version
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_RepositoryIdSeq *&); // deprecated
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_RepositoryIdSeq *&);
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const IR_OpDescriptionSeq &); // copying version
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR_OpDescriptionSeq*); // noncopying version
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_OpDescriptionSeq *&); // deprecated
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_OpDescriptionSeq *&);
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const IR_AttrDescriptionSeq &); // copying version
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR_AttrDescriptionSeq*); // noncopying version
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_AttrDescriptionSeq *&); // deprecated
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_AttrDescriptionSeq *&);
-// Any operators for interface IR_InterfaceDef
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR_InterfaceDef_ptr);
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_InterfaceDef *&);
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const IR_InterfaceDescription &); // copying version
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR_InterfaceDescription*); // noncopying version
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_InterfaceDescription *&); // deprecated
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_InterfaceDescription *&);
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const IR_ValueMember &); // copying version
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR_ValueMember*); // noncopying version
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_ValueMember *&); // deprecated
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_ValueMember *&);
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const IR_ValueMemberSeq &); // copying version
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR_ValueMemberSeq*); // noncopying version
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_ValueMemberSeq *&); // deprecated
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_ValueMemberSeq *&);
-// Any operators for interface IR_ValueMemberDef
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR_ValueMemberDef_ptr);
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_ValueMemberDef *&);
-// Any operators for interface IR_ValueDef
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR_ValueDef_ptr);
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_ValueDef *&);
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const IR_ValueDescription &); // copying version
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR_ValueDescription*); // noncopying version
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_ValueDescription *&); // deprecated
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_ValueDescription *&);
-// Any operators for interface IR_ValueBoxDef
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR_ValueBoxDef_ptr);
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_ValueBoxDef *&);
-// Any operators for interface IR_ProvidesDef
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR_ProvidesDef_ptr);
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_ProvidesDef *&);
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const IR_ProvidesDescription &); // copying version
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR_ProvidesDescription*); // noncopying version
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_ProvidesDescription *&); // deprecated
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_ProvidesDescription *&);
-// Any operators for interface IR_UsesDef
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR_UsesDef_ptr);
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_UsesDef *&);
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const IR_UsesDescription &); // copying version
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR_UsesDescription*); // noncopying version
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_UsesDescription *&); // deprecated
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_UsesDescription *&);
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const IR_ProvidesDescSeq &); // copying version
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR_ProvidesDescSeq*); // noncopying version
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_ProvidesDescSeq *&); // deprecated
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_ProvidesDescSeq *&);
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const IR_UsesDescSeq &); // copying version
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR_UsesDescSeq*); // noncopying version
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_UsesDescSeq *&); // deprecated
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_UsesDescSeq *&);
-// Any operators for interface IR_EventDef
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR_EventDef_ptr);
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_EventDef *&);
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const IR_EventDescription &); // copying version
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR_EventDescription*); // noncopying version
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_EventDescription *&); // deprecated
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_EventDescription *&);
-// Any operators for interface IR_EmitsDef
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR_EmitsDef_ptr);
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_EmitsDef *&);
-// Any operators for interface IR_PublishesDef
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR_PublishesDef_ptr);
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_PublishesDef *&);
-// Any operators for interface IR_ConsumesDef
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR_ConsumesDef_ptr);
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_ConsumesDef *&);
-// Any operators for interface IR_ComponentDef
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR_ComponentDef_ptr);
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_ComponentDef *&);
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const IR_ComponentDescription &); // copying version
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR_ComponentDescription*); // noncopying version
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_ComponentDescription *&); // deprecated
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_ComponentDescription *&);
-// Any operators for interface IR_PrimaryKeyDef
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR_PrimaryKeyDef_ptr);
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_PrimaryKeyDef *&);
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const IR_PrimaryKeyDescription &); // copying version
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR_PrimaryKeyDescription*); // noncopying version
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_PrimaryKeyDescription *&); // deprecated
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_PrimaryKeyDescription *&);
-// Any operators for interface IR_FactoryDef
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR_FactoryDef_ptr);
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_FactoryDef *&);
-// Any operators for interface IR_FinderDef
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR_FinderDef_ptr);
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_FinderDef *&);
-// Any operators for interface IR_HomeDef
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR_HomeDef_ptr);
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_HomeDef *&);
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, const IR_HomeDescription &); // copying version
-TAO_IFR_Client_Export void operator<<= (CORBA::Any &, IR_HomeDescription*); // noncopying version
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_HomeDescription *&); // deprecated
-TAO_IFR_Client_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_HomeDescription *&);
-
-#ifndef __ACE_INLINE__
-
-TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_DefinitionKind &); //
-TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_DefinitionKind &);
-TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA_IRObject_ptr );
-TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA_IRObject_ptr &);
-TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_Contained_ptr );
-TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_Contained_ptr &);
-TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_Contained::Description &);
-TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_Contained::Description &);
-
-TAO_IFR_Client_Export CORBA::Boolean operator<< (
-    TAO_OutputCDR &,
-    const IR_InterfaceDefSeq &
-  );
-TAO_IFR_Client_Export CORBA::Boolean operator>> (
-    TAO_InputCDR &,
-    IR_InterfaceDefSeq &
-  );
-
-TAO_IFR_Client_Export CORBA::Boolean operator<< (
-    TAO_OutputCDR &,
-    const IR_ValueDefSeq &
-  );
-TAO_IFR_Client_Export CORBA::Boolean operator>> (
-    TAO_InputCDR &,
-    IR_ValueDefSeq &
-  );
-
-TAO_IFR_Client_Export CORBA::Boolean operator<< (
-    TAO_OutputCDR &,
-    const IR_ComponentDefSeq &
-  );
-TAO_IFR_Client_Export CORBA::Boolean operator>> (
-    TAO_InputCDR &,
-    IR_ComponentDefSeq &
-  );
-
-TAO_IFR_Client_Export CORBA::Boolean operator<< (
-    TAO_OutputCDR &,
-    const IR_ProvidesDefSeq &
-  );
-TAO_IFR_Client_Export CORBA::Boolean operator>> (
-    TAO_InputCDR &,
-    IR_ProvidesDefSeq &
-  );
-
-TAO_IFR_Client_Export CORBA::Boolean operator<< (
-    TAO_OutputCDR &,
-    const IR_UsesDefSeq &
-  );
-TAO_IFR_Client_Export CORBA::Boolean operator>> (
-    TAO_InputCDR &,
-    IR_UsesDefSeq &
-  );
-
-TAO_IFR_Client_Export CORBA::Boolean operator<< (
-    TAO_OutputCDR &,
-    const IR_HomeDefSeq &
-  );
-TAO_IFR_Client_Export CORBA::Boolean operator>> (
-    TAO_InputCDR &,
-    IR_HomeDefSeq &
-  );
-
-TAO_IFR_Client_Export CORBA::Boolean operator<< (
-    TAO_OutputCDR &,
-    const IR_EmitsDefSeq &
-  );
-TAO_IFR_Client_Export CORBA::Boolean operator>> (
-    TAO_InputCDR &,
-    IR_EmitsDefSeq &
-  );
-
-TAO_IFR_Client_Export CORBA::Boolean operator<< (
-    TAO_OutputCDR &,
-    const IR_PublishesDefSeq &
-  );
-TAO_IFR_Client_Export CORBA::Boolean operator>> (
-    TAO_InputCDR &,
-    IR_PublishesDefSeq &
-  );
-
-TAO_IFR_Client_Export CORBA::Boolean operator<< (
-    TAO_OutputCDR &,
-    const IR_ConsumesDefSeq &
-  );
-TAO_IFR_Client_Export CORBA::Boolean operator>> (
-    TAO_InputCDR &,
-    IR_ConsumesDefSeq &
-  );
-
-TAO_IFR_Client_Export CORBA::Boolean operator<< (
-    TAO_OutputCDR &,
-    const IR_FactoryDefSeq &
-  );
-TAO_IFR_Client_Export CORBA::Boolean operator>> (
-    TAO_InputCDR &,
-    IR_FactoryDefSeq &
-  );
-
-TAO_IFR_Client_Export CORBA::Boolean operator<< (
-    TAO_OutputCDR &,
-    const IR_FinderDefSeq &
-  );
-TAO_IFR_Client_Export CORBA::Boolean operator>> (
-    TAO_InputCDR &,
-    IR_FinderDefSeq &
-  );
-
-TAO_IFR_Client_Export CORBA::Boolean operator<< (
-    TAO_OutputCDR &,
-    const IR_ContainedSeq &
-  );
-TAO_IFR_Client_Export CORBA::Boolean operator>> (
-    TAO_InputCDR &,
-    IR_ContainedSeq &
-  );
-
-TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_StructMember &);
-TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_StructMember &);
-
-TAO_IFR_Client_Export CORBA::Boolean operator<< (
-    TAO_OutputCDR &,
-    const IR_StructMemberSeq &
-  );
-TAO_IFR_Client_Export CORBA::Boolean operator>> (
-    TAO_InputCDR &,
-    IR_StructMemberSeq &
-  );
-
-TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_Initializer &);
-TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_Initializer &);
-
-TAO_IFR_Client_Export CORBA::Boolean operator<< (
-    TAO_OutputCDR &,
-    const IR_InitializerSeq &
-  );
-TAO_IFR_Client_Export CORBA::Boolean operator>> (
-    TAO_InputCDR &,
-    IR_InitializerSeq &
-  );
-
-TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_UnionMember &);
-TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_UnionMember &);
-
-TAO_IFR_Client_Export CORBA::Boolean operator<< (
-    TAO_OutputCDR &,
-    const IR_UnionMemberSeq &
-  );
-TAO_IFR_Client_Export CORBA::Boolean operator>> (
-    TAO_InputCDR &,
-    IR_UnionMemberSeq &
-  );
-
-TAO_IFR_Client_Export CORBA::Boolean operator<< (
-    TAO_OutputCDR &,
-    const IR_EnumMemberSeq &
-  );
-TAO_IFR_Client_Export CORBA::Boolean operator>> (
-    TAO_InputCDR &,
-    IR_EnumMemberSeq &
-  );
-
-TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_Container_ptr );
-TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_Container_ptr &);
-TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_Container::Description &);
-TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_Container::Description &);
-
-TAO_IFR_Client_Export CORBA::Boolean operator<< (
-    TAO_OutputCDR &,
-    const IR_Container::DescriptionSeq &
-  );
-TAO_IFR_Client_Export CORBA::Boolean operator>> (
-    TAO_InputCDR &,
-    IR_Container::DescriptionSeq &
-  );
-
-TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_IDLType_ptr );
-TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_IDLType_ptr &);
-TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_PrimitiveKind &); //
-TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_PrimitiveKind &);
-TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_Repository_ptr );
-TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_Repository_ptr &);
-TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_ComponentRepository_ptr );
-TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_ComponentRepository_ptr &);
-TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_ModuleDef_ptr );
-TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_ModuleDef_ptr &);
-TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_ModuleDescription &);
-TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_ModuleDescription &);
-TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_ConstantDef_ptr );
-TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_ConstantDef_ptr &);
-TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_ConstantDescription &);
-TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_ConstantDescription &);
-TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_TypedefDef_ptr );
-TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_TypedefDef_ptr &);
-TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_TypeDescription &);
-TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_TypeDescription &);
-TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_StructDef_ptr );
-TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_StructDef_ptr &);
-TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_UnionDef_ptr );
-TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_UnionDef_ptr &);
-TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_EnumDef_ptr );
-TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_EnumDef_ptr &);
-TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_AliasDef_ptr );
-TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_AliasDef_ptr &);
-TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_NativeDef_ptr );
-TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_NativeDef_ptr &);
-TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_PrimitiveDef_ptr );
-TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_PrimitiveDef_ptr &);
-TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_StringDef_ptr );
-TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_StringDef_ptr &);
-TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_WstringDef_ptr );
-TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_WstringDef_ptr &);
-TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_FixedDef_ptr );
-TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_FixedDef_ptr &);
-TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_SequenceDef_ptr );
-TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_SequenceDef_ptr &);
-TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_ArrayDef_ptr );
-TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_ArrayDef_ptr &);
-TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_ExceptionDef_ptr );
-TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_ExceptionDef_ptr &);
-TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_ExceptionDescription &);
-TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_ExceptionDescription &);
-
-TAO_IFR_Client_Export CORBA::Boolean operator<< (
-    TAO_OutputCDR &,
-    const IR_ExceptionDefSeq &
-  );
-TAO_IFR_Client_Export CORBA::Boolean operator>> (
-    TAO_InputCDR &,
-    IR_ExceptionDefSeq &
-  );
-
-TAO_IFR_Client_Export CORBA::Boolean operator<< (
-    TAO_OutputCDR &,
-    const IR_ExcDescriptionSeq &
-  );
-TAO_IFR_Client_Export CORBA::Boolean operator>> (
-    TAO_InputCDR &,
-    IR_ExcDescriptionSeq &
-  );
-
-TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_AttributeMode &); //
-TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_AttributeMode &);
-TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_AttributeDef_ptr );
-TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_AttributeDef_ptr &);
-TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_AttributeDescription &);
-TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_AttributeDescription &);
-TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_OperationMode &); //
-TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_OperationMode &);
-TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_ParameterMode &); //
-TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_ParameterMode &);
-TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_ParameterDescription &);
-TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_ParameterDescription &);
-
-TAO_IFR_Client_Export CORBA::Boolean operator<< (
-    TAO_OutputCDR &,
-    const IR_ParDescriptionSeq &
-  );
-TAO_IFR_Client_Export CORBA::Boolean operator>> (
-    TAO_InputCDR &,
-    IR_ParDescriptionSeq &
-  );
-
-TAO_IFR_Client_Export CORBA::Boolean operator<< (
-    TAO_OutputCDR &,
-    const IR_ContextIdSeq &
-  );
-TAO_IFR_Client_Export CORBA::Boolean operator>> (
-    TAO_InputCDR &,
-    IR_ContextIdSeq &
-  );
-
-TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_OperationDef_ptr );
-TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_OperationDef_ptr &);
-TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_OperationDescription &);
-TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_OperationDescription &);
-
-TAO_IFR_Client_Export CORBA::Boolean operator<< (
-    TAO_OutputCDR &,
-    const IR_RepositoryIdSeq &
-  );
-TAO_IFR_Client_Export CORBA::Boolean operator>> (
-    TAO_InputCDR &,
-    IR_RepositoryIdSeq &
-  );
-
-TAO_IFR_Client_Export CORBA::Boolean operator<< (
-    TAO_OutputCDR &,
-    const IR_OpDescriptionSeq &
-  );
-TAO_IFR_Client_Export CORBA::Boolean operator>> (
-    TAO_InputCDR &,
-    IR_OpDescriptionSeq &
-  );
-
-TAO_IFR_Client_Export CORBA::Boolean operator<< (
-    TAO_OutputCDR &,
-    const IR_AttrDescriptionSeq &
-  );
-TAO_IFR_Client_Export CORBA::Boolean operator>> (
-    TAO_InputCDR &,
-    IR_AttrDescriptionSeq &
-  );
-
-TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_InterfaceDef_ptr );
-TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_InterfaceDef_ptr &);
-TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_InterfaceDescription &);
-TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_InterfaceDescription &);
-TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_ValueMember &);
-TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_ValueMember &);
-
-TAO_IFR_Client_Export CORBA::Boolean operator<< (
-    TAO_OutputCDR &,
-    const IR_ValueMemberSeq &
-  );
-TAO_IFR_Client_Export CORBA::Boolean operator>> (
-    TAO_InputCDR &,
-    IR_ValueMemberSeq &
-  );
-
-TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_ValueMemberDef_ptr );
-TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_ValueMemberDef_ptr &);
-TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_ValueDef_ptr );
-TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_ValueDef_ptr &);
-TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_ValueDescription &);
-TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_ValueDescription &);
-TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_ValueBoxDef_ptr );
-TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_ValueBoxDef_ptr &);
-TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_ProvidesDef_ptr );
-TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_ProvidesDef_ptr &);
-TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_ProvidesDescription &);
-TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_ProvidesDescription &);
-TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_UsesDef_ptr );
-TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_UsesDef_ptr &);
-TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_UsesDescription &);
-TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_UsesDescription &);
-
-TAO_IFR_Client_Export CORBA::Boolean operator<< (
-    TAO_OutputCDR &,
-    const IR_ProvidesDescSeq &
-  );
-TAO_IFR_Client_Export CORBA::Boolean operator>> (
-    TAO_InputCDR &,
-    IR_ProvidesDescSeq &
-  );
-
-TAO_IFR_Client_Export CORBA::Boolean operator<< (
-    TAO_OutputCDR &,
-    const IR_UsesDescSeq &
-  );
-TAO_IFR_Client_Export CORBA::Boolean operator>> (
-    TAO_InputCDR &,
-    IR_UsesDescSeq &
-  );
-
-TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_EventDef_ptr );
-TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_EventDef_ptr &);
-TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_EventDescription &);
-TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_EventDescription &);
-TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_EmitsDef_ptr );
-TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_EmitsDef_ptr &);
-TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_PublishesDef_ptr );
-TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_PublishesDef_ptr &);
-TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_ConsumesDef_ptr );
-TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_ConsumesDef_ptr &);
-TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_ComponentDef_ptr );
-TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_ComponentDef_ptr &);
-TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_ComponentDescription &);
-TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_ComponentDescription &);
-TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_PrimaryKeyDef_ptr );
-TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_PrimaryKeyDef_ptr &);
-TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_PrimaryKeyDescription &);
-TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_PrimaryKeyDescription &);
-TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_FactoryDef_ptr );
-TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_FactoryDef_ptr &);
-TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_FinderDef_ptr );
-TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_FinderDef_ptr &);
-TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_HomeDef_ptr );
-TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_HomeDef_ptr &);
-TAO_IFR_Client_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_HomeDescription &);
-TAO_IFR_Client_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_HomeDescription &);
-
-#endif /* __ACE_INLINE__ */
-
-
-#if defined (__ACE_INLINE__)
-#include "InterfaceC.i"
-#endif /* defined INLINE */
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-#pragma warning(pop)
-#endif /* _MSC_VER */
-
-#if defined (__BORLANDC__)
-#pragma option pop
-#endif /* __BORLANDC__ */
-
-#include "ace/post.h"
-#endif /* ifndef */
diff --git a/TAO/tao/IFR_Client/InterfaceC.i b/TAO/tao/IFR_Client/InterfaceC.i
deleted file mode 100644
index 211172973c0..00000000000
--- a/TAO/tao/IFR_Client/InterfaceC.i
+++ /dev/null
@@ -1,22315 +0,0 @@
-// -*- C++ -*-
-//
-//$Id$
-
-// ****  Code generated by the The ACE ORB (TAO) IDL Compiler ****
-// TAO and the TAO IDL Compiler have been developed by:
-//       Center for Distributed Object Computing
-//       Washington University
-//       St. Louis, MO
-//       USA
-//       http://www.cs.wustl.edu/~schmidt/doc-center.html
-// and
-//       Distributed Object Computing Laboratory
-//       University of California at Irvine
-//       Irvine, CA
-//       USA
-//       http://doc.ece.uci.edu/
-//
-// Information about TAO is available at:
-//     http://www.cs.wustl.edu/~schmidt/TAO.html
-
-ACE_INLINE
-CORBA_IRObject::CORBA_IRObject (
-    TAO_Stub *objref,
-    CORBA::Boolean _tao_collocated,
-    TAO_Abstract_ServantBase *servant
-  )
-  : CORBA_Object (objref, _tao_collocated, servant)
-{
-  this->CORBA_IRObject_setup_collocation (_tao_collocated);
-}
-
-// *************************************************************
-// Inline operations for class CORBA_IRObject_var
-// *************************************************************
-
-ACE_INLINE
-CORBA_IRObject_var::CORBA_IRObject_var (void) // default constructor
-  : ptr_ (CORBA_IRObject::_nil ())
-{}
-
-ACE_INLINE ::CORBA_IRObject_ptr
-CORBA_IRObject_var::ptr (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE
-CORBA_IRObject_var::CORBA_IRObject_var (const ::CORBA_IRObject_var &p) // copy constructor
-  : TAO_Base_var (),
-    ptr_ (CORBA_IRObject::_duplicate (p.ptr ()))
-{}
-
-ACE_INLINE
-CORBA_IRObject_var::~CORBA_IRObject_var (void) // destructor
-{
-  CORBA::release (this->ptr_);
-}
-
-ACE_INLINE CORBA_IRObject_var &
-CORBA_IRObject_var::operator= (CORBA_IRObject_ptr p)
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE CORBA_IRObject_var &
-CORBA_IRObject_var::operator= (const CORBA_IRObject_var &p)
-{
-  if (this != &p)
-  {
-    CORBA::release (this->ptr_);
-    this->ptr_ = ::CORBA_IRObject::_duplicate (p.ptr ());
-  }
-  return *this;
-}
-
-ACE_INLINE 
-CORBA_IRObject_var::operator const ::CORBA_IRObject_ptr &() const // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE 
-CORBA_IRObject_var::operator ::CORBA_IRObject_ptr &() // cast 
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::CORBA_IRObject_ptr
-CORBA_IRObject_var::operator-> (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::CORBA_IRObject_ptr
-CORBA_IRObject_var::in (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::CORBA_IRObject_ptr &
-CORBA_IRObject_var::inout (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::CORBA_IRObject_ptr &
-CORBA_IRObject_var::out (void)
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = ::CORBA_IRObject::_nil ();
-  return this->ptr_;
-}
-
-ACE_INLINE ::CORBA_IRObject_ptr
-CORBA_IRObject_var::_retn (void)
-{
-  // yield ownership of managed obj reference
-  ::CORBA_IRObject_ptr val = this->ptr_;
-  this->ptr_ = ::CORBA_IRObject::_nil ();
-  return val;
-}
-
-// *************************************************************
-// Inline operations for class CORBA_IRObject_out
-// *************************************************************
-
-ACE_INLINE
-CORBA_IRObject_out::CORBA_IRObject_out (CORBA_IRObject_ptr &p)
-  : ptr_ (p)
-{
-  this->ptr_ = ::CORBA_IRObject::_nil ();
-}
-
-ACE_INLINE
-CORBA_IRObject_out::CORBA_IRObject_out (CORBA_IRObject_var &p) // constructor from _var
-  : ptr_ (p.out ())
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = ::CORBA_IRObject::_nil ();
-}
-
-ACE_INLINE
-CORBA_IRObject_out::CORBA_IRObject_out (const ::CORBA_IRObject_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (CORBA_IRObject_out &, p).ptr_)
-{}
-
-ACE_INLINE ::CORBA_IRObject_out &
-CORBA_IRObject_out::operator= (const CORBA_IRObject_out &p)
-{
-  this->ptr_ = ACE_const_cast (CORBA_IRObject_out&, p).ptr_;
-  return *this;
-}
-
-ACE_INLINE CORBA_IRObject_out &
-CORBA_IRObject_out::operator= (const CORBA_IRObject_var &p)
-{
-  this->ptr_ = ::CORBA_IRObject::_duplicate (p.ptr ());
-  return *this;
-}
-
-ACE_INLINE CORBA_IRObject_out &
-CORBA_IRObject_out::operator= (CORBA_IRObject_ptr p)
-{
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE 
-CORBA_IRObject_out::operator ::CORBA_IRObject_ptr &() // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::CORBA_IRObject_ptr &
-CORBA_IRObject_out::ptr (void) // ptr
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::CORBA_IRObject_ptr
-CORBA_IRObject_out::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE
-IR_Contained::IR_Contained (
-    TAO_Stub *objref,
-    CORBA::Boolean _tao_collocated,
-    TAO_Abstract_ServantBase *servant
-  )
-  : CORBA_Object (objref, _tao_collocated, servant)
-{
-  this->IR_Contained_setup_collocation (_tao_collocated);
-}
-
-// *************************************************************
-// Inline operations for class IR_Contained_var
-// *************************************************************
-
-ACE_INLINE
-IR_Contained_var::IR_Contained_var (void) // default constructor
-  : ptr_ (IR_Contained::_nil ())
-{}
-
-ACE_INLINE IR_Contained_ptr 
-IR_Contained_var::ptr (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE
-IR_Contained_var::IR_Contained_var (const IR_Contained_var &p) // copy constructor
-  : TAO_Base_var (),
-    ptr_ (IR_Contained::_duplicate (p.ptr ()))
-{}
-
-ACE_INLINE
-IR_Contained_var::~IR_Contained_var (void) // destructor
-{
-  CORBA::release (this->ptr_);
-}
-
-ACE_INLINE IR_Contained_var &
-IR_Contained_var::operator= (IR_Contained_ptr p)
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE IR_Contained_var &
-IR_Contained_var::operator= (const IR_Contained_var &p)
-{
-  if (this != &p)
-  {
-    CORBA::release (this->ptr_);
-    this->ptr_ = IR_Contained::_duplicate (p.ptr ());
-  }
-  return *this;
-}
-
-ACE_INLINE 
-IR_Contained_var::operator const IR_Contained_ptr &() const // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE 
-IR_Contained_var::operator IR_Contained_ptr &() // cast 
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_Contained_ptr 
-IR_Contained_var::operator-> (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_Contained_ptr
-IR_Contained_var::in (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_Contained_ptr &
-IR_Contained_var::inout (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_Contained_ptr &
-IR_Contained_var::out (void)
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = IR_Contained::_nil ();
-  return this->ptr_;
-}
-
-ACE_INLINE IR_Contained_ptr 
-IR_Contained_var::_retn (void)
-{
-  // yield ownership of managed obj reference
-  IR_Contained_ptr val = this->ptr_;
-  this->ptr_ = IR_Contained::_nil ();
-  return val;
-}
-
-// *************************************************************
-// Inline operations for class IR_Contained_out
-// *************************************************************
-
-ACE_INLINE
-IR_Contained_out::IR_Contained_out (IR_Contained_ptr &p)
-  : ptr_ (p)
-{
-  this->ptr_ = IR_Contained::_nil ();
-}
-
-ACE_INLINE
-IR_Contained_out::IR_Contained_out (IR_Contained_var &p) // constructor from _var
-  : ptr_ (p.out ())
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = IR_Contained::_nil ();
-}
-
-ACE_INLINE
-IR_Contained_out::IR_Contained_out (const IR_Contained_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (IR_Contained_out&,p).ptr_)
-{}
-
-ACE_INLINE IR_Contained_out &
-IR_Contained_out::operator= (const IR_Contained_out &p)
-{
-  this->ptr_ = ACE_const_cast (IR_Contained_out&,p).ptr_;
-  return *this;
-}
-
-ACE_INLINE IR_Contained_out &
-IR_Contained_out::operator= (const IR_Contained_var &p)
-{
-  this->ptr_ = IR_Contained::_duplicate (p.ptr ());
-  return *this;
-}
-
-ACE_INLINE IR_Contained_out &
-IR_Contained_out::operator= (IR_Contained_ptr p)
-{
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE 
-IR_Contained_out::operator IR_Contained_ptr &() // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_Contained_ptr &
-IR_Contained_out::ptr (void) // ptr
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_Contained_ptr 
-IR_Contained_out::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE
-IR_Repository::IR_Repository (
-    TAO_Stub *objref,
-    CORBA::Boolean _tao_collocated,
-    TAO_Abstract_ServantBase *servant
-  )
-  : CORBA_Object (objref, _tao_collocated, servant)
-{
-  this->IR_Repository_setup_collocation (_tao_collocated);
-}
-
-// *************************************************************
-// Inline operations for class IR_Repository_var
-// *************************************************************
-
-ACE_INLINE
-IR_Repository_var::IR_Repository_var (void) // default constructor
-  : ptr_ (IR_Repository::_nil ())
-{}
-
-ACE_INLINE IR_Repository_ptr 
-IR_Repository_var::ptr (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE
-IR_Repository_var::IR_Repository_var (const IR_Repository_var &p) // copy constructor
-  : TAO_Base_var (),
-    ptr_ (IR_Repository::_duplicate (p.ptr ()))
-{}
-
-ACE_INLINE
-IR_Repository_var::~IR_Repository_var (void) // destructor
-{
-  CORBA::release (this->ptr_);
-}
-
-ACE_INLINE IR_Repository_var &
-IR_Repository_var::operator= (IR_Repository_ptr p)
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE IR_Repository_var &
-IR_Repository_var::operator= (const IR_Repository_var &p)
-{
-  if (this != &p)
-  {
-    CORBA::release (this->ptr_);
-    this->ptr_ = IR_Repository::_duplicate (p.ptr ());
-  }
-  return *this;
-}
-
-ACE_INLINE 
-IR_Repository_var::operator const IR_Repository_ptr &() const // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE 
-IR_Repository_var::operator IR_Repository_ptr &() // cast 
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_Repository_ptr 
-IR_Repository_var::operator-> (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_Repository_ptr
-IR_Repository_var::in (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_Repository_ptr &
-IR_Repository_var::inout (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_Repository_ptr &
-IR_Repository_var::out (void)
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = IR_Repository::_nil ();
-  return this->ptr_;
-}
-
-ACE_INLINE IR_Repository_ptr 
-IR_Repository_var::_retn (void)
-{
-  // yield ownership of managed obj reference
-  IR_Repository_ptr val = this->ptr_;
-  this->ptr_ = IR_Repository::_nil ();
-  return val;
-}
-
-// *************************************************************
-// Inline operations for class IR_Repository_out
-// *************************************************************
-
-ACE_INLINE
-IR_Repository_out::IR_Repository_out (IR_Repository_ptr &p)
-  : ptr_ (p)
-{
-  this->ptr_ = IR_Repository::_nil ();
-}
-
-ACE_INLINE
-IR_Repository_out::IR_Repository_out (IR_Repository_var &p) // constructor from _var
-  : ptr_ (p.out ())
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = IR_Repository::_nil ();
-}
-
-ACE_INLINE
-IR_Repository_out::IR_Repository_out (const IR_Repository_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (IR_Repository_out&,p).ptr_)
-{}
-
-ACE_INLINE IR_Repository_out &
-IR_Repository_out::operator= (const IR_Repository_out &p)
-{
-  this->ptr_ = ACE_const_cast (IR_Repository_out&,p).ptr_;
-  return *this;
-}
-
-ACE_INLINE IR_Repository_out &
-IR_Repository_out::operator= (const IR_Repository_var &p)
-{
-  this->ptr_ = IR_Repository::_duplicate (p.ptr ());
-  return *this;
-}
-
-ACE_INLINE IR_Repository_out &
-IR_Repository_out::operator= (IR_Repository_ptr p)
-{
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE 
-IR_Repository_out::operator IR_Repository_ptr &() // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_Repository_ptr &
-IR_Repository_out::ptr (void) // ptr
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_Repository_ptr 
-IR_Repository_out::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE
-IR_Container::IR_Container (
-    TAO_Stub *objref,
-    CORBA::Boolean _tao_collocated,
-    TAO_Abstract_ServantBase *servant
-  )
-  : CORBA_Object (objref, _tao_collocated, servant)
-{
-  this->IR_Container_setup_collocation (_tao_collocated);
-}
-
-// *************************************************************
-// Inline operations for class IR_Container_var
-// *************************************************************
-
-ACE_INLINE
-IR_Container_var::IR_Container_var (void) // default constructor
-  : ptr_ (IR_Container::_nil ())
-{}
-
-ACE_INLINE IR_Container_ptr 
-IR_Container_var::ptr (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE
-IR_Container_var::IR_Container_var (const IR_Container_var &p) // copy constructor
-  : TAO_Base_var (),
-    ptr_ (IR_Container::_duplicate (p.ptr ()))
-{}
-
-ACE_INLINE
-IR_Container_var::~IR_Container_var (void) // destructor
-{
-  CORBA::release (this->ptr_);
-}
-
-ACE_INLINE IR_Container_var &
-IR_Container_var::operator= (IR_Container_ptr p)
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE IR_Container_var &
-IR_Container_var::operator= (const IR_Container_var &p)
-{
-  if (this != &p)
-  {
-    CORBA::release (this->ptr_);
-    this->ptr_ = IR_Container::_duplicate (p.ptr ());
-  }
-  return *this;
-}
-
-ACE_INLINE 
-IR_Container_var::operator const IR_Container_ptr &() const // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE 
-IR_Container_var::operator IR_Container_ptr &() // cast 
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_Container_ptr 
-IR_Container_var::operator-> (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_Container_ptr
-IR_Container_var::in (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_Container_ptr &
-IR_Container_var::inout (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_Container_ptr &
-IR_Container_var::out (void)
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = IR_Container::_nil ();
-  return this->ptr_;
-}
-
-ACE_INLINE IR_Container_ptr 
-IR_Container_var::_retn (void)
-{
-  // yield ownership of managed obj reference
-  IR_Container_ptr val = this->ptr_;
-  this->ptr_ = IR_Container::_nil ();
-  return val;
-}
-
-// *************************************************************
-// Inline operations for class IR_Container_out
-// *************************************************************
-
-ACE_INLINE
-IR_Container_out::IR_Container_out (IR_Container_ptr &p)
-  : ptr_ (p)
-{
-  this->ptr_ = IR_Container::_nil ();
-}
-
-ACE_INLINE
-IR_Container_out::IR_Container_out (IR_Container_var &p) // constructor from _var
-  : ptr_ (p.out ())
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = IR_Container::_nil ();
-}
-
-ACE_INLINE
-IR_Container_out::IR_Container_out (const IR_Container_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (IR_Container_out&,p).ptr_)
-{}
-
-ACE_INLINE IR_Container_out &
-IR_Container_out::operator= (const IR_Container_out &p)
-{
-  this->ptr_ = ACE_const_cast (IR_Container_out&,p).ptr_;
-  return *this;
-}
-
-ACE_INLINE IR_Container_out &
-IR_Container_out::operator= (const IR_Container_var &p)
-{
-  this->ptr_ = IR_Container::_duplicate (p.ptr ());
-  return *this;
-}
-
-ACE_INLINE IR_Container_out &
-IR_Container_out::operator= (IR_Container_ptr p)
-{
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE 
-IR_Container_out::operator IR_Container_ptr &() // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_Container_ptr &
-IR_Container_out::ptr (void) // ptr
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_Container_ptr 
-IR_Container_out::operator-> (void)
-{
-  return this->ptr_;
-}
-
-// *************************************************************
-// Inline operations for class IR_Contained::Description_var
-// *************************************************************
-
-ACE_INLINE
-IR_Contained::Description_var::Description_var (void) // default constructor
-  : ptr_ (0)
-{}
-
-ACE_INLINE
-IR_Contained::Description_var::Description_var (Description *p)
-  : ptr_ (p)
-{}
-
-ACE_INLINE
-IR_Contained::Description_var::Description_var (const ::IR_Contained::Description_var &p) // copy constructor
-{
-  if (p.ptr_)
-    ACE_NEW (this->ptr_, ::IR_Contained::Description (*p.ptr_));
-  else
-    this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_Contained::Description_var::~Description_var (void) // destructor
-{
-  delete this->ptr_;
-}
-
-ACE_INLINE IR_Contained::Description_var &
-IR_Contained::Description_var::operator= (Description *p)
-{
-  delete this->ptr_;
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE ::IR_Contained::Description_var &
-IR_Contained::Description_var::operator= (const ::IR_Contained::Description_var &p)
-{
-  if (this != &p)
-    {
-      if (p.ptr_ == 0)
-        {
-          delete this->ptr_;
-          this->ptr_ = 0;
-        }
-      else
-        {
-          IR_Contained::Description *deep_copy = 
-            new IR_Contained::Description (*p.ptr_);
-          
-          if (deep_copy != 0)
-            {
-              IR_Contained::Description *tmp = deep_copy;
-              deep_copy = this->ptr_;
-              this->ptr_ = tmp;
-              delete deep_copy;
-            }
-        }
-    }
-  
-  return *this;
-}
-
-ACE_INLINE const ::IR_Contained::Description *
-IR_Contained::Description_var::operator-> (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_Contained::Description *
-IR_Contained::Description_var::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE
-IR_Contained::Description_var::operator const ::IR_Contained::Description &() const // cast
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE
-IR_Contained::Description_var::operator ::IR_Contained::Description &() // cast 
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE
-IR_Contained::Description_var::operator ::IR_Contained::Description &() const // cast 
-{
-  return *this->ptr_;
-}
-
-// variable-size types only
-ACE_INLINE
-IR_Contained::Description_var::operator ::IR_Contained::Description *&() // cast 
-{
-  return this->ptr_;
-}
-
-ACE_INLINE const ::IR_Contained::Description &
-IR_Contained::Description_var::in (void) const
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE ::IR_Contained::Description &
-IR_Contained::Description_var::inout (void)
-{
-  return *this->ptr_;
-}
-
-// mapping for variable size 
-ACE_INLINE ::IR_Contained::Description *&
-IR_Contained::Description_var::out (void)
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_Contained::Description *
-IR_Contained::Description_var::_retn (void)
-{
-  ::IR_Contained::Description *tmp = this->ptr_;
-  this->ptr_ = 0;
-  return tmp;
-}
-
-ACE_INLINE ::IR_Contained::Description *
-IR_Contained::Description_var::ptr (void) const
-{
-  return this->ptr_;
-}
-
-// *************************************************************
-// Inline operations for class IR_Contained::Description_out
-// *************************************************************
-
-ACE_INLINE
-IR_Contained::Description_out::Description_out (::IR_Contained::Description *&p)
-  : ptr_ (p)
-{
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_Contained::Description_out::Description_out (Description_var &p) // constructor from _var
-  : ptr_ (p.out ())
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_Contained::Description_out::Description_out (const ::IR_Contained::Description_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (Description_out&, p).ptr_)
-{}
-
-ACE_INLINE IR_Contained::Description_out &
-IR_Contained::Description_out::operator= (const ::IR_Contained::Description_out &p)
-{
-  this->ptr_ = ACE_const_cast (Description_out&, p).ptr_;
-  return *this;
-}
-
-ACE_INLINE IR_Contained::Description_out &
-IR_Contained::Description_out::operator= (Description *p)
-{
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE 
-IR_Contained::Description_out::operator ::IR_Contained::Description *&() // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_Contained::Description *&
-IR_Contained::Description_out::ptr (void) // ptr
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_Contained::Description *
-IR_Contained::Description_out::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE
-IR_ModuleDef::IR_ModuleDef (
-    TAO_Stub *objref,
-    CORBA::Boolean _tao_collocated,
-    TAO_Abstract_ServantBase *servant
-  )
-  : CORBA_Object (objref, _tao_collocated, servant)
-{
-  this->IR_ModuleDef_setup_collocation (_tao_collocated);
-}
-
-// *************************************************************
-// Inline operations for class IR_ModuleDef_var
-// *************************************************************
-
-ACE_INLINE
-IR_ModuleDef_var::IR_ModuleDef_var (void) // default constructor
-  : ptr_ (IR_ModuleDef::_nil ())
-{}
-
-ACE_INLINE IR_ModuleDef_ptr 
-IR_ModuleDef_var::ptr (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE
-IR_ModuleDef_var::IR_ModuleDef_var (const IR_ModuleDef_var &p) // copy constructor
-  : TAO_Base_var (),
-    ptr_ (IR_ModuleDef::_duplicate (p.ptr ()))
-{}
-
-ACE_INLINE
-IR_ModuleDef_var::~IR_ModuleDef_var (void) // destructor
-{
-  CORBA::release (this->ptr_);
-}
-
-ACE_INLINE IR_ModuleDef_var &
-IR_ModuleDef_var::operator= (IR_ModuleDef_ptr p)
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE IR_ModuleDef_var &
-IR_ModuleDef_var::operator= (const IR_ModuleDef_var &p)
-{
-  if (this != &p)
-  {
-    CORBA::release (this->ptr_);
-    this->ptr_ = IR_ModuleDef::_duplicate (p.ptr ());
-  }
-  return *this;
-}
-
-ACE_INLINE 
-IR_ModuleDef_var::operator const IR_ModuleDef_ptr &() const // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE 
-IR_ModuleDef_var::operator IR_ModuleDef_ptr &() // cast 
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_ModuleDef_ptr 
-IR_ModuleDef_var::operator-> (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_ModuleDef_ptr
-IR_ModuleDef_var::in (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_ModuleDef_ptr &
-IR_ModuleDef_var::inout (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_ModuleDef_ptr &
-IR_ModuleDef_var::out (void)
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = IR_ModuleDef::_nil ();
-  return this->ptr_;
-}
-
-ACE_INLINE IR_ModuleDef_ptr 
-IR_ModuleDef_var::_retn (void)
-{
-  // yield ownership of managed obj reference
-  IR_ModuleDef_ptr val = this->ptr_;
-  this->ptr_ = IR_ModuleDef::_nil ();
-  return val;
-}
-
-// *************************************************************
-// Inline operations for class IR_ModuleDef_out
-// *************************************************************
-
-ACE_INLINE
-IR_ModuleDef_out::IR_ModuleDef_out (IR_ModuleDef_ptr &p)
-  : ptr_ (p)
-{
-  this->ptr_ = IR_ModuleDef::_nil ();
-}
-
-ACE_INLINE
-IR_ModuleDef_out::IR_ModuleDef_out (IR_ModuleDef_var &p) // constructor from _var
-  : ptr_ (p.out ())
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = IR_ModuleDef::_nil ();
-}
-
-ACE_INLINE
-IR_ModuleDef_out::IR_ModuleDef_out (const IR_ModuleDef_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (IR_ModuleDef_out&,p).ptr_)
-{}
-
-ACE_INLINE IR_ModuleDef_out &
-IR_ModuleDef_out::operator= (const IR_ModuleDef_out &p)
-{
-  this->ptr_ = ACE_const_cast (IR_ModuleDef_out&,p).ptr_;
-  return *this;
-}
-
-ACE_INLINE IR_ModuleDef_out &
-IR_ModuleDef_out::operator= (const IR_ModuleDef_var &p)
-{
-  this->ptr_ = IR_ModuleDef::_duplicate (p.ptr ());
-  return *this;
-}
-
-ACE_INLINE IR_ModuleDef_out &
-IR_ModuleDef_out::operator= (IR_ModuleDef_ptr p)
-{
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE 
-IR_ModuleDef_out::operator IR_ModuleDef_ptr &() // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_ModuleDef_ptr &
-IR_ModuleDef_out::ptr (void) // ptr
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_ModuleDef_ptr 
-IR_ModuleDef_out::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE
-IR_ConstantDef::IR_ConstantDef (
-    TAO_Stub *objref,
-    CORBA::Boolean _tao_collocated,
-    TAO_Abstract_ServantBase *servant
-  )
-  : CORBA_Object (objref, _tao_collocated, servant)
-{
-  this->IR_ConstantDef_setup_collocation (_tao_collocated);
-}
-
-// *************************************************************
-// Inline operations for class IR_ConstantDef_var
-// *************************************************************
-
-ACE_INLINE
-IR_ConstantDef_var::IR_ConstantDef_var (void) // default constructor
-  : ptr_ (IR_ConstantDef::_nil ())
-{}
-
-ACE_INLINE IR_ConstantDef_ptr 
-IR_ConstantDef_var::ptr (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE
-IR_ConstantDef_var::IR_ConstantDef_var (const IR_ConstantDef_var &p) // copy constructor
-  : TAO_Base_var (),
-    ptr_ (IR_ConstantDef::_duplicate (p.ptr ()))
-{}
-
-ACE_INLINE
-IR_ConstantDef_var::~IR_ConstantDef_var (void) // destructor
-{
-  CORBA::release (this->ptr_);
-}
-
-ACE_INLINE IR_ConstantDef_var &
-IR_ConstantDef_var::operator= (IR_ConstantDef_ptr p)
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE IR_ConstantDef_var &
-IR_ConstantDef_var::operator= (const IR_ConstantDef_var &p)
-{
-  if (this != &p)
-  {
-    CORBA::release (this->ptr_);
-    this->ptr_ = IR_ConstantDef::_duplicate (p.ptr ());
-  }
-  return *this;
-}
-
-ACE_INLINE 
-IR_ConstantDef_var::operator const IR_ConstantDef_ptr &() const // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE 
-IR_ConstantDef_var::operator IR_ConstantDef_ptr &() // cast 
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_ConstantDef_ptr 
-IR_ConstantDef_var::operator-> (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_ConstantDef_ptr
-IR_ConstantDef_var::in (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_ConstantDef_ptr &
-IR_ConstantDef_var::inout (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_ConstantDef_ptr &
-IR_ConstantDef_var::out (void)
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = IR_ConstantDef::_nil ();
-  return this->ptr_;
-}
-
-ACE_INLINE IR_ConstantDef_ptr 
-IR_ConstantDef_var::_retn (void)
-{
-  // yield ownership of managed obj reference
-  IR_ConstantDef_ptr val = this->ptr_;
-  this->ptr_ = IR_ConstantDef::_nil ();
-  return val;
-}
-
-// *************************************************************
-// Inline operations for class IR_ConstantDef_out
-// *************************************************************
-
-ACE_INLINE
-IR_ConstantDef_out::IR_ConstantDef_out (IR_ConstantDef_ptr &p)
-  : ptr_ (p)
-{
-  this->ptr_ = IR_ConstantDef::_nil ();
-}
-
-ACE_INLINE
-IR_ConstantDef_out::IR_ConstantDef_out (IR_ConstantDef_var &p) // constructor from _var
-  : ptr_ (p.out ())
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = IR_ConstantDef::_nil ();
-}
-
-ACE_INLINE
-IR_ConstantDef_out::IR_ConstantDef_out (const IR_ConstantDef_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (IR_ConstantDef_out&,p).ptr_)
-{}
-
-ACE_INLINE IR_ConstantDef_out &
-IR_ConstantDef_out::operator= (const IR_ConstantDef_out &p)
-{
-  this->ptr_ = ACE_const_cast (IR_ConstantDef_out&,p).ptr_;
-  return *this;
-}
-
-ACE_INLINE IR_ConstantDef_out &
-IR_ConstantDef_out::operator= (const IR_ConstantDef_var &p)
-{
-  this->ptr_ = IR_ConstantDef::_duplicate (p.ptr ());
-  return *this;
-}
-
-ACE_INLINE IR_ConstantDef_out &
-IR_ConstantDef_out::operator= (IR_ConstantDef_ptr p)
-{
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE 
-IR_ConstantDef_out::operator IR_ConstantDef_ptr &() // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_ConstantDef_ptr &
-IR_ConstantDef_out::ptr (void) // ptr
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_ConstantDef_ptr 
-IR_ConstantDef_out::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE
-IR_IDLType::IR_IDLType (
-    TAO_Stub *objref,
-    CORBA::Boolean _tao_collocated,
-    TAO_Abstract_ServantBase *servant
-  )
-  : CORBA_Object (objref, _tao_collocated, servant)
-{
-  this->IR_IDLType_setup_collocation (_tao_collocated);
-}
-
-// *************************************************************
-// Inline operations for class IR_IDLType_var
-// *************************************************************
-
-ACE_INLINE
-IR_IDLType_var::IR_IDLType_var (void) // default constructor
-  : ptr_ (IR_IDLType::_nil ())
-{}
-
-ACE_INLINE IR_IDLType_ptr 
-IR_IDLType_var::ptr (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE
-IR_IDLType_var::IR_IDLType_var (const IR_IDLType_var &p) // copy constructor
-  : TAO_Base_var (),
-    ptr_ (IR_IDLType::_duplicate (p.ptr ()))
-{}
-
-ACE_INLINE
-IR_IDLType_var::~IR_IDLType_var (void) // destructor
-{
-  CORBA::release (this->ptr_);
-}
-
-ACE_INLINE IR_IDLType_var &
-IR_IDLType_var::operator= (IR_IDLType_ptr p)
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE IR_IDLType_var &
-IR_IDLType_var::operator= (const IR_IDLType_var &p)
-{
-  if (this != &p)
-  {
-    CORBA::release (this->ptr_);
-    this->ptr_ = IR_IDLType::_duplicate (p.ptr ());
-  }
-  return *this;
-}
-
-ACE_INLINE 
-IR_IDLType_var::operator const IR_IDLType_ptr &() const // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE 
-IR_IDLType_var::operator IR_IDLType_ptr &() // cast 
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_IDLType_ptr 
-IR_IDLType_var::operator-> (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_IDLType_ptr
-IR_IDLType_var::in (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_IDLType_ptr &
-IR_IDLType_var::inout (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_IDLType_ptr &
-IR_IDLType_var::out (void)
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = IR_IDLType::_nil ();
-  return this->ptr_;
-}
-
-ACE_INLINE IR_IDLType_ptr 
-IR_IDLType_var::_retn (void)
-{
-  // yield ownership of managed obj reference
-  IR_IDLType_ptr val = this->ptr_;
-  this->ptr_ = IR_IDLType::_nil ();
-  return val;
-}
-
-// *************************************************************
-// Inline operations for class IR_IDLType_out
-// *************************************************************
-
-ACE_INLINE
-IR_IDLType_out::IR_IDLType_out (IR_IDLType_ptr &p)
-  : ptr_ (p)
-{
-  this->ptr_ = IR_IDLType::_nil ();
-}
-
-ACE_INLINE
-IR_IDLType_out::IR_IDLType_out (IR_IDLType_var &p) // constructor from _var
-  : ptr_ (p.out ())
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = IR_IDLType::_nil ();
-}
-
-ACE_INLINE
-IR_IDLType_out::IR_IDLType_out (const IR_IDLType_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (IR_IDLType_out&,p).ptr_)
-{}
-
-ACE_INLINE IR_IDLType_out &
-IR_IDLType_out::operator= (const IR_IDLType_out &p)
-{
-  this->ptr_ = ACE_const_cast (IR_IDLType_out&,p).ptr_;
-  return *this;
-}
-
-ACE_INLINE IR_IDLType_out &
-IR_IDLType_out::operator= (const IR_IDLType_var &p)
-{
-  this->ptr_ = IR_IDLType::_duplicate (p.ptr ());
-  return *this;
-}
-
-ACE_INLINE IR_IDLType_out &
-IR_IDLType_out::operator= (IR_IDLType_ptr p)
-{
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE 
-IR_IDLType_out::operator IR_IDLType_ptr &() // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_IDLType_ptr &
-IR_IDLType_out::ptr (void) // ptr
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_IDLType_ptr 
-IR_IDLType_out::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE
-IR_StructDef::IR_StructDef (
-    TAO_Stub *objref,
-    CORBA::Boolean _tao_collocated,
-    TAO_Abstract_ServantBase *servant
-  )
-  : CORBA_Object (objref, _tao_collocated, servant)
-{
-  this->IR_StructDef_setup_collocation (_tao_collocated);
-}
-
-// *************************************************************
-// Inline operations for class IR_StructDef_var
-// *************************************************************
-
-ACE_INLINE
-IR_StructDef_var::IR_StructDef_var (void) // default constructor
-  : ptr_ (IR_StructDef::_nil ())
-{}
-
-ACE_INLINE IR_StructDef_ptr 
-IR_StructDef_var::ptr (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE
-IR_StructDef_var::IR_StructDef_var (const IR_StructDef_var &p) // copy constructor
-  : TAO_Base_var (),
-    ptr_ (IR_StructDef::_duplicate (p.ptr ()))
-{}
-
-ACE_INLINE
-IR_StructDef_var::~IR_StructDef_var (void) // destructor
-{
-  CORBA::release (this->ptr_);
-}
-
-ACE_INLINE IR_StructDef_var &
-IR_StructDef_var::operator= (IR_StructDef_ptr p)
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE IR_StructDef_var &
-IR_StructDef_var::operator= (const IR_StructDef_var &p)
-{
-  if (this != &p)
-  {
-    CORBA::release (this->ptr_);
-    this->ptr_ = IR_StructDef::_duplicate (p.ptr ());
-  }
-  return *this;
-}
-
-ACE_INLINE 
-IR_StructDef_var::operator const IR_StructDef_ptr &() const // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE 
-IR_StructDef_var::operator IR_StructDef_ptr &() // cast 
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_StructDef_ptr 
-IR_StructDef_var::operator-> (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_StructDef_ptr
-IR_StructDef_var::in (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_StructDef_ptr &
-IR_StructDef_var::inout (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_StructDef_ptr &
-IR_StructDef_var::out (void)
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = IR_StructDef::_nil ();
-  return this->ptr_;
-}
-
-ACE_INLINE IR_StructDef_ptr 
-IR_StructDef_var::_retn (void)
-{
-  // yield ownership of managed obj reference
-  IR_StructDef_ptr val = this->ptr_;
-  this->ptr_ = IR_StructDef::_nil ();
-  return val;
-}
-
-// *************************************************************
-// Inline operations for class IR_StructDef_out
-// *************************************************************
-
-ACE_INLINE
-IR_StructDef_out::IR_StructDef_out (IR_StructDef_ptr &p)
-  : ptr_ (p)
-{
-  this->ptr_ = IR_StructDef::_nil ();
-}
-
-ACE_INLINE
-IR_StructDef_out::IR_StructDef_out (IR_StructDef_var &p) // constructor from _var
-  : ptr_ (p.out ())
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = IR_StructDef::_nil ();
-}
-
-ACE_INLINE
-IR_StructDef_out::IR_StructDef_out (const IR_StructDef_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (IR_StructDef_out&,p).ptr_)
-{}
-
-ACE_INLINE IR_StructDef_out &
-IR_StructDef_out::operator= (const IR_StructDef_out &p)
-{
-  this->ptr_ = ACE_const_cast (IR_StructDef_out&,p).ptr_;
-  return *this;
-}
-
-ACE_INLINE IR_StructDef_out &
-IR_StructDef_out::operator= (const IR_StructDef_var &p)
-{
-  this->ptr_ = IR_StructDef::_duplicate (p.ptr ());
-  return *this;
-}
-
-ACE_INLINE IR_StructDef_out &
-IR_StructDef_out::operator= (IR_StructDef_ptr p)
-{
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE 
-IR_StructDef_out::operator IR_StructDef_ptr &() // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_StructDef_ptr &
-IR_StructDef_out::ptr (void) // ptr
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_StructDef_ptr 
-IR_StructDef_out::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE
-IR_UnionDef::IR_UnionDef (
-    TAO_Stub *objref,
-    CORBA::Boolean _tao_collocated,
-    TAO_Abstract_ServantBase *servant
-  )
-  : CORBA_Object (objref, _tao_collocated, servant)
-{
-  this->IR_UnionDef_setup_collocation (_tao_collocated);
-}
-
-// *************************************************************
-// Inline operations for class IR_UnionDef_var
-// *************************************************************
-
-ACE_INLINE
-IR_UnionDef_var::IR_UnionDef_var (void) // default constructor
-  : ptr_ (IR_UnionDef::_nil ())
-{}
-
-ACE_INLINE IR_UnionDef_ptr 
-IR_UnionDef_var::ptr (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE
-IR_UnionDef_var::IR_UnionDef_var (const IR_UnionDef_var &p) // copy constructor
-  : TAO_Base_var (),
-    ptr_ (IR_UnionDef::_duplicate (p.ptr ()))
-{}
-
-ACE_INLINE
-IR_UnionDef_var::~IR_UnionDef_var (void) // destructor
-{
-  CORBA::release (this->ptr_);
-}
-
-ACE_INLINE IR_UnionDef_var &
-IR_UnionDef_var::operator= (IR_UnionDef_ptr p)
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE IR_UnionDef_var &
-IR_UnionDef_var::operator= (const IR_UnionDef_var &p)
-{
-  if (this != &p)
-  {
-    CORBA::release (this->ptr_);
-    this->ptr_ = IR_UnionDef::_duplicate (p.ptr ());
-  }
-  return *this;
-}
-
-ACE_INLINE 
-IR_UnionDef_var::operator const IR_UnionDef_ptr &() const // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE 
-IR_UnionDef_var::operator IR_UnionDef_ptr &() // cast 
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_UnionDef_ptr 
-IR_UnionDef_var::operator-> (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_UnionDef_ptr
-IR_UnionDef_var::in (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_UnionDef_ptr &
-IR_UnionDef_var::inout (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_UnionDef_ptr &
-IR_UnionDef_var::out (void)
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = IR_UnionDef::_nil ();
-  return this->ptr_;
-}
-
-ACE_INLINE IR_UnionDef_ptr 
-IR_UnionDef_var::_retn (void)
-{
-  // yield ownership of managed obj reference
-  IR_UnionDef_ptr val = this->ptr_;
-  this->ptr_ = IR_UnionDef::_nil ();
-  return val;
-}
-
-// *************************************************************
-// Inline operations for class IR_UnionDef_out
-// *************************************************************
-
-ACE_INLINE
-IR_UnionDef_out::IR_UnionDef_out (IR_UnionDef_ptr &p)
-  : ptr_ (p)
-{
-  this->ptr_ = IR_UnionDef::_nil ();
-}
-
-ACE_INLINE
-IR_UnionDef_out::IR_UnionDef_out (IR_UnionDef_var &p) // constructor from _var
-  : ptr_ (p.out ())
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = IR_UnionDef::_nil ();
-}
-
-ACE_INLINE
-IR_UnionDef_out::IR_UnionDef_out (const IR_UnionDef_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (IR_UnionDef_out&,p).ptr_)
-{}
-
-ACE_INLINE IR_UnionDef_out &
-IR_UnionDef_out::operator= (const IR_UnionDef_out &p)
-{
-  this->ptr_ = ACE_const_cast (IR_UnionDef_out&,p).ptr_;
-  return *this;
-}
-
-ACE_INLINE IR_UnionDef_out &
-IR_UnionDef_out::operator= (const IR_UnionDef_var &p)
-{
-  this->ptr_ = IR_UnionDef::_duplicate (p.ptr ());
-  return *this;
-}
-
-ACE_INLINE IR_UnionDef_out &
-IR_UnionDef_out::operator= (IR_UnionDef_ptr p)
-{
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE 
-IR_UnionDef_out::operator IR_UnionDef_ptr &() // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_UnionDef_ptr &
-IR_UnionDef_out::ptr (void) // ptr
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_UnionDef_ptr 
-IR_UnionDef_out::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE
-IR_EnumDef::IR_EnumDef (
-    TAO_Stub *objref,
-    CORBA::Boolean _tao_collocated,
-    TAO_Abstract_ServantBase *servant
-  )
-  : CORBA_Object (objref, _tao_collocated, servant)
-{
-  this->IR_EnumDef_setup_collocation (_tao_collocated);
-}
-
-// *************************************************************
-// Inline operations for class IR_EnumDef_var
-// *************************************************************
-
-ACE_INLINE
-IR_EnumDef_var::IR_EnumDef_var (void) // default constructor
-  : ptr_ (IR_EnumDef::_nil ())
-{}
-
-ACE_INLINE IR_EnumDef_ptr 
-IR_EnumDef_var::ptr (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE
-IR_EnumDef_var::IR_EnumDef_var (const IR_EnumDef_var &p) // copy constructor
-  : TAO_Base_var (),
-    ptr_ (IR_EnumDef::_duplicate (p.ptr ()))
-{}
-
-ACE_INLINE
-IR_EnumDef_var::~IR_EnumDef_var (void) // destructor
-{
-  CORBA::release (this->ptr_);
-}
-
-ACE_INLINE IR_EnumDef_var &
-IR_EnumDef_var::operator= (IR_EnumDef_ptr p)
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE IR_EnumDef_var &
-IR_EnumDef_var::operator= (const IR_EnumDef_var &p)
-{
-  if (this != &p)
-  {
-    CORBA::release (this->ptr_);
-    this->ptr_ = IR_EnumDef::_duplicate (p.ptr ());
-  }
-  return *this;
-}
-
-ACE_INLINE 
-IR_EnumDef_var::operator const IR_EnumDef_ptr &() const // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE 
-IR_EnumDef_var::operator IR_EnumDef_ptr &() // cast 
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_EnumDef_ptr 
-IR_EnumDef_var::operator-> (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_EnumDef_ptr
-IR_EnumDef_var::in (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_EnumDef_ptr &
-IR_EnumDef_var::inout (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_EnumDef_ptr &
-IR_EnumDef_var::out (void)
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = IR_EnumDef::_nil ();
-  return this->ptr_;
-}
-
-ACE_INLINE IR_EnumDef_ptr 
-IR_EnumDef_var::_retn (void)
-{
-  // yield ownership of managed obj reference
-  IR_EnumDef_ptr val = this->ptr_;
-  this->ptr_ = IR_EnumDef::_nil ();
-  return val;
-}
-
-// *************************************************************
-// Inline operations for class IR_EnumDef_out
-// *************************************************************
-
-ACE_INLINE
-IR_EnumDef_out::IR_EnumDef_out (IR_EnumDef_ptr &p)
-  : ptr_ (p)
-{
-  this->ptr_ = IR_EnumDef::_nil ();
-}
-
-ACE_INLINE
-IR_EnumDef_out::IR_EnumDef_out (IR_EnumDef_var &p) // constructor from _var
-  : ptr_ (p.out ())
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = IR_EnumDef::_nil ();
-}
-
-ACE_INLINE
-IR_EnumDef_out::IR_EnumDef_out (const IR_EnumDef_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (IR_EnumDef_out&,p).ptr_)
-{}
-
-ACE_INLINE IR_EnumDef_out &
-IR_EnumDef_out::operator= (const IR_EnumDef_out &p)
-{
-  this->ptr_ = ACE_const_cast (IR_EnumDef_out&,p).ptr_;
-  return *this;
-}
-
-ACE_INLINE IR_EnumDef_out &
-IR_EnumDef_out::operator= (const IR_EnumDef_var &p)
-{
-  this->ptr_ = IR_EnumDef::_duplicate (p.ptr ());
-  return *this;
-}
-
-ACE_INLINE IR_EnumDef_out &
-IR_EnumDef_out::operator= (IR_EnumDef_ptr p)
-{
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE 
-IR_EnumDef_out::operator IR_EnumDef_ptr &() // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_EnumDef_ptr &
-IR_EnumDef_out::ptr (void) // ptr
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_EnumDef_ptr 
-IR_EnumDef_out::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE
-IR_AliasDef::IR_AliasDef (
-    TAO_Stub *objref,
-    CORBA::Boolean _tao_collocated,
-    TAO_Abstract_ServantBase *servant
-  )
-  : CORBA_Object (objref, _tao_collocated, servant)
-{
-  this->IR_AliasDef_setup_collocation (_tao_collocated);
-}
-
-// *************************************************************
-// Inline operations for class IR_AliasDef_var
-// *************************************************************
-
-ACE_INLINE
-IR_AliasDef_var::IR_AliasDef_var (void) // default constructor
-  : ptr_ (IR_AliasDef::_nil ())
-{}
-
-ACE_INLINE IR_AliasDef_ptr 
-IR_AliasDef_var::ptr (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE
-IR_AliasDef_var::IR_AliasDef_var (const IR_AliasDef_var &p) // copy constructor
-  : TAO_Base_var (),
-    ptr_ (IR_AliasDef::_duplicate (p.ptr ()))
-{}
-
-ACE_INLINE
-IR_AliasDef_var::~IR_AliasDef_var (void) // destructor
-{
-  CORBA::release (this->ptr_);
-}
-
-ACE_INLINE IR_AliasDef_var &
-IR_AliasDef_var::operator= (IR_AliasDef_ptr p)
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE IR_AliasDef_var &
-IR_AliasDef_var::operator= (const IR_AliasDef_var &p)
-{
-  if (this != &p)
-  {
-    CORBA::release (this->ptr_);
-    this->ptr_ = IR_AliasDef::_duplicate (p.ptr ());
-  }
-  return *this;
-}
-
-ACE_INLINE 
-IR_AliasDef_var::operator const IR_AliasDef_ptr &() const // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE 
-IR_AliasDef_var::operator IR_AliasDef_ptr &() // cast 
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_AliasDef_ptr 
-IR_AliasDef_var::operator-> (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_AliasDef_ptr
-IR_AliasDef_var::in (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_AliasDef_ptr &
-IR_AliasDef_var::inout (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_AliasDef_ptr &
-IR_AliasDef_var::out (void)
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = IR_AliasDef::_nil ();
-  return this->ptr_;
-}
-
-ACE_INLINE IR_AliasDef_ptr 
-IR_AliasDef_var::_retn (void)
-{
-  // yield ownership of managed obj reference
-  IR_AliasDef_ptr val = this->ptr_;
-  this->ptr_ = IR_AliasDef::_nil ();
-  return val;
-}
-
-// *************************************************************
-// Inline operations for class IR_AliasDef_out
-// *************************************************************
-
-ACE_INLINE
-IR_AliasDef_out::IR_AliasDef_out (IR_AliasDef_ptr &p)
-  : ptr_ (p)
-{
-  this->ptr_ = IR_AliasDef::_nil ();
-}
-
-ACE_INLINE
-IR_AliasDef_out::IR_AliasDef_out (IR_AliasDef_var &p) // constructor from _var
-  : ptr_ (p.out ())
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = IR_AliasDef::_nil ();
-}
-
-ACE_INLINE
-IR_AliasDef_out::IR_AliasDef_out (const IR_AliasDef_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (IR_AliasDef_out&,p).ptr_)
-{}
-
-ACE_INLINE IR_AliasDef_out &
-IR_AliasDef_out::operator= (const IR_AliasDef_out &p)
-{
-  this->ptr_ = ACE_const_cast (IR_AliasDef_out&,p).ptr_;
-  return *this;
-}
-
-ACE_INLINE IR_AliasDef_out &
-IR_AliasDef_out::operator= (const IR_AliasDef_var &p)
-{
-  this->ptr_ = IR_AliasDef::_duplicate (p.ptr ());
-  return *this;
-}
-
-ACE_INLINE IR_AliasDef_out &
-IR_AliasDef_out::operator= (IR_AliasDef_ptr p)
-{
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE 
-IR_AliasDef_out::operator IR_AliasDef_ptr &() // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_AliasDef_ptr &
-IR_AliasDef_out::ptr (void) // ptr
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_AliasDef_ptr 
-IR_AliasDef_out::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE
-IR_InterfaceDef::IR_InterfaceDef (
-    TAO_Stub *objref,
-    CORBA::Boolean _tao_collocated,
-    TAO_Abstract_ServantBase *servant
-  )
-  : CORBA_Object (objref, _tao_collocated, servant)
-{
-  this->IR_InterfaceDef_setup_collocation (_tao_collocated);
-}
-
-// *************************************************************
-// Inline operations for class IR_InterfaceDef_var
-// *************************************************************
-
-ACE_INLINE
-IR_InterfaceDef_var::IR_InterfaceDef_var (void) // default constructor
-  : ptr_ (IR_InterfaceDef::_nil ())
-{}
-
-ACE_INLINE IR_InterfaceDef_ptr 
-IR_InterfaceDef_var::ptr (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE
-IR_InterfaceDef_var::IR_InterfaceDef_var (const IR_InterfaceDef_var &p) // copy constructor
-  : TAO_Base_var (),
-    ptr_ (IR_InterfaceDef::_duplicate (p.ptr ()))
-{}
-
-ACE_INLINE
-IR_InterfaceDef_var::~IR_InterfaceDef_var (void) // destructor
-{
-  CORBA::release (this->ptr_);
-}
-
-ACE_INLINE IR_InterfaceDef_var &
-IR_InterfaceDef_var::operator= (IR_InterfaceDef_ptr p)
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE IR_InterfaceDef_var &
-IR_InterfaceDef_var::operator= (const IR_InterfaceDef_var &p)
-{
-  if (this != &p)
-  {
-    CORBA::release (this->ptr_);
-    this->ptr_ = IR_InterfaceDef::_duplicate (p.ptr ());
-  }
-  return *this;
-}
-
-ACE_INLINE 
-IR_InterfaceDef_var::operator const IR_InterfaceDef_ptr &() const // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE 
-IR_InterfaceDef_var::operator IR_InterfaceDef_ptr &() // cast 
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_InterfaceDef_ptr 
-IR_InterfaceDef_var::operator-> (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_InterfaceDef_ptr
-IR_InterfaceDef_var::in (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_InterfaceDef_ptr &
-IR_InterfaceDef_var::inout (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_InterfaceDef_ptr &
-IR_InterfaceDef_var::out (void)
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = IR_InterfaceDef::_nil ();
-  return this->ptr_;
-}
-
-ACE_INLINE IR_InterfaceDef_ptr 
-IR_InterfaceDef_var::_retn (void)
-{
-  // yield ownership of managed obj reference
-  IR_InterfaceDef_ptr val = this->ptr_;
-  this->ptr_ = IR_InterfaceDef::_nil ();
-  return val;
-}
-
-// *************************************************************
-// Inline operations for class IR_InterfaceDef_out
-// *************************************************************
-
-ACE_INLINE
-IR_InterfaceDef_out::IR_InterfaceDef_out (IR_InterfaceDef_ptr &p)
-  : ptr_ (p)
-{
-  this->ptr_ = IR_InterfaceDef::_nil ();
-}
-
-ACE_INLINE
-IR_InterfaceDef_out::IR_InterfaceDef_out (IR_InterfaceDef_var &p) // constructor from _var
-  : ptr_ (p.out ())
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = IR_InterfaceDef::_nil ();
-}
-
-ACE_INLINE
-IR_InterfaceDef_out::IR_InterfaceDef_out (const IR_InterfaceDef_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (IR_InterfaceDef_out&,p).ptr_)
-{}
-
-ACE_INLINE IR_InterfaceDef_out &
-IR_InterfaceDef_out::operator= (const IR_InterfaceDef_out &p)
-{
-  this->ptr_ = ACE_const_cast (IR_InterfaceDef_out&,p).ptr_;
-  return *this;
-}
-
-ACE_INLINE IR_InterfaceDef_out &
-IR_InterfaceDef_out::operator= (const IR_InterfaceDef_var &p)
-{
-  this->ptr_ = IR_InterfaceDef::_duplicate (p.ptr ());
-  return *this;
-}
-
-ACE_INLINE IR_InterfaceDef_out &
-IR_InterfaceDef_out::operator= (IR_InterfaceDef_ptr p)
-{
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE 
-IR_InterfaceDef_out::operator IR_InterfaceDef_ptr &() // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_InterfaceDef_ptr &
-IR_InterfaceDef_out::ptr (void) // ptr
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_InterfaceDef_ptr 
-IR_InterfaceDef_out::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE
-IR_ExceptionDef::IR_ExceptionDef (
-    TAO_Stub *objref,
-    CORBA::Boolean _tao_collocated,
-    TAO_Abstract_ServantBase *servant
-  )
-  : CORBA_Object (objref, _tao_collocated, servant)
-{
-  this->IR_ExceptionDef_setup_collocation (_tao_collocated);
-}
-
-// *************************************************************
-// Inline operations for class IR_ExceptionDef_var
-// *************************************************************
-
-ACE_INLINE
-IR_ExceptionDef_var::IR_ExceptionDef_var (void) // default constructor
-  : ptr_ (IR_ExceptionDef::_nil ())
-{}
-
-ACE_INLINE IR_ExceptionDef_ptr 
-IR_ExceptionDef_var::ptr (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE
-IR_ExceptionDef_var::IR_ExceptionDef_var (const IR_ExceptionDef_var &p) // copy constructor
-  : TAO_Base_var (),
-    ptr_ (IR_ExceptionDef::_duplicate (p.ptr ()))
-{}
-
-ACE_INLINE
-IR_ExceptionDef_var::~IR_ExceptionDef_var (void) // destructor
-{
-  CORBA::release (this->ptr_);
-}
-
-ACE_INLINE IR_ExceptionDef_var &
-IR_ExceptionDef_var::operator= (IR_ExceptionDef_ptr p)
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE IR_ExceptionDef_var &
-IR_ExceptionDef_var::operator= (const IR_ExceptionDef_var &p)
-{
-  if (this != &p)
-  {
-    CORBA::release (this->ptr_);
-    this->ptr_ = IR_ExceptionDef::_duplicate (p.ptr ());
-  }
-  return *this;
-}
-
-ACE_INLINE 
-IR_ExceptionDef_var::operator const IR_ExceptionDef_ptr &() const // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE 
-IR_ExceptionDef_var::operator IR_ExceptionDef_ptr &() // cast 
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_ExceptionDef_ptr 
-IR_ExceptionDef_var::operator-> (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_ExceptionDef_ptr
-IR_ExceptionDef_var::in (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_ExceptionDef_ptr &
-IR_ExceptionDef_var::inout (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_ExceptionDef_ptr &
-IR_ExceptionDef_var::out (void)
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = IR_ExceptionDef::_nil ();
-  return this->ptr_;
-}
-
-ACE_INLINE IR_ExceptionDef_ptr 
-IR_ExceptionDef_var::_retn (void)
-{
-  // yield ownership of managed obj reference
-  IR_ExceptionDef_ptr val = this->ptr_;
-  this->ptr_ = IR_ExceptionDef::_nil ();
-  return val;
-}
-
-// *************************************************************
-// Inline operations for class IR_ExceptionDef_out
-// *************************************************************
-
-ACE_INLINE
-IR_ExceptionDef_out::IR_ExceptionDef_out (IR_ExceptionDef_ptr &p)
-  : ptr_ (p)
-{
-  this->ptr_ = IR_ExceptionDef::_nil ();
-}
-
-ACE_INLINE
-IR_ExceptionDef_out::IR_ExceptionDef_out (IR_ExceptionDef_var &p) // constructor from _var
-  : ptr_ (p.out ())
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = IR_ExceptionDef::_nil ();
-}
-
-ACE_INLINE
-IR_ExceptionDef_out::IR_ExceptionDef_out (const IR_ExceptionDef_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (IR_ExceptionDef_out&,p).ptr_)
-{}
-
-ACE_INLINE IR_ExceptionDef_out &
-IR_ExceptionDef_out::operator= (const IR_ExceptionDef_out &p)
-{
-  this->ptr_ = ACE_const_cast (IR_ExceptionDef_out&,p).ptr_;
-  return *this;
-}
-
-ACE_INLINE IR_ExceptionDef_out &
-IR_ExceptionDef_out::operator= (const IR_ExceptionDef_var &p)
-{
-  this->ptr_ = IR_ExceptionDef::_duplicate (p.ptr ());
-  return *this;
-}
-
-ACE_INLINE IR_ExceptionDef_out &
-IR_ExceptionDef_out::operator= (IR_ExceptionDef_ptr p)
-{
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE 
-IR_ExceptionDef_out::operator IR_ExceptionDef_ptr &() // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_ExceptionDef_ptr &
-IR_ExceptionDef_out::ptr (void) // ptr
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_ExceptionDef_ptr 
-IR_ExceptionDef_out::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE
-IR_NativeDef::IR_NativeDef (
-    TAO_Stub *objref,
-    CORBA::Boolean _tao_collocated,
-    TAO_Abstract_ServantBase *servant
-  )
-  : CORBA_Object (objref, _tao_collocated, servant)
-{
-  this->IR_NativeDef_setup_collocation (_tao_collocated);
-}
-
-// *************************************************************
-// Inline operations for class IR_NativeDef_var
-// *************************************************************
-
-ACE_INLINE
-IR_NativeDef_var::IR_NativeDef_var (void) // default constructor
-  : ptr_ (IR_NativeDef::_nil ())
-{}
-
-ACE_INLINE IR_NativeDef_ptr 
-IR_NativeDef_var::ptr (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE
-IR_NativeDef_var::IR_NativeDef_var (const IR_NativeDef_var &p) // copy constructor
-  : TAO_Base_var (),
-    ptr_ (IR_NativeDef::_duplicate (p.ptr ()))
-{}
-
-ACE_INLINE
-IR_NativeDef_var::~IR_NativeDef_var (void) // destructor
-{
-  CORBA::release (this->ptr_);
-}
-
-ACE_INLINE IR_NativeDef_var &
-IR_NativeDef_var::operator= (IR_NativeDef_ptr p)
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE IR_NativeDef_var &
-IR_NativeDef_var::operator= (const IR_NativeDef_var &p)
-{
-  if (this != &p)
-  {
-    CORBA::release (this->ptr_);
-    this->ptr_ = IR_NativeDef::_duplicate (p.ptr ());
-  }
-  return *this;
-}
-
-ACE_INLINE 
-IR_NativeDef_var::operator const IR_NativeDef_ptr &() const // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE 
-IR_NativeDef_var::operator IR_NativeDef_ptr &() // cast 
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_NativeDef_ptr 
-IR_NativeDef_var::operator-> (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_NativeDef_ptr
-IR_NativeDef_var::in (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_NativeDef_ptr &
-IR_NativeDef_var::inout (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_NativeDef_ptr &
-IR_NativeDef_var::out (void)
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = IR_NativeDef::_nil ();
-  return this->ptr_;
-}
-
-ACE_INLINE IR_NativeDef_ptr 
-IR_NativeDef_var::_retn (void)
-{
-  // yield ownership of managed obj reference
-  IR_NativeDef_ptr val = this->ptr_;
-  this->ptr_ = IR_NativeDef::_nil ();
-  return val;
-}
-
-// *************************************************************
-// Inline operations for class IR_NativeDef_out
-// *************************************************************
-
-ACE_INLINE
-IR_NativeDef_out::IR_NativeDef_out (IR_NativeDef_ptr &p)
-  : ptr_ (p)
-{
-  this->ptr_ = IR_NativeDef::_nil ();
-}
-
-ACE_INLINE
-IR_NativeDef_out::IR_NativeDef_out (IR_NativeDef_var &p) // constructor from _var
-  : ptr_ (p.out ())
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = IR_NativeDef::_nil ();
-}
-
-ACE_INLINE
-IR_NativeDef_out::IR_NativeDef_out (const IR_NativeDef_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (IR_NativeDef_out&,p).ptr_)
-{}
-
-ACE_INLINE IR_NativeDef_out &
-IR_NativeDef_out::operator= (const IR_NativeDef_out &p)
-{
-  this->ptr_ = ACE_const_cast (IR_NativeDef_out&,p).ptr_;
-  return *this;
-}
-
-ACE_INLINE IR_NativeDef_out &
-IR_NativeDef_out::operator= (const IR_NativeDef_var &p)
-{
-  this->ptr_ = IR_NativeDef::_duplicate (p.ptr ());
-  return *this;
-}
-
-ACE_INLINE IR_NativeDef_out &
-IR_NativeDef_out::operator= (IR_NativeDef_ptr p)
-{
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE 
-IR_NativeDef_out::operator IR_NativeDef_ptr &() // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_NativeDef_ptr &
-IR_NativeDef_out::ptr (void) // ptr
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_NativeDef_ptr 
-IR_NativeDef_out::operator-> (void)
-{
-  return this->ptr_;
-}
-
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  
-  ACE_INLINE IR_InterfaceDef **
-  _TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq::allocbuf (CORBA::ULong nelems)
-  {
-    IR_InterfaceDef **buf = 0;
-    
-    ACE_NEW_RETURN (buf, IR_InterfaceDef*[nelems], 0);
-    
-    for (CORBA::ULong i = 0; i < nelems; i++)
-      buf[i] = IR_InterfaceDef::_nil ();
-    
-    return buf;
-  }
-  
-  ACE_INLINE void 
-  _TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq::freebuf (IR_InterfaceDef **buffer)
-  {
-    if (buffer == 0)
-      return;
-    delete[] buffer;
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq::_TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq (void)
-  {
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq::_TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq (CORBA::ULong maximum)
-    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq::allocbuf (maximum))
-  {
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq::_TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq (CORBA::ULong maximum,
-    CORBA::ULong length,
-    IR_InterfaceDef* *value,
-    CORBA::Boolean release)
-  : TAO_Unbounded_Base_Sequence (maximum, length, value, release)
-  {
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq::_TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq(const _TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq &rhs)
-    : TAO_Unbounded_Base_Sequence (rhs)
-  {
-    if (rhs.buffer_ != 0)
-    {
-      IR_InterfaceDef **tmp1 = _TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq::allocbuf (this->maximum_);
-      IR_InterfaceDef ** const tmp2 = ACE_reinterpret_cast (IR_InterfaceDef ** ACE_CAST_CONST, rhs.buffer_);
-      
-      for (CORBA::ULong i = 0; i < rhs.length_; ++i)
-        tmp1[i] = IR_InterfaceDef::_duplicate (tmp2[i]);
-      
-      this->buffer_ = tmp1;
-    }
-    else
-    {
-      this->buffer_ = 0;
-    }
-  }
-  
-  ACE_INLINE _TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq &
-  _TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq::operator= (const _TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq &rhs)
-  {
-    if (this == &rhs)
-      return *this;
-    
-    if (this->release_)
-    {
-      IR_InterfaceDef **tmp = ACE_reinterpret_cast (IR_InterfaceDef **, this->buffer_);
-      
-      for (CORBA::ULong i = 0; i < this->length_; ++i)
-      {
-        CORBA::release (tmp[i]);
-        tmp[i] = IR_InterfaceDef::_nil ();
-      }
-      if (this->maximum_ < rhs.maximum_)
-      {
-        _TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq::freebuf (tmp);
-        this->buffer_ = _TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq::allocbuf (rhs.maximum_);
-      }
-    }
-    else
-      this->buffer_ = _TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq::allocbuf (rhs.maximum_);
-    
-    TAO_Unbounded_Base_Sequence::operator= (rhs);
-    
-    IR_InterfaceDef **tmp1 = ACE_reinterpret_cast (IR_InterfaceDef **, this->buffer_);
-    IR_InterfaceDef ** const tmp2 = ACE_reinterpret_cast (IR_InterfaceDef ** ACE_CAST_CONST, rhs.buffer_);
-    
-    for (CORBA::ULong i = 0; i < rhs.length_; ++i)
-      tmp1[i] = IR_InterfaceDef::_duplicate (tmp2[i]);
-    
-    return *this;
-  }
-  
-  ACE_INLINE TAO_Object_Manager<IR_InterfaceDef,IR_InterfaceDef_var>
-  _TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq::operator[] (CORBA::ULong index) const
-  // read-write accessor
-  {
-    ACE_ASSERT (index < this->maximum_);
-    IR_InterfaceDef ** const tmp = ACE_reinterpret_cast (IR_InterfaceDef ** ACE_CAST_CONST, this->buffer_);
-    return TAO_Object_Manager<IR_InterfaceDef,IR_InterfaceDef_var> (tmp + index, this->release_);
-  }
-  
-  ACE_INLINE IR_InterfaceDef* *
-  _TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq::get_buffer (CORBA::Boolean orphan)
-  {
-    IR_InterfaceDef **result = 0;
-    if (orphan == 0)
-    {
-      // We retain ownership.
-      if (this->buffer_ == 0)
-      {
-        result = _TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq::allocbuf (this->maximum_);
-        this->buffer_ = result;
-        this->release_ = 1;
-      }
-      else
-      {
-        result = ACE_reinterpret_cast (IR_InterfaceDef**, this->buffer_);
-      }
-    }
-    else // if (orphan == 1)
-    {
-      if (this->release_ != 0)
-      {
-        // We set the state back to default and relinquish
-        // ownership.
-        result = ACE_reinterpret_cast(IR_InterfaceDef**,this->buffer_);
-        this->maximum_ = 0;
-        this->length_ = 0;
-        this->buffer_ = 0;
-        this->release_ = 0;
-      }
-    }
-    return result;
-  }
-  
-  ACE_INLINE const IR_InterfaceDef* *
-  _TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq::get_buffer (void) const
-  {
-    return ACE_reinterpret_cast(const IR_InterfaceDef ** ACE_CAST_CONST, this->buffer_);
-  }
-  
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
-
-// *************************************************************
-// Inline operations for class IR_InterfaceDefSeq_var
-// *************************************************************
-
-ACE_INLINE
-IR_InterfaceDefSeq_var::IR_InterfaceDefSeq_var (void) // default constructor
-  : ptr_ (0)
-{}
-
-ACE_INLINE
-IR_InterfaceDefSeq_var::IR_InterfaceDefSeq_var (IR_InterfaceDefSeq *p)
-  : ptr_ (p)
-{}
-
-ACE_INLINE
-IR_InterfaceDefSeq_var::IR_InterfaceDefSeq_var (const ::IR_InterfaceDefSeq_var &p) // copy constructor
-{
-  if (p.ptr_)
-    ACE_NEW (this->ptr_, ::IR_InterfaceDefSeq (*p.ptr_));
-  else
-    this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_InterfaceDefSeq_var::~IR_InterfaceDefSeq_var (void) // destructor
-{
-  delete this->ptr_;
-}
-
-ACE_INLINE IR_InterfaceDefSeq_var &
-IR_InterfaceDefSeq_var::operator= (IR_InterfaceDefSeq *p)
-{
-  delete this->ptr_;
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE IR_InterfaceDefSeq_var &
-IR_InterfaceDefSeq_var::operator= (const ::IR_InterfaceDefSeq_var &p) // deep copy
-{
-  if (this != &p)
-    {
-      if (p.ptr_ == 0)
-        {
-          delete this->ptr_;
-          this->ptr_ = 0;
-        }
-      else
-        {
-          IR_InterfaceDefSeq *deep_copy = 
-            new IR_InterfaceDefSeq (*p.ptr_);
-          
-          if (deep_copy != 0)
-            {
-              IR_InterfaceDefSeq *tmp = deep_copy;
-              deep_copy = this->ptr_;
-              this->ptr_ = tmp;
-              delete deep_copy;
-            }
-        }
-    }
-  
-  return *this;
-}
-
-ACE_INLINE const ::IR_InterfaceDefSeq *
-IR_InterfaceDefSeq_var::operator-> (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_InterfaceDefSeq *
-IR_InterfaceDefSeq_var::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE 
-IR_InterfaceDefSeq_var::operator const ::IR_InterfaceDefSeq &() const // cast
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE 
-IR_InterfaceDefSeq_var::operator ::IR_InterfaceDefSeq &() // cast 
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE 
-IR_InterfaceDefSeq_var::operator ::IR_InterfaceDefSeq &() const // cast 
-{
-  return *this->ptr_;
-}
-
-// variable-size types only
-ACE_INLINE
-IR_InterfaceDefSeq_var::operator ::IR_InterfaceDefSeq *&() // cast 
-{
-  return this->ptr_;
-}
-
-ACE_INLINE TAO_Object_Manager<IR_InterfaceDef, IR_InterfaceDef_var>
-IR_InterfaceDefSeq_var::operator[] (CORBA::ULong index)
-{
-  return this->ptr_->operator[] (index);
-}
-
-ACE_INLINE const ::IR_InterfaceDefSeq &
-IR_InterfaceDefSeq_var::in (void) const
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE ::IR_InterfaceDefSeq &
-IR_InterfaceDefSeq_var::inout (void)
-{
-  return *this->ptr_;
-}
-
-// mapping for variable size 
-ACE_INLINE ::IR_InterfaceDefSeq *&
-IR_InterfaceDefSeq_var::out (void)
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_InterfaceDefSeq *
-IR_InterfaceDefSeq_var::_retn (void)
-{
-  ::IR_InterfaceDefSeq *tmp = this->ptr_;
-  this->ptr_ = 0;
-  return tmp;
-}
-
-ACE_INLINE ::IR_InterfaceDefSeq *
-IR_InterfaceDefSeq_var::ptr (void) const
-{
-  return this->ptr_;
-}
-
-// *************************************************************
-// Inline operations for class IR_InterfaceDefSeq_out
-// *************************************************************
-
-ACE_INLINE
-IR_InterfaceDefSeq_out::IR_InterfaceDefSeq_out (IR_InterfaceDefSeq *&p)
-  : ptr_ (p)
-{
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_InterfaceDefSeq_out::IR_InterfaceDefSeq_out (IR_InterfaceDefSeq_var &p) // constructor from _var
-  : ptr_ (p.out ())
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_InterfaceDefSeq_out::IR_InterfaceDefSeq_out (const ::IR_InterfaceDefSeq_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (IR_InterfaceDefSeq_out&, p).ptr_)
-{}
-
-ACE_INLINE ::IR_InterfaceDefSeq_out &
-IR_InterfaceDefSeq_out::operator= (const ::IR_InterfaceDefSeq_out &p)
-{
-  this->ptr_ = ACE_const_cast (IR_InterfaceDefSeq_out&, p).ptr_;
-  return *this;
-}
-
-ACE_INLINE ::IR_InterfaceDefSeq_out &
-IR_InterfaceDefSeq_out::operator= (IR_InterfaceDefSeq *p)
-{
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE 
-IR_InterfaceDefSeq_out::operator ::IR_InterfaceDefSeq *&() // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_InterfaceDefSeq *&
-IR_InterfaceDefSeq_out::ptr (void) // ptr
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_InterfaceDefSeq *
-IR_InterfaceDefSeq_out::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE TAO_Object_Manager<IR_InterfaceDef, IR_InterfaceDef_var>
-IR_InterfaceDefSeq_out::operator[] (CORBA::ULong index)
-{
-  return this->ptr_->operator[] (index);
-}
-
-ACE_INLINE
-IR_ValueDef::IR_ValueDef (
-    TAO_Stub *objref,
-    CORBA::Boolean _tao_collocated,
-    TAO_Abstract_ServantBase *servant
-  )
-  : CORBA_Object (objref, _tao_collocated, servant)
-{
-  this->IR_ValueDef_setup_collocation (_tao_collocated);
-}
-
-// *************************************************************
-// Inline operations for class IR_ValueDef_var
-// *************************************************************
-
-ACE_INLINE
-IR_ValueDef_var::IR_ValueDef_var (void) // default constructor
-  : ptr_ (IR_ValueDef::_nil ())
-{}
-
-ACE_INLINE IR_ValueDef_ptr 
-IR_ValueDef_var::ptr (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE
-IR_ValueDef_var::IR_ValueDef_var (const IR_ValueDef_var &p) // copy constructor
-  : TAO_Base_var (),
-    ptr_ (IR_ValueDef::_duplicate (p.ptr ()))
-{}
-
-ACE_INLINE
-IR_ValueDef_var::~IR_ValueDef_var (void) // destructor
-{
-  CORBA::release (this->ptr_);
-}
-
-ACE_INLINE IR_ValueDef_var &
-IR_ValueDef_var::operator= (IR_ValueDef_ptr p)
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE IR_ValueDef_var &
-IR_ValueDef_var::operator= (const IR_ValueDef_var &p)
-{
-  if (this != &p)
-  {
-    CORBA::release (this->ptr_);
-    this->ptr_ = IR_ValueDef::_duplicate (p.ptr ());
-  }
-  return *this;
-}
-
-ACE_INLINE 
-IR_ValueDef_var::operator const IR_ValueDef_ptr &() const // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE 
-IR_ValueDef_var::operator IR_ValueDef_ptr &() // cast 
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_ValueDef_ptr 
-IR_ValueDef_var::operator-> (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_ValueDef_ptr
-IR_ValueDef_var::in (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_ValueDef_ptr &
-IR_ValueDef_var::inout (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_ValueDef_ptr &
-IR_ValueDef_var::out (void)
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = IR_ValueDef::_nil ();
-  return this->ptr_;
-}
-
-ACE_INLINE IR_ValueDef_ptr 
-IR_ValueDef_var::_retn (void)
-{
-  // yield ownership of managed obj reference
-  IR_ValueDef_ptr val = this->ptr_;
-  this->ptr_ = IR_ValueDef::_nil ();
-  return val;
-}
-
-// *************************************************************
-// Inline operations for class IR_ValueDef_out
-// *************************************************************
-
-ACE_INLINE
-IR_ValueDef_out::IR_ValueDef_out (IR_ValueDef_ptr &p)
-  : ptr_ (p)
-{
-  this->ptr_ = IR_ValueDef::_nil ();
-}
-
-ACE_INLINE
-IR_ValueDef_out::IR_ValueDef_out (IR_ValueDef_var &p) // constructor from _var
-  : ptr_ (p.out ())
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = IR_ValueDef::_nil ();
-}
-
-ACE_INLINE
-IR_ValueDef_out::IR_ValueDef_out (const IR_ValueDef_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (IR_ValueDef_out&,p).ptr_)
-{}
-
-ACE_INLINE IR_ValueDef_out &
-IR_ValueDef_out::operator= (const IR_ValueDef_out &p)
-{
-  this->ptr_ = ACE_const_cast (IR_ValueDef_out&,p).ptr_;
-  return *this;
-}
-
-ACE_INLINE IR_ValueDef_out &
-IR_ValueDef_out::operator= (const IR_ValueDef_var &p)
-{
-  this->ptr_ = IR_ValueDef::_duplicate (p.ptr ());
-  return *this;
-}
-
-ACE_INLINE IR_ValueDef_out &
-IR_ValueDef_out::operator= (IR_ValueDef_ptr p)
-{
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE 
-IR_ValueDef_out::operator IR_ValueDef_ptr &() // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_ValueDef_ptr &
-IR_ValueDef_out::ptr (void) // ptr
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_ValueDef_ptr 
-IR_ValueDef_out::operator-> (void)
-{
-  return this->ptr_;
-}
-
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  
-  ACE_INLINE IR_ValueDef **
-  _TAO_Unbounded_Object_Sequence_IR_ValueDefSeq::allocbuf (CORBA::ULong nelems)
-  {
-    IR_ValueDef **buf = 0;
-    
-    ACE_NEW_RETURN (buf, IR_ValueDef*[nelems], 0);
-    
-    for (CORBA::ULong i = 0; i < nelems; i++)
-      buf[i] = IR_ValueDef::_nil ();
-    
-    return buf;
-  }
-  
-  ACE_INLINE void 
-  _TAO_Unbounded_Object_Sequence_IR_ValueDefSeq::freebuf (IR_ValueDef **buffer)
-  {
-    if (buffer == 0)
-      return;
-    delete[] buffer;
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Object_Sequence_IR_ValueDefSeq::_TAO_Unbounded_Object_Sequence_IR_ValueDefSeq (void)
-  {
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Object_Sequence_IR_ValueDefSeq::_TAO_Unbounded_Object_Sequence_IR_ValueDefSeq (CORBA::ULong maximum)
-    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Object_Sequence_IR_ValueDefSeq::allocbuf (maximum))
-  {
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Object_Sequence_IR_ValueDefSeq::_TAO_Unbounded_Object_Sequence_IR_ValueDefSeq (CORBA::ULong maximum,
-    CORBA::ULong length,
-    IR_ValueDef* *value,
-    CORBA::Boolean release)
-  : TAO_Unbounded_Base_Sequence (maximum, length, value, release)
-  {
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Object_Sequence_IR_ValueDefSeq::_TAO_Unbounded_Object_Sequence_IR_ValueDefSeq(const _TAO_Unbounded_Object_Sequence_IR_ValueDefSeq &rhs)
-    : TAO_Unbounded_Base_Sequence (rhs)
-  {
-    if (rhs.buffer_ != 0)
-    {
-      IR_ValueDef **tmp1 = _TAO_Unbounded_Object_Sequence_IR_ValueDefSeq::allocbuf (this->maximum_);
-      IR_ValueDef ** const tmp2 = ACE_reinterpret_cast (IR_ValueDef ** ACE_CAST_CONST, rhs.buffer_);
-      
-      for (CORBA::ULong i = 0; i < rhs.length_; ++i)
-        tmp1[i] = IR_ValueDef::_duplicate (tmp2[i]);
-      
-      this->buffer_ = tmp1;
-    }
-    else
-    {
-      this->buffer_ = 0;
-    }
-  }
-  
-  ACE_INLINE _TAO_Unbounded_Object_Sequence_IR_ValueDefSeq &
-  _TAO_Unbounded_Object_Sequence_IR_ValueDefSeq::operator= (const _TAO_Unbounded_Object_Sequence_IR_ValueDefSeq &rhs)
-  {
-    if (this == &rhs)
-      return *this;
-    
-    if (this->release_)
-    {
-      IR_ValueDef **tmp = ACE_reinterpret_cast (IR_ValueDef **, this->buffer_);
-      
-      for (CORBA::ULong i = 0; i < this->length_; ++i)
-      {
-        CORBA::release (tmp[i]);
-        tmp[i] = IR_ValueDef::_nil ();
-      }
-      if (this->maximum_ < rhs.maximum_)
-      {
-        _TAO_Unbounded_Object_Sequence_IR_ValueDefSeq::freebuf (tmp);
-        this->buffer_ = _TAO_Unbounded_Object_Sequence_IR_ValueDefSeq::allocbuf (rhs.maximum_);
-      }
-    }
-    else
-      this->buffer_ = _TAO_Unbounded_Object_Sequence_IR_ValueDefSeq::allocbuf (rhs.maximum_);
-    
-    TAO_Unbounded_Base_Sequence::operator= (rhs);
-    
-    IR_ValueDef **tmp1 = ACE_reinterpret_cast (IR_ValueDef **, this->buffer_);
-    IR_ValueDef ** const tmp2 = ACE_reinterpret_cast (IR_ValueDef ** ACE_CAST_CONST, rhs.buffer_);
-    
-    for (CORBA::ULong i = 0; i < rhs.length_; ++i)
-      tmp1[i] = IR_ValueDef::_duplicate (tmp2[i]);
-    
-    return *this;
-  }
-  
-  ACE_INLINE TAO_Object_Manager<IR_ValueDef,IR_ValueDef_var>
-  _TAO_Unbounded_Object_Sequence_IR_ValueDefSeq::operator[] (CORBA::ULong index) const
-  // read-write accessor
-  {
-    ACE_ASSERT (index < this->maximum_);
-    IR_ValueDef ** const tmp = ACE_reinterpret_cast (IR_ValueDef ** ACE_CAST_CONST, this->buffer_);
-    return TAO_Object_Manager<IR_ValueDef,IR_ValueDef_var> (tmp + index, this->release_);
-  }
-  
-  ACE_INLINE IR_ValueDef* *
-  _TAO_Unbounded_Object_Sequence_IR_ValueDefSeq::get_buffer (CORBA::Boolean orphan)
-  {
-    IR_ValueDef **result = 0;
-    if (orphan == 0)
-    {
-      // We retain ownership.
-      if (this->buffer_ == 0)
-      {
-        result = _TAO_Unbounded_Object_Sequence_IR_ValueDefSeq::allocbuf (this->maximum_);
-        this->buffer_ = result;
-        this->release_ = 1;
-      }
-      else
-      {
-        result = ACE_reinterpret_cast (IR_ValueDef**, this->buffer_);
-      }
-    }
-    else // if (orphan == 1)
-    {
-      if (this->release_ != 0)
-      {
-        // We set the state back to default and relinquish
-        // ownership.
-        result = ACE_reinterpret_cast(IR_ValueDef**,this->buffer_);
-        this->maximum_ = 0;
-        this->length_ = 0;
-        this->buffer_ = 0;
-        this->release_ = 0;
-      }
-    }
-    return result;
-  }
-  
-  ACE_INLINE const IR_ValueDef* *
-  _TAO_Unbounded_Object_Sequence_IR_ValueDefSeq::get_buffer (void) const
-  {
-    return ACE_reinterpret_cast(const IR_ValueDef ** ACE_CAST_CONST, this->buffer_);
-  }
-  
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
-
-// *************************************************************
-// Inline operations for class IR_ValueDefSeq_var
-// *************************************************************
-
-ACE_INLINE
-IR_ValueDefSeq_var::IR_ValueDefSeq_var (void) // default constructor
-  : ptr_ (0)
-{}
-
-ACE_INLINE
-IR_ValueDefSeq_var::IR_ValueDefSeq_var (IR_ValueDefSeq *p)
-  : ptr_ (p)
-{}
-
-ACE_INLINE
-IR_ValueDefSeq_var::IR_ValueDefSeq_var (const ::IR_ValueDefSeq_var &p) // copy constructor
-{
-  if (p.ptr_)
-    ACE_NEW (this->ptr_, ::IR_ValueDefSeq (*p.ptr_));
-  else
-    this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_ValueDefSeq_var::~IR_ValueDefSeq_var (void) // destructor
-{
-  delete this->ptr_;
-}
-
-ACE_INLINE IR_ValueDefSeq_var &
-IR_ValueDefSeq_var::operator= (IR_ValueDefSeq *p)
-{
-  delete this->ptr_;
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE IR_ValueDefSeq_var &
-IR_ValueDefSeq_var::operator= (const ::IR_ValueDefSeq_var &p) // deep copy
-{
-  if (this != &p)
-    {
-      if (p.ptr_ == 0)
-        {
-          delete this->ptr_;
-          this->ptr_ = 0;
-        }
-      else
-        {
-          IR_ValueDefSeq *deep_copy = 
-            new IR_ValueDefSeq (*p.ptr_);
-          
-          if (deep_copy != 0)
-            {
-              IR_ValueDefSeq *tmp = deep_copy;
-              deep_copy = this->ptr_;
-              this->ptr_ = tmp;
-              delete deep_copy;
-            }
-        }
-    }
-  
-  return *this;
-}
-
-ACE_INLINE const ::IR_ValueDefSeq *
-IR_ValueDefSeq_var::operator-> (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_ValueDefSeq *
-IR_ValueDefSeq_var::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE 
-IR_ValueDefSeq_var::operator const ::IR_ValueDefSeq &() const // cast
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE 
-IR_ValueDefSeq_var::operator ::IR_ValueDefSeq &() // cast 
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE 
-IR_ValueDefSeq_var::operator ::IR_ValueDefSeq &() const // cast 
-{
-  return *this->ptr_;
-}
-
-// variable-size types only
-ACE_INLINE
-IR_ValueDefSeq_var::operator ::IR_ValueDefSeq *&() // cast 
-{
-  return this->ptr_;
-}
-
-ACE_INLINE TAO_Object_Manager<IR_ValueDef, IR_ValueDef_var>
-IR_ValueDefSeq_var::operator[] (CORBA::ULong index)
-{
-  return this->ptr_->operator[] (index);
-}
-
-ACE_INLINE const ::IR_ValueDefSeq &
-IR_ValueDefSeq_var::in (void) const
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE ::IR_ValueDefSeq &
-IR_ValueDefSeq_var::inout (void)
-{
-  return *this->ptr_;
-}
-
-// mapping for variable size 
-ACE_INLINE ::IR_ValueDefSeq *&
-IR_ValueDefSeq_var::out (void)
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_ValueDefSeq *
-IR_ValueDefSeq_var::_retn (void)
-{
-  ::IR_ValueDefSeq *tmp = this->ptr_;
-  this->ptr_ = 0;
-  return tmp;
-}
-
-ACE_INLINE ::IR_ValueDefSeq *
-IR_ValueDefSeq_var::ptr (void) const
-{
-  return this->ptr_;
-}
-
-// *************************************************************
-// Inline operations for class IR_ValueDefSeq_out
-// *************************************************************
-
-ACE_INLINE
-IR_ValueDefSeq_out::IR_ValueDefSeq_out (IR_ValueDefSeq *&p)
-  : ptr_ (p)
-{
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_ValueDefSeq_out::IR_ValueDefSeq_out (IR_ValueDefSeq_var &p) // constructor from _var
-  : ptr_ (p.out ())
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_ValueDefSeq_out::IR_ValueDefSeq_out (const ::IR_ValueDefSeq_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (IR_ValueDefSeq_out&, p).ptr_)
-{}
-
-ACE_INLINE ::IR_ValueDefSeq_out &
-IR_ValueDefSeq_out::operator= (const ::IR_ValueDefSeq_out &p)
-{
-  this->ptr_ = ACE_const_cast (IR_ValueDefSeq_out&, p).ptr_;
-  return *this;
-}
-
-ACE_INLINE ::IR_ValueDefSeq_out &
-IR_ValueDefSeq_out::operator= (IR_ValueDefSeq *p)
-{
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE 
-IR_ValueDefSeq_out::operator ::IR_ValueDefSeq *&() // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_ValueDefSeq *&
-IR_ValueDefSeq_out::ptr (void) // ptr
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_ValueDefSeq *
-IR_ValueDefSeq_out::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE TAO_Object_Manager<IR_ValueDef, IR_ValueDef_var>
-IR_ValueDefSeq_out::operator[] (CORBA::ULong index)
-{
-  return this->ptr_->operator[] (index);
-}
-
-ACE_INLINE
-IR_ValueBoxDef::IR_ValueBoxDef (
-    TAO_Stub *objref,
-    CORBA::Boolean _tao_collocated,
-    TAO_Abstract_ServantBase *servant
-  )
-  : CORBA_Object (objref, _tao_collocated, servant)
-{
-  this->IR_ValueBoxDef_setup_collocation (_tao_collocated);
-}
-
-// *************************************************************
-// Inline operations for class IR_ValueBoxDef_var
-// *************************************************************
-
-ACE_INLINE
-IR_ValueBoxDef_var::IR_ValueBoxDef_var (void) // default constructor
-  : ptr_ (IR_ValueBoxDef::_nil ())
-{}
-
-ACE_INLINE IR_ValueBoxDef_ptr 
-IR_ValueBoxDef_var::ptr (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE
-IR_ValueBoxDef_var::IR_ValueBoxDef_var (const IR_ValueBoxDef_var &p) // copy constructor
-  : TAO_Base_var (),
-    ptr_ (IR_ValueBoxDef::_duplicate (p.ptr ()))
-{}
-
-ACE_INLINE
-IR_ValueBoxDef_var::~IR_ValueBoxDef_var (void) // destructor
-{
-  CORBA::release (this->ptr_);
-}
-
-ACE_INLINE IR_ValueBoxDef_var &
-IR_ValueBoxDef_var::operator= (IR_ValueBoxDef_ptr p)
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE IR_ValueBoxDef_var &
-IR_ValueBoxDef_var::operator= (const IR_ValueBoxDef_var &p)
-{
-  if (this != &p)
-  {
-    CORBA::release (this->ptr_);
-    this->ptr_ = IR_ValueBoxDef::_duplicate (p.ptr ());
-  }
-  return *this;
-}
-
-ACE_INLINE 
-IR_ValueBoxDef_var::operator const IR_ValueBoxDef_ptr &() const // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE 
-IR_ValueBoxDef_var::operator IR_ValueBoxDef_ptr &() // cast 
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_ValueBoxDef_ptr 
-IR_ValueBoxDef_var::operator-> (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_ValueBoxDef_ptr
-IR_ValueBoxDef_var::in (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_ValueBoxDef_ptr &
-IR_ValueBoxDef_var::inout (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_ValueBoxDef_ptr &
-IR_ValueBoxDef_var::out (void)
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = IR_ValueBoxDef::_nil ();
-  return this->ptr_;
-}
-
-ACE_INLINE IR_ValueBoxDef_ptr 
-IR_ValueBoxDef_var::_retn (void)
-{
-  // yield ownership of managed obj reference
-  IR_ValueBoxDef_ptr val = this->ptr_;
-  this->ptr_ = IR_ValueBoxDef::_nil ();
-  return val;
-}
-
-// *************************************************************
-// Inline operations for class IR_ValueBoxDef_out
-// *************************************************************
-
-ACE_INLINE
-IR_ValueBoxDef_out::IR_ValueBoxDef_out (IR_ValueBoxDef_ptr &p)
-  : ptr_ (p)
-{
-  this->ptr_ = IR_ValueBoxDef::_nil ();
-}
-
-ACE_INLINE
-IR_ValueBoxDef_out::IR_ValueBoxDef_out (IR_ValueBoxDef_var &p) // constructor from _var
-  : ptr_ (p.out ())
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = IR_ValueBoxDef::_nil ();
-}
-
-ACE_INLINE
-IR_ValueBoxDef_out::IR_ValueBoxDef_out (const IR_ValueBoxDef_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (IR_ValueBoxDef_out&,p).ptr_)
-{}
-
-ACE_INLINE IR_ValueBoxDef_out &
-IR_ValueBoxDef_out::operator= (const IR_ValueBoxDef_out &p)
-{
-  this->ptr_ = ACE_const_cast (IR_ValueBoxDef_out&,p).ptr_;
-  return *this;
-}
-
-ACE_INLINE IR_ValueBoxDef_out &
-IR_ValueBoxDef_out::operator= (const IR_ValueBoxDef_var &p)
-{
-  this->ptr_ = IR_ValueBoxDef::_duplicate (p.ptr ());
-  return *this;
-}
-
-ACE_INLINE IR_ValueBoxDef_out &
-IR_ValueBoxDef_out::operator= (IR_ValueBoxDef_ptr p)
-{
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE 
-IR_ValueBoxDef_out::operator IR_ValueBoxDef_ptr &() // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_ValueBoxDef_ptr &
-IR_ValueBoxDef_out::ptr (void) // ptr
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_ValueBoxDef_ptr 
-IR_ValueBoxDef_out::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE
-IR_ComponentDef::IR_ComponentDef (
-    TAO_Stub *objref,
-    CORBA::Boolean _tao_collocated,
-    TAO_Abstract_ServantBase *servant
-  )
-  : CORBA_Object (objref, _tao_collocated, servant)
-{
-  this->IR_ComponentDef_setup_collocation (_tao_collocated);
-}
-
-// *************************************************************
-// Inline operations for class IR_ComponentDef_var
-// *************************************************************
-
-ACE_INLINE
-IR_ComponentDef_var::IR_ComponentDef_var (void) // default constructor
-  : ptr_ (IR_ComponentDef::_nil ())
-{}
-
-ACE_INLINE IR_ComponentDef_ptr 
-IR_ComponentDef_var::ptr (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE
-IR_ComponentDef_var::IR_ComponentDef_var (const IR_ComponentDef_var &p) // copy constructor
-  : TAO_Base_var (),
-    ptr_ (IR_ComponentDef::_duplicate (p.ptr ()))
-{}
-
-ACE_INLINE
-IR_ComponentDef_var::~IR_ComponentDef_var (void) // destructor
-{
-  CORBA::release (this->ptr_);
-}
-
-ACE_INLINE IR_ComponentDef_var &
-IR_ComponentDef_var::operator= (IR_ComponentDef_ptr p)
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE IR_ComponentDef_var &
-IR_ComponentDef_var::operator= (const IR_ComponentDef_var &p)
-{
-  if (this != &p)
-  {
-    CORBA::release (this->ptr_);
-    this->ptr_ = IR_ComponentDef::_duplicate (p.ptr ());
-  }
-  return *this;
-}
-
-ACE_INLINE 
-IR_ComponentDef_var::operator const IR_ComponentDef_ptr &() const // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE 
-IR_ComponentDef_var::operator IR_ComponentDef_ptr &() // cast 
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_ComponentDef_ptr 
-IR_ComponentDef_var::operator-> (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_ComponentDef_ptr
-IR_ComponentDef_var::in (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_ComponentDef_ptr &
-IR_ComponentDef_var::inout (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_ComponentDef_ptr &
-IR_ComponentDef_var::out (void)
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = IR_ComponentDef::_nil ();
-  return this->ptr_;
-}
-
-ACE_INLINE IR_ComponentDef_ptr 
-IR_ComponentDef_var::_retn (void)
-{
-  // yield ownership of managed obj reference
-  IR_ComponentDef_ptr val = this->ptr_;
-  this->ptr_ = IR_ComponentDef::_nil ();
-  return val;
-}
-
-// *************************************************************
-// Inline operations for class IR_ComponentDef_out
-// *************************************************************
-
-ACE_INLINE
-IR_ComponentDef_out::IR_ComponentDef_out (IR_ComponentDef_ptr &p)
-  : ptr_ (p)
-{
-  this->ptr_ = IR_ComponentDef::_nil ();
-}
-
-ACE_INLINE
-IR_ComponentDef_out::IR_ComponentDef_out (IR_ComponentDef_var &p) // constructor from _var
-  : ptr_ (p.out ())
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = IR_ComponentDef::_nil ();
-}
-
-ACE_INLINE
-IR_ComponentDef_out::IR_ComponentDef_out (const IR_ComponentDef_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (IR_ComponentDef_out&,p).ptr_)
-{}
-
-ACE_INLINE IR_ComponentDef_out &
-IR_ComponentDef_out::operator= (const IR_ComponentDef_out &p)
-{
-  this->ptr_ = ACE_const_cast (IR_ComponentDef_out&,p).ptr_;
-  return *this;
-}
-
-ACE_INLINE IR_ComponentDef_out &
-IR_ComponentDef_out::operator= (const IR_ComponentDef_var &p)
-{
-  this->ptr_ = IR_ComponentDef::_duplicate (p.ptr ());
-  return *this;
-}
-
-ACE_INLINE IR_ComponentDef_out &
-IR_ComponentDef_out::operator= (IR_ComponentDef_ptr p)
-{
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE 
-IR_ComponentDef_out::operator IR_ComponentDef_ptr &() // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_ComponentDef_ptr &
-IR_ComponentDef_out::ptr (void) // ptr
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_ComponentDef_ptr 
-IR_ComponentDef_out::operator-> (void)
-{
-  return this->ptr_;
-}
-
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  
-  ACE_INLINE IR_ComponentDef **
-  _TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq::allocbuf (CORBA::ULong nelems)
-  {
-    IR_ComponentDef **buf = 0;
-    
-    ACE_NEW_RETURN (buf, IR_ComponentDef*[nelems], 0);
-    
-    for (CORBA::ULong i = 0; i < nelems; i++)
-      buf[i] = IR_ComponentDef::_nil ();
-    
-    return buf;
-  }
-  
-  ACE_INLINE void 
-  _TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq::freebuf (IR_ComponentDef **buffer)
-  {
-    if (buffer == 0)
-      return;
-    delete[] buffer;
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq::_TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq (void)
-  {
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq::_TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq (CORBA::ULong maximum)
-    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq::allocbuf (maximum))
-  {
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq::_TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq (CORBA::ULong maximum,
-    CORBA::ULong length,
-    IR_ComponentDef* *value,
-    CORBA::Boolean release)
-  : TAO_Unbounded_Base_Sequence (maximum, length, value, release)
-  {
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq::_TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq(const _TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq &rhs)
-    : TAO_Unbounded_Base_Sequence (rhs)
-  {
-    if (rhs.buffer_ != 0)
-    {
-      IR_ComponentDef **tmp1 = _TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq::allocbuf (this->maximum_);
-      IR_ComponentDef ** const tmp2 = ACE_reinterpret_cast (IR_ComponentDef ** ACE_CAST_CONST, rhs.buffer_);
-      
-      for (CORBA::ULong i = 0; i < rhs.length_; ++i)
-        tmp1[i] = IR_ComponentDef::_duplicate (tmp2[i]);
-      
-      this->buffer_ = tmp1;
-    }
-    else
-    {
-      this->buffer_ = 0;
-    }
-  }
-  
-  ACE_INLINE _TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq &
-  _TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq::operator= (const _TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq &rhs)
-  {
-    if (this == &rhs)
-      return *this;
-    
-    if (this->release_)
-    {
-      IR_ComponentDef **tmp = ACE_reinterpret_cast (IR_ComponentDef **, this->buffer_);
-      
-      for (CORBA::ULong i = 0; i < this->length_; ++i)
-      {
-        CORBA::release (tmp[i]);
-        tmp[i] = IR_ComponentDef::_nil ();
-      }
-      if (this->maximum_ < rhs.maximum_)
-      {
-        _TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq::freebuf (tmp);
-        this->buffer_ = _TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq::allocbuf (rhs.maximum_);
-      }
-    }
-    else
-      this->buffer_ = _TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq::allocbuf (rhs.maximum_);
-    
-    TAO_Unbounded_Base_Sequence::operator= (rhs);
-    
-    IR_ComponentDef **tmp1 = ACE_reinterpret_cast (IR_ComponentDef **, this->buffer_);
-    IR_ComponentDef ** const tmp2 = ACE_reinterpret_cast (IR_ComponentDef ** ACE_CAST_CONST, rhs.buffer_);
-    
-    for (CORBA::ULong i = 0; i < rhs.length_; ++i)
-      tmp1[i] = IR_ComponentDef::_duplicate (tmp2[i]);
-    
-    return *this;
-  }
-  
-  ACE_INLINE TAO_Object_Manager<IR_ComponentDef,IR_ComponentDef_var>
-  _TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq::operator[] (CORBA::ULong index) const
-  // read-write accessor
-  {
-    ACE_ASSERT (index < this->maximum_);
-    IR_ComponentDef ** const tmp = ACE_reinterpret_cast (IR_ComponentDef ** ACE_CAST_CONST, this->buffer_);
-    return TAO_Object_Manager<IR_ComponentDef,IR_ComponentDef_var> (tmp + index, this->release_);
-  }
-  
-  ACE_INLINE IR_ComponentDef* *
-  _TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq::get_buffer (CORBA::Boolean orphan)
-  {
-    IR_ComponentDef **result = 0;
-    if (orphan == 0)
-    {
-      // We retain ownership.
-      if (this->buffer_ == 0)
-      {
-        result = _TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq::allocbuf (this->maximum_);
-        this->buffer_ = result;
-        this->release_ = 1;
-      }
-      else
-      {
-        result = ACE_reinterpret_cast (IR_ComponentDef**, this->buffer_);
-      }
-    }
-    else // if (orphan == 1)
-    {
-      if (this->release_ != 0)
-      {
-        // We set the state back to default and relinquish
-        // ownership.
-        result = ACE_reinterpret_cast(IR_ComponentDef**,this->buffer_);
-        this->maximum_ = 0;
-        this->length_ = 0;
-        this->buffer_ = 0;
-        this->release_ = 0;
-      }
-    }
-    return result;
-  }
-  
-  ACE_INLINE const IR_ComponentDef* *
-  _TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq::get_buffer (void) const
-  {
-    return ACE_reinterpret_cast(const IR_ComponentDef ** ACE_CAST_CONST, this->buffer_);
-  }
-  
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
-
-// *************************************************************
-// Inline operations for class IR_ComponentDefSeq_var
-// *************************************************************
-
-ACE_INLINE
-IR_ComponentDefSeq_var::IR_ComponentDefSeq_var (void) // default constructor
-  : ptr_ (0)
-{}
-
-ACE_INLINE
-IR_ComponentDefSeq_var::IR_ComponentDefSeq_var (IR_ComponentDefSeq *p)
-  : ptr_ (p)
-{}
-
-ACE_INLINE
-IR_ComponentDefSeq_var::IR_ComponentDefSeq_var (const ::IR_ComponentDefSeq_var &p) // copy constructor
-{
-  if (p.ptr_)
-    ACE_NEW (this->ptr_, ::IR_ComponentDefSeq (*p.ptr_));
-  else
-    this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_ComponentDefSeq_var::~IR_ComponentDefSeq_var (void) // destructor
-{
-  delete this->ptr_;
-}
-
-ACE_INLINE IR_ComponentDefSeq_var &
-IR_ComponentDefSeq_var::operator= (IR_ComponentDefSeq *p)
-{
-  delete this->ptr_;
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE IR_ComponentDefSeq_var &
-IR_ComponentDefSeq_var::operator= (const ::IR_ComponentDefSeq_var &p) // deep copy
-{
-  if (this != &p)
-    {
-      if (p.ptr_ == 0)
-        {
-          delete this->ptr_;
-          this->ptr_ = 0;
-        }
-      else
-        {
-          IR_ComponentDefSeq *deep_copy = 
-            new IR_ComponentDefSeq (*p.ptr_);
-          
-          if (deep_copy != 0)
-            {
-              IR_ComponentDefSeq *tmp = deep_copy;
-              deep_copy = this->ptr_;
-              this->ptr_ = tmp;
-              delete deep_copy;
-            }
-        }
-    }
-  
-  return *this;
-}
-
-ACE_INLINE const ::IR_ComponentDefSeq *
-IR_ComponentDefSeq_var::operator-> (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_ComponentDefSeq *
-IR_ComponentDefSeq_var::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE 
-IR_ComponentDefSeq_var::operator const ::IR_ComponentDefSeq &() const // cast
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE 
-IR_ComponentDefSeq_var::operator ::IR_ComponentDefSeq &() // cast 
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE 
-IR_ComponentDefSeq_var::operator ::IR_ComponentDefSeq &() const // cast 
-{
-  return *this->ptr_;
-}
-
-// variable-size types only
-ACE_INLINE
-IR_ComponentDefSeq_var::operator ::IR_ComponentDefSeq *&() // cast 
-{
-  return this->ptr_;
-}
-
-ACE_INLINE TAO_Object_Manager<IR_ComponentDef, IR_ComponentDef_var>
-IR_ComponentDefSeq_var::operator[] (CORBA::ULong index)
-{
-  return this->ptr_->operator[] (index);
-}
-
-ACE_INLINE const ::IR_ComponentDefSeq &
-IR_ComponentDefSeq_var::in (void) const
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE ::IR_ComponentDefSeq &
-IR_ComponentDefSeq_var::inout (void)
-{
-  return *this->ptr_;
-}
-
-// mapping for variable size 
-ACE_INLINE ::IR_ComponentDefSeq *&
-IR_ComponentDefSeq_var::out (void)
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_ComponentDefSeq *
-IR_ComponentDefSeq_var::_retn (void)
-{
-  ::IR_ComponentDefSeq *tmp = this->ptr_;
-  this->ptr_ = 0;
-  return tmp;
-}
-
-ACE_INLINE ::IR_ComponentDefSeq *
-IR_ComponentDefSeq_var::ptr (void) const
-{
-  return this->ptr_;
-}
-
-// *************************************************************
-// Inline operations for class IR_ComponentDefSeq_out
-// *************************************************************
-
-ACE_INLINE
-IR_ComponentDefSeq_out::IR_ComponentDefSeq_out (IR_ComponentDefSeq *&p)
-  : ptr_ (p)
-{
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_ComponentDefSeq_out::IR_ComponentDefSeq_out (IR_ComponentDefSeq_var &p) // constructor from _var
-  : ptr_ (p.out ())
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_ComponentDefSeq_out::IR_ComponentDefSeq_out (const ::IR_ComponentDefSeq_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (IR_ComponentDefSeq_out&, p).ptr_)
-{}
-
-ACE_INLINE ::IR_ComponentDefSeq_out &
-IR_ComponentDefSeq_out::operator= (const ::IR_ComponentDefSeq_out &p)
-{
-  this->ptr_ = ACE_const_cast (IR_ComponentDefSeq_out&, p).ptr_;
-  return *this;
-}
-
-ACE_INLINE ::IR_ComponentDefSeq_out &
-IR_ComponentDefSeq_out::operator= (IR_ComponentDefSeq *p)
-{
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE 
-IR_ComponentDefSeq_out::operator ::IR_ComponentDefSeq *&() // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_ComponentDefSeq *&
-IR_ComponentDefSeq_out::ptr (void) // ptr
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_ComponentDefSeq *
-IR_ComponentDefSeq_out::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE TAO_Object_Manager<IR_ComponentDef, IR_ComponentDef_var>
-IR_ComponentDefSeq_out::operator[] (CORBA::ULong index)
-{
-  return this->ptr_->operator[] (index);
-}
-
-ACE_INLINE
-IR_ProvidesDef::IR_ProvidesDef (
-    TAO_Stub *objref,
-    CORBA::Boolean _tao_collocated,
-    TAO_Abstract_ServantBase *servant
-  )
-  : CORBA_Object (objref, _tao_collocated, servant)
-{
-  this->IR_ProvidesDef_setup_collocation (_tao_collocated);
-}
-
-// *************************************************************
-// Inline operations for class IR_ProvidesDef_var
-// *************************************************************
-
-ACE_INLINE
-IR_ProvidesDef_var::IR_ProvidesDef_var (void) // default constructor
-  : ptr_ (IR_ProvidesDef::_nil ())
-{}
-
-ACE_INLINE IR_ProvidesDef_ptr 
-IR_ProvidesDef_var::ptr (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE
-IR_ProvidesDef_var::IR_ProvidesDef_var (const IR_ProvidesDef_var &p) // copy constructor
-  : TAO_Base_var (),
-    ptr_ (IR_ProvidesDef::_duplicate (p.ptr ()))
-{}
-
-ACE_INLINE
-IR_ProvidesDef_var::~IR_ProvidesDef_var (void) // destructor
-{
-  CORBA::release (this->ptr_);
-}
-
-ACE_INLINE IR_ProvidesDef_var &
-IR_ProvidesDef_var::operator= (IR_ProvidesDef_ptr p)
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE IR_ProvidesDef_var &
-IR_ProvidesDef_var::operator= (const IR_ProvidesDef_var &p)
-{
-  if (this != &p)
-  {
-    CORBA::release (this->ptr_);
-    this->ptr_ = IR_ProvidesDef::_duplicate (p.ptr ());
-  }
-  return *this;
-}
-
-ACE_INLINE 
-IR_ProvidesDef_var::operator const IR_ProvidesDef_ptr &() const // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE 
-IR_ProvidesDef_var::operator IR_ProvidesDef_ptr &() // cast 
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_ProvidesDef_ptr 
-IR_ProvidesDef_var::operator-> (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_ProvidesDef_ptr
-IR_ProvidesDef_var::in (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_ProvidesDef_ptr &
-IR_ProvidesDef_var::inout (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_ProvidesDef_ptr &
-IR_ProvidesDef_var::out (void)
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = IR_ProvidesDef::_nil ();
-  return this->ptr_;
-}
-
-ACE_INLINE IR_ProvidesDef_ptr 
-IR_ProvidesDef_var::_retn (void)
-{
-  // yield ownership of managed obj reference
-  IR_ProvidesDef_ptr val = this->ptr_;
-  this->ptr_ = IR_ProvidesDef::_nil ();
-  return val;
-}
-
-// *************************************************************
-// Inline operations for class IR_ProvidesDef_out
-// *************************************************************
-
-ACE_INLINE
-IR_ProvidesDef_out::IR_ProvidesDef_out (IR_ProvidesDef_ptr &p)
-  : ptr_ (p)
-{
-  this->ptr_ = IR_ProvidesDef::_nil ();
-}
-
-ACE_INLINE
-IR_ProvidesDef_out::IR_ProvidesDef_out (IR_ProvidesDef_var &p) // constructor from _var
-  : ptr_ (p.out ())
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = IR_ProvidesDef::_nil ();
-}
-
-ACE_INLINE
-IR_ProvidesDef_out::IR_ProvidesDef_out (const IR_ProvidesDef_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (IR_ProvidesDef_out&,p).ptr_)
-{}
-
-ACE_INLINE IR_ProvidesDef_out &
-IR_ProvidesDef_out::operator= (const IR_ProvidesDef_out &p)
-{
-  this->ptr_ = ACE_const_cast (IR_ProvidesDef_out&,p).ptr_;
-  return *this;
-}
-
-ACE_INLINE IR_ProvidesDef_out &
-IR_ProvidesDef_out::operator= (const IR_ProvidesDef_var &p)
-{
-  this->ptr_ = IR_ProvidesDef::_duplicate (p.ptr ());
-  return *this;
-}
-
-ACE_INLINE IR_ProvidesDef_out &
-IR_ProvidesDef_out::operator= (IR_ProvidesDef_ptr p)
-{
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE 
-IR_ProvidesDef_out::operator IR_ProvidesDef_ptr &() // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_ProvidesDef_ptr &
-IR_ProvidesDef_out::ptr (void) // ptr
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_ProvidesDef_ptr 
-IR_ProvidesDef_out::operator-> (void)
-{
-  return this->ptr_;
-}
-
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  
-  ACE_INLINE IR_ProvidesDef **
-  _TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq::allocbuf (CORBA::ULong nelems)
-  {
-    IR_ProvidesDef **buf = 0;
-    
-    ACE_NEW_RETURN (buf, IR_ProvidesDef*[nelems], 0);
-    
-    for (CORBA::ULong i = 0; i < nelems; i++)
-      buf[i] = IR_ProvidesDef::_nil ();
-    
-    return buf;
-  }
-  
-  ACE_INLINE void 
-  _TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq::freebuf (IR_ProvidesDef **buffer)
-  {
-    if (buffer == 0)
-      return;
-    delete[] buffer;
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq::_TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq (void)
-  {
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq::_TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq (CORBA::ULong maximum)
-    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq::allocbuf (maximum))
-  {
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq::_TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq (CORBA::ULong maximum,
-    CORBA::ULong length,
-    IR_ProvidesDef* *value,
-    CORBA::Boolean release)
-  : TAO_Unbounded_Base_Sequence (maximum, length, value, release)
-  {
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq::_TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq(const _TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq &rhs)
-    : TAO_Unbounded_Base_Sequence (rhs)
-  {
-    if (rhs.buffer_ != 0)
-    {
-      IR_ProvidesDef **tmp1 = _TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq::allocbuf (this->maximum_);
-      IR_ProvidesDef ** const tmp2 = ACE_reinterpret_cast (IR_ProvidesDef ** ACE_CAST_CONST, rhs.buffer_);
-      
-      for (CORBA::ULong i = 0; i < rhs.length_; ++i)
-        tmp1[i] = IR_ProvidesDef::_duplicate (tmp2[i]);
-      
-      this->buffer_ = tmp1;
-    }
-    else
-    {
-      this->buffer_ = 0;
-    }
-  }
-  
-  ACE_INLINE _TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq &
-  _TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq::operator= (const _TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq &rhs)
-  {
-    if (this == &rhs)
-      return *this;
-    
-    if (this->release_)
-    {
-      IR_ProvidesDef **tmp = ACE_reinterpret_cast (IR_ProvidesDef **, this->buffer_);
-      
-      for (CORBA::ULong i = 0; i < this->length_; ++i)
-      {
-        CORBA::release (tmp[i]);
-        tmp[i] = IR_ProvidesDef::_nil ();
-      }
-      if (this->maximum_ < rhs.maximum_)
-      {
-        _TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq::freebuf (tmp);
-        this->buffer_ = _TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq::allocbuf (rhs.maximum_);
-      }
-    }
-    else
-      this->buffer_ = _TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq::allocbuf (rhs.maximum_);
-    
-    TAO_Unbounded_Base_Sequence::operator= (rhs);
-    
-    IR_ProvidesDef **tmp1 = ACE_reinterpret_cast (IR_ProvidesDef **, this->buffer_);
-    IR_ProvidesDef ** const tmp2 = ACE_reinterpret_cast (IR_ProvidesDef ** ACE_CAST_CONST, rhs.buffer_);
-    
-    for (CORBA::ULong i = 0; i < rhs.length_; ++i)
-      tmp1[i] = IR_ProvidesDef::_duplicate (tmp2[i]);
-    
-    return *this;
-  }
-  
-  ACE_INLINE TAO_Object_Manager<IR_ProvidesDef,IR_ProvidesDef_var>
-  _TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq::operator[] (CORBA::ULong index) const
-  // read-write accessor
-  {
-    ACE_ASSERT (index < this->maximum_);
-    IR_ProvidesDef ** const tmp = ACE_reinterpret_cast (IR_ProvidesDef ** ACE_CAST_CONST, this->buffer_);
-    return TAO_Object_Manager<IR_ProvidesDef,IR_ProvidesDef_var> (tmp + index, this->release_);
-  }
-  
-  ACE_INLINE IR_ProvidesDef* *
-  _TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq::get_buffer (CORBA::Boolean orphan)
-  {
-    IR_ProvidesDef **result = 0;
-    if (orphan == 0)
-    {
-      // We retain ownership.
-      if (this->buffer_ == 0)
-      {
-        result = _TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq::allocbuf (this->maximum_);
-        this->buffer_ = result;
-        this->release_ = 1;
-      }
-      else
-      {
-        result = ACE_reinterpret_cast (IR_ProvidesDef**, this->buffer_);
-      }
-    }
-    else // if (orphan == 1)
-    {
-      if (this->release_ != 0)
-      {
-        // We set the state back to default and relinquish
-        // ownership.
-        result = ACE_reinterpret_cast(IR_ProvidesDef**,this->buffer_);
-        this->maximum_ = 0;
-        this->length_ = 0;
-        this->buffer_ = 0;
-        this->release_ = 0;
-      }
-    }
-    return result;
-  }
-  
-  ACE_INLINE const IR_ProvidesDef* *
-  _TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq::get_buffer (void) const
-  {
-    return ACE_reinterpret_cast(const IR_ProvidesDef ** ACE_CAST_CONST, this->buffer_);
-  }
-  
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
-
-// *************************************************************
-// Inline operations for class IR_ProvidesDefSeq_var
-// *************************************************************
-
-ACE_INLINE
-IR_ProvidesDefSeq_var::IR_ProvidesDefSeq_var (void) // default constructor
-  : ptr_ (0)
-{}
-
-ACE_INLINE
-IR_ProvidesDefSeq_var::IR_ProvidesDefSeq_var (IR_ProvidesDefSeq *p)
-  : ptr_ (p)
-{}
-
-ACE_INLINE
-IR_ProvidesDefSeq_var::IR_ProvidesDefSeq_var (const ::IR_ProvidesDefSeq_var &p) // copy constructor
-{
-  if (p.ptr_)
-    ACE_NEW (this->ptr_, ::IR_ProvidesDefSeq (*p.ptr_));
-  else
-    this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_ProvidesDefSeq_var::~IR_ProvidesDefSeq_var (void) // destructor
-{
-  delete this->ptr_;
-}
-
-ACE_INLINE IR_ProvidesDefSeq_var &
-IR_ProvidesDefSeq_var::operator= (IR_ProvidesDefSeq *p)
-{
-  delete this->ptr_;
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE IR_ProvidesDefSeq_var &
-IR_ProvidesDefSeq_var::operator= (const ::IR_ProvidesDefSeq_var &p) // deep copy
-{
-  if (this != &p)
-    {
-      if (p.ptr_ == 0)
-        {
-          delete this->ptr_;
-          this->ptr_ = 0;
-        }
-      else
-        {
-          IR_ProvidesDefSeq *deep_copy = 
-            new IR_ProvidesDefSeq (*p.ptr_);
-          
-          if (deep_copy != 0)
-            {
-              IR_ProvidesDefSeq *tmp = deep_copy;
-              deep_copy = this->ptr_;
-              this->ptr_ = tmp;
-              delete deep_copy;
-            }
-        }
-    }
-  
-  return *this;
-}
-
-ACE_INLINE const ::IR_ProvidesDefSeq *
-IR_ProvidesDefSeq_var::operator-> (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_ProvidesDefSeq *
-IR_ProvidesDefSeq_var::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE 
-IR_ProvidesDefSeq_var::operator const ::IR_ProvidesDefSeq &() const // cast
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE 
-IR_ProvidesDefSeq_var::operator ::IR_ProvidesDefSeq &() // cast 
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE 
-IR_ProvidesDefSeq_var::operator ::IR_ProvidesDefSeq &() const // cast 
-{
-  return *this->ptr_;
-}
-
-// variable-size types only
-ACE_INLINE
-IR_ProvidesDefSeq_var::operator ::IR_ProvidesDefSeq *&() // cast 
-{
-  return this->ptr_;
-}
-
-ACE_INLINE TAO_Object_Manager<IR_ProvidesDef, IR_ProvidesDef_var>
-IR_ProvidesDefSeq_var::operator[] (CORBA::ULong index)
-{
-  return this->ptr_->operator[] (index);
-}
-
-ACE_INLINE const ::IR_ProvidesDefSeq &
-IR_ProvidesDefSeq_var::in (void) const
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE ::IR_ProvidesDefSeq &
-IR_ProvidesDefSeq_var::inout (void)
-{
-  return *this->ptr_;
-}
-
-// mapping for variable size 
-ACE_INLINE ::IR_ProvidesDefSeq *&
-IR_ProvidesDefSeq_var::out (void)
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_ProvidesDefSeq *
-IR_ProvidesDefSeq_var::_retn (void)
-{
-  ::IR_ProvidesDefSeq *tmp = this->ptr_;
-  this->ptr_ = 0;
-  return tmp;
-}
-
-ACE_INLINE ::IR_ProvidesDefSeq *
-IR_ProvidesDefSeq_var::ptr (void) const
-{
-  return this->ptr_;
-}
-
-// *************************************************************
-// Inline operations for class IR_ProvidesDefSeq_out
-// *************************************************************
-
-ACE_INLINE
-IR_ProvidesDefSeq_out::IR_ProvidesDefSeq_out (IR_ProvidesDefSeq *&p)
-  : ptr_ (p)
-{
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_ProvidesDefSeq_out::IR_ProvidesDefSeq_out (IR_ProvidesDefSeq_var &p) // constructor from _var
-  : ptr_ (p.out ())
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_ProvidesDefSeq_out::IR_ProvidesDefSeq_out (const ::IR_ProvidesDefSeq_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (IR_ProvidesDefSeq_out&, p).ptr_)
-{}
-
-ACE_INLINE ::IR_ProvidesDefSeq_out &
-IR_ProvidesDefSeq_out::operator= (const ::IR_ProvidesDefSeq_out &p)
-{
-  this->ptr_ = ACE_const_cast (IR_ProvidesDefSeq_out&, p).ptr_;
-  return *this;
-}
-
-ACE_INLINE ::IR_ProvidesDefSeq_out &
-IR_ProvidesDefSeq_out::operator= (IR_ProvidesDefSeq *p)
-{
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE 
-IR_ProvidesDefSeq_out::operator ::IR_ProvidesDefSeq *&() // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_ProvidesDefSeq *&
-IR_ProvidesDefSeq_out::ptr (void) // ptr
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_ProvidesDefSeq *
-IR_ProvidesDefSeq_out::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE TAO_Object_Manager<IR_ProvidesDef, IR_ProvidesDef_var>
-IR_ProvidesDefSeq_out::operator[] (CORBA::ULong index)
-{
-  return this->ptr_->operator[] (index);
-}
-
-ACE_INLINE
-IR_UsesDef::IR_UsesDef (
-    TAO_Stub *objref,
-    CORBA::Boolean _tao_collocated,
-    TAO_Abstract_ServantBase *servant
-  )
-  : CORBA_Object (objref, _tao_collocated, servant)
-{
-  this->IR_UsesDef_setup_collocation (_tao_collocated);
-}
-
-// *************************************************************
-// Inline operations for class IR_UsesDef_var
-// *************************************************************
-
-ACE_INLINE
-IR_UsesDef_var::IR_UsesDef_var (void) // default constructor
-  : ptr_ (IR_UsesDef::_nil ())
-{}
-
-ACE_INLINE IR_UsesDef_ptr 
-IR_UsesDef_var::ptr (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE
-IR_UsesDef_var::IR_UsesDef_var (const IR_UsesDef_var &p) // copy constructor
-  : TAO_Base_var (),
-    ptr_ (IR_UsesDef::_duplicate (p.ptr ()))
-{}
-
-ACE_INLINE
-IR_UsesDef_var::~IR_UsesDef_var (void) // destructor
-{
-  CORBA::release (this->ptr_);
-}
-
-ACE_INLINE IR_UsesDef_var &
-IR_UsesDef_var::operator= (IR_UsesDef_ptr p)
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE IR_UsesDef_var &
-IR_UsesDef_var::operator= (const IR_UsesDef_var &p)
-{
-  if (this != &p)
-  {
-    CORBA::release (this->ptr_);
-    this->ptr_ = IR_UsesDef::_duplicate (p.ptr ());
-  }
-  return *this;
-}
-
-ACE_INLINE 
-IR_UsesDef_var::operator const IR_UsesDef_ptr &() const // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE 
-IR_UsesDef_var::operator IR_UsesDef_ptr &() // cast 
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_UsesDef_ptr 
-IR_UsesDef_var::operator-> (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_UsesDef_ptr
-IR_UsesDef_var::in (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_UsesDef_ptr &
-IR_UsesDef_var::inout (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_UsesDef_ptr &
-IR_UsesDef_var::out (void)
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = IR_UsesDef::_nil ();
-  return this->ptr_;
-}
-
-ACE_INLINE IR_UsesDef_ptr 
-IR_UsesDef_var::_retn (void)
-{
-  // yield ownership of managed obj reference
-  IR_UsesDef_ptr val = this->ptr_;
-  this->ptr_ = IR_UsesDef::_nil ();
-  return val;
-}
-
-// *************************************************************
-// Inline operations for class IR_UsesDef_out
-// *************************************************************
-
-ACE_INLINE
-IR_UsesDef_out::IR_UsesDef_out (IR_UsesDef_ptr &p)
-  : ptr_ (p)
-{
-  this->ptr_ = IR_UsesDef::_nil ();
-}
-
-ACE_INLINE
-IR_UsesDef_out::IR_UsesDef_out (IR_UsesDef_var &p) // constructor from _var
-  : ptr_ (p.out ())
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = IR_UsesDef::_nil ();
-}
-
-ACE_INLINE
-IR_UsesDef_out::IR_UsesDef_out (const IR_UsesDef_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (IR_UsesDef_out&,p).ptr_)
-{}
-
-ACE_INLINE IR_UsesDef_out &
-IR_UsesDef_out::operator= (const IR_UsesDef_out &p)
-{
-  this->ptr_ = ACE_const_cast (IR_UsesDef_out&,p).ptr_;
-  return *this;
-}
-
-ACE_INLINE IR_UsesDef_out &
-IR_UsesDef_out::operator= (const IR_UsesDef_var &p)
-{
-  this->ptr_ = IR_UsesDef::_duplicate (p.ptr ());
-  return *this;
-}
-
-ACE_INLINE IR_UsesDef_out &
-IR_UsesDef_out::operator= (IR_UsesDef_ptr p)
-{
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE 
-IR_UsesDef_out::operator IR_UsesDef_ptr &() // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_UsesDef_ptr &
-IR_UsesDef_out::ptr (void) // ptr
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_UsesDef_ptr 
-IR_UsesDef_out::operator-> (void)
-{
-  return this->ptr_;
-}
-
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  
-  ACE_INLINE IR_UsesDef **
-  _TAO_Unbounded_Object_Sequence_IR_UsesDefSeq::allocbuf (CORBA::ULong nelems)
-  {
-    IR_UsesDef **buf = 0;
-    
-    ACE_NEW_RETURN (buf, IR_UsesDef*[nelems], 0);
-    
-    for (CORBA::ULong i = 0; i < nelems; i++)
-      buf[i] = IR_UsesDef::_nil ();
-    
-    return buf;
-  }
-  
-  ACE_INLINE void 
-  _TAO_Unbounded_Object_Sequence_IR_UsesDefSeq::freebuf (IR_UsesDef **buffer)
-  {
-    if (buffer == 0)
-      return;
-    delete[] buffer;
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Object_Sequence_IR_UsesDefSeq::_TAO_Unbounded_Object_Sequence_IR_UsesDefSeq (void)
-  {
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Object_Sequence_IR_UsesDefSeq::_TAO_Unbounded_Object_Sequence_IR_UsesDefSeq (CORBA::ULong maximum)
-    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Object_Sequence_IR_UsesDefSeq::allocbuf (maximum))
-  {
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Object_Sequence_IR_UsesDefSeq::_TAO_Unbounded_Object_Sequence_IR_UsesDefSeq (CORBA::ULong maximum,
-    CORBA::ULong length,
-    IR_UsesDef* *value,
-    CORBA::Boolean release)
-  : TAO_Unbounded_Base_Sequence (maximum, length, value, release)
-  {
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Object_Sequence_IR_UsesDefSeq::_TAO_Unbounded_Object_Sequence_IR_UsesDefSeq(const _TAO_Unbounded_Object_Sequence_IR_UsesDefSeq &rhs)
-    : TAO_Unbounded_Base_Sequence (rhs)
-  {
-    if (rhs.buffer_ != 0)
-    {
-      IR_UsesDef **tmp1 = _TAO_Unbounded_Object_Sequence_IR_UsesDefSeq::allocbuf (this->maximum_);
-      IR_UsesDef ** const tmp2 = ACE_reinterpret_cast (IR_UsesDef ** ACE_CAST_CONST, rhs.buffer_);
-      
-      for (CORBA::ULong i = 0; i < rhs.length_; ++i)
-        tmp1[i] = IR_UsesDef::_duplicate (tmp2[i]);
-      
-      this->buffer_ = tmp1;
-    }
-    else
-    {
-      this->buffer_ = 0;
-    }
-  }
-  
-  ACE_INLINE _TAO_Unbounded_Object_Sequence_IR_UsesDefSeq &
-  _TAO_Unbounded_Object_Sequence_IR_UsesDefSeq::operator= (const _TAO_Unbounded_Object_Sequence_IR_UsesDefSeq &rhs)
-  {
-    if (this == &rhs)
-      return *this;
-    
-    if (this->release_)
-    {
-      IR_UsesDef **tmp = ACE_reinterpret_cast (IR_UsesDef **, this->buffer_);
-      
-      for (CORBA::ULong i = 0; i < this->length_; ++i)
-      {
-        CORBA::release (tmp[i]);
-        tmp[i] = IR_UsesDef::_nil ();
-      }
-      if (this->maximum_ < rhs.maximum_)
-      {
-        _TAO_Unbounded_Object_Sequence_IR_UsesDefSeq::freebuf (tmp);
-        this->buffer_ = _TAO_Unbounded_Object_Sequence_IR_UsesDefSeq::allocbuf (rhs.maximum_);
-      }
-    }
-    else
-      this->buffer_ = _TAO_Unbounded_Object_Sequence_IR_UsesDefSeq::allocbuf (rhs.maximum_);
-    
-    TAO_Unbounded_Base_Sequence::operator= (rhs);
-    
-    IR_UsesDef **tmp1 = ACE_reinterpret_cast (IR_UsesDef **, this->buffer_);
-    IR_UsesDef ** const tmp2 = ACE_reinterpret_cast (IR_UsesDef ** ACE_CAST_CONST, rhs.buffer_);
-    
-    for (CORBA::ULong i = 0; i < rhs.length_; ++i)
-      tmp1[i] = IR_UsesDef::_duplicate (tmp2[i]);
-    
-    return *this;
-  }
-  
-  ACE_INLINE TAO_Object_Manager<IR_UsesDef,IR_UsesDef_var>
-  _TAO_Unbounded_Object_Sequence_IR_UsesDefSeq::operator[] (CORBA::ULong index) const
-  // read-write accessor
-  {
-    ACE_ASSERT (index < this->maximum_);
-    IR_UsesDef ** const tmp = ACE_reinterpret_cast (IR_UsesDef ** ACE_CAST_CONST, this->buffer_);
-    return TAO_Object_Manager<IR_UsesDef,IR_UsesDef_var> (tmp + index, this->release_);
-  }
-  
-  ACE_INLINE IR_UsesDef* *
-  _TAO_Unbounded_Object_Sequence_IR_UsesDefSeq::get_buffer (CORBA::Boolean orphan)
-  {
-    IR_UsesDef **result = 0;
-    if (orphan == 0)
-    {
-      // We retain ownership.
-      if (this->buffer_ == 0)
-      {
-        result = _TAO_Unbounded_Object_Sequence_IR_UsesDefSeq::allocbuf (this->maximum_);
-        this->buffer_ = result;
-        this->release_ = 1;
-      }
-      else
-      {
-        result = ACE_reinterpret_cast (IR_UsesDef**, this->buffer_);
-      }
-    }
-    else // if (orphan == 1)
-    {
-      if (this->release_ != 0)
-      {
-        // We set the state back to default and relinquish
-        // ownership.
-        result = ACE_reinterpret_cast(IR_UsesDef**,this->buffer_);
-        this->maximum_ = 0;
-        this->length_ = 0;
-        this->buffer_ = 0;
-        this->release_ = 0;
-      }
-    }
-    return result;
-  }
-  
-  ACE_INLINE const IR_UsesDef* *
-  _TAO_Unbounded_Object_Sequence_IR_UsesDefSeq::get_buffer (void) const
-  {
-    return ACE_reinterpret_cast(const IR_UsesDef ** ACE_CAST_CONST, this->buffer_);
-  }
-  
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
-
-// *************************************************************
-// Inline operations for class IR_UsesDefSeq_var
-// *************************************************************
-
-ACE_INLINE
-IR_UsesDefSeq_var::IR_UsesDefSeq_var (void) // default constructor
-  : ptr_ (0)
-{}
-
-ACE_INLINE
-IR_UsesDefSeq_var::IR_UsesDefSeq_var (IR_UsesDefSeq *p)
-  : ptr_ (p)
-{}
-
-ACE_INLINE
-IR_UsesDefSeq_var::IR_UsesDefSeq_var (const ::IR_UsesDefSeq_var &p) // copy constructor
-{
-  if (p.ptr_)
-    ACE_NEW (this->ptr_, ::IR_UsesDefSeq (*p.ptr_));
-  else
-    this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_UsesDefSeq_var::~IR_UsesDefSeq_var (void) // destructor
-{
-  delete this->ptr_;
-}
-
-ACE_INLINE IR_UsesDefSeq_var &
-IR_UsesDefSeq_var::operator= (IR_UsesDefSeq *p)
-{
-  delete this->ptr_;
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE IR_UsesDefSeq_var &
-IR_UsesDefSeq_var::operator= (const ::IR_UsesDefSeq_var &p) // deep copy
-{
-  if (this != &p)
-    {
-      if (p.ptr_ == 0)
-        {
-          delete this->ptr_;
-          this->ptr_ = 0;
-        }
-      else
-        {
-          IR_UsesDefSeq *deep_copy = 
-            new IR_UsesDefSeq (*p.ptr_);
-          
-          if (deep_copy != 0)
-            {
-              IR_UsesDefSeq *tmp = deep_copy;
-              deep_copy = this->ptr_;
-              this->ptr_ = tmp;
-              delete deep_copy;
-            }
-        }
-    }
-  
-  return *this;
-}
-
-ACE_INLINE const ::IR_UsesDefSeq *
-IR_UsesDefSeq_var::operator-> (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_UsesDefSeq *
-IR_UsesDefSeq_var::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE 
-IR_UsesDefSeq_var::operator const ::IR_UsesDefSeq &() const // cast
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE 
-IR_UsesDefSeq_var::operator ::IR_UsesDefSeq &() // cast 
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE 
-IR_UsesDefSeq_var::operator ::IR_UsesDefSeq &() const // cast 
-{
-  return *this->ptr_;
-}
-
-// variable-size types only
-ACE_INLINE
-IR_UsesDefSeq_var::operator ::IR_UsesDefSeq *&() // cast 
-{
-  return this->ptr_;
-}
-
-ACE_INLINE TAO_Object_Manager<IR_UsesDef, IR_UsesDef_var>
-IR_UsesDefSeq_var::operator[] (CORBA::ULong index)
-{
-  return this->ptr_->operator[] (index);
-}
-
-ACE_INLINE const ::IR_UsesDefSeq &
-IR_UsesDefSeq_var::in (void) const
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE ::IR_UsesDefSeq &
-IR_UsesDefSeq_var::inout (void)
-{
-  return *this->ptr_;
-}
-
-// mapping for variable size 
-ACE_INLINE ::IR_UsesDefSeq *&
-IR_UsesDefSeq_var::out (void)
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_UsesDefSeq *
-IR_UsesDefSeq_var::_retn (void)
-{
-  ::IR_UsesDefSeq *tmp = this->ptr_;
-  this->ptr_ = 0;
-  return tmp;
-}
-
-ACE_INLINE ::IR_UsesDefSeq *
-IR_UsesDefSeq_var::ptr (void) const
-{
-  return this->ptr_;
-}
-
-// *************************************************************
-// Inline operations for class IR_UsesDefSeq_out
-// *************************************************************
-
-ACE_INLINE
-IR_UsesDefSeq_out::IR_UsesDefSeq_out (IR_UsesDefSeq *&p)
-  : ptr_ (p)
-{
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_UsesDefSeq_out::IR_UsesDefSeq_out (IR_UsesDefSeq_var &p) // constructor from _var
-  : ptr_ (p.out ())
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_UsesDefSeq_out::IR_UsesDefSeq_out (const ::IR_UsesDefSeq_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (IR_UsesDefSeq_out&, p).ptr_)
-{}
-
-ACE_INLINE ::IR_UsesDefSeq_out &
-IR_UsesDefSeq_out::operator= (const ::IR_UsesDefSeq_out &p)
-{
-  this->ptr_ = ACE_const_cast (IR_UsesDefSeq_out&, p).ptr_;
-  return *this;
-}
-
-ACE_INLINE ::IR_UsesDefSeq_out &
-IR_UsesDefSeq_out::operator= (IR_UsesDefSeq *p)
-{
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE 
-IR_UsesDefSeq_out::operator ::IR_UsesDefSeq *&() // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_UsesDefSeq *&
-IR_UsesDefSeq_out::ptr (void) // ptr
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_UsesDefSeq *
-IR_UsesDefSeq_out::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE TAO_Object_Manager<IR_UsesDef, IR_UsesDef_var>
-IR_UsesDefSeq_out::operator[] (CORBA::ULong index)
-{
-  return this->ptr_->operator[] (index);
-}
-
-ACE_INLINE
-IR_HomeDef::IR_HomeDef (
-    TAO_Stub *objref,
-    CORBA::Boolean _tao_collocated,
-    TAO_Abstract_ServantBase *servant
-  )
-  : CORBA_Object (objref, _tao_collocated, servant)
-{
-  this->IR_HomeDef_setup_collocation (_tao_collocated);
-}
-
-// *************************************************************
-// Inline operations for class IR_HomeDef_var
-// *************************************************************
-
-ACE_INLINE
-IR_HomeDef_var::IR_HomeDef_var (void) // default constructor
-  : ptr_ (IR_HomeDef::_nil ())
-{}
-
-ACE_INLINE IR_HomeDef_ptr 
-IR_HomeDef_var::ptr (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE
-IR_HomeDef_var::IR_HomeDef_var (const IR_HomeDef_var &p) // copy constructor
-  : TAO_Base_var (),
-    ptr_ (IR_HomeDef::_duplicate (p.ptr ()))
-{}
-
-ACE_INLINE
-IR_HomeDef_var::~IR_HomeDef_var (void) // destructor
-{
-  CORBA::release (this->ptr_);
-}
-
-ACE_INLINE IR_HomeDef_var &
-IR_HomeDef_var::operator= (IR_HomeDef_ptr p)
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE IR_HomeDef_var &
-IR_HomeDef_var::operator= (const IR_HomeDef_var &p)
-{
-  if (this != &p)
-  {
-    CORBA::release (this->ptr_);
-    this->ptr_ = IR_HomeDef::_duplicate (p.ptr ());
-  }
-  return *this;
-}
-
-ACE_INLINE 
-IR_HomeDef_var::operator const IR_HomeDef_ptr &() const // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE 
-IR_HomeDef_var::operator IR_HomeDef_ptr &() // cast 
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_HomeDef_ptr 
-IR_HomeDef_var::operator-> (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_HomeDef_ptr
-IR_HomeDef_var::in (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_HomeDef_ptr &
-IR_HomeDef_var::inout (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_HomeDef_ptr &
-IR_HomeDef_var::out (void)
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = IR_HomeDef::_nil ();
-  return this->ptr_;
-}
-
-ACE_INLINE IR_HomeDef_ptr 
-IR_HomeDef_var::_retn (void)
-{
-  // yield ownership of managed obj reference
-  IR_HomeDef_ptr val = this->ptr_;
-  this->ptr_ = IR_HomeDef::_nil ();
-  return val;
-}
-
-// *************************************************************
-// Inline operations for class IR_HomeDef_out
-// *************************************************************
-
-ACE_INLINE
-IR_HomeDef_out::IR_HomeDef_out (IR_HomeDef_ptr &p)
-  : ptr_ (p)
-{
-  this->ptr_ = IR_HomeDef::_nil ();
-}
-
-ACE_INLINE
-IR_HomeDef_out::IR_HomeDef_out (IR_HomeDef_var &p) // constructor from _var
-  : ptr_ (p.out ())
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = IR_HomeDef::_nil ();
-}
-
-ACE_INLINE
-IR_HomeDef_out::IR_HomeDef_out (const IR_HomeDef_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (IR_HomeDef_out&,p).ptr_)
-{}
-
-ACE_INLINE IR_HomeDef_out &
-IR_HomeDef_out::operator= (const IR_HomeDef_out &p)
-{
-  this->ptr_ = ACE_const_cast (IR_HomeDef_out&,p).ptr_;
-  return *this;
-}
-
-ACE_INLINE IR_HomeDef_out &
-IR_HomeDef_out::operator= (const IR_HomeDef_var &p)
-{
-  this->ptr_ = IR_HomeDef::_duplicate (p.ptr ());
-  return *this;
-}
-
-ACE_INLINE IR_HomeDef_out &
-IR_HomeDef_out::operator= (IR_HomeDef_ptr p)
-{
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE 
-IR_HomeDef_out::operator IR_HomeDef_ptr &() // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_HomeDef_ptr &
-IR_HomeDef_out::ptr (void) // ptr
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_HomeDef_ptr 
-IR_HomeDef_out::operator-> (void)
-{
-  return this->ptr_;
-}
-
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  
-  ACE_INLINE IR_HomeDef **
-  _TAO_Unbounded_Object_Sequence_IR_HomeDefSeq::allocbuf (CORBA::ULong nelems)
-  {
-    IR_HomeDef **buf = 0;
-    
-    ACE_NEW_RETURN (buf, IR_HomeDef*[nelems], 0);
-    
-    for (CORBA::ULong i = 0; i < nelems; i++)
-      buf[i] = IR_HomeDef::_nil ();
-    
-    return buf;
-  }
-  
-  ACE_INLINE void 
-  _TAO_Unbounded_Object_Sequence_IR_HomeDefSeq::freebuf (IR_HomeDef **buffer)
-  {
-    if (buffer == 0)
-      return;
-    delete[] buffer;
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Object_Sequence_IR_HomeDefSeq::_TAO_Unbounded_Object_Sequence_IR_HomeDefSeq (void)
-  {
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Object_Sequence_IR_HomeDefSeq::_TAO_Unbounded_Object_Sequence_IR_HomeDefSeq (CORBA::ULong maximum)
-    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Object_Sequence_IR_HomeDefSeq::allocbuf (maximum))
-  {
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Object_Sequence_IR_HomeDefSeq::_TAO_Unbounded_Object_Sequence_IR_HomeDefSeq (CORBA::ULong maximum,
-    CORBA::ULong length,
-    IR_HomeDef* *value,
-    CORBA::Boolean release)
-  : TAO_Unbounded_Base_Sequence (maximum, length, value, release)
-  {
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Object_Sequence_IR_HomeDefSeq::_TAO_Unbounded_Object_Sequence_IR_HomeDefSeq(const _TAO_Unbounded_Object_Sequence_IR_HomeDefSeq &rhs)
-    : TAO_Unbounded_Base_Sequence (rhs)
-  {
-    if (rhs.buffer_ != 0)
-    {
-      IR_HomeDef **tmp1 = _TAO_Unbounded_Object_Sequence_IR_HomeDefSeq::allocbuf (this->maximum_);
-      IR_HomeDef ** const tmp2 = ACE_reinterpret_cast (IR_HomeDef ** ACE_CAST_CONST, rhs.buffer_);
-      
-      for (CORBA::ULong i = 0; i < rhs.length_; ++i)
-        tmp1[i] = IR_HomeDef::_duplicate (tmp2[i]);
-      
-      this->buffer_ = tmp1;
-    }
-    else
-    {
-      this->buffer_ = 0;
-    }
-  }
-  
-  ACE_INLINE _TAO_Unbounded_Object_Sequence_IR_HomeDefSeq &
-  _TAO_Unbounded_Object_Sequence_IR_HomeDefSeq::operator= (const _TAO_Unbounded_Object_Sequence_IR_HomeDefSeq &rhs)
-  {
-    if (this == &rhs)
-      return *this;
-    
-    if (this->release_)
-    {
-      IR_HomeDef **tmp = ACE_reinterpret_cast (IR_HomeDef **, this->buffer_);
-      
-      for (CORBA::ULong i = 0; i < this->length_; ++i)
-      {
-        CORBA::release (tmp[i]);
-        tmp[i] = IR_HomeDef::_nil ();
-      }
-      if (this->maximum_ < rhs.maximum_)
-      {
-        _TAO_Unbounded_Object_Sequence_IR_HomeDefSeq::freebuf (tmp);
-        this->buffer_ = _TAO_Unbounded_Object_Sequence_IR_HomeDefSeq::allocbuf (rhs.maximum_);
-      }
-    }
-    else
-      this->buffer_ = _TAO_Unbounded_Object_Sequence_IR_HomeDefSeq::allocbuf (rhs.maximum_);
-    
-    TAO_Unbounded_Base_Sequence::operator= (rhs);
-    
-    IR_HomeDef **tmp1 = ACE_reinterpret_cast (IR_HomeDef **, this->buffer_);
-    IR_HomeDef ** const tmp2 = ACE_reinterpret_cast (IR_HomeDef ** ACE_CAST_CONST, rhs.buffer_);
-    
-    for (CORBA::ULong i = 0; i < rhs.length_; ++i)
-      tmp1[i] = IR_HomeDef::_duplicate (tmp2[i]);
-    
-    return *this;
-  }
-  
-  ACE_INLINE TAO_Object_Manager<IR_HomeDef,IR_HomeDef_var>
-  _TAO_Unbounded_Object_Sequence_IR_HomeDefSeq::operator[] (CORBA::ULong index) const
-  // read-write accessor
-  {
-    ACE_ASSERT (index < this->maximum_);
-    IR_HomeDef ** const tmp = ACE_reinterpret_cast (IR_HomeDef ** ACE_CAST_CONST, this->buffer_);
-    return TAO_Object_Manager<IR_HomeDef,IR_HomeDef_var> (tmp + index, this->release_);
-  }
-  
-  ACE_INLINE IR_HomeDef* *
-  _TAO_Unbounded_Object_Sequence_IR_HomeDefSeq::get_buffer (CORBA::Boolean orphan)
-  {
-    IR_HomeDef **result = 0;
-    if (orphan == 0)
-    {
-      // We retain ownership.
-      if (this->buffer_ == 0)
-      {
-        result = _TAO_Unbounded_Object_Sequence_IR_HomeDefSeq::allocbuf (this->maximum_);
-        this->buffer_ = result;
-        this->release_ = 1;
-      }
-      else
-      {
-        result = ACE_reinterpret_cast (IR_HomeDef**, this->buffer_);
-      }
-    }
-    else // if (orphan == 1)
-    {
-      if (this->release_ != 0)
-      {
-        // We set the state back to default and relinquish
-        // ownership.
-        result = ACE_reinterpret_cast(IR_HomeDef**,this->buffer_);
-        this->maximum_ = 0;
-        this->length_ = 0;
-        this->buffer_ = 0;
-        this->release_ = 0;
-      }
-    }
-    return result;
-  }
-  
-  ACE_INLINE const IR_HomeDef* *
-  _TAO_Unbounded_Object_Sequence_IR_HomeDefSeq::get_buffer (void) const
-  {
-    return ACE_reinterpret_cast(const IR_HomeDef ** ACE_CAST_CONST, this->buffer_);
-  }
-  
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
-
-// *************************************************************
-// Inline operations for class IR_HomeDefSeq_var
-// *************************************************************
-
-ACE_INLINE
-IR_HomeDefSeq_var::IR_HomeDefSeq_var (void) // default constructor
-  : ptr_ (0)
-{}
-
-ACE_INLINE
-IR_HomeDefSeq_var::IR_HomeDefSeq_var (IR_HomeDefSeq *p)
-  : ptr_ (p)
-{}
-
-ACE_INLINE
-IR_HomeDefSeq_var::IR_HomeDefSeq_var (const ::IR_HomeDefSeq_var &p) // copy constructor
-{
-  if (p.ptr_)
-    ACE_NEW (this->ptr_, ::IR_HomeDefSeq (*p.ptr_));
-  else
-    this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_HomeDefSeq_var::~IR_HomeDefSeq_var (void) // destructor
-{
-  delete this->ptr_;
-}
-
-ACE_INLINE IR_HomeDefSeq_var &
-IR_HomeDefSeq_var::operator= (IR_HomeDefSeq *p)
-{
-  delete this->ptr_;
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE IR_HomeDefSeq_var &
-IR_HomeDefSeq_var::operator= (const ::IR_HomeDefSeq_var &p) // deep copy
-{
-  if (this != &p)
-    {
-      if (p.ptr_ == 0)
-        {
-          delete this->ptr_;
-          this->ptr_ = 0;
-        }
-      else
-        {
-          IR_HomeDefSeq *deep_copy = 
-            new IR_HomeDefSeq (*p.ptr_);
-          
-          if (deep_copy != 0)
-            {
-              IR_HomeDefSeq *tmp = deep_copy;
-              deep_copy = this->ptr_;
-              this->ptr_ = tmp;
-              delete deep_copy;
-            }
-        }
-    }
-  
-  return *this;
-}
-
-ACE_INLINE const ::IR_HomeDefSeq *
-IR_HomeDefSeq_var::operator-> (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_HomeDefSeq *
-IR_HomeDefSeq_var::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE 
-IR_HomeDefSeq_var::operator const ::IR_HomeDefSeq &() const // cast
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE 
-IR_HomeDefSeq_var::operator ::IR_HomeDefSeq &() // cast 
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE 
-IR_HomeDefSeq_var::operator ::IR_HomeDefSeq &() const // cast 
-{
-  return *this->ptr_;
-}
-
-// variable-size types only
-ACE_INLINE
-IR_HomeDefSeq_var::operator ::IR_HomeDefSeq *&() // cast 
-{
-  return this->ptr_;
-}
-
-ACE_INLINE TAO_Object_Manager<IR_HomeDef, IR_HomeDef_var>
-IR_HomeDefSeq_var::operator[] (CORBA::ULong index)
-{
-  return this->ptr_->operator[] (index);
-}
-
-ACE_INLINE const ::IR_HomeDefSeq &
-IR_HomeDefSeq_var::in (void) const
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE ::IR_HomeDefSeq &
-IR_HomeDefSeq_var::inout (void)
-{
-  return *this->ptr_;
-}
-
-// mapping for variable size 
-ACE_INLINE ::IR_HomeDefSeq *&
-IR_HomeDefSeq_var::out (void)
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_HomeDefSeq *
-IR_HomeDefSeq_var::_retn (void)
-{
-  ::IR_HomeDefSeq *tmp = this->ptr_;
-  this->ptr_ = 0;
-  return tmp;
-}
-
-ACE_INLINE ::IR_HomeDefSeq *
-IR_HomeDefSeq_var::ptr (void) const
-{
-  return this->ptr_;
-}
-
-// *************************************************************
-// Inline operations for class IR_HomeDefSeq_out
-// *************************************************************
-
-ACE_INLINE
-IR_HomeDefSeq_out::IR_HomeDefSeq_out (IR_HomeDefSeq *&p)
-  : ptr_ (p)
-{
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_HomeDefSeq_out::IR_HomeDefSeq_out (IR_HomeDefSeq_var &p) // constructor from _var
-  : ptr_ (p.out ())
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_HomeDefSeq_out::IR_HomeDefSeq_out (const ::IR_HomeDefSeq_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (IR_HomeDefSeq_out&, p).ptr_)
-{}
-
-ACE_INLINE ::IR_HomeDefSeq_out &
-IR_HomeDefSeq_out::operator= (const ::IR_HomeDefSeq_out &p)
-{
-  this->ptr_ = ACE_const_cast (IR_HomeDefSeq_out&, p).ptr_;
-  return *this;
-}
-
-ACE_INLINE ::IR_HomeDefSeq_out &
-IR_HomeDefSeq_out::operator= (IR_HomeDefSeq *p)
-{
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE 
-IR_HomeDefSeq_out::operator ::IR_HomeDefSeq *&() // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_HomeDefSeq *&
-IR_HomeDefSeq_out::ptr (void) // ptr
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_HomeDefSeq *
-IR_HomeDefSeq_out::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE TAO_Object_Manager<IR_HomeDef, IR_HomeDef_var>
-IR_HomeDefSeq_out::operator[] (CORBA::ULong index)
-{
-  return this->ptr_->operator[] (index);
-}
-
-ACE_INLINE
-IR_EventDef::IR_EventDef (
-    TAO_Stub *objref,
-    CORBA::Boolean _tao_collocated,
-    TAO_Abstract_ServantBase *servant
-  )
-  : CORBA_Object (objref, _tao_collocated, servant)
-{
-  this->IR_EventDef_setup_collocation (_tao_collocated);
-}
-
-// *************************************************************
-// Inline operations for class IR_EventDef_var
-// *************************************************************
-
-ACE_INLINE
-IR_EventDef_var::IR_EventDef_var (void) // default constructor
-  : ptr_ (IR_EventDef::_nil ())
-{}
-
-ACE_INLINE IR_EventDef_ptr 
-IR_EventDef_var::ptr (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE
-IR_EventDef_var::IR_EventDef_var (const IR_EventDef_var &p) // copy constructor
-  : TAO_Base_var (),
-    ptr_ (IR_EventDef::_duplicate (p.ptr ()))
-{}
-
-ACE_INLINE
-IR_EventDef_var::~IR_EventDef_var (void) // destructor
-{
-  CORBA::release (this->ptr_);
-}
-
-ACE_INLINE IR_EventDef_var &
-IR_EventDef_var::operator= (IR_EventDef_ptr p)
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE IR_EventDef_var &
-IR_EventDef_var::operator= (const IR_EventDef_var &p)
-{
-  if (this != &p)
-  {
-    CORBA::release (this->ptr_);
-    this->ptr_ = IR_EventDef::_duplicate (p.ptr ());
-  }
-  return *this;
-}
-
-ACE_INLINE 
-IR_EventDef_var::operator const IR_EventDef_ptr &() const // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE 
-IR_EventDef_var::operator IR_EventDef_ptr &() // cast 
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_EventDef_ptr 
-IR_EventDef_var::operator-> (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_EventDef_ptr
-IR_EventDef_var::in (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_EventDef_ptr &
-IR_EventDef_var::inout (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_EventDef_ptr &
-IR_EventDef_var::out (void)
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = IR_EventDef::_nil ();
-  return this->ptr_;
-}
-
-ACE_INLINE IR_EventDef_ptr 
-IR_EventDef_var::_retn (void)
-{
-  // yield ownership of managed obj reference
-  IR_EventDef_ptr val = this->ptr_;
-  this->ptr_ = IR_EventDef::_nil ();
-  return val;
-}
-
-// *************************************************************
-// Inline operations for class IR_EventDef_out
-// *************************************************************
-
-ACE_INLINE
-IR_EventDef_out::IR_EventDef_out (IR_EventDef_ptr &p)
-  : ptr_ (p)
-{
-  this->ptr_ = IR_EventDef::_nil ();
-}
-
-ACE_INLINE
-IR_EventDef_out::IR_EventDef_out (IR_EventDef_var &p) // constructor from _var
-  : ptr_ (p.out ())
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = IR_EventDef::_nil ();
-}
-
-ACE_INLINE
-IR_EventDef_out::IR_EventDef_out (const IR_EventDef_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (IR_EventDef_out&,p).ptr_)
-{}
-
-ACE_INLINE IR_EventDef_out &
-IR_EventDef_out::operator= (const IR_EventDef_out &p)
-{
-  this->ptr_ = ACE_const_cast (IR_EventDef_out&,p).ptr_;
-  return *this;
-}
-
-ACE_INLINE IR_EventDef_out &
-IR_EventDef_out::operator= (const IR_EventDef_var &p)
-{
-  this->ptr_ = IR_EventDef::_duplicate (p.ptr ());
-  return *this;
-}
-
-ACE_INLINE IR_EventDef_out &
-IR_EventDef_out::operator= (IR_EventDef_ptr p)
-{
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE 
-IR_EventDef_out::operator IR_EventDef_ptr &() // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_EventDef_ptr &
-IR_EventDef_out::ptr (void) // ptr
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_EventDef_ptr 
-IR_EventDef_out::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE
-IR_EmitsDef::IR_EmitsDef (
-    TAO_Stub *objref,
-    CORBA::Boolean _tao_collocated,
-    TAO_Abstract_ServantBase *servant
-  )
-  : CORBA_Object (objref, _tao_collocated, servant)
-{
-  this->IR_EmitsDef_setup_collocation (_tao_collocated);
-}
-
-// *************************************************************
-// Inline operations for class IR_EmitsDef_var
-// *************************************************************
-
-ACE_INLINE
-IR_EmitsDef_var::IR_EmitsDef_var (void) // default constructor
-  : ptr_ (IR_EmitsDef::_nil ())
-{}
-
-ACE_INLINE IR_EmitsDef_ptr 
-IR_EmitsDef_var::ptr (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE
-IR_EmitsDef_var::IR_EmitsDef_var (const IR_EmitsDef_var &p) // copy constructor
-  : TAO_Base_var (),
-    ptr_ (IR_EmitsDef::_duplicate (p.ptr ()))
-{}
-
-ACE_INLINE
-IR_EmitsDef_var::~IR_EmitsDef_var (void) // destructor
-{
-  CORBA::release (this->ptr_);
-}
-
-ACE_INLINE IR_EmitsDef_var &
-IR_EmitsDef_var::operator= (IR_EmitsDef_ptr p)
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE IR_EmitsDef_var &
-IR_EmitsDef_var::operator= (const IR_EmitsDef_var &p)
-{
-  if (this != &p)
-  {
-    CORBA::release (this->ptr_);
-    this->ptr_ = IR_EmitsDef::_duplicate (p.ptr ());
-  }
-  return *this;
-}
-
-ACE_INLINE 
-IR_EmitsDef_var::operator const IR_EmitsDef_ptr &() const // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE 
-IR_EmitsDef_var::operator IR_EmitsDef_ptr &() // cast 
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_EmitsDef_ptr 
-IR_EmitsDef_var::operator-> (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_EmitsDef_ptr
-IR_EmitsDef_var::in (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_EmitsDef_ptr &
-IR_EmitsDef_var::inout (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_EmitsDef_ptr &
-IR_EmitsDef_var::out (void)
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = IR_EmitsDef::_nil ();
-  return this->ptr_;
-}
-
-ACE_INLINE IR_EmitsDef_ptr 
-IR_EmitsDef_var::_retn (void)
-{
-  // yield ownership of managed obj reference
-  IR_EmitsDef_ptr val = this->ptr_;
-  this->ptr_ = IR_EmitsDef::_nil ();
-  return val;
-}
-
-// *************************************************************
-// Inline operations for class IR_EmitsDef_out
-// *************************************************************
-
-ACE_INLINE
-IR_EmitsDef_out::IR_EmitsDef_out (IR_EmitsDef_ptr &p)
-  : ptr_ (p)
-{
-  this->ptr_ = IR_EmitsDef::_nil ();
-}
-
-ACE_INLINE
-IR_EmitsDef_out::IR_EmitsDef_out (IR_EmitsDef_var &p) // constructor from _var
-  : ptr_ (p.out ())
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = IR_EmitsDef::_nil ();
-}
-
-ACE_INLINE
-IR_EmitsDef_out::IR_EmitsDef_out (const IR_EmitsDef_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (IR_EmitsDef_out&,p).ptr_)
-{}
-
-ACE_INLINE IR_EmitsDef_out &
-IR_EmitsDef_out::operator= (const IR_EmitsDef_out &p)
-{
-  this->ptr_ = ACE_const_cast (IR_EmitsDef_out&,p).ptr_;
-  return *this;
-}
-
-ACE_INLINE IR_EmitsDef_out &
-IR_EmitsDef_out::operator= (const IR_EmitsDef_var &p)
-{
-  this->ptr_ = IR_EmitsDef::_duplicate (p.ptr ());
-  return *this;
-}
-
-ACE_INLINE IR_EmitsDef_out &
-IR_EmitsDef_out::operator= (IR_EmitsDef_ptr p)
-{
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE 
-IR_EmitsDef_out::operator IR_EmitsDef_ptr &() // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_EmitsDef_ptr &
-IR_EmitsDef_out::ptr (void) // ptr
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_EmitsDef_ptr 
-IR_EmitsDef_out::operator-> (void)
-{
-  return this->ptr_;
-}
-
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  
-  ACE_INLINE IR_EmitsDef **
-  _TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq::allocbuf (CORBA::ULong nelems)
-  {
-    IR_EmitsDef **buf = 0;
-    
-    ACE_NEW_RETURN (buf, IR_EmitsDef*[nelems], 0);
-    
-    for (CORBA::ULong i = 0; i < nelems; i++)
-      buf[i] = IR_EmitsDef::_nil ();
-    
-    return buf;
-  }
-  
-  ACE_INLINE void 
-  _TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq::freebuf (IR_EmitsDef **buffer)
-  {
-    if (buffer == 0)
-      return;
-    delete[] buffer;
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq::_TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq (void)
-  {
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq::_TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq (CORBA::ULong maximum)
-    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq::allocbuf (maximum))
-  {
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq::_TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq (CORBA::ULong maximum,
-    CORBA::ULong length,
-    IR_EmitsDef* *value,
-    CORBA::Boolean release)
-  : TAO_Unbounded_Base_Sequence (maximum, length, value, release)
-  {
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq::_TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq(const _TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq &rhs)
-    : TAO_Unbounded_Base_Sequence (rhs)
-  {
-    if (rhs.buffer_ != 0)
-    {
-      IR_EmitsDef **tmp1 = _TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq::allocbuf (this->maximum_);
-      IR_EmitsDef ** const tmp2 = ACE_reinterpret_cast (IR_EmitsDef ** ACE_CAST_CONST, rhs.buffer_);
-      
-      for (CORBA::ULong i = 0; i < rhs.length_; ++i)
-        tmp1[i] = IR_EmitsDef::_duplicate (tmp2[i]);
-      
-      this->buffer_ = tmp1;
-    }
-    else
-    {
-      this->buffer_ = 0;
-    }
-  }
-  
-  ACE_INLINE _TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq &
-  _TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq::operator= (const _TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq &rhs)
-  {
-    if (this == &rhs)
-      return *this;
-    
-    if (this->release_)
-    {
-      IR_EmitsDef **tmp = ACE_reinterpret_cast (IR_EmitsDef **, this->buffer_);
-      
-      for (CORBA::ULong i = 0; i < this->length_; ++i)
-      {
-        CORBA::release (tmp[i]);
-        tmp[i] = IR_EmitsDef::_nil ();
-      }
-      if (this->maximum_ < rhs.maximum_)
-      {
-        _TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq::freebuf (tmp);
-        this->buffer_ = _TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq::allocbuf (rhs.maximum_);
-      }
-    }
-    else
-      this->buffer_ = _TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq::allocbuf (rhs.maximum_);
-    
-    TAO_Unbounded_Base_Sequence::operator= (rhs);
-    
-    IR_EmitsDef **tmp1 = ACE_reinterpret_cast (IR_EmitsDef **, this->buffer_);
-    IR_EmitsDef ** const tmp2 = ACE_reinterpret_cast (IR_EmitsDef ** ACE_CAST_CONST, rhs.buffer_);
-    
-    for (CORBA::ULong i = 0; i < rhs.length_; ++i)
-      tmp1[i] = IR_EmitsDef::_duplicate (tmp2[i]);
-    
-    return *this;
-  }
-  
-  ACE_INLINE TAO_Object_Manager<IR_EmitsDef,IR_EmitsDef_var>
-  _TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq::operator[] (CORBA::ULong index) const
-  // read-write accessor
-  {
-    ACE_ASSERT (index < this->maximum_);
-    IR_EmitsDef ** const tmp = ACE_reinterpret_cast (IR_EmitsDef ** ACE_CAST_CONST, this->buffer_);
-    return TAO_Object_Manager<IR_EmitsDef,IR_EmitsDef_var> (tmp + index, this->release_);
-  }
-  
-  ACE_INLINE IR_EmitsDef* *
-  _TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq::get_buffer (CORBA::Boolean orphan)
-  {
-    IR_EmitsDef **result = 0;
-    if (orphan == 0)
-    {
-      // We retain ownership.
-      if (this->buffer_ == 0)
-      {
-        result = _TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq::allocbuf (this->maximum_);
-        this->buffer_ = result;
-        this->release_ = 1;
-      }
-      else
-      {
-        result = ACE_reinterpret_cast (IR_EmitsDef**, this->buffer_);
-      }
-    }
-    else // if (orphan == 1)
-    {
-      if (this->release_ != 0)
-      {
-        // We set the state back to default and relinquish
-        // ownership.
-        result = ACE_reinterpret_cast(IR_EmitsDef**,this->buffer_);
-        this->maximum_ = 0;
-        this->length_ = 0;
-        this->buffer_ = 0;
-        this->release_ = 0;
-      }
-    }
-    return result;
-  }
-  
-  ACE_INLINE const IR_EmitsDef* *
-  _TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq::get_buffer (void) const
-  {
-    return ACE_reinterpret_cast(const IR_EmitsDef ** ACE_CAST_CONST, this->buffer_);
-  }
-  
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
-
-// *************************************************************
-// Inline operations for class IR_EmitsDefSeq_var
-// *************************************************************
-
-ACE_INLINE
-IR_EmitsDefSeq_var::IR_EmitsDefSeq_var (void) // default constructor
-  : ptr_ (0)
-{}
-
-ACE_INLINE
-IR_EmitsDefSeq_var::IR_EmitsDefSeq_var (IR_EmitsDefSeq *p)
-  : ptr_ (p)
-{}
-
-ACE_INLINE
-IR_EmitsDefSeq_var::IR_EmitsDefSeq_var (const ::IR_EmitsDefSeq_var &p) // copy constructor
-{
-  if (p.ptr_)
-    ACE_NEW (this->ptr_, ::IR_EmitsDefSeq (*p.ptr_));
-  else
-    this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_EmitsDefSeq_var::~IR_EmitsDefSeq_var (void) // destructor
-{
-  delete this->ptr_;
-}
-
-ACE_INLINE IR_EmitsDefSeq_var &
-IR_EmitsDefSeq_var::operator= (IR_EmitsDefSeq *p)
-{
-  delete this->ptr_;
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE IR_EmitsDefSeq_var &
-IR_EmitsDefSeq_var::operator= (const ::IR_EmitsDefSeq_var &p) // deep copy
-{
-  if (this != &p)
-    {
-      if (p.ptr_ == 0)
-        {
-          delete this->ptr_;
-          this->ptr_ = 0;
-        }
-      else
-        {
-          IR_EmitsDefSeq *deep_copy = 
-            new IR_EmitsDefSeq (*p.ptr_);
-          
-          if (deep_copy != 0)
-            {
-              IR_EmitsDefSeq *tmp = deep_copy;
-              deep_copy = this->ptr_;
-              this->ptr_ = tmp;
-              delete deep_copy;
-            }
-        }
-    }
-  
-  return *this;
-}
-
-ACE_INLINE const ::IR_EmitsDefSeq *
-IR_EmitsDefSeq_var::operator-> (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_EmitsDefSeq *
-IR_EmitsDefSeq_var::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE 
-IR_EmitsDefSeq_var::operator const ::IR_EmitsDefSeq &() const // cast
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE 
-IR_EmitsDefSeq_var::operator ::IR_EmitsDefSeq &() // cast 
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE 
-IR_EmitsDefSeq_var::operator ::IR_EmitsDefSeq &() const // cast 
-{
-  return *this->ptr_;
-}
-
-// variable-size types only
-ACE_INLINE
-IR_EmitsDefSeq_var::operator ::IR_EmitsDefSeq *&() // cast 
-{
-  return this->ptr_;
-}
-
-ACE_INLINE TAO_Object_Manager<IR_EmitsDef, IR_EmitsDef_var>
-IR_EmitsDefSeq_var::operator[] (CORBA::ULong index)
-{
-  return this->ptr_->operator[] (index);
-}
-
-ACE_INLINE const ::IR_EmitsDefSeq &
-IR_EmitsDefSeq_var::in (void) const
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE ::IR_EmitsDefSeq &
-IR_EmitsDefSeq_var::inout (void)
-{
-  return *this->ptr_;
-}
-
-// mapping for variable size 
-ACE_INLINE ::IR_EmitsDefSeq *&
-IR_EmitsDefSeq_var::out (void)
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_EmitsDefSeq *
-IR_EmitsDefSeq_var::_retn (void)
-{
-  ::IR_EmitsDefSeq *tmp = this->ptr_;
-  this->ptr_ = 0;
-  return tmp;
-}
-
-ACE_INLINE ::IR_EmitsDefSeq *
-IR_EmitsDefSeq_var::ptr (void) const
-{
-  return this->ptr_;
-}
-
-// *************************************************************
-// Inline operations for class IR_EmitsDefSeq_out
-// *************************************************************
-
-ACE_INLINE
-IR_EmitsDefSeq_out::IR_EmitsDefSeq_out (IR_EmitsDefSeq *&p)
-  : ptr_ (p)
-{
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_EmitsDefSeq_out::IR_EmitsDefSeq_out (IR_EmitsDefSeq_var &p) // constructor from _var
-  : ptr_ (p.out ())
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_EmitsDefSeq_out::IR_EmitsDefSeq_out (const ::IR_EmitsDefSeq_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (IR_EmitsDefSeq_out&, p).ptr_)
-{}
-
-ACE_INLINE ::IR_EmitsDefSeq_out &
-IR_EmitsDefSeq_out::operator= (const ::IR_EmitsDefSeq_out &p)
-{
-  this->ptr_ = ACE_const_cast (IR_EmitsDefSeq_out&, p).ptr_;
-  return *this;
-}
-
-ACE_INLINE ::IR_EmitsDefSeq_out &
-IR_EmitsDefSeq_out::operator= (IR_EmitsDefSeq *p)
-{
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE 
-IR_EmitsDefSeq_out::operator ::IR_EmitsDefSeq *&() // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_EmitsDefSeq *&
-IR_EmitsDefSeq_out::ptr (void) // ptr
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_EmitsDefSeq *
-IR_EmitsDefSeq_out::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE TAO_Object_Manager<IR_EmitsDef, IR_EmitsDef_var>
-IR_EmitsDefSeq_out::operator[] (CORBA::ULong index)
-{
-  return this->ptr_->operator[] (index);
-}
-
-ACE_INLINE
-IR_PublishesDef::IR_PublishesDef (
-    TAO_Stub *objref,
-    CORBA::Boolean _tao_collocated,
-    TAO_Abstract_ServantBase *servant
-  )
-  : CORBA_Object (objref, _tao_collocated, servant)
-{
-  this->IR_PublishesDef_setup_collocation (_tao_collocated);
-}
-
-// *************************************************************
-// Inline operations for class IR_PublishesDef_var
-// *************************************************************
-
-ACE_INLINE
-IR_PublishesDef_var::IR_PublishesDef_var (void) // default constructor
-  : ptr_ (IR_PublishesDef::_nil ())
-{}
-
-ACE_INLINE IR_PublishesDef_ptr 
-IR_PublishesDef_var::ptr (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE
-IR_PublishesDef_var::IR_PublishesDef_var (const IR_PublishesDef_var &p) // copy constructor
-  : TAO_Base_var (),
-    ptr_ (IR_PublishesDef::_duplicate (p.ptr ()))
-{}
-
-ACE_INLINE
-IR_PublishesDef_var::~IR_PublishesDef_var (void) // destructor
-{
-  CORBA::release (this->ptr_);
-}
-
-ACE_INLINE IR_PublishesDef_var &
-IR_PublishesDef_var::operator= (IR_PublishesDef_ptr p)
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE IR_PublishesDef_var &
-IR_PublishesDef_var::operator= (const IR_PublishesDef_var &p)
-{
-  if (this != &p)
-  {
-    CORBA::release (this->ptr_);
-    this->ptr_ = IR_PublishesDef::_duplicate (p.ptr ());
-  }
-  return *this;
-}
-
-ACE_INLINE 
-IR_PublishesDef_var::operator const IR_PublishesDef_ptr &() const // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE 
-IR_PublishesDef_var::operator IR_PublishesDef_ptr &() // cast 
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_PublishesDef_ptr 
-IR_PublishesDef_var::operator-> (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_PublishesDef_ptr
-IR_PublishesDef_var::in (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_PublishesDef_ptr &
-IR_PublishesDef_var::inout (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_PublishesDef_ptr &
-IR_PublishesDef_var::out (void)
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = IR_PublishesDef::_nil ();
-  return this->ptr_;
-}
-
-ACE_INLINE IR_PublishesDef_ptr 
-IR_PublishesDef_var::_retn (void)
-{
-  // yield ownership of managed obj reference
-  IR_PublishesDef_ptr val = this->ptr_;
-  this->ptr_ = IR_PublishesDef::_nil ();
-  return val;
-}
-
-// *************************************************************
-// Inline operations for class IR_PublishesDef_out
-// *************************************************************
-
-ACE_INLINE
-IR_PublishesDef_out::IR_PublishesDef_out (IR_PublishesDef_ptr &p)
-  : ptr_ (p)
-{
-  this->ptr_ = IR_PublishesDef::_nil ();
-}
-
-ACE_INLINE
-IR_PublishesDef_out::IR_PublishesDef_out (IR_PublishesDef_var &p) // constructor from _var
-  : ptr_ (p.out ())
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = IR_PublishesDef::_nil ();
-}
-
-ACE_INLINE
-IR_PublishesDef_out::IR_PublishesDef_out (const IR_PublishesDef_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (IR_PublishesDef_out&,p).ptr_)
-{}
-
-ACE_INLINE IR_PublishesDef_out &
-IR_PublishesDef_out::operator= (const IR_PublishesDef_out &p)
-{
-  this->ptr_ = ACE_const_cast (IR_PublishesDef_out&,p).ptr_;
-  return *this;
-}
-
-ACE_INLINE IR_PublishesDef_out &
-IR_PublishesDef_out::operator= (const IR_PublishesDef_var &p)
-{
-  this->ptr_ = IR_PublishesDef::_duplicate (p.ptr ());
-  return *this;
-}
-
-ACE_INLINE IR_PublishesDef_out &
-IR_PublishesDef_out::operator= (IR_PublishesDef_ptr p)
-{
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE 
-IR_PublishesDef_out::operator IR_PublishesDef_ptr &() // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_PublishesDef_ptr &
-IR_PublishesDef_out::ptr (void) // ptr
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_PublishesDef_ptr 
-IR_PublishesDef_out::operator-> (void)
-{
-  return this->ptr_;
-}
-
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  
-  ACE_INLINE IR_PublishesDef **
-  _TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq::allocbuf (CORBA::ULong nelems)
-  {
-    IR_PublishesDef **buf = 0;
-    
-    ACE_NEW_RETURN (buf, IR_PublishesDef*[nelems], 0);
-    
-    for (CORBA::ULong i = 0; i < nelems; i++)
-      buf[i] = IR_PublishesDef::_nil ();
-    
-    return buf;
-  }
-  
-  ACE_INLINE void 
-  _TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq::freebuf (IR_PublishesDef **buffer)
-  {
-    if (buffer == 0)
-      return;
-    delete[] buffer;
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq::_TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq (void)
-  {
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq::_TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq (CORBA::ULong maximum)
-    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq::allocbuf (maximum))
-  {
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq::_TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq (CORBA::ULong maximum,
-    CORBA::ULong length,
-    IR_PublishesDef* *value,
-    CORBA::Boolean release)
-  : TAO_Unbounded_Base_Sequence (maximum, length, value, release)
-  {
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq::_TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq(const _TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq &rhs)
-    : TAO_Unbounded_Base_Sequence (rhs)
-  {
-    if (rhs.buffer_ != 0)
-    {
-      IR_PublishesDef **tmp1 = _TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq::allocbuf (this->maximum_);
-      IR_PublishesDef ** const tmp2 = ACE_reinterpret_cast (IR_PublishesDef ** ACE_CAST_CONST, rhs.buffer_);
-      
-      for (CORBA::ULong i = 0; i < rhs.length_; ++i)
-        tmp1[i] = IR_PublishesDef::_duplicate (tmp2[i]);
-      
-      this->buffer_ = tmp1;
-    }
-    else
-    {
-      this->buffer_ = 0;
-    }
-  }
-  
-  ACE_INLINE _TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq &
-  _TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq::operator= (const _TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq &rhs)
-  {
-    if (this == &rhs)
-      return *this;
-    
-    if (this->release_)
-    {
-      IR_PublishesDef **tmp = ACE_reinterpret_cast (IR_PublishesDef **, this->buffer_);
-      
-      for (CORBA::ULong i = 0; i < this->length_; ++i)
-      {
-        CORBA::release (tmp[i]);
-        tmp[i] = IR_PublishesDef::_nil ();
-      }
-      if (this->maximum_ < rhs.maximum_)
-      {
-        _TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq::freebuf (tmp);
-        this->buffer_ = _TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq::allocbuf (rhs.maximum_);
-      }
-    }
-    else
-      this->buffer_ = _TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq::allocbuf (rhs.maximum_);
-    
-    TAO_Unbounded_Base_Sequence::operator= (rhs);
-    
-    IR_PublishesDef **tmp1 = ACE_reinterpret_cast (IR_PublishesDef **, this->buffer_);
-    IR_PublishesDef ** const tmp2 = ACE_reinterpret_cast (IR_PublishesDef ** ACE_CAST_CONST, rhs.buffer_);
-    
-    for (CORBA::ULong i = 0; i < rhs.length_; ++i)
-      tmp1[i] = IR_PublishesDef::_duplicate (tmp2[i]);
-    
-    return *this;
-  }
-  
-  ACE_INLINE TAO_Object_Manager<IR_PublishesDef,IR_PublishesDef_var>
-  _TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq::operator[] (CORBA::ULong index) const
-  // read-write accessor
-  {
-    ACE_ASSERT (index < this->maximum_);
-    IR_PublishesDef ** const tmp = ACE_reinterpret_cast (IR_PublishesDef ** ACE_CAST_CONST, this->buffer_);
-    return TAO_Object_Manager<IR_PublishesDef,IR_PublishesDef_var> (tmp + index, this->release_);
-  }
-  
-  ACE_INLINE IR_PublishesDef* *
-  _TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq::get_buffer (CORBA::Boolean orphan)
-  {
-    IR_PublishesDef **result = 0;
-    if (orphan == 0)
-    {
-      // We retain ownership.
-      if (this->buffer_ == 0)
-      {
-        result = _TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq::allocbuf (this->maximum_);
-        this->buffer_ = result;
-        this->release_ = 1;
-      }
-      else
-      {
-        result = ACE_reinterpret_cast (IR_PublishesDef**, this->buffer_);
-      }
-    }
-    else // if (orphan == 1)
-    {
-      if (this->release_ != 0)
-      {
-        // We set the state back to default and relinquish
-        // ownership.
-        result = ACE_reinterpret_cast(IR_PublishesDef**,this->buffer_);
-        this->maximum_ = 0;
-        this->length_ = 0;
-        this->buffer_ = 0;
-        this->release_ = 0;
-      }
-    }
-    return result;
-  }
-  
-  ACE_INLINE const IR_PublishesDef* *
-  _TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq::get_buffer (void) const
-  {
-    return ACE_reinterpret_cast(const IR_PublishesDef ** ACE_CAST_CONST, this->buffer_);
-  }
-  
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
-
-// *************************************************************
-// Inline operations for class IR_PublishesDefSeq_var
-// *************************************************************
-
-ACE_INLINE
-IR_PublishesDefSeq_var::IR_PublishesDefSeq_var (void) // default constructor
-  : ptr_ (0)
-{}
-
-ACE_INLINE
-IR_PublishesDefSeq_var::IR_PublishesDefSeq_var (IR_PublishesDefSeq *p)
-  : ptr_ (p)
-{}
-
-ACE_INLINE
-IR_PublishesDefSeq_var::IR_PublishesDefSeq_var (const ::IR_PublishesDefSeq_var &p) // copy constructor
-{
-  if (p.ptr_)
-    ACE_NEW (this->ptr_, ::IR_PublishesDefSeq (*p.ptr_));
-  else
-    this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_PublishesDefSeq_var::~IR_PublishesDefSeq_var (void) // destructor
-{
-  delete this->ptr_;
-}
-
-ACE_INLINE IR_PublishesDefSeq_var &
-IR_PublishesDefSeq_var::operator= (IR_PublishesDefSeq *p)
-{
-  delete this->ptr_;
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE IR_PublishesDefSeq_var &
-IR_PublishesDefSeq_var::operator= (const ::IR_PublishesDefSeq_var &p) // deep copy
-{
-  if (this != &p)
-    {
-      if (p.ptr_ == 0)
-        {
-          delete this->ptr_;
-          this->ptr_ = 0;
-        }
-      else
-        {
-          IR_PublishesDefSeq *deep_copy = 
-            new IR_PublishesDefSeq (*p.ptr_);
-          
-          if (deep_copy != 0)
-            {
-              IR_PublishesDefSeq *tmp = deep_copy;
-              deep_copy = this->ptr_;
-              this->ptr_ = tmp;
-              delete deep_copy;
-            }
-        }
-    }
-  
-  return *this;
-}
-
-ACE_INLINE const ::IR_PublishesDefSeq *
-IR_PublishesDefSeq_var::operator-> (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_PublishesDefSeq *
-IR_PublishesDefSeq_var::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE 
-IR_PublishesDefSeq_var::operator const ::IR_PublishesDefSeq &() const // cast
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE 
-IR_PublishesDefSeq_var::operator ::IR_PublishesDefSeq &() // cast 
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE 
-IR_PublishesDefSeq_var::operator ::IR_PublishesDefSeq &() const // cast 
-{
-  return *this->ptr_;
-}
-
-// variable-size types only
-ACE_INLINE
-IR_PublishesDefSeq_var::operator ::IR_PublishesDefSeq *&() // cast 
-{
-  return this->ptr_;
-}
-
-ACE_INLINE TAO_Object_Manager<IR_PublishesDef, IR_PublishesDef_var>
-IR_PublishesDefSeq_var::operator[] (CORBA::ULong index)
-{
-  return this->ptr_->operator[] (index);
-}
-
-ACE_INLINE const ::IR_PublishesDefSeq &
-IR_PublishesDefSeq_var::in (void) const
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE ::IR_PublishesDefSeq &
-IR_PublishesDefSeq_var::inout (void)
-{
-  return *this->ptr_;
-}
-
-// mapping for variable size 
-ACE_INLINE ::IR_PublishesDefSeq *&
-IR_PublishesDefSeq_var::out (void)
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_PublishesDefSeq *
-IR_PublishesDefSeq_var::_retn (void)
-{
-  ::IR_PublishesDefSeq *tmp = this->ptr_;
-  this->ptr_ = 0;
-  return tmp;
-}
-
-ACE_INLINE ::IR_PublishesDefSeq *
-IR_PublishesDefSeq_var::ptr (void) const
-{
-  return this->ptr_;
-}
-
-// *************************************************************
-// Inline operations for class IR_PublishesDefSeq_out
-// *************************************************************
-
-ACE_INLINE
-IR_PublishesDefSeq_out::IR_PublishesDefSeq_out (IR_PublishesDefSeq *&p)
-  : ptr_ (p)
-{
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_PublishesDefSeq_out::IR_PublishesDefSeq_out (IR_PublishesDefSeq_var &p) // constructor from _var
-  : ptr_ (p.out ())
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_PublishesDefSeq_out::IR_PublishesDefSeq_out (const ::IR_PublishesDefSeq_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (IR_PublishesDefSeq_out&, p).ptr_)
-{}
-
-ACE_INLINE ::IR_PublishesDefSeq_out &
-IR_PublishesDefSeq_out::operator= (const ::IR_PublishesDefSeq_out &p)
-{
-  this->ptr_ = ACE_const_cast (IR_PublishesDefSeq_out&, p).ptr_;
-  return *this;
-}
-
-ACE_INLINE ::IR_PublishesDefSeq_out &
-IR_PublishesDefSeq_out::operator= (IR_PublishesDefSeq *p)
-{
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE 
-IR_PublishesDefSeq_out::operator ::IR_PublishesDefSeq *&() // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_PublishesDefSeq *&
-IR_PublishesDefSeq_out::ptr (void) // ptr
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_PublishesDefSeq *
-IR_PublishesDefSeq_out::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE TAO_Object_Manager<IR_PublishesDef, IR_PublishesDef_var>
-IR_PublishesDefSeq_out::operator[] (CORBA::ULong index)
-{
-  return this->ptr_->operator[] (index);
-}
-
-ACE_INLINE
-IR_ConsumesDef::IR_ConsumesDef (
-    TAO_Stub *objref,
-    CORBA::Boolean _tao_collocated,
-    TAO_Abstract_ServantBase *servant
-  )
-  : CORBA_Object (objref, _tao_collocated, servant)
-{
-  this->IR_ConsumesDef_setup_collocation (_tao_collocated);
-}
-
-// *************************************************************
-// Inline operations for class IR_ConsumesDef_var
-// *************************************************************
-
-ACE_INLINE
-IR_ConsumesDef_var::IR_ConsumesDef_var (void) // default constructor
-  : ptr_ (IR_ConsumesDef::_nil ())
-{}
-
-ACE_INLINE IR_ConsumesDef_ptr 
-IR_ConsumesDef_var::ptr (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE
-IR_ConsumesDef_var::IR_ConsumesDef_var (const IR_ConsumesDef_var &p) // copy constructor
-  : TAO_Base_var (),
-    ptr_ (IR_ConsumesDef::_duplicate (p.ptr ()))
-{}
-
-ACE_INLINE
-IR_ConsumesDef_var::~IR_ConsumesDef_var (void) // destructor
-{
-  CORBA::release (this->ptr_);
-}
-
-ACE_INLINE IR_ConsumesDef_var &
-IR_ConsumesDef_var::operator= (IR_ConsumesDef_ptr p)
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE IR_ConsumesDef_var &
-IR_ConsumesDef_var::operator= (const IR_ConsumesDef_var &p)
-{
-  if (this != &p)
-  {
-    CORBA::release (this->ptr_);
-    this->ptr_ = IR_ConsumesDef::_duplicate (p.ptr ());
-  }
-  return *this;
-}
-
-ACE_INLINE 
-IR_ConsumesDef_var::operator const IR_ConsumesDef_ptr &() const // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE 
-IR_ConsumesDef_var::operator IR_ConsumesDef_ptr &() // cast 
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_ConsumesDef_ptr 
-IR_ConsumesDef_var::operator-> (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_ConsumesDef_ptr
-IR_ConsumesDef_var::in (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_ConsumesDef_ptr &
-IR_ConsumesDef_var::inout (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_ConsumesDef_ptr &
-IR_ConsumesDef_var::out (void)
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = IR_ConsumesDef::_nil ();
-  return this->ptr_;
-}
-
-ACE_INLINE IR_ConsumesDef_ptr 
-IR_ConsumesDef_var::_retn (void)
-{
-  // yield ownership of managed obj reference
-  IR_ConsumesDef_ptr val = this->ptr_;
-  this->ptr_ = IR_ConsumesDef::_nil ();
-  return val;
-}
-
-// *************************************************************
-// Inline operations for class IR_ConsumesDef_out
-// *************************************************************
-
-ACE_INLINE
-IR_ConsumesDef_out::IR_ConsumesDef_out (IR_ConsumesDef_ptr &p)
-  : ptr_ (p)
-{
-  this->ptr_ = IR_ConsumesDef::_nil ();
-}
-
-ACE_INLINE
-IR_ConsumesDef_out::IR_ConsumesDef_out (IR_ConsumesDef_var &p) // constructor from _var
-  : ptr_ (p.out ())
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = IR_ConsumesDef::_nil ();
-}
-
-ACE_INLINE
-IR_ConsumesDef_out::IR_ConsumesDef_out (const IR_ConsumesDef_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (IR_ConsumesDef_out&,p).ptr_)
-{}
-
-ACE_INLINE IR_ConsumesDef_out &
-IR_ConsumesDef_out::operator= (const IR_ConsumesDef_out &p)
-{
-  this->ptr_ = ACE_const_cast (IR_ConsumesDef_out&,p).ptr_;
-  return *this;
-}
-
-ACE_INLINE IR_ConsumesDef_out &
-IR_ConsumesDef_out::operator= (const IR_ConsumesDef_var &p)
-{
-  this->ptr_ = IR_ConsumesDef::_duplicate (p.ptr ());
-  return *this;
-}
-
-ACE_INLINE IR_ConsumesDef_out &
-IR_ConsumesDef_out::operator= (IR_ConsumesDef_ptr p)
-{
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE 
-IR_ConsumesDef_out::operator IR_ConsumesDef_ptr &() // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_ConsumesDef_ptr &
-IR_ConsumesDef_out::ptr (void) // ptr
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_ConsumesDef_ptr 
-IR_ConsumesDef_out::operator-> (void)
-{
-  return this->ptr_;
-}
-
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  
-  ACE_INLINE IR_ConsumesDef **
-  _TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq::allocbuf (CORBA::ULong nelems)
-  {
-    IR_ConsumesDef **buf = 0;
-    
-    ACE_NEW_RETURN (buf, IR_ConsumesDef*[nelems], 0);
-    
-    for (CORBA::ULong i = 0; i < nelems; i++)
-      buf[i] = IR_ConsumesDef::_nil ();
-    
-    return buf;
-  }
-  
-  ACE_INLINE void 
-  _TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq::freebuf (IR_ConsumesDef **buffer)
-  {
-    if (buffer == 0)
-      return;
-    delete[] buffer;
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq::_TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq (void)
-  {
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq::_TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq (CORBA::ULong maximum)
-    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq::allocbuf (maximum))
-  {
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq::_TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq (CORBA::ULong maximum,
-    CORBA::ULong length,
-    IR_ConsumesDef* *value,
-    CORBA::Boolean release)
-  : TAO_Unbounded_Base_Sequence (maximum, length, value, release)
-  {
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq::_TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq(const _TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq &rhs)
-    : TAO_Unbounded_Base_Sequence (rhs)
-  {
-    if (rhs.buffer_ != 0)
-    {
-      IR_ConsumesDef **tmp1 = _TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq::allocbuf (this->maximum_);
-      IR_ConsumesDef ** const tmp2 = ACE_reinterpret_cast (IR_ConsumesDef ** ACE_CAST_CONST, rhs.buffer_);
-      
-      for (CORBA::ULong i = 0; i < rhs.length_; ++i)
-        tmp1[i] = IR_ConsumesDef::_duplicate (tmp2[i]);
-      
-      this->buffer_ = tmp1;
-    }
-    else
-    {
-      this->buffer_ = 0;
-    }
-  }
-  
-  ACE_INLINE _TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq &
-  _TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq::operator= (const _TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq &rhs)
-  {
-    if (this == &rhs)
-      return *this;
-    
-    if (this->release_)
-    {
-      IR_ConsumesDef **tmp = ACE_reinterpret_cast (IR_ConsumesDef **, this->buffer_);
-      
-      for (CORBA::ULong i = 0; i < this->length_; ++i)
-      {
-        CORBA::release (tmp[i]);
-        tmp[i] = IR_ConsumesDef::_nil ();
-      }
-      if (this->maximum_ < rhs.maximum_)
-      {
-        _TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq::freebuf (tmp);
-        this->buffer_ = _TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq::allocbuf (rhs.maximum_);
-      }
-    }
-    else
-      this->buffer_ = _TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq::allocbuf (rhs.maximum_);
-    
-    TAO_Unbounded_Base_Sequence::operator= (rhs);
-    
-    IR_ConsumesDef **tmp1 = ACE_reinterpret_cast (IR_ConsumesDef **, this->buffer_);
-    IR_ConsumesDef ** const tmp2 = ACE_reinterpret_cast (IR_ConsumesDef ** ACE_CAST_CONST, rhs.buffer_);
-    
-    for (CORBA::ULong i = 0; i < rhs.length_; ++i)
-      tmp1[i] = IR_ConsumesDef::_duplicate (tmp2[i]);
-    
-    return *this;
-  }
-  
-  ACE_INLINE TAO_Object_Manager<IR_ConsumesDef,IR_ConsumesDef_var>
-  _TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq::operator[] (CORBA::ULong index) const
-  // read-write accessor
-  {
-    ACE_ASSERT (index < this->maximum_);
-    IR_ConsumesDef ** const tmp = ACE_reinterpret_cast (IR_ConsumesDef ** ACE_CAST_CONST, this->buffer_);
-    return TAO_Object_Manager<IR_ConsumesDef,IR_ConsumesDef_var> (tmp + index, this->release_);
-  }
-  
-  ACE_INLINE IR_ConsumesDef* *
-  _TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq::get_buffer (CORBA::Boolean orphan)
-  {
-    IR_ConsumesDef **result = 0;
-    if (orphan == 0)
-    {
-      // We retain ownership.
-      if (this->buffer_ == 0)
-      {
-        result = _TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq::allocbuf (this->maximum_);
-        this->buffer_ = result;
-        this->release_ = 1;
-      }
-      else
-      {
-        result = ACE_reinterpret_cast (IR_ConsumesDef**, this->buffer_);
-      }
-    }
-    else // if (orphan == 1)
-    {
-      if (this->release_ != 0)
-      {
-        // We set the state back to default and relinquish
-        // ownership.
-        result = ACE_reinterpret_cast(IR_ConsumesDef**,this->buffer_);
-        this->maximum_ = 0;
-        this->length_ = 0;
-        this->buffer_ = 0;
-        this->release_ = 0;
-      }
-    }
-    return result;
-  }
-  
-  ACE_INLINE const IR_ConsumesDef* *
-  _TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq::get_buffer (void) const
-  {
-    return ACE_reinterpret_cast(const IR_ConsumesDef ** ACE_CAST_CONST, this->buffer_);
-  }
-  
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
-
-// *************************************************************
-// Inline operations for class IR_ConsumesDefSeq_var
-// *************************************************************
-
-ACE_INLINE
-IR_ConsumesDefSeq_var::IR_ConsumesDefSeq_var (void) // default constructor
-  : ptr_ (0)
-{}
-
-ACE_INLINE
-IR_ConsumesDefSeq_var::IR_ConsumesDefSeq_var (IR_ConsumesDefSeq *p)
-  : ptr_ (p)
-{}
-
-ACE_INLINE
-IR_ConsumesDefSeq_var::IR_ConsumesDefSeq_var (const ::IR_ConsumesDefSeq_var &p) // copy constructor
-{
-  if (p.ptr_)
-    ACE_NEW (this->ptr_, ::IR_ConsumesDefSeq (*p.ptr_));
-  else
-    this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_ConsumesDefSeq_var::~IR_ConsumesDefSeq_var (void) // destructor
-{
-  delete this->ptr_;
-}
-
-ACE_INLINE IR_ConsumesDefSeq_var &
-IR_ConsumesDefSeq_var::operator= (IR_ConsumesDefSeq *p)
-{
-  delete this->ptr_;
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE IR_ConsumesDefSeq_var &
-IR_ConsumesDefSeq_var::operator= (const ::IR_ConsumesDefSeq_var &p) // deep copy
-{
-  if (this != &p)
-    {
-      if (p.ptr_ == 0)
-        {
-          delete this->ptr_;
-          this->ptr_ = 0;
-        }
-      else
-        {
-          IR_ConsumesDefSeq *deep_copy = 
-            new IR_ConsumesDefSeq (*p.ptr_);
-          
-          if (deep_copy != 0)
-            {
-              IR_ConsumesDefSeq *tmp = deep_copy;
-              deep_copy = this->ptr_;
-              this->ptr_ = tmp;
-              delete deep_copy;
-            }
-        }
-    }
-  
-  return *this;
-}
-
-ACE_INLINE const ::IR_ConsumesDefSeq *
-IR_ConsumesDefSeq_var::operator-> (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_ConsumesDefSeq *
-IR_ConsumesDefSeq_var::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE 
-IR_ConsumesDefSeq_var::operator const ::IR_ConsumesDefSeq &() const // cast
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE 
-IR_ConsumesDefSeq_var::operator ::IR_ConsumesDefSeq &() // cast 
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE 
-IR_ConsumesDefSeq_var::operator ::IR_ConsumesDefSeq &() const // cast 
-{
-  return *this->ptr_;
-}
-
-// variable-size types only
-ACE_INLINE
-IR_ConsumesDefSeq_var::operator ::IR_ConsumesDefSeq *&() // cast 
-{
-  return this->ptr_;
-}
-
-ACE_INLINE TAO_Object_Manager<IR_ConsumesDef, IR_ConsumesDef_var>
-IR_ConsumesDefSeq_var::operator[] (CORBA::ULong index)
-{
-  return this->ptr_->operator[] (index);
-}
-
-ACE_INLINE const ::IR_ConsumesDefSeq &
-IR_ConsumesDefSeq_var::in (void) const
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE ::IR_ConsumesDefSeq &
-IR_ConsumesDefSeq_var::inout (void)
-{
-  return *this->ptr_;
-}
-
-// mapping for variable size 
-ACE_INLINE ::IR_ConsumesDefSeq *&
-IR_ConsumesDefSeq_var::out (void)
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_ConsumesDefSeq *
-IR_ConsumesDefSeq_var::_retn (void)
-{
-  ::IR_ConsumesDefSeq *tmp = this->ptr_;
-  this->ptr_ = 0;
-  return tmp;
-}
-
-ACE_INLINE ::IR_ConsumesDefSeq *
-IR_ConsumesDefSeq_var::ptr (void) const
-{
-  return this->ptr_;
-}
-
-// *************************************************************
-// Inline operations for class IR_ConsumesDefSeq_out
-// *************************************************************
-
-ACE_INLINE
-IR_ConsumesDefSeq_out::IR_ConsumesDefSeq_out (IR_ConsumesDefSeq *&p)
-  : ptr_ (p)
-{
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_ConsumesDefSeq_out::IR_ConsumesDefSeq_out (IR_ConsumesDefSeq_var &p) // constructor from _var
-  : ptr_ (p.out ())
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_ConsumesDefSeq_out::IR_ConsumesDefSeq_out (const ::IR_ConsumesDefSeq_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (IR_ConsumesDefSeq_out&, p).ptr_)
-{}
-
-ACE_INLINE ::IR_ConsumesDefSeq_out &
-IR_ConsumesDefSeq_out::operator= (const ::IR_ConsumesDefSeq_out &p)
-{
-  this->ptr_ = ACE_const_cast (IR_ConsumesDefSeq_out&, p).ptr_;
-  return *this;
-}
-
-ACE_INLINE ::IR_ConsumesDefSeq_out &
-IR_ConsumesDefSeq_out::operator= (IR_ConsumesDefSeq *p)
-{
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE 
-IR_ConsumesDefSeq_out::operator ::IR_ConsumesDefSeq *&() // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_ConsumesDefSeq *&
-IR_ConsumesDefSeq_out::ptr (void) // ptr
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_ConsumesDefSeq *
-IR_ConsumesDefSeq_out::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE TAO_Object_Manager<IR_ConsumesDef, IR_ConsumesDef_var>
-IR_ConsumesDefSeq_out::operator[] (CORBA::ULong index)
-{
-  return this->ptr_->operator[] (index);
-}
-
-ACE_INLINE
-IR_FactoryDef::IR_FactoryDef (
-    TAO_Stub *objref,
-    CORBA::Boolean _tao_collocated,
-    TAO_Abstract_ServantBase *servant
-  )
-  : CORBA_Object (objref, _tao_collocated, servant)
-{
-  this->IR_FactoryDef_setup_collocation (_tao_collocated);
-}
-
-// *************************************************************
-// Inline operations for class IR_FactoryDef_var
-// *************************************************************
-
-ACE_INLINE
-IR_FactoryDef_var::IR_FactoryDef_var (void) // default constructor
-  : ptr_ (IR_FactoryDef::_nil ())
-{}
-
-ACE_INLINE IR_FactoryDef_ptr 
-IR_FactoryDef_var::ptr (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE
-IR_FactoryDef_var::IR_FactoryDef_var (const IR_FactoryDef_var &p) // copy constructor
-  : TAO_Base_var (),
-    ptr_ (IR_FactoryDef::_duplicate (p.ptr ()))
-{}
-
-ACE_INLINE
-IR_FactoryDef_var::~IR_FactoryDef_var (void) // destructor
-{
-  CORBA::release (this->ptr_);
-}
-
-ACE_INLINE IR_FactoryDef_var &
-IR_FactoryDef_var::operator= (IR_FactoryDef_ptr p)
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE IR_FactoryDef_var &
-IR_FactoryDef_var::operator= (const IR_FactoryDef_var &p)
-{
-  if (this != &p)
-  {
-    CORBA::release (this->ptr_);
-    this->ptr_ = IR_FactoryDef::_duplicate (p.ptr ());
-  }
-  return *this;
-}
-
-ACE_INLINE 
-IR_FactoryDef_var::operator const IR_FactoryDef_ptr &() const // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE 
-IR_FactoryDef_var::operator IR_FactoryDef_ptr &() // cast 
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_FactoryDef_ptr 
-IR_FactoryDef_var::operator-> (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_FactoryDef_ptr
-IR_FactoryDef_var::in (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_FactoryDef_ptr &
-IR_FactoryDef_var::inout (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_FactoryDef_ptr &
-IR_FactoryDef_var::out (void)
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = IR_FactoryDef::_nil ();
-  return this->ptr_;
-}
-
-ACE_INLINE IR_FactoryDef_ptr 
-IR_FactoryDef_var::_retn (void)
-{
-  // yield ownership of managed obj reference
-  IR_FactoryDef_ptr val = this->ptr_;
-  this->ptr_ = IR_FactoryDef::_nil ();
-  return val;
-}
-
-// *************************************************************
-// Inline operations for class IR_FactoryDef_out
-// *************************************************************
-
-ACE_INLINE
-IR_FactoryDef_out::IR_FactoryDef_out (IR_FactoryDef_ptr &p)
-  : ptr_ (p)
-{
-  this->ptr_ = IR_FactoryDef::_nil ();
-}
-
-ACE_INLINE
-IR_FactoryDef_out::IR_FactoryDef_out (IR_FactoryDef_var &p) // constructor from _var
-  : ptr_ (p.out ())
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = IR_FactoryDef::_nil ();
-}
-
-ACE_INLINE
-IR_FactoryDef_out::IR_FactoryDef_out (const IR_FactoryDef_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (IR_FactoryDef_out&,p).ptr_)
-{}
-
-ACE_INLINE IR_FactoryDef_out &
-IR_FactoryDef_out::operator= (const IR_FactoryDef_out &p)
-{
-  this->ptr_ = ACE_const_cast (IR_FactoryDef_out&,p).ptr_;
-  return *this;
-}
-
-ACE_INLINE IR_FactoryDef_out &
-IR_FactoryDef_out::operator= (const IR_FactoryDef_var &p)
-{
-  this->ptr_ = IR_FactoryDef::_duplicate (p.ptr ());
-  return *this;
-}
-
-ACE_INLINE IR_FactoryDef_out &
-IR_FactoryDef_out::operator= (IR_FactoryDef_ptr p)
-{
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE 
-IR_FactoryDef_out::operator IR_FactoryDef_ptr &() // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_FactoryDef_ptr &
-IR_FactoryDef_out::ptr (void) // ptr
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_FactoryDef_ptr 
-IR_FactoryDef_out::operator-> (void)
-{
-  return this->ptr_;
-}
-
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  
-  ACE_INLINE IR_FactoryDef **
-  _TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq::allocbuf (CORBA::ULong nelems)
-  {
-    IR_FactoryDef **buf = 0;
-    
-    ACE_NEW_RETURN (buf, IR_FactoryDef*[nelems], 0);
-    
-    for (CORBA::ULong i = 0; i < nelems; i++)
-      buf[i] = IR_FactoryDef::_nil ();
-    
-    return buf;
-  }
-  
-  ACE_INLINE void 
-  _TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq::freebuf (IR_FactoryDef **buffer)
-  {
-    if (buffer == 0)
-      return;
-    delete[] buffer;
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq::_TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq (void)
-  {
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq::_TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq (CORBA::ULong maximum)
-    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq::allocbuf (maximum))
-  {
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq::_TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq (CORBA::ULong maximum,
-    CORBA::ULong length,
-    IR_FactoryDef* *value,
-    CORBA::Boolean release)
-  : TAO_Unbounded_Base_Sequence (maximum, length, value, release)
-  {
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq::_TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq(const _TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq &rhs)
-    : TAO_Unbounded_Base_Sequence (rhs)
-  {
-    if (rhs.buffer_ != 0)
-    {
-      IR_FactoryDef **tmp1 = _TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq::allocbuf (this->maximum_);
-      IR_FactoryDef ** const tmp2 = ACE_reinterpret_cast (IR_FactoryDef ** ACE_CAST_CONST, rhs.buffer_);
-      
-      for (CORBA::ULong i = 0; i < rhs.length_; ++i)
-        tmp1[i] = IR_FactoryDef::_duplicate (tmp2[i]);
-      
-      this->buffer_ = tmp1;
-    }
-    else
-    {
-      this->buffer_ = 0;
-    }
-  }
-  
-  ACE_INLINE _TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq &
-  _TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq::operator= (const _TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq &rhs)
-  {
-    if (this == &rhs)
-      return *this;
-    
-    if (this->release_)
-    {
-      IR_FactoryDef **tmp = ACE_reinterpret_cast (IR_FactoryDef **, this->buffer_);
-      
-      for (CORBA::ULong i = 0; i < this->length_; ++i)
-      {
-        CORBA::release (tmp[i]);
-        tmp[i] = IR_FactoryDef::_nil ();
-      }
-      if (this->maximum_ < rhs.maximum_)
-      {
-        _TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq::freebuf (tmp);
-        this->buffer_ = _TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq::allocbuf (rhs.maximum_);
-      }
-    }
-    else
-      this->buffer_ = _TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq::allocbuf (rhs.maximum_);
-    
-    TAO_Unbounded_Base_Sequence::operator= (rhs);
-    
-    IR_FactoryDef **tmp1 = ACE_reinterpret_cast (IR_FactoryDef **, this->buffer_);
-    IR_FactoryDef ** const tmp2 = ACE_reinterpret_cast (IR_FactoryDef ** ACE_CAST_CONST, rhs.buffer_);
-    
-    for (CORBA::ULong i = 0; i < rhs.length_; ++i)
-      tmp1[i] = IR_FactoryDef::_duplicate (tmp2[i]);
-    
-    return *this;
-  }
-  
-  ACE_INLINE TAO_Object_Manager<IR_FactoryDef,IR_FactoryDef_var>
-  _TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq::operator[] (CORBA::ULong index) const
-  // read-write accessor
-  {
-    ACE_ASSERT (index < this->maximum_);
-    IR_FactoryDef ** const tmp = ACE_reinterpret_cast (IR_FactoryDef ** ACE_CAST_CONST, this->buffer_);
-    return TAO_Object_Manager<IR_FactoryDef,IR_FactoryDef_var> (tmp + index, this->release_);
-  }
-  
-  ACE_INLINE IR_FactoryDef* *
-  _TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq::get_buffer (CORBA::Boolean orphan)
-  {
-    IR_FactoryDef **result = 0;
-    if (orphan == 0)
-    {
-      // We retain ownership.
-      if (this->buffer_ == 0)
-      {
-        result = _TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq::allocbuf (this->maximum_);
-        this->buffer_ = result;
-        this->release_ = 1;
-      }
-      else
-      {
-        result = ACE_reinterpret_cast (IR_FactoryDef**, this->buffer_);
-      }
-    }
-    else // if (orphan == 1)
-    {
-      if (this->release_ != 0)
-      {
-        // We set the state back to default and relinquish
-        // ownership.
-        result = ACE_reinterpret_cast(IR_FactoryDef**,this->buffer_);
-        this->maximum_ = 0;
-        this->length_ = 0;
-        this->buffer_ = 0;
-        this->release_ = 0;
-      }
-    }
-    return result;
-  }
-  
-  ACE_INLINE const IR_FactoryDef* *
-  _TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq::get_buffer (void) const
-  {
-    return ACE_reinterpret_cast(const IR_FactoryDef ** ACE_CAST_CONST, this->buffer_);
-  }
-  
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
-
-// *************************************************************
-// Inline operations for class IR_FactoryDefSeq_var
-// *************************************************************
-
-ACE_INLINE
-IR_FactoryDefSeq_var::IR_FactoryDefSeq_var (void) // default constructor
-  : ptr_ (0)
-{}
-
-ACE_INLINE
-IR_FactoryDefSeq_var::IR_FactoryDefSeq_var (IR_FactoryDefSeq *p)
-  : ptr_ (p)
-{}
-
-ACE_INLINE
-IR_FactoryDefSeq_var::IR_FactoryDefSeq_var (const ::IR_FactoryDefSeq_var &p) // copy constructor
-{
-  if (p.ptr_)
-    ACE_NEW (this->ptr_, ::IR_FactoryDefSeq (*p.ptr_));
-  else
-    this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_FactoryDefSeq_var::~IR_FactoryDefSeq_var (void) // destructor
-{
-  delete this->ptr_;
-}
-
-ACE_INLINE IR_FactoryDefSeq_var &
-IR_FactoryDefSeq_var::operator= (IR_FactoryDefSeq *p)
-{
-  delete this->ptr_;
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE IR_FactoryDefSeq_var &
-IR_FactoryDefSeq_var::operator= (const ::IR_FactoryDefSeq_var &p) // deep copy
-{
-  if (this != &p)
-    {
-      if (p.ptr_ == 0)
-        {
-          delete this->ptr_;
-          this->ptr_ = 0;
-        }
-      else
-        {
-          IR_FactoryDefSeq *deep_copy = 
-            new IR_FactoryDefSeq (*p.ptr_);
-          
-          if (deep_copy != 0)
-            {
-              IR_FactoryDefSeq *tmp = deep_copy;
-              deep_copy = this->ptr_;
-              this->ptr_ = tmp;
-              delete deep_copy;
-            }
-        }
-    }
-  
-  return *this;
-}
-
-ACE_INLINE const ::IR_FactoryDefSeq *
-IR_FactoryDefSeq_var::operator-> (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_FactoryDefSeq *
-IR_FactoryDefSeq_var::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE 
-IR_FactoryDefSeq_var::operator const ::IR_FactoryDefSeq &() const // cast
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE 
-IR_FactoryDefSeq_var::operator ::IR_FactoryDefSeq &() // cast 
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE 
-IR_FactoryDefSeq_var::operator ::IR_FactoryDefSeq &() const // cast 
-{
-  return *this->ptr_;
-}
-
-// variable-size types only
-ACE_INLINE
-IR_FactoryDefSeq_var::operator ::IR_FactoryDefSeq *&() // cast 
-{
-  return this->ptr_;
-}
-
-ACE_INLINE TAO_Object_Manager<IR_FactoryDef, IR_FactoryDef_var>
-IR_FactoryDefSeq_var::operator[] (CORBA::ULong index)
-{
-  return this->ptr_->operator[] (index);
-}
-
-ACE_INLINE const ::IR_FactoryDefSeq &
-IR_FactoryDefSeq_var::in (void) const
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE ::IR_FactoryDefSeq &
-IR_FactoryDefSeq_var::inout (void)
-{
-  return *this->ptr_;
-}
-
-// mapping for variable size 
-ACE_INLINE ::IR_FactoryDefSeq *&
-IR_FactoryDefSeq_var::out (void)
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_FactoryDefSeq *
-IR_FactoryDefSeq_var::_retn (void)
-{
-  ::IR_FactoryDefSeq *tmp = this->ptr_;
-  this->ptr_ = 0;
-  return tmp;
-}
-
-ACE_INLINE ::IR_FactoryDefSeq *
-IR_FactoryDefSeq_var::ptr (void) const
-{
-  return this->ptr_;
-}
-
-// *************************************************************
-// Inline operations for class IR_FactoryDefSeq_out
-// *************************************************************
-
-ACE_INLINE
-IR_FactoryDefSeq_out::IR_FactoryDefSeq_out (IR_FactoryDefSeq *&p)
-  : ptr_ (p)
-{
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_FactoryDefSeq_out::IR_FactoryDefSeq_out (IR_FactoryDefSeq_var &p) // constructor from _var
-  : ptr_ (p.out ())
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_FactoryDefSeq_out::IR_FactoryDefSeq_out (const ::IR_FactoryDefSeq_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (IR_FactoryDefSeq_out&, p).ptr_)
-{}
-
-ACE_INLINE ::IR_FactoryDefSeq_out &
-IR_FactoryDefSeq_out::operator= (const ::IR_FactoryDefSeq_out &p)
-{
-  this->ptr_ = ACE_const_cast (IR_FactoryDefSeq_out&, p).ptr_;
-  return *this;
-}
-
-ACE_INLINE ::IR_FactoryDefSeq_out &
-IR_FactoryDefSeq_out::operator= (IR_FactoryDefSeq *p)
-{
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE 
-IR_FactoryDefSeq_out::operator ::IR_FactoryDefSeq *&() // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_FactoryDefSeq *&
-IR_FactoryDefSeq_out::ptr (void) // ptr
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_FactoryDefSeq *
-IR_FactoryDefSeq_out::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE TAO_Object_Manager<IR_FactoryDef, IR_FactoryDef_var>
-IR_FactoryDefSeq_out::operator[] (CORBA::ULong index)
-{
-  return this->ptr_->operator[] (index);
-}
-
-ACE_INLINE
-IR_FinderDef::IR_FinderDef (
-    TAO_Stub *objref,
-    CORBA::Boolean _tao_collocated,
-    TAO_Abstract_ServantBase *servant
-  )
-  : CORBA_Object (objref, _tao_collocated, servant)
-{
-  this->IR_FinderDef_setup_collocation (_tao_collocated);
-}
-
-// *************************************************************
-// Inline operations for class IR_FinderDef_var
-// *************************************************************
-
-ACE_INLINE
-IR_FinderDef_var::IR_FinderDef_var (void) // default constructor
-  : ptr_ (IR_FinderDef::_nil ())
-{}
-
-ACE_INLINE IR_FinderDef_ptr 
-IR_FinderDef_var::ptr (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE
-IR_FinderDef_var::IR_FinderDef_var (const IR_FinderDef_var &p) // copy constructor
-  : TAO_Base_var (),
-    ptr_ (IR_FinderDef::_duplicate (p.ptr ()))
-{}
-
-ACE_INLINE
-IR_FinderDef_var::~IR_FinderDef_var (void) // destructor
-{
-  CORBA::release (this->ptr_);
-}
-
-ACE_INLINE IR_FinderDef_var &
-IR_FinderDef_var::operator= (IR_FinderDef_ptr p)
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE IR_FinderDef_var &
-IR_FinderDef_var::operator= (const IR_FinderDef_var &p)
-{
-  if (this != &p)
-  {
-    CORBA::release (this->ptr_);
-    this->ptr_ = IR_FinderDef::_duplicate (p.ptr ());
-  }
-  return *this;
-}
-
-ACE_INLINE 
-IR_FinderDef_var::operator const IR_FinderDef_ptr &() const // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE 
-IR_FinderDef_var::operator IR_FinderDef_ptr &() // cast 
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_FinderDef_ptr 
-IR_FinderDef_var::operator-> (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_FinderDef_ptr
-IR_FinderDef_var::in (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_FinderDef_ptr &
-IR_FinderDef_var::inout (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_FinderDef_ptr &
-IR_FinderDef_var::out (void)
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = IR_FinderDef::_nil ();
-  return this->ptr_;
-}
-
-ACE_INLINE IR_FinderDef_ptr 
-IR_FinderDef_var::_retn (void)
-{
-  // yield ownership of managed obj reference
-  IR_FinderDef_ptr val = this->ptr_;
-  this->ptr_ = IR_FinderDef::_nil ();
-  return val;
-}
-
-// *************************************************************
-// Inline operations for class IR_FinderDef_out
-// *************************************************************
-
-ACE_INLINE
-IR_FinderDef_out::IR_FinderDef_out (IR_FinderDef_ptr &p)
-  : ptr_ (p)
-{
-  this->ptr_ = IR_FinderDef::_nil ();
-}
-
-ACE_INLINE
-IR_FinderDef_out::IR_FinderDef_out (IR_FinderDef_var &p) // constructor from _var
-  : ptr_ (p.out ())
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = IR_FinderDef::_nil ();
-}
-
-ACE_INLINE
-IR_FinderDef_out::IR_FinderDef_out (const IR_FinderDef_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (IR_FinderDef_out&,p).ptr_)
-{}
-
-ACE_INLINE IR_FinderDef_out &
-IR_FinderDef_out::operator= (const IR_FinderDef_out &p)
-{
-  this->ptr_ = ACE_const_cast (IR_FinderDef_out&,p).ptr_;
-  return *this;
-}
-
-ACE_INLINE IR_FinderDef_out &
-IR_FinderDef_out::operator= (const IR_FinderDef_var &p)
-{
-  this->ptr_ = IR_FinderDef::_duplicate (p.ptr ());
-  return *this;
-}
-
-ACE_INLINE IR_FinderDef_out &
-IR_FinderDef_out::operator= (IR_FinderDef_ptr p)
-{
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE 
-IR_FinderDef_out::operator IR_FinderDef_ptr &() // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_FinderDef_ptr &
-IR_FinderDef_out::ptr (void) // ptr
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_FinderDef_ptr 
-IR_FinderDef_out::operator-> (void)
-{
-  return this->ptr_;
-}
-
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  
-  ACE_INLINE IR_FinderDef **
-  _TAO_Unbounded_Object_Sequence_IR_FinderDefSeq::allocbuf (CORBA::ULong nelems)
-  {
-    IR_FinderDef **buf = 0;
-    
-    ACE_NEW_RETURN (buf, IR_FinderDef*[nelems], 0);
-    
-    for (CORBA::ULong i = 0; i < nelems; i++)
-      buf[i] = IR_FinderDef::_nil ();
-    
-    return buf;
-  }
-  
-  ACE_INLINE void 
-  _TAO_Unbounded_Object_Sequence_IR_FinderDefSeq::freebuf (IR_FinderDef **buffer)
-  {
-    if (buffer == 0)
-      return;
-    delete[] buffer;
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Object_Sequence_IR_FinderDefSeq::_TAO_Unbounded_Object_Sequence_IR_FinderDefSeq (void)
-  {
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Object_Sequence_IR_FinderDefSeq::_TAO_Unbounded_Object_Sequence_IR_FinderDefSeq (CORBA::ULong maximum)
-    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Object_Sequence_IR_FinderDefSeq::allocbuf (maximum))
-  {
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Object_Sequence_IR_FinderDefSeq::_TAO_Unbounded_Object_Sequence_IR_FinderDefSeq (CORBA::ULong maximum,
-    CORBA::ULong length,
-    IR_FinderDef* *value,
-    CORBA::Boolean release)
-  : TAO_Unbounded_Base_Sequence (maximum, length, value, release)
-  {
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Object_Sequence_IR_FinderDefSeq::_TAO_Unbounded_Object_Sequence_IR_FinderDefSeq(const _TAO_Unbounded_Object_Sequence_IR_FinderDefSeq &rhs)
-    : TAO_Unbounded_Base_Sequence (rhs)
-  {
-    if (rhs.buffer_ != 0)
-    {
-      IR_FinderDef **tmp1 = _TAO_Unbounded_Object_Sequence_IR_FinderDefSeq::allocbuf (this->maximum_);
-      IR_FinderDef ** const tmp2 = ACE_reinterpret_cast (IR_FinderDef ** ACE_CAST_CONST, rhs.buffer_);
-      
-      for (CORBA::ULong i = 0; i < rhs.length_; ++i)
-        tmp1[i] = IR_FinderDef::_duplicate (tmp2[i]);
-      
-      this->buffer_ = tmp1;
-    }
-    else
-    {
-      this->buffer_ = 0;
-    }
-  }
-  
-  ACE_INLINE _TAO_Unbounded_Object_Sequence_IR_FinderDefSeq &
-  _TAO_Unbounded_Object_Sequence_IR_FinderDefSeq::operator= (const _TAO_Unbounded_Object_Sequence_IR_FinderDefSeq &rhs)
-  {
-    if (this == &rhs)
-      return *this;
-    
-    if (this->release_)
-    {
-      IR_FinderDef **tmp = ACE_reinterpret_cast (IR_FinderDef **, this->buffer_);
-      
-      for (CORBA::ULong i = 0; i < this->length_; ++i)
-      {
-        CORBA::release (tmp[i]);
-        tmp[i] = IR_FinderDef::_nil ();
-      }
-      if (this->maximum_ < rhs.maximum_)
-      {
-        _TAO_Unbounded_Object_Sequence_IR_FinderDefSeq::freebuf (tmp);
-        this->buffer_ = _TAO_Unbounded_Object_Sequence_IR_FinderDefSeq::allocbuf (rhs.maximum_);
-      }
-    }
-    else
-      this->buffer_ = _TAO_Unbounded_Object_Sequence_IR_FinderDefSeq::allocbuf (rhs.maximum_);
-    
-    TAO_Unbounded_Base_Sequence::operator= (rhs);
-    
-    IR_FinderDef **tmp1 = ACE_reinterpret_cast (IR_FinderDef **, this->buffer_);
-    IR_FinderDef ** const tmp2 = ACE_reinterpret_cast (IR_FinderDef ** ACE_CAST_CONST, rhs.buffer_);
-    
-    for (CORBA::ULong i = 0; i < rhs.length_; ++i)
-      tmp1[i] = IR_FinderDef::_duplicate (tmp2[i]);
-    
-    return *this;
-  }
-  
-  ACE_INLINE TAO_Object_Manager<IR_FinderDef,IR_FinderDef_var>
-  _TAO_Unbounded_Object_Sequence_IR_FinderDefSeq::operator[] (CORBA::ULong index) const
-  // read-write accessor
-  {
-    ACE_ASSERT (index < this->maximum_);
-    IR_FinderDef ** const tmp = ACE_reinterpret_cast (IR_FinderDef ** ACE_CAST_CONST, this->buffer_);
-    return TAO_Object_Manager<IR_FinderDef,IR_FinderDef_var> (tmp + index, this->release_);
-  }
-  
-  ACE_INLINE IR_FinderDef* *
-  _TAO_Unbounded_Object_Sequence_IR_FinderDefSeq::get_buffer (CORBA::Boolean orphan)
-  {
-    IR_FinderDef **result = 0;
-    if (orphan == 0)
-    {
-      // We retain ownership.
-      if (this->buffer_ == 0)
-      {
-        result = _TAO_Unbounded_Object_Sequence_IR_FinderDefSeq::allocbuf (this->maximum_);
-        this->buffer_ = result;
-        this->release_ = 1;
-      }
-      else
-      {
-        result = ACE_reinterpret_cast (IR_FinderDef**, this->buffer_);
-      }
-    }
-    else // if (orphan == 1)
-    {
-      if (this->release_ != 0)
-      {
-        // We set the state back to default and relinquish
-        // ownership.
-        result = ACE_reinterpret_cast(IR_FinderDef**,this->buffer_);
-        this->maximum_ = 0;
-        this->length_ = 0;
-        this->buffer_ = 0;
-        this->release_ = 0;
-      }
-    }
-    return result;
-  }
-  
-  ACE_INLINE const IR_FinderDef* *
-  _TAO_Unbounded_Object_Sequence_IR_FinderDefSeq::get_buffer (void) const
-  {
-    return ACE_reinterpret_cast(const IR_FinderDef ** ACE_CAST_CONST, this->buffer_);
-  }
-  
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
-
-// *************************************************************
-// Inline operations for class IR_FinderDefSeq_var
-// *************************************************************
-
-ACE_INLINE
-IR_FinderDefSeq_var::IR_FinderDefSeq_var (void) // default constructor
-  : ptr_ (0)
-{}
-
-ACE_INLINE
-IR_FinderDefSeq_var::IR_FinderDefSeq_var (IR_FinderDefSeq *p)
-  : ptr_ (p)
-{}
-
-ACE_INLINE
-IR_FinderDefSeq_var::IR_FinderDefSeq_var (const ::IR_FinderDefSeq_var &p) // copy constructor
-{
-  if (p.ptr_)
-    ACE_NEW (this->ptr_, ::IR_FinderDefSeq (*p.ptr_));
-  else
-    this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_FinderDefSeq_var::~IR_FinderDefSeq_var (void) // destructor
-{
-  delete this->ptr_;
-}
-
-ACE_INLINE IR_FinderDefSeq_var &
-IR_FinderDefSeq_var::operator= (IR_FinderDefSeq *p)
-{
-  delete this->ptr_;
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE IR_FinderDefSeq_var &
-IR_FinderDefSeq_var::operator= (const ::IR_FinderDefSeq_var &p) // deep copy
-{
-  if (this != &p)
-    {
-      if (p.ptr_ == 0)
-        {
-          delete this->ptr_;
-          this->ptr_ = 0;
-        }
-      else
-        {
-          IR_FinderDefSeq *deep_copy = 
-            new IR_FinderDefSeq (*p.ptr_);
-          
-          if (deep_copy != 0)
-            {
-              IR_FinderDefSeq *tmp = deep_copy;
-              deep_copy = this->ptr_;
-              this->ptr_ = tmp;
-              delete deep_copy;
-            }
-        }
-    }
-  
-  return *this;
-}
-
-ACE_INLINE const ::IR_FinderDefSeq *
-IR_FinderDefSeq_var::operator-> (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_FinderDefSeq *
-IR_FinderDefSeq_var::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE 
-IR_FinderDefSeq_var::operator const ::IR_FinderDefSeq &() const // cast
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE 
-IR_FinderDefSeq_var::operator ::IR_FinderDefSeq &() // cast 
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE 
-IR_FinderDefSeq_var::operator ::IR_FinderDefSeq &() const // cast 
-{
-  return *this->ptr_;
-}
-
-// variable-size types only
-ACE_INLINE
-IR_FinderDefSeq_var::operator ::IR_FinderDefSeq *&() // cast 
-{
-  return this->ptr_;
-}
-
-ACE_INLINE TAO_Object_Manager<IR_FinderDef, IR_FinderDef_var>
-IR_FinderDefSeq_var::operator[] (CORBA::ULong index)
-{
-  return this->ptr_->operator[] (index);
-}
-
-ACE_INLINE const ::IR_FinderDefSeq &
-IR_FinderDefSeq_var::in (void) const
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE ::IR_FinderDefSeq &
-IR_FinderDefSeq_var::inout (void)
-{
-  return *this->ptr_;
-}
-
-// mapping for variable size 
-ACE_INLINE ::IR_FinderDefSeq *&
-IR_FinderDefSeq_var::out (void)
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_FinderDefSeq *
-IR_FinderDefSeq_var::_retn (void)
-{
-  ::IR_FinderDefSeq *tmp = this->ptr_;
-  this->ptr_ = 0;
-  return tmp;
-}
-
-ACE_INLINE ::IR_FinderDefSeq *
-IR_FinderDefSeq_var::ptr (void) const
-{
-  return this->ptr_;
-}
-
-// *************************************************************
-// Inline operations for class IR_FinderDefSeq_out
-// *************************************************************
-
-ACE_INLINE
-IR_FinderDefSeq_out::IR_FinderDefSeq_out (IR_FinderDefSeq *&p)
-  : ptr_ (p)
-{
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_FinderDefSeq_out::IR_FinderDefSeq_out (IR_FinderDefSeq_var &p) // constructor from _var
-  : ptr_ (p.out ())
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_FinderDefSeq_out::IR_FinderDefSeq_out (const ::IR_FinderDefSeq_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (IR_FinderDefSeq_out&, p).ptr_)
-{}
-
-ACE_INLINE ::IR_FinderDefSeq_out &
-IR_FinderDefSeq_out::operator= (const ::IR_FinderDefSeq_out &p)
-{
-  this->ptr_ = ACE_const_cast (IR_FinderDefSeq_out&, p).ptr_;
-  return *this;
-}
-
-ACE_INLINE ::IR_FinderDefSeq_out &
-IR_FinderDefSeq_out::operator= (IR_FinderDefSeq *p)
-{
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE 
-IR_FinderDefSeq_out::operator ::IR_FinderDefSeq *&() // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_FinderDefSeq *&
-IR_FinderDefSeq_out::ptr (void) // ptr
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_FinderDefSeq *
-IR_FinderDefSeq_out::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE TAO_Object_Manager<IR_FinderDef, IR_FinderDef_var>
-IR_FinderDefSeq_out::operator[] (CORBA::ULong index)
-{
-  return this->ptr_->operator[] (index);
-}
-
-ACE_INLINE
-IR_PrimaryKeyDef::IR_PrimaryKeyDef (
-    TAO_Stub *objref,
-    CORBA::Boolean _tao_collocated,
-    TAO_Abstract_ServantBase *servant
-  )
-  : CORBA_Object (objref, _tao_collocated, servant)
-{
-  this->IR_PrimaryKeyDef_setup_collocation (_tao_collocated);
-}
-
-// *************************************************************
-// Inline operations for class IR_PrimaryKeyDef_var
-// *************************************************************
-
-ACE_INLINE
-IR_PrimaryKeyDef_var::IR_PrimaryKeyDef_var (void) // default constructor
-  : ptr_ (IR_PrimaryKeyDef::_nil ())
-{}
-
-ACE_INLINE IR_PrimaryKeyDef_ptr 
-IR_PrimaryKeyDef_var::ptr (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE
-IR_PrimaryKeyDef_var::IR_PrimaryKeyDef_var (const IR_PrimaryKeyDef_var &p) // copy constructor
-  : TAO_Base_var (),
-    ptr_ (IR_PrimaryKeyDef::_duplicate (p.ptr ()))
-{}
-
-ACE_INLINE
-IR_PrimaryKeyDef_var::~IR_PrimaryKeyDef_var (void) // destructor
-{
-  CORBA::release (this->ptr_);
-}
-
-ACE_INLINE IR_PrimaryKeyDef_var &
-IR_PrimaryKeyDef_var::operator= (IR_PrimaryKeyDef_ptr p)
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE IR_PrimaryKeyDef_var &
-IR_PrimaryKeyDef_var::operator= (const IR_PrimaryKeyDef_var &p)
-{
-  if (this != &p)
-  {
-    CORBA::release (this->ptr_);
-    this->ptr_ = IR_PrimaryKeyDef::_duplicate (p.ptr ());
-  }
-  return *this;
-}
-
-ACE_INLINE 
-IR_PrimaryKeyDef_var::operator const IR_PrimaryKeyDef_ptr &() const // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE 
-IR_PrimaryKeyDef_var::operator IR_PrimaryKeyDef_ptr &() // cast 
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_PrimaryKeyDef_ptr 
-IR_PrimaryKeyDef_var::operator-> (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_PrimaryKeyDef_ptr
-IR_PrimaryKeyDef_var::in (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_PrimaryKeyDef_ptr &
-IR_PrimaryKeyDef_var::inout (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_PrimaryKeyDef_ptr &
-IR_PrimaryKeyDef_var::out (void)
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = IR_PrimaryKeyDef::_nil ();
-  return this->ptr_;
-}
-
-ACE_INLINE IR_PrimaryKeyDef_ptr 
-IR_PrimaryKeyDef_var::_retn (void)
-{
-  // yield ownership of managed obj reference
-  IR_PrimaryKeyDef_ptr val = this->ptr_;
-  this->ptr_ = IR_PrimaryKeyDef::_nil ();
-  return val;
-}
-
-// *************************************************************
-// Inline operations for class IR_PrimaryKeyDef_out
-// *************************************************************
-
-ACE_INLINE
-IR_PrimaryKeyDef_out::IR_PrimaryKeyDef_out (IR_PrimaryKeyDef_ptr &p)
-  : ptr_ (p)
-{
-  this->ptr_ = IR_PrimaryKeyDef::_nil ();
-}
-
-ACE_INLINE
-IR_PrimaryKeyDef_out::IR_PrimaryKeyDef_out (IR_PrimaryKeyDef_var &p) // constructor from _var
-  : ptr_ (p.out ())
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = IR_PrimaryKeyDef::_nil ();
-}
-
-ACE_INLINE
-IR_PrimaryKeyDef_out::IR_PrimaryKeyDef_out (const IR_PrimaryKeyDef_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (IR_PrimaryKeyDef_out&,p).ptr_)
-{}
-
-ACE_INLINE IR_PrimaryKeyDef_out &
-IR_PrimaryKeyDef_out::operator= (const IR_PrimaryKeyDef_out &p)
-{
-  this->ptr_ = ACE_const_cast (IR_PrimaryKeyDef_out&,p).ptr_;
-  return *this;
-}
-
-ACE_INLINE IR_PrimaryKeyDef_out &
-IR_PrimaryKeyDef_out::operator= (const IR_PrimaryKeyDef_var &p)
-{
-  this->ptr_ = IR_PrimaryKeyDef::_duplicate (p.ptr ());
-  return *this;
-}
-
-ACE_INLINE IR_PrimaryKeyDef_out &
-IR_PrimaryKeyDef_out::operator= (IR_PrimaryKeyDef_ptr p)
-{
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE 
-IR_PrimaryKeyDef_out::operator IR_PrimaryKeyDef_ptr &() // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_PrimaryKeyDef_ptr &
-IR_PrimaryKeyDef_out::ptr (void) // ptr
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_PrimaryKeyDef_ptr 
-IR_PrimaryKeyDef_out::operator-> (void)
-{
-  return this->ptr_;
-}
-
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  
-  ACE_INLINE IR_Contained **
-  _TAO_Unbounded_Object_Sequence_IR_ContainedSeq::allocbuf (CORBA::ULong nelems)
-  {
-    IR_Contained **buf = 0;
-    
-    ACE_NEW_RETURN (buf, IR_Contained*[nelems], 0);
-    
-    for (CORBA::ULong i = 0; i < nelems; i++)
-      buf[i] = IR_Contained::_nil ();
-    
-    return buf;
-  }
-  
-  ACE_INLINE void 
-  _TAO_Unbounded_Object_Sequence_IR_ContainedSeq::freebuf (IR_Contained **buffer)
-  {
-    if (buffer == 0)
-      return;
-    delete[] buffer;
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Object_Sequence_IR_ContainedSeq::_TAO_Unbounded_Object_Sequence_IR_ContainedSeq (void)
-  {
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Object_Sequence_IR_ContainedSeq::_TAO_Unbounded_Object_Sequence_IR_ContainedSeq (CORBA::ULong maximum)
-    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Object_Sequence_IR_ContainedSeq::allocbuf (maximum))
-  {
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Object_Sequence_IR_ContainedSeq::_TAO_Unbounded_Object_Sequence_IR_ContainedSeq (CORBA::ULong maximum,
-    CORBA::ULong length,
-    IR_Contained* *value,
-    CORBA::Boolean release)
-  : TAO_Unbounded_Base_Sequence (maximum, length, value, release)
-  {
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Object_Sequence_IR_ContainedSeq::_TAO_Unbounded_Object_Sequence_IR_ContainedSeq(const _TAO_Unbounded_Object_Sequence_IR_ContainedSeq &rhs)
-    : TAO_Unbounded_Base_Sequence (rhs)
-  {
-    if (rhs.buffer_ != 0)
-    {
-      IR_Contained **tmp1 = _TAO_Unbounded_Object_Sequence_IR_ContainedSeq::allocbuf (this->maximum_);
-      IR_Contained ** const tmp2 = ACE_reinterpret_cast (IR_Contained ** ACE_CAST_CONST, rhs.buffer_);
-      
-      for (CORBA::ULong i = 0; i < rhs.length_; ++i)
-        tmp1[i] = IR_Contained::_duplicate (tmp2[i]);
-      
-      this->buffer_ = tmp1;
-    }
-    else
-    {
-      this->buffer_ = 0;
-    }
-  }
-  
-  ACE_INLINE _TAO_Unbounded_Object_Sequence_IR_ContainedSeq &
-  _TAO_Unbounded_Object_Sequence_IR_ContainedSeq::operator= (const _TAO_Unbounded_Object_Sequence_IR_ContainedSeq &rhs)
-  {
-    if (this == &rhs)
-      return *this;
-    
-    if (this->release_)
-    {
-      IR_Contained **tmp = ACE_reinterpret_cast (IR_Contained **, this->buffer_);
-      
-      for (CORBA::ULong i = 0; i < this->length_; ++i)
-      {
-        CORBA::release (tmp[i]);
-        tmp[i] = IR_Contained::_nil ();
-      }
-      if (this->maximum_ < rhs.maximum_)
-      {
-        _TAO_Unbounded_Object_Sequence_IR_ContainedSeq::freebuf (tmp);
-        this->buffer_ = _TAO_Unbounded_Object_Sequence_IR_ContainedSeq::allocbuf (rhs.maximum_);
-      }
-    }
-    else
-      this->buffer_ = _TAO_Unbounded_Object_Sequence_IR_ContainedSeq::allocbuf (rhs.maximum_);
-    
-    TAO_Unbounded_Base_Sequence::operator= (rhs);
-    
-    IR_Contained **tmp1 = ACE_reinterpret_cast (IR_Contained **, this->buffer_);
-    IR_Contained ** const tmp2 = ACE_reinterpret_cast (IR_Contained ** ACE_CAST_CONST, rhs.buffer_);
-    
-    for (CORBA::ULong i = 0; i < rhs.length_; ++i)
-      tmp1[i] = IR_Contained::_duplicate (tmp2[i]);
-    
-    return *this;
-  }
-  
-  ACE_INLINE TAO_Object_Manager<IR_Contained,IR_Contained_var>
-  _TAO_Unbounded_Object_Sequence_IR_ContainedSeq::operator[] (CORBA::ULong index) const
-  // read-write accessor
-  {
-    ACE_ASSERT (index < this->maximum_);
-    IR_Contained ** const tmp = ACE_reinterpret_cast (IR_Contained ** ACE_CAST_CONST, this->buffer_);
-    return TAO_Object_Manager<IR_Contained,IR_Contained_var> (tmp + index, this->release_);
-  }
-  
-  ACE_INLINE IR_Contained* *
-  _TAO_Unbounded_Object_Sequence_IR_ContainedSeq::get_buffer (CORBA::Boolean orphan)
-  {
-    IR_Contained **result = 0;
-    if (orphan == 0)
-    {
-      // We retain ownership.
-      if (this->buffer_ == 0)
-      {
-        result = _TAO_Unbounded_Object_Sequence_IR_ContainedSeq::allocbuf (this->maximum_);
-        this->buffer_ = result;
-        this->release_ = 1;
-      }
-      else
-      {
-        result = ACE_reinterpret_cast (IR_Contained**, this->buffer_);
-      }
-    }
-    else // if (orphan == 1)
-    {
-      if (this->release_ != 0)
-      {
-        // We set the state back to default and relinquish
-        // ownership.
-        result = ACE_reinterpret_cast(IR_Contained**,this->buffer_);
-        this->maximum_ = 0;
-        this->length_ = 0;
-        this->buffer_ = 0;
-        this->release_ = 0;
-      }
-    }
-    return result;
-  }
-  
-  ACE_INLINE const IR_Contained* *
-  _TAO_Unbounded_Object_Sequence_IR_ContainedSeq::get_buffer (void) const
-  {
-    return ACE_reinterpret_cast(const IR_Contained ** ACE_CAST_CONST, this->buffer_);
-  }
-  
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
-
-// *************************************************************
-// Inline operations for class IR_ContainedSeq_var
-// *************************************************************
-
-ACE_INLINE
-IR_ContainedSeq_var::IR_ContainedSeq_var (void) // default constructor
-  : ptr_ (0)
-{}
-
-ACE_INLINE
-IR_ContainedSeq_var::IR_ContainedSeq_var (IR_ContainedSeq *p)
-  : ptr_ (p)
-{}
-
-ACE_INLINE
-IR_ContainedSeq_var::IR_ContainedSeq_var (const ::IR_ContainedSeq_var &p) // copy constructor
-{
-  if (p.ptr_)
-    ACE_NEW (this->ptr_, ::IR_ContainedSeq (*p.ptr_));
-  else
-    this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_ContainedSeq_var::~IR_ContainedSeq_var (void) // destructor
-{
-  delete this->ptr_;
-}
-
-ACE_INLINE IR_ContainedSeq_var &
-IR_ContainedSeq_var::operator= (IR_ContainedSeq *p)
-{
-  delete this->ptr_;
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE IR_ContainedSeq_var &
-IR_ContainedSeq_var::operator= (const ::IR_ContainedSeq_var &p) // deep copy
-{
-  if (this != &p)
-    {
-      if (p.ptr_ == 0)
-        {
-          delete this->ptr_;
-          this->ptr_ = 0;
-        }
-      else
-        {
-          IR_ContainedSeq *deep_copy = 
-            new IR_ContainedSeq (*p.ptr_);
-          
-          if (deep_copy != 0)
-            {
-              IR_ContainedSeq *tmp = deep_copy;
-              deep_copy = this->ptr_;
-              this->ptr_ = tmp;
-              delete deep_copy;
-            }
-        }
-    }
-  
-  return *this;
-}
-
-ACE_INLINE const ::IR_ContainedSeq *
-IR_ContainedSeq_var::operator-> (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_ContainedSeq *
-IR_ContainedSeq_var::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE 
-IR_ContainedSeq_var::operator const ::IR_ContainedSeq &() const // cast
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE 
-IR_ContainedSeq_var::operator ::IR_ContainedSeq &() // cast 
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE 
-IR_ContainedSeq_var::operator ::IR_ContainedSeq &() const // cast 
-{
-  return *this->ptr_;
-}
-
-// variable-size types only
-ACE_INLINE
-IR_ContainedSeq_var::operator ::IR_ContainedSeq *&() // cast 
-{
-  return this->ptr_;
-}
-
-ACE_INLINE TAO_Object_Manager<IR_Contained, IR_Contained_var>
-IR_ContainedSeq_var::operator[] (CORBA::ULong index)
-{
-  return this->ptr_->operator[] (index);
-}
-
-ACE_INLINE const ::IR_ContainedSeq &
-IR_ContainedSeq_var::in (void) const
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE ::IR_ContainedSeq &
-IR_ContainedSeq_var::inout (void)
-{
-  return *this->ptr_;
-}
-
-// mapping for variable size 
-ACE_INLINE ::IR_ContainedSeq *&
-IR_ContainedSeq_var::out (void)
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_ContainedSeq *
-IR_ContainedSeq_var::_retn (void)
-{
-  ::IR_ContainedSeq *tmp = this->ptr_;
-  this->ptr_ = 0;
-  return tmp;
-}
-
-ACE_INLINE ::IR_ContainedSeq *
-IR_ContainedSeq_var::ptr (void) const
-{
-  return this->ptr_;
-}
-
-// *************************************************************
-// Inline operations for class IR_ContainedSeq_out
-// *************************************************************
-
-ACE_INLINE
-IR_ContainedSeq_out::IR_ContainedSeq_out (IR_ContainedSeq *&p)
-  : ptr_ (p)
-{
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_ContainedSeq_out::IR_ContainedSeq_out (IR_ContainedSeq_var &p) // constructor from _var
-  : ptr_ (p.out ())
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_ContainedSeq_out::IR_ContainedSeq_out (const ::IR_ContainedSeq_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (IR_ContainedSeq_out&, p).ptr_)
-{}
-
-ACE_INLINE ::IR_ContainedSeq_out &
-IR_ContainedSeq_out::operator= (const ::IR_ContainedSeq_out &p)
-{
-  this->ptr_ = ACE_const_cast (IR_ContainedSeq_out&, p).ptr_;
-  return *this;
-}
-
-ACE_INLINE ::IR_ContainedSeq_out &
-IR_ContainedSeq_out::operator= (IR_ContainedSeq *p)
-{
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE 
-IR_ContainedSeq_out::operator ::IR_ContainedSeq *&() // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_ContainedSeq *&
-IR_ContainedSeq_out::ptr (void) // ptr
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_ContainedSeq *
-IR_ContainedSeq_out::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE TAO_Object_Manager<IR_Contained, IR_Contained_var>
-IR_ContainedSeq_out::operator[] (CORBA::ULong index)
-{
-  return this->ptr_->operator[] (index);
-}
-
-// *************************************************************
-// Inline operations for class IR_StructMember_var
-// *************************************************************
-
-ACE_INLINE
-IR_StructMember_var::IR_StructMember_var (void) // default constructor
-  : ptr_ (0)
-{}
-
-ACE_INLINE
-IR_StructMember_var::IR_StructMember_var (IR_StructMember *p)
-  : ptr_ (p)
-{}
-
-ACE_INLINE
-IR_StructMember_var::IR_StructMember_var (const ::IR_StructMember_var &p) // copy constructor
-{
-  if (p.ptr_)
-    ACE_NEW (this->ptr_, ::IR_StructMember (*p.ptr_));
-  else
-    this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_StructMember_var::~IR_StructMember_var (void) // destructor
-{
-  delete this->ptr_;
-}
-
-ACE_INLINE IR_StructMember_var &
-IR_StructMember_var::operator= (IR_StructMember *p)
-{
-  delete this->ptr_;
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE ::IR_StructMember_var &
-IR_StructMember_var::operator= (const ::IR_StructMember_var &p)
-{
-  if (this != &p)
-    {
-      if (p.ptr_ == 0)
-        {
-          delete this->ptr_;
-          this->ptr_ = 0;
-        }
-      else
-        {
-          IR_StructMember *deep_copy = 
-            new IR_StructMember (*p.ptr_);
-          
-          if (deep_copy != 0)
-            {
-              IR_StructMember *tmp = deep_copy;
-              deep_copy = this->ptr_;
-              this->ptr_ = tmp;
-              delete deep_copy;
-            }
-        }
-    }
-  
-  return *this;
-}
-
-ACE_INLINE const ::IR_StructMember *
-IR_StructMember_var::operator-> (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_StructMember *
-IR_StructMember_var::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE
-IR_StructMember_var::operator const ::IR_StructMember &() const // cast
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE
-IR_StructMember_var::operator ::IR_StructMember &() // cast 
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE
-IR_StructMember_var::operator ::IR_StructMember &() const // cast 
-{
-  return *this->ptr_;
-}
-
-// variable-size types only
-ACE_INLINE
-IR_StructMember_var::operator ::IR_StructMember *&() // cast 
-{
-  return this->ptr_;
-}
-
-ACE_INLINE const ::IR_StructMember &
-IR_StructMember_var::in (void) const
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE ::IR_StructMember &
-IR_StructMember_var::inout (void)
-{
-  return *this->ptr_;
-}
-
-// mapping for variable size 
-ACE_INLINE ::IR_StructMember *&
-IR_StructMember_var::out (void)
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_StructMember *
-IR_StructMember_var::_retn (void)
-{
-  ::IR_StructMember *tmp = this->ptr_;
-  this->ptr_ = 0;
-  return tmp;
-}
-
-ACE_INLINE ::IR_StructMember *
-IR_StructMember_var::ptr (void) const
-{
-  return this->ptr_;
-}
-
-// *************************************************************
-// Inline operations for class IR_StructMember_out
-// *************************************************************
-
-ACE_INLINE
-IR_StructMember_out::IR_StructMember_out (::IR_StructMember *&p)
-  : ptr_ (p)
-{
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_StructMember_out::IR_StructMember_out (IR_StructMember_var &p) // constructor from _var
-  : ptr_ (p.out ())
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_StructMember_out::IR_StructMember_out (const ::IR_StructMember_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (IR_StructMember_out&, p).ptr_)
-{}
-
-ACE_INLINE IR_StructMember_out &
-IR_StructMember_out::operator= (const ::IR_StructMember_out &p)
-{
-  this->ptr_ = ACE_const_cast (IR_StructMember_out&, p).ptr_;
-  return *this;
-}
-
-ACE_INLINE IR_StructMember_out &
-IR_StructMember_out::operator= (IR_StructMember *p)
-{
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE 
-IR_StructMember_out::operator ::IR_StructMember *&() // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_StructMember *&
-IR_StructMember_out::ptr (void) // ptr
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_StructMember *
-IR_StructMember_out::operator-> (void)
-{
-  return this->ptr_;
-}
-
-
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  
-  // = Static operations.
-  ACE_INLINE IR_StructMember *
-  _TAO_Unbounded_Sequence_IR_StructMemberSeq::allocbuf (CORBA::ULong size)
-  // Allocate storage for the sequence.
-  {
-    IR_StructMember *retval = 0;
-    ACE_NEW_RETURN (retval, IR_StructMember[size], 0);
-    return retval;
-  }
-  
-  ACE_INLINE void _TAO_Unbounded_Sequence_IR_StructMemberSeq::freebuf (IR_StructMember *buffer)
-  // Free the sequence.
-  {
-    delete [] buffer;
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Sequence_IR_StructMemberSeq::_TAO_Unbounded_Sequence_IR_StructMemberSeq (void) // Default constructor.
-  {
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Sequence_IR_StructMemberSeq::_TAO_Unbounded_Sequence_IR_StructMemberSeq (CORBA::ULong maximum) // Constructor using a maximum length value.
-    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Sequence_IR_StructMemberSeq::allocbuf (maximum))
-  {
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Sequence_IR_StructMemberSeq::_TAO_Unbounded_Sequence_IR_StructMemberSeq (CORBA::ULong maximum,
-    CORBA::ULong length,
-    IR_StructMember *data,
-    CORBA::Boolean release)
-  : TAO_Unbounded_Base_Sequence (maximum, length, data, release)
-  {
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Sequence_IR_StructMemberSeq::_TAO_Unbounded_Sequence_IR_StructMemberSeq (const _TAO_Unbounded_Sequence_IR_StructMemberSeq &rhs)
-  // Copy constructor.
-    : TAO_Unbounded_Base_Sequence (rhs)
-  {
-    if (rhs.buffer_ != 0)
-    {
-      IR_StructMember *tmp1 = _TAO_Unbounded_Sequence_IR_StructMemberSeq::allocbuf (this->maximum_);
-      IR_StructMember * const tmp2 = ACE_reinterpret_cast (IR_StructMember * ACE_CAST_CONST, rhs.buffer_);
-      
-      for (CORBA::ULong i = 0; i < this->length_; ++i)
-        tmp1[i] = tmp2[i];
-      
-      this->buffer_ = tmp1;
-    }
-    else
-    {
-      this->buffer_ = 0;
-    }
-  }
-  
-  ACE_INLINE _TAO_Unbounded_Sequence_IR_StructMemberSeq &
-  _TAO_Unbounded_Sequence_IR_StructMemberSeq::operator= (const _TAO_Unbounded_Sequence_IR_StructMemberSeq &rhs)
-  // Assignment operator.
-  {
-    if (this == &rhs)
-      return *this;
-    
-    if (this->release_)
-    {
-      if (this->maximum_ < rhs.maximum_)
-      {
-        // free the old buffer
-        IR_StructMember *tmp = ACE_reinterpret_cast (IR_StructMember *, this->buffer_);
-        _TAO_Unbounded_Sequence_IR_StructMemberSeq::freebuf (tmp);
-        this->buffer_ = _TAO_Unbounded_Sequence_IR_StructMemberSeq::allocbuf (rhs.maximum_);
-      }
-    }
-    else
-      this->buffer_ = _TAO_Unbounded_Sequence_IR_StructMemberSeq::allocbuf (rhs.maximum_);
-    
-    TAO_Unbounded_Base_Sequence::operator= (rhs);
-    
-    IR_StructMember *tmp1 = ACE_reinterpret_cast (IR_StructMember *, this->buffer_);
-    IR_StructMember * const tmp2 = ACE_reinterpret_cast (IR_StructMember * ACE_CAST_CONST, rhs.buffer_);
-    
-    for (CORBA::ULong i = 0; i < this->length_; ++i)
-      tmp1[i] = tmp2[i];
-    
-    return *this;
-  }
-  
-  // = Accessors.
-  ACE_INLINE IR_StructMember &
-  _TAO_Unbounded_Sequence_IR_StructMemberSeq::operator[] (CORBA::ULong i)
-  // operator []
-  {
-    ACE_ASSERT (i < this->maximum_);
-    IR_StructMember* tmp = ACE_reinterpret_cast(IR_StructMember*,this->buffer_);
-    return tmp[i];
-  }
-  
-  ACE_INLINE const IR_StructMember &
-  _TAO_Unbounded_Sequence_IR_StructMemberSeq::operator[] (CORBA::ULong i) const
-  // operator []
-  {
-    ACE_ASSERT (i < this->maximum_);
-    IR_StructMember * const tmp = ACE_reinterpret_cast (IR_StructMember* ACE_CAST_CONST, this->buffer_);
-    return tmp[i];
-  }
-  
-  // Implement the TAO_Base_Sequence methods (see Sequence.h)
-  
-  ACE_INLINE IR_StructMember *
-  _TAO_Unbounded_Sequence_IR_StructMemberSeq::get_buffer (CORBA::Boolean orphan)
-  {
-    IR_StructMember *result = 0;
-    if (orphan == 0)
-    {
-      // We retain ownership.
-      if (this->buffer_ == 0)
-      {
-        result = _TAO_Unbounded_Sequence_IR_StructMemberSeq::allocbuf (this->length_);
-        this->buffer_ = result;
-        this->release_ = 1;
-      }
-      else
-      {
-        result = ACE_reinterpret_cast (IR_StructMember*, this->buffer_);
-      }
-    }
-    else // if (orphan == 1)
-    {
-      if (this->release_ != 0)
-      {
-        // We set the state back to default and relinquish
-        // ownership.
-        result = ACE_reinterpret_cast(IR_StructMember*,this->buffer_);
-        this->maximum_ = 0;
-        this->length_ = 0;
-        this->buffer_ = 0;
-        this->release_ = 0;
-      }
-    }
-    return result;
-  }
-  
-  ACE_INLINE const IR_StructMember *
-  _TAO_Unbounded_Sequence_IR_StructMemberSeq::get_buffer (void) const
-  {
-    return ACE_reinterpret_cast(const IR_StructMember * ACE_CAST_CONST, this->buffer_);
-  }
-  
-  ACE_INLINE void
-  _TAO_Unbounded_Sequence_IR_StructMemberSeq::replace (CORBA::ULong max,
-  CORBA::ULong length,
-  IR_StructMember *data,
-  CORBA::Boolean release)
-  {
-    this->maximum_ = max;
-    this->length_ = length;
-    if (this->buffer_ && this->release_ == 1)
-    {
-      IR_StructMember *tmp = ACE_reinterpret_cast(IR_StructMember*,this->buffer_);
-      _TAO_Unbounded_Sequence_IR_StructMemberSeq::freebuf (tmp);
-    }
-    this->buffer_ = data;
-    this->release_ = release;
-  }
-  
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
-
-// *************************************************************
-// Inline operations for class IR_StructMemberSeq_var
-// *************************************************************
-
-ACE_INLINE
-IR_StructMemberSeq_var::IR_StructMemberSeq_var (void) // default constructor
-  : ptr_ (0)
-{}
-
-ACE_INLINE
-IR_StructMemberSeq_var::IR_StructMemberSeq_var (IR_StructMemberSeq *p)
-  : ptr_ (p)
-{}
-
-ACE_INLINE
-IR_StructMemberSeq_var::IR_StructMemberSeq_var (const ::IR_StructMemberSeq_var &p) // copy constructor
-{
-  if (p.ptr_)
-    ACE_NEW (this->ptr_, ::IR_StructMemberSeq (*p.ptr_));
-  else
-    this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_StructMemberSeq_var::~IR_StructMemberSeq_var (void) // destructor
-{
-  delete this->ptr_;
-}
-
-ACE_INLINE IR_StructMemberSeq_var &
-IR_StructMemberSeq_var::operator= (IR_StructMemberSeq *p)
-{
-  delete this->ptr_;
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE IR_StructMemberSeq_var &
-IR_StructMemberSeq_var::operator= (const ::IR_StructMemberSeq_var &p) // deep copy
-{
-  if (this != &p)
-    {
-      if (p.ptr_ == 0)
-        {
-          delete this->ptr_;
-          this->ptr_ = 0;
-        }
-      else
-        {
-          IR_StructMemberSeq *deep_copy = 
-            new IR_StructMemberSeq (*p.ptr_);
-          
-          if (deep_copy != 0)
-            {
-              IR_StructMemberSeq *tmp = deep_copy;
-              deep_copy = this->ptr_;
-              this->ptr_ = tmp;
-              delete deep_copy;
-            }
-        }
-    }
-  
-  return *this;
-}
-
-ACE_INLINE const ::IR_StructMemberSeq *
-IR_StructMemberSeq_var::operator-> (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_StructMemberSeq *
-IR_StructMemberSeq_var::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE 
-IR_StructMemberSeq_var::operator const ::IR_StructMemberSeq &() const // cast
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE 
-IR_StructMemberSeq_var::operator ::IR_StructMemberSeq &() // cast 
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE 
-IR_StructMemberSeq_var::operator ::IR_StructMemberSeq &() const // cast 
-{
-  return *this->ptr_;
-}
-
-// variable-size types only
-ACE_INLINE
-IR_StructMemberSeq_var::operator ::IR_StructMemberSeq *&() // cast 
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_StructMember &
-IR_StructMemberSeq_var::operator[] (CORBA::ULong index)
-{
-  return this->ptr_->operator[] (index);
-}
-
-ACE_INLINE const IR_StructMember &
-IR_StructMemberSeq_var::operator[] (CORBA::ULong index) const
-{
-  return ACE_const_cast (const IR_StructMember &, this->ptr_->operator[] (index));
-}
-
-ACE_INLINE const ::IR_StructMemberSeq &
-IR_StructMemberSeq_var::in (void) const
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE ::IR_StructMemberSeq &
-IR_StructMemberSeq_var::inout (void)
-{
-  return *this->ptr_;
-}
-
-// mapping for variable size 
-ACE_INLINE ::IR_StructMemberSeq *&
-IR_StructMemberSeq_var::out (void)
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_StructMemberSeq *
-IR_StructMemberSeq_var::_retn (void)
-{
-  ::IR_StructMemberSeq *tmp = this->ptr_;
-  this->ptr_ = 0;
-  return tmp;
-}
-
-ACE_INLINE ::IR_StructMemberSeq *
-IR_StructMemberSeq_var::ptr (void) const
-{
-  return this->ptr_;
-}
-
-// *************************************************************
-// Inline operations for class IR_StructMemberSeq_out
-// *************************************************************
-
-ACE_INLINE
-IR_StructMemberSeq_out::IR_StructMemberSeq_out (IR_StructMemberSeq *&p)
-  : ptr_ (p)
-{
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_StructMemberSeq_out::IR_StructMemberSeq_out (IR_StructMemberSeq_var &p) // constructor from _var
-  : ptr_ (p.out ())
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_StructMemberSeq_out::IR_StructMemberSeq_out (const ::IR_StructMemberSeq_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (IR_StructMemberSeq_out&, p).ptr_)
-{}
-
-ACE_INLINE ::IR_StructMemberSeq_out &
-IR_StructMemberSeq_out::operator= (const ::IR_StructMemberSeq_out &p)
-{
-  this->ptr_ = ACE_const_cast (IR_StructMemberSeq_out&, p).ptr_;
-  return *this;
-}
-
-ACE_INLINE ::IR_StructMemberSeq_out &
-IR_StructMemberSeq_out::operator= (IR_StructMemberSeq *p)
-{
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE 
-IR_StructMemberSeq_out::operator ::IR_StructMemberSeq *&() // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_StructMemberSeq *&
-IR_StructMemberSeq_out::ptr (void) // ptr
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_StructMemberSeq *
-IR_StructMemberSeq_out::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_StructMember &
-IR_StructMemberSeq_out::operator[] (CORBA::ULong index)
-{
-  return this->ptr_->operator[] (index);
-}
-
-// *************************************************************
-// Inline operations for class IR_Initializer_var
-// *************************************************************
-
-ACE_INLINE
-IR_Initializer_var::IR_Initializer_var (void) // default constructor
-  : ptr_ (0)
-{}
-
-ACE_INLINE
-IR_Initializer_var::IR_Initializer_var (IR_Initializer *p)
-  : ptr_ (p)
-{}
-
-ACE_INLINE
-IR_Initializer_var::IR_Initializer_var (const ::IR_Initializer_var &p) // copy constructor
-{
-  if (p.ptr_)
-    ACE_NEW (this->ptr_, ::IR_Initializer (*p.ptr_));
-  else
-    this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_Initializer_var::~IR_Initializer_var (void) // destructor
-{
-  delete this->ptr_;
-}
-
-ACE_INLINE IR_Initializer_var &
-IR_Initializer_var::operator= (IR_Initializer *p)
-{
-  delete this->ptr_;
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE ::IR_Initializer_var &
-IR_Initializer_var::operator= (const ::IR_Initializer_var &p)
-{
-  if (this != &p)
-    {
-      if (p.ptr_ == 0)
-        {
-          delete this->ptr_;
-          this->ptr_ = 0;
-        }
-      else
-        {
-          IR_Initializer *deep_copy = 
-            new IR_Initializer (*p.ptr_);
-          
-          if (deep_copy != 0)
-            {
-              IR_Initializer *tmp = deep_copy;
-              deep_copy = this->ptr_;
-              this->ptr_ = tmp;
-              delete deep_copy;
-            }
-        }
-    }
-  
-  return *this;
-}
-
-ACE_INLINE const ::IR_Initializer *
-IR_Initializer_var::operator-> (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_Initializer *
-IR_Initializer_var::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE
-IR_Initializer_var::operator const ::IR_Initializer &() const // cast
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE
-IR_Initializer_var::operator ::IR_Initializer &() // cast 
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE
-IR_Initializer_var::operator ::IR_Initializer &() const // cast 
-{
-  return *this->ptr_;
-}
-
-// variable-size types only
-ACE_INLINE
-IR_Initializer_var::operator ::IR_Initializer *&() // cast 
-{
-  return this->ptr_;
-}
-
-ACE_INLINE const ::IR_Initializer &
-IR_Initializer_var::in (void) const
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE ::IR_Initializer &
-IR_Initializer_var::inout (void)
-{
-  return *this->ptr_;
-}
-
-// mapping for variable size 
-ACE_INLINE ::IR_Initializer *&
-IR_Initializer_var::out (void)
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_Initializer *
-IR_Initializer_var::_retn (void)
-{
-  ::IR_Initializer *tmp = this->ptr_;
-  this->ptr_ = 0;
-  return tmp;
-}
-
-ACE_INLINE ::IR_Initializer *
-IR_Initializer_var::ptr (void) const
-{
-  return this->ptr_;
-}
-
-// *************************************************************
-// Inline operations for class IR_Initializer_out
-// *************************************************************
-
-ACE_INLINE
-IR_Initializer_out::IR_Initializer_out (::IR_Initializer *&p)
-  : ptr_ (p)
-{
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_Initializer_out::IR_Initializer_out (IR_Initializer_var &p) // constructor from _var
-  : ptr_ (p.out ())
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_Initializer_out::IR_Initializer_out (const ::IR_Initializer_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (IR_Initializer_out&, p).ptr_)
-{}
-
-ACE_INLINE IR_Initializer_out &
-IR_Initializer_out::operator= (const ::IR_Initializer_out &p)
-{
-  this->ptr_ = ACE_const_cast (IR_Initializer_out&, p).ptr_;
-  return *this;
-}
-
-ACE_INLINE IR_Initializer_out &
-IR_Initializer_out::operator= (IR_Initializer *p)
-{
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE 
-IR_Initializer_out::operator ::IR_Initializer *&() // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_Initializer *&
-IR_Initializer_out::ptr (void) // ptr
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_Initializer *
-IR_Initializer_out::operator-> (void)
-{
-  return this->ptr_;
-}
-
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  
-  // = Static operations.
-  ACE_INLINE IR_Initializer *
-  _TAO_Unbounded_Sequence_IR_InitializerSeq::allocbuf (CORBA::ULong size)
-  // Allocate storage for the sequence.
-  {
-    IR_Initializer *retval = 0;
-    ACE_NEW_RETURN (retval, IR_Initializer[size], 0);
-    return retval;
-  }
-  
-  ACE_INLINE void _TAO_Unbounded_Sequence_IR_InitializerSeq::freebuf (IR_Initializer *buffer)
-  // Free the sequence.
-  {
-    delete [] buffer;
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Sequence_IR_InitializerSeq::_TAO_Unbounded_Sequence_IR_InitializerSeq (void) // Default constructor.
-  {
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Sequence_IR_InitializerSeq::_TAO_Unbounded_Sequence_IR_InitializerSeq (CORBA::ULong maximum) // Constructor using a maximum length value.
-    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Sequence_IR_InitializerSeq::allocbuf (maximum))
-  {
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Sequence_IR_InitializerSeq::_TAO_Unbounded_Sequence_IR_InitializerSeq (CORBA::ULong maximum,
-    CORBA::ULong length,
-    IR_Initializer *data,
-    CORBA::Boolean release)
-  : TAO_Unbounded_Base_Sequence (maximum, length, data, release)
-  {
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Sequence_IR_InitializerSeq::_TAO_Unbounded_Sequence_IR_InitializerSeq (const _TAO_Unbounded_Sequence_IR_InitializerSeq &rhs)
-  // Copy constructor.
-    : TAO_Unbounded_Base_Sequence (rhs)
-  {
-    if (rhs.buffer_ != 0)
-    {
-      IR_Initializer *tmp1 = _TAO_Unbounded_Sequence_IR_InitializerSeq::allocbuf (this->maximum_);
-      IR_Initializer * const tmp2 = ACE_reinterpret_cast (IR_Initializer * ACE_CAST_CONST, rhs.buffer_);
-      
-      for (CORBA::ULong i = 0; i < this->length_; ++i)
-        tmp1[i] = tmp2[i];
-      
-      this->buffer_ = tmp1;
-    }
-    else
-    {
-      this->buffer_ = 0;
-    }
-  }
-  
-  ACE_INLINE _TAO_Unbounded_Sequence_IR_InitializerSeq &
-  _TAO_Unbounded_Sequence_IR_InitializerSeq::operator= (const _TAO_Unbounded_Sequence_IR_InitializerSeq &rhs)
-  // Assignment operator.
-  {
-    if (this == &rhs)
-      return *this;
-    
-    if (this->release_)
-    {
-      if (this->maximum_ < rhs.maximum_)
-      {
-        // free the old buffer
-        IR_Initializer *tmp = ACE_reinterpret_cast (IR_Initializer *, this->buffer_);
-        _TAO_Unbounded_Sequence_IR_InitializerSeq::freebuf (tmp);
-        this->buffer_ = _TAO_Unbounded_Sequence_IR_InitializerSeq::allocbuf (rhs.maximum_);
-      }
-    }
-    else
-      this->buffer_ = _TAO_Unbounded_Sequence_IR_InitializerSeq::allocbuf (rhs.maximum_);
-    
-    TAO_Unbounded_Base_Sequence::operator= (rhs);
-    
-    IR_Initializer *tmp1 = ACE_reinterpret_cast (IR_Initializer *, this->buffer_);
-    IR_Initializer * const tmp2 = ACE_reinterpret_cast (IR_Initializer * ACE_CAST_CONST, rhs.buffer_);
-    
-    for (CORBA::ULong i = 0; i < this->length_; ++i)
-      tmp1[i] = tmp2[i];
-    
-    return *this;
-  }
-  
-  // = Accessors.
-  ACE_INLINE IR_Initializer &
-  _TAO_Unbounded_Sequence_IR_InitializerSeq::operator[] (CORBA::ULong i)
-  // operator []
-  {
-    ACE_ASSERT (i < this->maximum_);
-    IR_Initializer* tmp = ACE_reinterpret_cast(IR_Initializer*,this->buffer_);
-    return tmp[i];
-  }
-  
-  ACE_INLINE const IR_Initializer &
-  _TAO_Unbounded_Sequence_IR_InitializerSeq::operator[] (CORBA::ULong i) const
-  // operator []
-  {
-    ACE_ASSERT (i < this->maximum_);
-    IR_Initializer * const tmp = ACE_reinterpret_cast (IR_Initializer* ACE_CAST_CONST, this->buffer_);
-    return tmp[i];
-  }
-  
-  // Implement the TAO_Base_Sequence methods (see Sequence.h)
-  
-  ACE_INLINE IR_Initializer *
-  _TAO_Unbounded_Sequence_IR_InitializerSeq::get_buffer (CORBA::Boolean orphan)
-  {
-    IR_Initializer *result = 0;
-    if (orphan == 0)
-    {
-      // We retain ownership.
-      if (this->buffer_ == 0)
-      {
-        result = _TAO_Unbounded_Sequence_IR_InitializerSeq::allocbuf (this->length_);
-        this->buffer_ = result;
-        this->release_ = 1;
-      }
-      else
-      {
-        result = ACE_reinterpret_cast (IR_Initializer*, this->buffer_);
-      }
-    }
-    else // if (orphan == 1)
-    {
-      if (this->release_ != 0)
-      {
-        // We set the state back to default and relinquish
-        // ownership.
-        result = ACE_reinterpret_cast(IR_Initializer*,this->buffer_);
-        this->maximum_ = 0;
-        this->length_ = 0;
-        this->buffer_ = 0;
-        this->release_ = 0;
-      }
-    }
-    return result;
-  }
-  
-  ACE_INLINE const IR_Initializer *
-  _TAO_Unbounded_Sequence_IR_InitializerSeq::get_buffer (void) const
-  {
-    return ACE_reinterpret_cast(const IR_Initializer * ACE_CAST_CONST, this->buffer_);
-  }
-  
-  ACE_INLINE void
-  _TAO_Unbounded_Sequence_IR_InitializerSeq::replace (CORBA::ULong max,
-  CORBA::ULong length,
-  IR_Initializer *data,
-  CORBA::Boolean release)
-  {
-    this->maximum_ = max;
-    this->length_ = length;
-    if (this->buffer_ && this->release_ == 1)
-    {
-      IR_Initializer *tmp = ACE_reinterpret_cast(IR_Initializer*,this->buffer_);
-      _TAO_Unbounded_Sequence_IR_InitializerSeq::freebuf (tmp);
-    }
-    this->buffer_ = data;
-    this->release_ = release;
-  }
-  
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
-
-// *************************************************************
-// Inline operations for class IR_InitializerSeq_var
-// *************************************************************
-
-ACE_INLINE
-IR_InitializerSeq_var::IR_InitializerSeq_var (void) // default constructor
-  : ptr_ (0)
-{}
-
-ACE_INLINE
-IR_InitializerSeq_var::IR_InitializerSeq_var (IR_InitializerSeq *p)
-  : ptr_ (p)
-{}
-
-ACE_INLINE
-IR_InitializerSeq_var::IR_InitializerSeq_var (const ::IR_InitializerSeq_var &p) // copy constructor
-{
-  if (p.ptr_)
-    ACE_NEW (this->ptr_, ::IR_InitializerSeq (*p.ptr_));
-  else
-    this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_InitializerSeq_var::~IR_InitializerSeq_var (void) // destructor
-{
-  delete this->ptr_;
-}
-
-ACE_INLINE IR_InitializerSeq_var &
-IR_InitializerSeq_var::operator= (IR_InitializerSeq *p)
-{
-  delete this->ptr_;
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE IR_InitializerSeq_var &
-IR_InitializerSeq_var::operator= (const ::IR_InitializerSeq_var &p) // deep copy
-{
-  if (this != &p)
-    {
-      if (p.ptr_ == 0)
-        {
-          delete this->ptr_;
-          this->ptr_ = 0;
-        }
-      else
-        {
-          IR_InitializerSeq *deep_copy = 
-            new IR_InitializerSeq (*p.ptr_);
-          
-          if (deep_copy != 0)
-            {
-              IR_InitializerSeq *tmp = deep_copy;
-              deep_copy = this->ptr_;
-              this->ptr_ = tmp;
-              delete deep_copy;
-            }
-        }
-    }
-  
-  return *this;
-}
-
-ACE_INLINE const ::IR_InitializerSeq *
-IR_InitializerSeq_var::operator-> (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_InitializerSeq *
-IR_InitializerSeq_var::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE 
-IR_InitializerSeq_var::operator const ::IR_InitializerSeq &() const // cast
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE 
-IR_InitializerSeq_var::operator ::IR_InitializerSeq &() // cast 
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE 
-IR_InitializerSeq_var::operator ::IR_InitializerSeq &() const // cast 
-{
-  return *this->ptr_;
-}
-
-// variable-size types only
-ACE_INLINE
-IR_InitializerSeq_var::operator ::IR_InitializerSeq *&() // cast 
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_Initializer &
-IR_InitializerSeq_var::operator[] (CORBA::ULong index)
-{
-  return this->ptr_->operator[] (index);
-}
-
-ACE_INLINE const IR_Initializer &
-IR_InitializerSeq_var::operator[] (CORBA::ULong index) const
-{
-  return ACE_const_cast (const IR_Initializer &, this->ptr_->operator[] (index));
-}
-
-ACE_INLINE const ::IR_InitializerSeq &
-IR_InitializerSeq_var::in (void) const
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE ::IR_InitializerSeq &
-IR_InitializerSeq_var::inout (void)
-{
-  return *this->ptr_;
-}
-
-// mapping for variable size 
-ACE_INLINE ::IR_InitializerSeq *&
-IR_InitializerSeq_var::out (void)
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_InitializerSeq *
-IR_InitializerSeq_var::_retn (void)
-{
-  ::IR_InitializerSeq *tmp = this->ptr_;
-  this->ptr_ = 0;
-  return tmp;
-}
-
-ACE_INLINE ::IR_InitializerSeq *
-IR_InitializerSeq_var::ptr (void) const
-{
-  return this->ptr_;
-}
-
-// *************************************************************
-// Inline operations for class IR_InitializerSeq_out
-// *************************************************************
-
-ACE_INLINE
-IR_InitializerSeq_out::IR_InitializerSeq_out (IR_InitializerSeq *&p)
-  : ptr_ (p)
-{
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_InitializerSeq_out::IR_InitializerSeq_out (IR_InitializerSeq_var &p) // constructor from _var
-  : ptr_ (p.out ())
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_InitializerSeq_out::IR_InitializerSeq_out (const ::IR_InitializerSeq_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (IR_InitializerSeq_out&, p).ptr_)
-{}
-
-ACE_INLINE ::IR_InitializerSeq_out &
-IR_InitializerSeq_out::operator= (const ::IR_InitializerSeq_out &p)
-{
-  this->ptr_ = ACE_const_cast (IR_InitializerSeq_out&, p).ptr_;
-  return *this;
-}
-
-ACE_INLINE ::IR_InitializerSeq_out &
-IR_InitializerSeq_out::operator= (IR_InitializerSeq *p)
-{
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE 
-IR_InitializerSeq_out::operator ::IR_InitializerSeq *&() // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_InitializerSeq *&
-IR_InitializerSeq_out::ptr (void) // ptr
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_InitializerSeq *
-IR_InitializerSeq_out::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_Initializer &
-IR_InitializerSeq_out::operator[] (CORBA::ULong index)
-{
-  return this->ptr_->operator[] (index);
-}
-
-// *************************************************************
-// Inline operations for class IR_UnionMember_var
-// *************************************************************
-
-ACE_INLINE
-IR_UnionMember_var::IR_UnionMember_var (void) // default constructor
-  : ptr_ (0)
-{}
-
-ACE_INLINE
-IR_UnionMember_var::IR_UnionMember_var (IR_UnionMember *p)
-  : ptr_ (p)
-{}
-
-ACE_INLINE
-IR_UnionMember_var::IR_UnionMember_var (const ::IR_UnionMember_var &p) // copy constructor
-{
-  if (p.ptr_)
-    ACE_NEW (this->ptr_, ::IR_UnionMember (*p.ptr_));
-  else
-    this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_UnionMember_var::~IR_UnionMember_var (void) // destructor
-{
-  delete this->ptr_;
-}
-
-ACE_INLINE IR_UnionMember_var &
-IR_UnionMember_var::operator= (IR_UnionMember *p)
-{
-  delete this->ptr_;
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE ::IR_UnionMember_var &
-IR_UnionMember_var::operator= (const ::IR_UnionMember_var &p)
-{
-  if (this != &p)
-    {
-      if (p.ptr_ == 0)
-        {
-          delete this->ptr_;
-          this->ptr_ = 0;
-        }
-      else
-        {
-          IR_UnionMember *deep_copy = 
-            new IR_UnionMember (*p.ptr_);
-          
-          if (deep_copy != 0)
-            {
-              IR_UnionMember *tmp = deep_copy;
-              deep_copy = this->ptr_;
-              this->ptr_ = tmp;
-              delete deep_copy;
-            }
-        }
-    }
-  
-  return *this;
-}
-
-ACE_INLINE const ::IR_UnionMember *
-IR_UnionMember_var::operator-> (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_UnionMember *
-IR_UnionMember_var::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE
-IR_UnionMember_var::operator const ::IR_UnionMember &() const // cast
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE
-IR_UnionMember_var::operator ::IR_UnionMember &() // cast 
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE
-IR_UnionMember_var::operator ::IR_UnionMember &() const // cast 
-{
-  return *this->ptr_;
-}
-
-// variable-size types only
-ACE_INLINE
-IR_UnionMember_var::operator ::IR_UnionMember *&() // cast 
-{
-  return this->ptr_;
-}
-
-ACE_INLINE const ::IR_UnionMember &
-IR_UnionMember_var::in (void) const
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE ::IR_UnionMember &
-IR_UnionMember_var::inout (void)
-{
-  return *this->ptr_;
-}
-
-// mapping for variable size 
-ACE_INLINE ::IR_UnionMember *&
-IR_UnionMember_var::out (void)
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_UnionMember *
-IR_UnionMember_var::_retn (void)
-{
-  ::IR_UnionMember *tmp = this->ptr_;
-  this->ptr_ = 0;
-  return tmp;
-}
-
-ACE_INLINE ::IR_UnionMember *
-IR_UnionMember_var::ptr (void) const
-{
-  return this->ptr_;
-}
-
-// *************************************************************
-// Inline operations for class IR_UnionMember_out
-// *************************************************************
-
-ACE_INLINE
-IR_UnionMember_out::IR_UnionMember_out (::IR_UnionMember *&p)
-  : ptr_ (p)
-{
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_UnionMember_out::IR_UnionMember_out (IR_UnionMember_var &p) // constructor from _var
-  : ptr_ (p.out ())
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_UnionMember_out::IR_UnionMember_out (const ::IR_UnionMember_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (IR_UnionMember_out&, p).ptr_)
-{}
-
-ACE_INLINE IR_UnionMember_out &
-IR_UnionMember_out::operator= (const ::IR_UnionMember_out &p)
-{
-  this->ptr_ = ACE_const_cast (IR_UnionMember_out&, p).ptr_;
-  return *this;
-}
-
-ACE_INLINE IR_UnionMember_out &
-IR_UnionMember_out::operator= (IR_UnionMember *p)
-{
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE 
-IR_UnionMember_out::operator ::IR_UnionMember *&() // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_UnionMember *&
-IR_UnionMember_out::ptr (void) // ptr
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_UnionMember *
-IR_UnionMember_out::operator-> (void)
-{
-  return this->ptr_;
-}
-
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  
-  // = Static operations.
-  ACE_INLINE IR_UnionMember *
-  _TAO_Unbounded_Sequence_IR_UnionMemberSeq::allocbuf (CORBA::ULong size)
-  // Allocate storage for the sequence.
-  {
-    IR_UnionMember *retval = 0;
-    ACE_NEW_RETURN (retval, IR_UnionMember[size], 0);
-    return retval;
-  }
-  
-  ACE_INLINE void _TAO_Unbounded_Sequence_IR_UnionMemberSeq::freebuf (IR_UnionMember *buffer)
-  // Free the sequence.
-  {
-    delete [] buffer;
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Sequence_IR_UnionMemberSeq::_TAO_Unbounded_Sequence_IR_UnionMemberSeq (void) // Default constructor.
-  {
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Sequence_IR_UnionMemberSeq::_TAO_Unbounded_Sequence_IR_UnionMemberSeq (CORBA::ULong maximum) // Constructor using a maximum length value.
-    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Sequence_IR_UnionMemberSeq::allocbuf (maximum))
-  {
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Sequence_IR_UnionMemberSeq::_TAO_Unbounded_Sequence_IR_UnionMemberSeq (CORBA::ULong maximum,
-    CORBA::ULong length,
-    IR_UnionMember *data,
-    CORBA::Boolean release)
-  : TAO_Unbounded_Base_Sequence (maximum, length, data, release)
-  {
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Sequence_IR_UnionMemberSeq::_TAO_Unbounded_Sequence_IR_UnionMemberSeq (const _TAO_Unbounded_Sequence_IR_UnionMemberSeq &rhs)
-  // Copy constructor.
-    : TAO_Unbounded_Base_Sequence (rhs)
-  {
-    if (rhs.buffer_ != 0)
-    {
-      IR_UnionMember *tmp1 = _TAO_Unbounded_Sequence_IR_UnionMemberSeq::allocbuf (this->maximum_);
-      IR_UnionMember * const tmp2 = ACE_reinterpret_cast (IR_UnionMember * ACE_CAST_CONST, rhs.buffer_);
-      
-      for (CORBA::ULong i = 0; i < this->length_; ++i)
-        tmp1[i] = tmp2[i];
-      
-      this->buffer_ = tmp1;
-    }
-    else
-    {
-      this->buffer_ = 0;
-    }
-  }
-  
-  ACE_INLINE _TAO_Unbounded_Sequence_IR_UnionMemberSeq &
-  _TAO_Unbounded_Sequence_IR_UnionMemberSeq::operator= (const _TAO_Unbounded_Sequence_IR_UnionMemberSeq &rhs)
-  // Assignment operator.
-  {
-    if (this == &rhs)
-      return *this;
-    
-    if (this->release_)
-    {
-      if (this->maximum_ < rhs.maximum_)
-      {
-        // free the old buffer
-        IR_UnionMember *tmp = ACE_reinterpret_cast (IR_UnionMember *, this->buffer_);
-        _TAO_Unbounded_Sequence_IR_UnionMemberSeq::freebuf (tmp);
-        this->buffer_ = _TAO_Unbounded_Sequence_IR_UnionMemberSeq::allocbuf (rhs.maximum_);
-      }
-    }
-    else
-      this->buffer_ = _TAO_Unbounded_Sequence_IR_UnionMemberSeq::allocbuf (rhs.maximum_);
-    
-    TAO_Unbounded_Base_Sequence::operator= (rhs);
-    
-    IR_UnionMember *tmp1 = ACE_reinterpret_cast (IR_UnionMember *, this->buffer_);
-    IR_UnionMember * const tmp2 = ACE_reinterpret_cast (IR_UnionMember * ACE_CAST_CONST, rhs.buffer_);
-    
-    for (CORBA::ULong i = 0; i < this->length_; ++i)
-      tmp1[i] = tmp2[i];
-    
-    return *this;
-  }
-  
-  // = Accessors.
-  ACE_INLINE IR_UnionMember &
-  _TAO_Unbounded_Sequence_IR_UnionMemberSeq::operator[] (CORBA::ULong i)
-  // operator []
-  {
-    ACE_ASSERT (i < this->maximum_);
-    IR_UnionMember* tmp = ACE_reinterpret_cast(IR_UnionMember*,this->buffer_);
-    return tmp[i];
-  }
-  
-  ACE_INLINE const IR_UnionMember &
-  _TAO_Unbounded_Sequence_IR_UnionMemberSeq::operator[] (CORBA::ULong i) const
-  // operator []
-  {
-    ACE_ASSERT (i < this->maximum_);
-    IR_UnionMember * const tmp = ACE_reinterpret_cast (IR_UnionMember* ACE_CAST_CONST, this->buffer_);
-    return tmp[i];
-  }
-  
-  // Implement the TAO_Base_Sequence methods (see Sequence.h)
-  
-  ACE_INLINE IR_UnionMember *
-  _TAO_Unbounded_Sequence_IR_UnionMemberSeq::get_buffer (CORBA::Boolean orphan)
-  {
-    IR_UnionMember *result = 0;
-    if (orphan == 0)
-    {
-      // We retain ownership.
-      if (this->buffer_ == 0)
-      {
-        result = _TAO_Unbounded_Sequence_IR_UnionMemberSeq::allocbuf (this->length_);
-        this->buffer_ = result;
-        this->release_ = 1;
-      }
-      else
-      {
-        result = ACE_reinterpret_cast (IR_UnionMember*, this->buffer_);
-      }
-    }
-    else // if (orphan == 1)
-    {
-      if (this->release_ != 0)
-      {
-        // We set the state back to default and relinquish
-        // ownership.
-        result = ACE_reinterpret_cast(IR_UnionMember*,this->buffer_);
-        this->maximum_ = 0;
-        this->length_ = 0;
-        this->buffer_ = 0;
-        this->release_ = 0;
-      }
-    }
-    return result;
-  }
-  
-  ACE_INLINE const IR_UnionMember *
-  _TAO_Unbounded_Sequence_IR_UnionMemberSeq::get_buffer (void) const
-  {
-    return ACE_reinterpret_cast(const IR_UnionMember * ACE_CAST_CONST, this->buffer_);
-  }
-  
-  ACE_INLINE void
-  _TAO_Unbounded_Sequence_IR_UnionMemberSeq::replace (CORBA::ULong max,
-  CORBA::ULong length,
-  IR_UnionMember *data,
-  CORBA::Boolean release)
-  {
-    this->maximum_ = max;
-    this->length_ = length;
-    if (this->buffer_ && this->release_ == 1)
-    {
-      IR_UnionMember *tmp = ACE_reinterpret_cast(IR_UnionMember*,this->buffer_);
-      _TAO_Unbounded_Sequence_IR_UnionMemberSeq::freebuf (tmp);
-    }
-    this->buffer_ = data;
-    this->release_ = release;
-  }
-  
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
-
-// *************************************************************
-// Inline operations for class IR_UnionMemberSeq_var
-// *************************************************************
-
-ACE_INLINE
-IR_UnionMemberSeq_var::IR_UnionMemberSeq_var (void) // default constructor
-  : ptr_ (0)
-{}
-
-ACE_INLINE
-IR_UnionMemberSeq_var::IR_UnionMemberSeq_var (IR_UnionMemberSeq *p)
-  : ptr_ (p)
-{}
-
-ACE_INLINE
-IR_UnionMemberSeq_var::IR_UnionMemberSeq_var (const ::IR_UnionMemberSeq_var &p) // copy constructor
-{
-  if (p.ptr_)
-    ACE_NEW (this->ptr_, ::IR_UnionMemberSeq (*p.ptr_));
-  else
-    this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_UnionMemberSeq_var::~IR_UnionMemberSeq_var (void) // destructor
-{
-  delete this->ptr_;
-}
-
-ACE_INLINE IR_UnionMemberSeq_var &
-IR_UnionMemberSeq_var::operator= (IR_UnionMemberSeq *p)
-{
-  delete this->ptr_;
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE IR_UnionMemberSeq_var &
-IR_UnionMemberSeq_var::operator= (const ::IR_UnionMemberSeq_var &p) // deep copy
-{
-  if (this != &p)
-    {
-      if (p.ptr_ == 0)
-        {
-          delete this->ptr_;
-          this->ptr_ = 0;
-        }
-      else
-        {
-          IR_UnionMemberSeq *deep_copy = 
-            new IR_UnionMemberSeq (*p.ptr_);
-          
-          if (deep_copy != 0)
-            {
-              IR_UnionMemberSeq *tmp = deep_copy;
-              deep_copy = this->ptr_;
-              this->ptr_ = tmp;
-              delete deep_copy;
-            }
-        }
-    }
-  
-  return *this;
-}
-
-ACE_INLINE const ::IR_UnionMemberSeq *
-IR_UnionMemberSeq_var::operator-> (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_UnionMemberSeq *
-IR_UnionMemberSeq_var::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE 
-IR_UnionMemberSeq_var::operator const ::IR_UnionMemberSeq &() const // cast
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE 
-IR_UnionMemberSeq_var::operator ::IR_UnionMemberSeq &() // cast 
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE 
-IR_UnionMemberSeq_var::operator ::IR_UnionMemberSeq &() const // cast 
-{
-  return *this->ptr_;
-}
-
-// variable-size types only
-ACE_INLINE
-IR_UnionMemberSeq_var::operator ::IR_UnionMemberSeq *&() // cast 
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_UnionMember &
-IR_UnionMemberSeq_var::operator[] (CORBA::ULong index)
-{
-  return this->ptr_->operator[] (index);
-}
-
-ACE_INLINE const IR_UnionMember &
-IR_UnionMemberSeq_var::operator[] (CORBA::ULong index) const
-{
-  return ACE_const_cast (const IR_UnionMember &, this->ptr_->operator[] (index));
-}
-
-ACE_INLINE const ::IR_UnionMemberSeq &
-IR_UnionMemberSeq_var::in (void) const
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE ::IR_UnionMemberSeq &
-IR_UnionMemberSeq_var::inout (void)
-{
-  return *this->ptr_;
-}
-
-// mapping for variable size 
-ACE_INLINE ::IR_UnionMemberSeq *&
-IR_UnionMemberSeq_var::out (void)
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_UnionMemberSeq *
-IR_UnionMemberSeq_var::_retn (void)
-{
-  ::IR_UnionMemberSeq *tmp = this->ptr_;
-  this->ptr_ = 0;
-  return tmp;
-}
-
-ACE_INLINE ::IR_UnionMemberSeq *
-IR_UnionMemberSeq_var::ptr (void) const
-{
-  return this->ptr_;
-}
-
-// *************************************************************
-// Inline operations for class IR_UnionMemberSeq_out
-// *************************************************************
-
-ACE_INLINE
-IR_UnionMemberSeq_out::IR_UnionMemberSeq_out (IR_UnionMemberSeq *&p)
-  : ptr_ (p)
-{
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_UnionMemberSeq_out::IR_UnionMemberSeq_out (IR_UnionMemberSeq_var &p) // constructor from _var
-  : ptr_ (p.out ())
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_UnionMemberSeq_out::IR_UnionMemberSeq_out (const ::IR_UnionMemberSeq_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (IR_UnionMemberSeq_out&, p).ptr_)
-{}
-
-ACE_INLINE ::IR_UnionMemberSeq_out &
-IR_UnionMemberSeq_out::operator= (const ::IR_UnionMemberSeq_out &p)
-{
-  this->ptr_ = ACE_const_cast (IR_UnionMemberSeq_out&, p).ptr_;
-  return *this;
-}
-
-ACE_INLINE ::IR_UnionMemberSeq_out &
-IR_UnionMemberSeq_out::operator= (IR_UnionMemberSeq *p)
-{
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE 
-IR_UnionMemberSeq_out::operator ::IR_UnionMemberSeq *&() // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_UnionMemberSeq *&
-IR_UnionMemberSeq_out::ptr (void) // ptr
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_UnionMemberSeq *
-IR_UnionMemberSeq_out::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_UnionMember &
-IR_UnionMemberSeq_out::operator[] (CORBA::ULong index)
-{
-  return this->ptr_->operator[] (index);
-}
-
-// *************************************************************
-// Inline operations for class IR_EnumMemberSeq_var
-// *************************************************************
-
-ACE_INLINE
-IR_EnumMemberSeq_var::IR_EnumMemberSeq_var (void) // default constructor
-  : ptr_ (0)
-{}
-
-ACE_INLINE
-IR_EnumMemberSeq_var::IR_EnumMemberSeq_var (IR_EnumMemberSeq *p)
-  : ptr_ (p)
-{}
-
-ACE_INLINE
-IR_EnumMemberSeq_var::IR_EnumMemberSeq_var (const ::IR_EnumMemberSeq_var &p) // copy constructor
-{
-  if (p.ptr_)
-    ACE_NEW (this->ptr_, ::IR_EnumMemberSeq (*p.ptr_));
-  else
-    this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_EnumMemberSeq_var::~IR_EnumMemberSeq_var (void) // destructor
-{
-  delete this->ptr_;
-}
-
-ACE_INLINE IR_EnumMemberSeq_var &
-IR_EnumMemberSeq_var::operator= (IR_EnumMemberSeq *p)
-{
-  delete this->ptr_;
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE IR_EnumMemberSeq_var &
-IR_EnumMemberSeq_var::operator= (const ::IR_EnumMemberSeq_var &p) // deep copy
-{
-  if (this != &p)
-    {
-      if (p.ptr_ == 0)
-        {
-          delete this->ptr_;
-          this->ptr_ = 0;
-        }
-      else
-        {
-          IR_EnumMemberSeq *deep_copy = 
-            new IR_EnumMemberSeq (*p.ptr_);
-          
-          if (deep_copy != 0)
-            {
-              IR_EnumMemberSeq *tmp = deep_copy;
-              deep_copy = this->ptr_;
-              this->ptr_ = tmp;
-              delete deep_copy;
-            }
-        }
-    }
-  
-  return *this;
-}
-
-ACE_INLINE const ::IR_EnumMemberSeq *
-IR_EnumMemberSeq_var::operator-> (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_EnumMemberSeq *
-IR_EnumMemberSeq_var::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE 
-IR_EnumMemberSeq_var::operator const ::IR_EnumMemberSeq &() const // cast
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE 
-IR_EnumMemberSeq_var::operator ::IR_EnumMemberSeq &() // cast 
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE 
-IR_EnumMemberSeq_var::operator ::IR_EnumMemberSeq &() const // cast 
-{
-  return *this->ptr_;
-}
-
-// variable-size types only
-ACE_INLINE
-IR_EnumMemberSeq_var::operator ::IR_EnumMemberSeq *&() // cast 
-{
-  return this->ptr_;
-}
-
-ACE_INLINE TAO_SeqElem_String_Manager
-IR_EnumMemberSeq_var::operator[] (CORBA::ULong index)
-{
-  return this->ptr_->operator[] (index);
-}
-
-ACE_INLINE const ::IR_EnumMemberSeq &
-IR_EnumMemberSeq_var::in (void) const
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE ::IR_EnumMemberSeq &
-IR_EnumMemberSeq_var::inout (void)
-{
-  return *this->ptr_;
-}
-
-// mapping for variable size 
-ACE_INLINE ::IR_EnumMemberSeq *&
-IR_EnumMemberSeq_var::out (void)
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_EnumMemberSeq *
-IR_EnumMemberSeq_var::_retn (void)
-{
-  ::IR_EnumMemberSeq *tmp = this->ptr_;
-  this->ptr_ = 0;
-  return tmp;
-}
-
-ACE_INLINE ::IR_EnumMemberSeq *
-IR_EnumMemberSeq_var::ptr (void) const
-{
-  return this->ptr_;
-}
-
-// *************************************************************
-// Inline operations for class IR_EnumMemberSeq_out
-// *************************************************************
-
-ACE_INLINE
-IR_EnumMemberSeq_out::IR_EnumMemberSeq_out (IR_EnumMemberSeq *&p)
-  : ptr_ (p)
-{
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_EnumMemberSeq_out::IR_EnumMemberSeq_out (IR_EnumMemberSeq_var &p) // constructor from _var
-  : ptr_ (p.out ())
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_EnumMemberSeq_out::IR_EnumMemberSeq_out (const ::IR_EnumMemberSeq_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (IR_EnumMemberSeq_out&, p).ptr_)
-{}
-
-ACE_INLINE ::IR_EnumMemberSeq_out &
-IR_EnumMemberSeq_out::operator= (const ::IR_EnumMemberSeq_out &p)
-{
-  this->ptr_ = ACE_const_cast (IR_EnumMemberSeq_out&, p).ptr_;
-  return *this;
-}
-
-ACE_INLINE ::IR_EnumMemberSeq_out &
-IR_EnumMemberSeq_out::operator= (IR_EnumMemberSeq *p)
-{
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE 
-IR_EnumMemberSeq_out::operator ::IR_EnumMemberSeq *&() // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_EnumMemberSeq *&
-IR_EnumMemberSeq_out::ptr (void) // ptr
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_EnumMemberSeq *
-IR_EnumMemberSeq_out::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE TAO_SeqElem_String_Manager
-IR_EnumMemberSeq_out::operator[] (CORBA::ULong index)
-{
-  return this->ptr_->operator[] (index);
-}
-
-// *************************************************************
-// Inline operations for class IR_Container::Description_var
-// *************************************************************
-
-ACE_INLINE
-IR_Container::Description_var::Description_var (void) // default constructor
-  : ptr_ (0)
-{}
-
-ACE_INLINE
-IR_Container::Description_var::Description_var (Description *p)
-  : ptr_ (p)
-{}
-
-ACE_INLINE
-IR_Container::Description_var::Description_var (const ::IR_Container::Description_var &p) // copy constructor
-{
-  if (p.ptr_)
-    ACE_NEW (this->ptr_, ::IR_Container::Description (*p.ptr_));
-  else
-    this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_Container::Description_var::~Description_var (void) // destructor
-{
-  delete this->ptr_;
-}
-
-ACE_INLINE IR_Container::Description_var &
-IR_Container::Description_var::operator= (Description *p)
-{
-  delete this->ptr_;
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE ::IR_Container::Description_var &
-IR_Container::Description_var::operator= (const ::IR_Container::Description_var &p)
-{
-  if (this != &p)
-    {
-      if (p.ptr_ == 0)
-        {
-          delete this->ptr_;
-          this->ptr_ = 0;
-        }
-      else
-        {
-          IR_Container::Description *deep_copy = 
-            new IR_Container::Description (*p.ptr_);
-          
-          if (deep_copy != 0)
-            {
-              IR_Container::Description *tmp = deep_copy;
-              deep_copy = this->ptr_;
-              this->ptr_ = tmp;
-              delete deep_copy;
-            }
-        }
-    }
-  
-  return *this;
-}
-
-ACE_INLINE const ::IR_Container::Description *
-IR_Container::Description_var::operator-> (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_Container::Description *
-IR_Container::Description_var::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE
-IR_Container::Description_var::operator const ::IR_Container::Description &() const // cast
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE
-IR_Container::Description_var::operator ::IR_Container::Description &() // cast 
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE
-IR_Container::Description_var::operator ::IR_Container::Description &() const // cast 
-{
-  return *this->ptr_;
-}
-
-// variable-size types only
-ACE_INLINE
-IR_Container::Description_var::operator ::IR_Container::Description *&() // cast 
-{
-  return this->ptr_;
-}
-
-ACE_INLINE const ::IR_Container::Description &
-IR_Container::Description_var::in (void) const
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE ::IR_Container::Description &
-IR_Container::Description_var::inout (void)
-{
-  return *this->ptr_;
-}
-
-// mapping for variable size 
-ACE_INLINE ::IR_Container::Description *&
-IR_Container::Description_var::out (void)
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_Container::Description *
-IR_Container::Description_var::_retn (void)
-{
-  ::IR_Container::Description *tmp = this->ptr_;
-  this->ptr_ = 0;
-  return tmp;
-}
-
-ACE_INLINE ::IR_Container::Description *
-IR_Container::Description_var::ptr (void) const
-{
-  return this->ptr_;
-}
-
-// *************************************************************
-// Inline operations for class IR_Container::Description_out
-// *************************************************************
-
-ACE_INLINE
-IR_Container::Description_out::Description_out (::IR_Container::Description *&p)
-  : ptr_ (p)
-{
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_Container::Description_out::Description_out (Description_var &p) // constructor from _var
-  : ptr_ (p.out ())
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_Container::Description_out::Description_out (const ::IR_Container::Description_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (Description_out&, p).ptr_)
-{}
-
-ACE_INLINE IR_Container::Description_out &
-IR_Container::Description_out::operator= (const ::IR_Container::Description_out &p)
-{
-  this->ptr_ = ACE_const_cast (Description_out&, p).ptr_;
-  return *this;
-}
-
-ACE_INLINE IR_Container::Description_out &
-IR_Container::Description_out::operator= (Description *p)
-{
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE 
-IR_Container::Description_out::operator ::IR_Container::Description *&() // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_Container::Description *&
-IR_Container::Description_out::ptr (void) // ptr
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_Container::Description *
-IR_Container::Description_out::operator-> (void)
-{
-  return this->ptr_;
-}
-
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  
-  // = Static operations.
-  ACE_INLINE IR_Container::Description *
-  IR_Container::_TAO_Unbounded_Sequence_IR_Container_DescriptionSeq::allocbuf (CORBA::ULong size)
-  // Allocate storage for the sequence.
-  {
-    IR_Container::Description *retval = 0;
-    ACE_NEW_RETURN (retval, IR_Container::Description[size], 0);
-    return retval;
-  }
-  
-  ACE_INLINE void IR_Container::_TAO_Unbounded_Sequence_IR_Container_DescriptionSeq::freebuf (IR_Container::Description *buffer)
-  // Free the sequence.
-  {
-    delete [] buffer;
-  }
-  
-  ACE_INLINE
-  IR_Container::_TAO_Unbounded_Sequence_IR_Container_DescriptionSeq::_TAO_Unbounded_Sequence_IR_Container_DescriptionSeq (void) // Default constructor.
-  {
-  }
-  
-  ACE_INLINE
-  IR_Container::_TAO_Unbounded_Sequence_IR_Container_DescriptionSeq::_TAO_Unbounded_Sequence_IR_Container_DescriptionSeq (CORBA::ULong maximum) // Constructor using a maximum length value.
-    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Sequence_IR_Container_DescriptionSeq::allocbuf (maximum))
-  {
-  }
-  
-  ACE_INLINE
-  IR_Container::_TAO_Unbounded_Sequence_IR_Container_DescriptionSeq::_TAO_Unbounded_Sequence_IR_Container_DescriptionSeq (CORBA::ULong maximum,
-    CORBA::ULong length,
-    IR_Container::Description *data,
-    CORBA::Boolean release)
-  : TAO_Unbounded_Base_Sequence (maximum, length, data, release)
-  {
-  }
-  
-  ACE_INLINE
-  IR_Container::_TAO_Unbounded_Sequence_IR_Container_DescriptionSeq::_TAO_Unbounded_Sequence_IR_Container_DescriptionSeq (const _TAO_Unbounded_Sequence_IR_Container_DescriptionSeq &rhs)
-  // Copy constructor.
-    : TAO_Unbounded_Base_Sequence (rhs)
-  {
-    if (rhs.buffer_ != 0)
-    {
-      IR_Container::Description *tmp1 = _TAO_Unbounded_Sequence_IR_Container_DescriptionSeq::allocbuf (this->maximum_);
-      IR_Container::Description * const tmp2 = ACE_reinterpret_cast (IR_Container::Description * ACE_CAST_CONST, rhs.buffer_);
-      
-      for (CORBA::ULong i = 0; i < this->length_; ++i)
-        tmp1[i] = tmp2[i];
-      
-      this->buffer_ = tmp1;
-    }
-    else
-    {
-      this->buffer_ = 0;
-    }
-  }
-  
-  ACE_INLINE IR_Container::_TAO_Unbounded_Sequence_IR_Container_DescriptionSeq &
-  IR_Container::_TAO_Unbounded_Sequence_IR_Container_DescriptionSeq::operator= (const _TAO_Unbounded_Sequence_IR_Container_DescriptionSeq &rhs)
-  // Assignment operator.
-  {
-    if (this == &rhs)
-      return *this;
-    
-    if (this->release_)
-    {
-      if (this->maximum_ < rhs.maximum_)
-      {
-        // free the old buffer
-        IR_Container::Description *tmp = ACE_reinterpret_cast (IR_Container::Description *, this->buffer_);
-        _TAO_Unbounded_Sequence_IR_Container_DescriptionSeq::freebuf (tmp);
-        this->buffer_ = _TAO_Unbounded_Sequence_IR_Container_DescriptionSeq::allocbuf (rhs.maximum_);
-      }
-    }
-    else
-      this->buffer_ = _TAO_Unbounded_Sequence_IR_Container_DescriptionSeq::allocbuf (rhs.maximum_);
-    
-    TAO_Unbounded_Base_Sequence::operator= (rhs);
-    
-    IR_Container::Description *tmp1 = ACE_reinterpret_cast (IR_Container::Description *, this->buffer_);
-    IR_Container::Description * const tmp2 = ACE_reinterpret_cast (IR_Container::Description * ACE_CAST_CONST, rhs.buffer_);
-    
-    for (CORBA::ULong i = 0; i < this->length_; ++i)
-      tmp1[i] = tmp2[i];
-    
-    return *this;
-  }
-  
-  // = Accessors.
-  ACE_INLINE IR_Container::Description &
-  IR_Container::_TAO_Unbounded_Sequence_IR_Container_DescriptionSeq::operator[] (CORBA::ULong i)
-  // operator []
-  {
-    ACE_ASSERT (i < this->maximum_);
-    IR_Container::Description* tmp = ACE_reinterpret_cast(IR_Container::Description*,this->buffer_);
-    return tmp[i];
-  }
-  
-  ACE_INLINE const IR_Container::Description &
-  IR_Container::_TAO_Unbounded_Sequence_IR_Container_DescriptionSeq::operator[] (CORBA::ULong i) const
-  // operator []
-  {
-    ACE_ASSERT (i < this->maximum_);
-    IR_Container::Description * const tmp = ACE_reinterpret_cast (IR_Container::Description* ACE_CAST_CONST, this->buffer_);
-    return tmp[i];
-  }
-  
-  // Implement the TAO_Base_Sequence methods (see Sequence.h)
-  
-  ACE_INLINE IR_Container::Description *
-  IR_Container::_TAO_Unbounded_Sequence_IR_Container_DescriptionSeq::get_buffer (CORBA::Boolean orphan)
-  {
-    IR_Container::Description *result = 0;
-    if (orphan == 0)
-    {
-      // We retain ownership.
-      if (this->buffer_ == 0)
-      {
-        result = _TAO_Unbounded_Sequence_IR_Container_DescriptionSeq::allocbuf (this->length_);
-        this->buffer_ = result;
-        this->release_ = 1;
-      }
-      else
-      {
-        result = ACE_reinterpret_cast (IR_Container::Description*, this->buffer_);
-      }
-    }
-    else // if (orphan == 1)
-    {
-      if (this->release_ != 0)
-      {
-        // We set the state back to default and relinquish
-        // ownership.
-        result = ACE_reinterpret_cast(IR_Container::Description*,this->buffer_);
-        this->maximum_ = 0;
-        this->length_ = 0;
-        this->buffer_ = 0;
-        this->release_ = 0;
-      }
-    }
-    return result;
-  }
-  
-  ACE_INLINE const IR_Container::Description *
-  IR_Container::_TAO_Unbounded_Sequence_IR_Container_DescriptionSeq::get_buffer (void) const
-  {
-    return ACE_reinterpret_cast(const IR_Container::Description * ACE_CAST_CONST, this->buffer_);
-  }
-  
-  ACE_INLINE void
-  IR_Container::_TAO_Unbounded_Sequence_IR_Container_DescriptionSeq::replace (CORBA::ULong max,
-  CORBA::ULong length,
-  IR_Container::Description *data,
-  CORBA::Boolean release)
-  {
-    this->maximum_ = max;
-    this->length_ = length;
-    if (this->buffer_ && this->release_ == 1)
-    {
-      IR_Container::Description *tmp = ACE_reinterpret_cast(IR_Container::Description*,this->buffer_);
-      _TAO_Unbounded_Sequence_IR_Container_DescriptionSeq::freebuf (tmp);
-    }
-    this->buffer_ = data;
-    this->release_ = release;
-  }
-  
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
-
-// *************************************************************
-// Inline operations for class IR_Container::DescriptionSeq_var
-// *************************************************************
-
-ACE_INLINE
-IR_Container::DescriptionSeq_var::DescriptionSeq_var (void) // default constructor
-  : ptr_ (0)
-{}
-
-ACE_INLINE
-IR_Container::DescriptionSeq_var::DescriptionSeq_var (DescriptionSeq *p)
-  : ptr_ (p)
-{}
-
-ACE_INLINE
-IR_Container::DescriptionSeq_var::DescriptionSeq_var (const ::IR_Container::DescriptionSeq_var &p) // copy constructor
-{
-  if (p.ptr_)
-    ACE_NEW (this->ptr_, ::IR_Container::DescriptionSeq (*p.ptr_));
-  else
-    this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_Container::DescriptionSeq_var::~DescriptionSeq_var (void) // destructor
-{
-  delete this->ptr_;
-}
-
-ACE_INLINE IR_Container::DescriptionSeq_var &
-IR_Container::DescriptionSeq_var::operator= (DescriptionSeq *p)
-{
-  delete this->ptr_;
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE IR_Container::DescriptionSeq_var &
-IR_Container::DescriptionSeq_var::operator= (const ::IR_Container::DescriptionSeq_var &p) // deep copy
-{
-  if (this != &p)
-    {
-      if (p.ptr_ == 0)
-        {
-          delete this->ptr_;
-          this->ptr_ = 0;
-        }
-      else
-        {
-          IR_Container::DescriptionSeq *deep_copy = 
-            new IR_Container::DescriptionSeq (*p.ptr_);
-          
-          if (deep_copy != 0)
-            {
-              IR_Container::DescriptionSeq *tmp = deep_copy;
-              deep_copy = this->ptr_;
-              this->ptr_ = tmp;
-              delete deep_copy;
-            }
-        }
-    }
-  
-  return *this;
-}
-
-ACE_INLINE const ::IR_Container::DescriptionSeq *
-IR_Container::DescriptionSeq_var::operator-> (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_Container::DescriptionSeq *
-IR_Container::DescriptionSeq_var::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE 
-IR_Container::DescriptionSeq_var::operator const ::IR_Container::DescriptionSeq &() const // cast
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE 
-IR_Container::DescriptionSeq_var::operator ::IR_Container::DescriptionSeq &() // cast 
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE 
-IR_Container::DescriptionSeq_var::operator ::IR_Container::DescriptionSeq &() const // cast 
-{
-  return *this->ptr_;
-}
-
-// variable-size types only
-ACE_INLINE
-IR_Container::DescriptionSeq_var::operator ::IR_Container::DescriptionSeq *&() // cast 
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_Container::Description &
-IR_Container::DescriptionSeq_var::operator[] (CORBA::ULong index)
-{
-  return this->ptr_->operator[] (index);
-}
-
-ACE_INLINE const IR_Container::Description &
-IR_Container::DescriptionSeq_var::operator[] (CORBA::ULong index) const
-{
-  return ACE_const_cast (const IR_Container::Description &, this->ptr_->operator[] (index));
-}
-
-ACE_INLINE const ::IR_Container::DescriptionSeq &
-IR_Container::DescriptionSeq_var::in (void) const
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE ::IR_Container::DescriptionSeq &
-IR_Container::DescriptionSeq_var::inout (void)
-{
-  return *this->ptr_;
-}
-
-// mapping for variable size 
-ACE_INLINE ::IR_Container::DescriptionSeq *&
-IR_Container::DescriptionSeq_var::out (void)
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_Container::DescriptionSeq *
-IR_Container::DescriptionSeq_var::_retn (void)
-{
-  ::IR_Container::DescriptionSeq *tmp = this->ptr_;
-  this->ptr_ = 0;
-  return tmp;
-}
-
-ACE_INLINE ::IR_Container::DescriptionSeq *
-IR_Container::DescriptionSeq_var::ptr (void) const
-{
-  return this->ptr_;
-}
-
-// *************************************************************
-// Inline operations for class IR_Container::DescriptionSeq_out
-// *************************************************************
-
-ACE_INLINE
-IR_Container::DescriptionSeq_out::DescriptionSeq_out (DescriptionSeq *&p)
-  : ptr_ (p)
-{
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_Container::DescriptionSeq_out::DescriptionSeq_out (DescriptionSeq_var &p) // constructor from _var
-  : ptr_ (p.out ())
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_Container::DescriptionSeq_out::DescriptionSeq_out (const ::IR_Container::DescriptionSeq_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (DescriptionSeq_out&, p).ptr_)
-{}
-
-ACE_INLINE ::IR_Container::DescriptionSeq_out &
-IR_Container::DescriptionSeq_out::operator= (const ::IR_Container::DescriptionSeq_out &p)
-{
-  this->ptr_ = ACE_const_cast (DescriptionSeq_out&, p).ptr_;
-  return *this;
-}
-
-ACE_INLINE ::IR_Container::DescriptionSeq_out &
-IR_Container::DescriptionSeq_out::operator= (DescriptionSeq *p)
-{
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE 
-IR_Container::DescriptionSeq_out::operator ::IR_Container::DescriptionSeq *&() // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_Container::DescriptionSeq *&
-IR_Container::DescriptionSeq_out::ptr (void) // ptr
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_Container::DescriptionSeq *
-IR_Container::DescriptionSeq_out::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_Container::Description &
-IR_Container::DescriptionSeq_out::operator[] (CORBA::ULong index)
-{
-  return this->ptr_->operator[] (index);
-}
-
-ACE_INLINE
-IR_PrimitiveDef::IR_PrimitiveDef (
-    TAO_Stub *objref,
-    CORBA::Boolean _tao_collocated,
-    TAO_Abstract_ServantBase *servant
-  )
-  : CORBA_Object (objref, _tao_collocated, servant)
-{
-  this->IR_PrimitiveDef_setup_collocation (_tao_collocated);
-}
-
-// *************************************************************
-// Inline operations for class IR_PrimitiveDef_var
-// *************************************************************
-
-ACE_INLINE
-IR_PrimitiveDef_var::IR_PrimitiveDef_var (void) // default constructor
-  : ptr_ (IR_PrimitiveDef::_nil ())
-{}
-
-ACE_INLINE IR_PrimitiveDef_ptr 
-IR_PrimitiveDef_var::ptr (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE
-IR_PrimitiveDef_var::IR_PrimitiveDef_var (const IR_PrimitiveDef_var &p) // copy constructor
-  : TAO_Base_var (),
-    ptr_ (IR_PrimitiveDef::_duplicate (p.ptr ()))
-{}
-
-ACE_INLINE
-IR_PrimitiveDef_var::~IR_PrimitiveDef_var (void) // destructor
-{
-  CORBA::release (this->ptr_);
-}
-
-ACE_INLINE IR_PrimitiveDef_var &
-IR_PrimitiveDef_var::operator= (IR_PrimitiveDef_ptr p)
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE IR_PrimitiveDef_var &
-IR_PrimitiveDef_var::operator= (const IR_PrimitiveDef_var &p)
-{
-  if (this != &p)
-  {
-    CORBA::release (this->ptr_);
-    this->ptr_ = IR_PrimitiveDef::_duplicate (p.ptr ());
-  }
-  return *this;
-}
-
-ACE_INLINE 
-IR_PrimitiveDef_var::operator const IR_PrimitiveDef_ptr &() const // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE 
-IR_PrimitiveDef_var::operator IR_PrimitiveDef_ptr &() // cast 
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_PrimitiveDef_ptr 
-IR_PrimitiveDef_var::operator-> (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_PrimitiveDef_ptr
-IR_PrimitiveDef_var::in (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_PrimitiveDef_ptr &
-IR_PrimitiveDef_var::inout (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_PrimitiveDef_ptr &
-IR_PrimitiveDef_var::out (void)
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = IR_PrimitiveDef::_nil ();
-  return this->ptr_;
-}
-
-ACE_INLINE IR_PrimitiveDef_ptr 
-IR_PrimitiveDef_var::_retn (void)
-{
-  // yield ownership of managed obj reference
-  IR_PrimitiveDef_ptr val = this->ptr_;
-  this->ptr_ = IR_PrimitiveDef::_nil ();
-  return val;
-}
-
-// *************************************************************
-// Inline operations for class IR_PrimitiveDef_out
-// *************************************************************
-
-ACE_INLINE
-IR_PrimitiveDef_out::IR_PrimitiveDef_out (IR_PrimitiveDef_ptr &p)
-  : ptr_ (p)
-{
-  this->ptr_ = IR_PrimitiveDef::_nil ();
-}
-
-ACE_INLINE
-IR_PrimitiveDef_out::IR_PrimitiveDef_out (IR_PrimitiveDef_var &p) // constructor from _var
-  : ptr_ (p.out ())
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = IR_PrimitiveDef::_nil ();
-}
-
-ACE_INLINE
-IR_PrimitiveDef_out::IR_PrimitiveDef_out (const IR_PrimitiveDef_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (IR_PrimitiveDef_out&,p).ptr_)
-{}
-
-ACE_INLINE IR_PrimitiveDef_out &
-IR_PrimitiveDef_out::operator= (const IR_PrimitiveDef_out &p)
-{
-  this->ptr_ = ACE_const_cast (IR_PrimitiveDef_out&,p).ptr_;
-  return *this;
-}
-
-ACE_INLINE IR_PrimitiveDef_out &
-IR_PrimitiveDef_out::operator= (const IR_PrimitiveDef_var &p)
-{
-  this->ptr_ = IR_PrimitiveDef::_duplicate (p.ptr ());
-  return *this;
-}
-
-ACE_INLINE IR_PrimitiveDef_out &
-IR_PrimitiveDef_out::operator= (IR_PrimitiveDef_ptr p)
-{
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE 
-IR_PrimitiveDef_out::operator IR_PrimitiveDef_ptr &() // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_PrimitiveDef_ptr &
-IR_PrimitiveDef_out::ptr (void) // ptr
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_PrimitiveDef_ptr 
-IR_PrimitiveDef_out::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE
-IR_StringDef::IR_StringDef (
-    TAO_Stub *objref,
-    CORBA::Boolean _tao_collocated,
-    TAO_Abstract_ServantBase *servant
-  )
-  : CORBA_Object (objref, _tao_collocated, servant)
-{
-  this->IR_StringDef_setup_collocation (_tao_collocated);
-}
-
-// *************************************************************
-// Inline operations for class IR_StringDef_var
-// *************************************************************
-
-ACE_INLINE
-IR_StringDef_var::IR_StringDef_var (void) // default constructor
-  : ptr_ (IR_StringDef::_nil ())
-{}
-
-ACE_INLINE IR_StringDef_ptr 
-IR_StringDef_var::ptr (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE
-IR_StringDef_var::IR_StringDef_var (const IR_StringDef_var &p) // copy constructor
-  : TAO_Base_var (),
-    ptr_ (IR_StringDef::_duplicate (p.ptr ()))
-{}
-
-ACE_INLINE
-IR_StringDef_var::~IR_StringDef_var (void) // destructor
-{
-  CORBA::release (this->ptr_);
-}
-
-ACE_INLINE IR_StringDef_var &
-IR_StringDef_var::operator= (IR_StringDef_ptr p)
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE IR_StringDef_var &
-IR_StringDef_var::operator= (const IR_StringDef_var &p)
-{
-  if (this != &p)
-  {
-    CORBA::release (this->ptr_);
-    this->ptr_ = IR_StringDef::_duplicate (p.ptr ());
-  }
-  return *this;
-}
-
-ACE_INLINE 
-IR_StringDef_var::operator const IR_StringDef_ptr &() const // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE 
-IR_StringDef_var::operator IR_StringDef_ptr &() // cast 
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_StringDef_ptr 
-IR_StringDef_var::operator-> (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_StringDef_ptr
-IR_StringDef_var::in (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_StringDef_ptr &
-IR_StringDef_var::inout (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_StringDef_ptr &
-IR_StringDef_var::out (void)
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = IR_StringDef::_nil ();
-  return this->ptr_;
-}
-
-ACE_INLINE IR_StringDef_ptr 
-IR_StringDef_var::_retn (void)
-{
-  // yield ownership of managed obj reference
-  IR_StringDef_ptr val = this->ptr_;
-  this->ptr_ = IR_StringDef::_nil ();
-  return val;
-}
-
-// *************************************************************
-// Inline operations for class IR_StringDef_out
-// *************************************************************
-
-ACE_INLINE
-IR_StringDef_out::IR_StringDef_out (IR_StringDef_ptr &p)
-  : ptr_ (p)
-{
-  this->ptr_ = IR_StringDef::_nil ();
-}
-
-ACE_INLINE
-IR_StringDef_out::IR_StringDef_out (IR_StringDef_var &p) // constructor from _var
-  : ptr_ (p.out ())
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = IR_StringDef::_nil ();
-}
-
-ACE_INLINE
-IR_StringDef_out::IR_StringDef_out (const IR_StringDef_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (IR_StringDef_out&,p).ptr_)
-{}
-
-ACE_INLINE IR_StringDef_out &
-IR_StringDef_out::operator= (const IR_StringDef_out &p)
-{
-  this->ptr_ = ACE_const_cast (IR_StringDef_out&,p).ptr_;
-  return *this;
-}
-
-ACE_INLINE IR_StringDef_out &
-IR_StringDef_out::operator= (const IR_StringDef_var &p)
-{
-  this->ptr_ = IR_StringDef::_duplicate (p.ptr ());
-  return *this;
-}
-
-ACE_INLINE IR_StringDef_out &
-IR_StringDef_out::operator= (IR_StringDef_ptr p)
-{
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE 
-IR_StringDef_out::operator IR_StringDef_ptr &() // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_StringDef_ptr &
-IR_StringDef_out::ptr (void) // ptr
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_StringDef_ptr 
-IR_StringDef_out::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE
-IR_SequenceDef::IR_SequenceDef (
-    TAO_Stub *objref,
-    CORBA::Boolean _tao_collocated,
-    TAO_Abstract_ServantBase *servant
-  )
-  : CORBA_Object (objref, _tao_collocated, servant)
-{
-  this->IR_SequenceDef_setup_collocation (_tao_collocated);
-}
-
-// *************************************************************
-// Inline operations for class IR_SequenceDef_var
-// *************************************************************
-
-ACE_INLINE
-IR_SequenceDef_var::IR_SequenceDef_var (void) // default constructor
-  : ptr_ (IR_SequenceDef::_nil ())
-{}
-
-ACE_INLINE IR_SequenceDef_ptr 
-IR_SequenceDef_var::ptr (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE
-IR_SequenceDef_var::IR_SequenceDef_var (const IR_SequenceDef_var &p) // copy constructor
-  : TAO_Base_var (),
-    ptr_ (IR_SequenceDef::_duplicate (p.ptr ()))
-{}
-
-ACE_INLINE
-IR_SequenceDef_var::~IR_SequenceDef_var (void) // destructor
-{
-  CORBA::release (this->ptr_);
-}
-
-ACE_INLINE IR_SequenceDef_var &
-IR_SequenceDef_var::operator= (IR_SequenceDef_ptr p)
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE IR_SequenceDef_var &
-IR_SequenceDef_var::operator= (const IR_SequenceDef_var &p)
-{
-  if (this != &p)
-  {
-    CORBA::release (this->ptr_);
-    this->ptr_ = IR_SequenceDef::_duplicate (p.ptr ());
-  }
-  return *this;
-}
-
-ACE_INLINE 
-IR_SequenceDef_var::operator const IR_SequenceDef_ptr &() const // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE 
-IR_SequenceDef_var::operator IR_SequenceDef_ptr &() // cast 
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_SequenceDef_ptr 
-IR_SequenceDef_var::operator-> (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_SequenceDef_ptr
-IR_SequenceDef_var::in (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_SequenceDef_ptr &
-IR_SequenceDef_var::inout (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_SequenceDef_ptr &
-IR_SequenceDef_var::out (void)
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = IR_SequenceDef::_nil ();
-  return this->ptr_;
-}
-
-ACE_INLINE IR_SequenceDef_ptr 
-IR_SequenceDef_var::_retn (void)
-{
-  // yield ownership of managed obj reference
-  IR_SequenceDef_ptr val = this->ptr_;
-  this->ptr_ = IR_SequenceDef::_nil ();
-  return val;
-}
-
-// *************************************************************
-// Inline operations for class IR_SequenceDef_out
-// *************************************************************
-
-ACE_INLINE
-IR_SequenceDef_out::IR_SequenceDef_out (IR_SequenceDef_ptr &p)
-  : ptr_ (p)
-{
-  this->ptr_ = IR_SequenceDef::_nil ();
-}
-
-ACE_INLINE
-IR_SequenceDef_out::IR_SequenceDef_out (IR_SequenceDef_var &p) // constructor from _var
-  : ptr_ (p.out ())
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = IR_SequenceDef::_nil ();
-}
-
-ACE_INLINE
-IR_SequenceDef_out::IR_SequenceDef_out (const IR_SequenceDef_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (IR_SequenceDef_out&,p).ptr_)
-{}
-
-ACE_INLINE IR_SequenceDef_out &
-IR_SequenceDef_out::operator= (const IR_SequenceDef_out &p)
-{
-  this->ptr_ = ACE_const_cast (IR_SequenceDef_out&,p).ptr_;
-  return *this;
-}
-
-ACE_INLINE IR_SequenceDef_out &
-IR_SequenceDef_out::operator= (const IR_SequenceDef_var &p)
-{
-  this->ptr_ = IR_SequenceDef::_duplicate (p.ptr ());
-  return *this;
-}
-
-ACE_INLINE IR_SequenceDef_out &
-IR_SequenceDef_out::operator= (IR_SequenceDef_ptr p)
-{
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE 
-IR_SequenceDef_out::operator IR_SequenceDef_ptr &() // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_SequenceDef_ptr &
-IR_SequenceDef_out::ptr (void) // ptr
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_SequenceDef_ptr 
-IR_SequenceDef_out::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE
-IR_ArrayDef::IR_ArrayDef (
-    TAO_Stub *objref,
-    CORBA::Boolean _tao_collocated,
-    TAO_Abstract_ServantBase *servant
-  )
-  : CORBA_Object (objref, _tao_collocated, servant)
-{
-  this->IR_ArrayDef_setup_collocation (_tao_collocated);
-}
-
-// *************************************************************
-// Inline operations for class IR_ArrayDef_var
-// *************************************************************
-
-ACE_INLINE
-IR_ArrayDef_var::IR_ArrayDef_var (void) // default constructor
-  : ptr_ (IR_ArrayDef::_nil ())
-{}
-
-ACE_INLINE IR_ArrayDef_ptr 
-IR_ArrayDef_var::ptr (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE
-IR_ArrayDef_var::IR_ArrayDef_var (const IR_ArrayDef_var &p) // copy constructor
-  : TAO_Base_var (),
-    ptr_ (IR_ArrayDef::_duplicate (p.ptr ()))
-{}
-
-ACE_INLINE
-IR_ArrayDef_var::~IR_ArrayDef_var (void) // destructor
-{
-  CORBA::release (this->ptr_);
-}
-
-ACE_INLINE IR_ArrayDef_var &
-IR_ArrayDef_var::operator= (IR_ArrayDef_ptr p)
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE IR_ArrayDef_var &
-IR_ArrayDef_var::operator= (const IR_ArrayDef_var &p)
-{
-  if (this != &p)
-  {
-    CORBA::release (this->ptr_);
-    this->ptr_ = IR_ArrayDef::_duplicate (p.ptr ());
-  }
-  return *this;
-}
-
-ACE_INLINE 
-IR_ArrayDef_var::operator const IR_ArrayDef_ptr &() const // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE 
-IR_ArrayDef_var::operator IR_ArrayDef_ptr &() // cast 
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_ArrayDef_ptr 
-IR_ArrayDef_var::operator-> (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_ArrayDef_ptr
-IR_ArrayDef_var::in (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_ArrayDef_ptr &
-IR_ArrayDef_var::inout (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_ArrayDef_ptr &
-IR_ArrayDef_var::out (void)
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = IR_ArrayDef::_nil ();
-  return this->ptr_;
-}
-
-ACE_INLINE IR_ArrayDef_ptr 
-IR_ArrayDef_var::_retn (void)
-{
-  // yield ownership of managed obj reference
-  IR_ArrayDef_ptr val = this->ptr_;
-  this->ptr_ = IR_ArrayDef::_nil ();
-  return val;
-}
-
-// *************************************************************
-// Inline operations for class IR_ArrayDef_out
-// *************************************************************
-
-ACE_INLINE
-IR_ArrayDef_out::IR_ArrayDef_out (IR_ArrayDef_ptr &p)
-  : ptr_ (p)
-{
-  this->ptr_ = IR_ArrayDef::_nil ();
-}
-
-ACE_INLINE
-IR_ArrayDef_out::IR_ArrayDef_out (IR_ArrayDef_var &p) // constructor from _var
-  : ptr_ (p.out ())
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = IR_ArrayDef::_nil ();
-}
-
-ACE_INLINE
-IR_ArrayDef_out::IR_ArrayDef_out (const IR_ArrayDef_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (IR_ArrayDef_out&,p).ptr_)
-{}
-
-ACE_INLINE IR_ArrayDef_out &
-IR_ArrayDef_out::operator= (const IR_ArrayDef_out &p)
-{
-  this->ptr_ = ACE_const_cast (IR_ArrayDef_out&,p).ptr_;
-  return *this;
-}
-
-ACE_INLINE IR_ArrayDef_out &
-IR_ArrayDef_out::operator= (const IR_ArrayDef_var &p)
-{
-  this->ptr_ = IR_ArrayDef::_duplicate (p.ptr ());
-  return *this;
-}
-
-ACE_INLINE IR_ArrayDef_out &
-IR_ArrayDef_out::operator= (IR_ArrayDef_ptr p)
-{
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE 
-IR_ArrayDef_out::operator IR_ArrayDef_ptr &() // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_ArrayDef_ptr &
-IR_ArrayDef_out::ptr (void) // ptr
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_ArrayDef_ptr 
-IR_ArrayDef_out::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE
-IR_WstringDef::IR_WstringDef (
-    TAO_Stub *objref,
-    CORBA::Boolean _tao_collocated,
-    TAO_Abstract_ServantBase *servant
-  )
-  : CORBA_Object (objref, _tao_collocated, servant)
-{
-  this->IR_WstringDef_setup_collocation (_tao_collocated);
-}
-
-// *************************************************************
-// Inline operations for class IR_WstringDef_var
-// *************************************************************
-
-ACE_INLINE
-IR_WstringDef_var::IR_WstringDef_var (void) // default constructor
-  : ptr_ (IR_WstringDef::_nil ())
-{}
-
-ACE_INLINE IR_WstringDef_ptr 
-IR_WstringDef_var::ptr (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE
-IR_WstringDef_var::IR_WstringDef_var (const IR_WstringDef_var &p) // copy constructor
-  : TAO_Base_var (),
-    ptr_ (IR_WstringDef::_duplicate (p.ptr ()))
-{}
-
-ACE_INLINE
-IR_WstringDef_var::~IR_WstringDef_var (void) // destructor
-{
-  CORBA::release (this->ptr_);
-}
-
-ACE_INLINE IR_WstringDef_var &
-IR_WstringDef_var::operator= (IR_WstringDef_ptr p)
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE IR_WstringDef_var &
-IR_WstringDef_var::operator= (const IR_WstringDef_var &p)
-{
-  if (this != &p)
-  {
-    CORBA::release (this->ptr_);
-    this->ptr_ = IR_WstringDef::_duplicate (p.ptr ());
-  }
-  return *this;
-}
-
-ACE_INLINE 
-IR_WstringDef_var::operator const IR_WstringDef_ptr &() const // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE 
-IR_WstringDef_var::operator IR_WstringDef_ptr &() // cast 
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_WstringDef_ptr 
-IR_WstringDef_var::operator-> (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_WstringDef_ptr
-IR_WstringDef_var::in (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_WstringDef_ptr &
-IR_WstringDef_var::inout (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_WstringDef_ptr &
-IR_WstringDef_var::out (void)
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = IR_WstringDef::_nil ();
-  return this->ptr_;
-}
-
-ACE_INLINE IR_WstringDef_ptr 
-IR_WstringDef_var::_retn (void)
-{
-  // yield ownership of managed obj reference
-  IR_WstringDef_ptr val = this->ptr_;
-  this->ptr_ = IR_WstringDef::_nil ();
-  return val;
-}
-
-// *************************************************************
-// Inline operations for class IR_WstringDef_out
-// *************************************************************
-
-ACE_INLINE
-IR_WstringDef_out::IR_WstringDef_out (IR_WstringDef_ptr &p)
-  : ptr_ (p)
-{
-  this->ptr_ = IR_WstringDef::_nil ();
-}
-
-ACE_INLINE
-IR_WstringDef_out::IR_WstringDef_out (IR_WstringDef_var &p) // constructor from _var
-  : ptr_ (p.out ())
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = IR_WstringDef::_nil ();
-}
-
-ACE_INLINE
-IR_WstringDef_out::IR_WstringDef_out (const IR_WstringDef_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (IR_WstringDef_out&,p).ptr_)
-{}
-
-ACE_INLINE IR_WstringDef_out &
-IR_WstringDef_out::operator= (const IR_WstringDef_out &p)
-{
-  this->ptr_ = ACE_const_cast (IR_WstringDef_out&,p).ptr_;
-  return *this;
-}
-
-ACE_INLINE IR_WstringDef_out &
-IR_WstringDef_out::operator= (const IR_WstringDef_var &p)
-{
-  this->ptr_ = IR_WstringDef::_duplicate (p.ptr ());
-  return *this;
-}
-
-ACE_INLINE IR_WstringDef_out &
-IR_WstringDef_out::operator= (IR_WstringDef_ptr p)
-{
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE 
-IR_WstringDef_out::operator IR_WstringDef_ptr &() // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_WstringDef_ptr &
-IR_WstringDef_out::ptr (void) // ptr
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_WstringDef_ptr 
-IR_WstringDef_out::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE
-IR_FixedDef::IR_FixedDef (
-    TAO_Stub *objref,
-    CORBA::Boolean _tao_collocated,
-    TAO_Abstract_ServantBase *servant
-  )
-  : CORBA_Object (objref, _tao_collocated, servant)
-{
-  this->IR_FixedDef_setup_collocation (_tao_collocated);
-}
-
-// *************************************************************
-// Inline operations for class IR_FixedDef_var
-// *************************************************************
-
-ACE_INLINE
-IR_FixedDef_var::IR_FixedDef_var (void) // default constructor
-  : ptr_ (IR_FixedDef::_nil ())
-{}
-
-ACE_INLINE IR_FixedDef_ptr 
-IR_FixedDef_var::ptr (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE
-IR_FixedDef_var::IR_FixedDef_var (const IR_FixedDef_var &p) // copy constructor
-  : TAO_Base_var (),
-    ptr_ (IR_FixedDef::_duplicate (p.ptr ()))
-{}
-
-ACE_INLINE
-IR_FixedDef_var::~IR_FixedDef_var (void) // destructor
-{
-  CORBA::release (this->ptr_);
-}
-
-ACE_INLINE IR_FixedDef_var &
-IR_FixedDef_var::operator= (IR_FixedDef_ptr p)
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE IR_FixedDef_var &
-IR_FixedDef_var::operator= (const IR_FixedDef_var &p)
-{
-  if (this != &p)
-  {
-    CORBA::release (this->ptr_);
-    this->ptr_ = IR_FixedDef::_duplicate (p.ptr ());
-  }
-  return *this;
-}
-
-ACE_INLINE 
-IR_FixedDef_var::operator const IR_FixedDef_ptr &() const // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE 
-IR_FixedDef_var::operator IR_FixedDef_ptr &() // cast 
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_FixedDef_ptr 
-IR_FixedDef_var::operator-> (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_FixedDef_ptr
-IR_FixedDef_var::in (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_FixedDef_ptr &
-IR_FixedDef_var::inout (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_FixedDef_ptr &
-IR_FixedDef_var::out (void)
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = IR_FixedDef::_nil ();
-  return this->ptr_;
-}
-
-ACE_INLINE IR_FixedDef_ptr 
-IR_FixedDef_var::_retn (void)
-{
-  // yield ownership of managed obj reference
-  IR_FixedDef_ptr val = this->ptr_;
-  this->ptr_ = IR_FixedDef::_nil ();
-  return val;
-}
-
-// *************************************************************
-// Inline operations for class IR_FixedDef_out
-// *************************************************************
-
-ACE_INLINE
-IR_FixedDef_out::IR_FixedDef_out (IR_FixedDef_ptr &p)
-  : ptr_ (p)
-{
-  this->ptr_ = IR_FixedDef::_nil ();
-}
-
-ACE_INLINE
-IR_FixedDef_out::IR_FixedDef_out (IR_FixedDef_var &p) // constructor from _var
-  : ptr_ (p.out ())
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = IR_FixedDef::_nil ();
-}
-
-ACE_INLINE
-IR_FixedDef_out::IR_FixedDef_out (const IR_FixedDef_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (IR_FixedDef_out&,p).ptr_)
-{}
-
-ACE_INLINE IR_FixedDef_out &
-IR_FixedDef_out::operator= (const IR_FixedDef_out &p)
-{
-  this->ptr_ = ACE_const_cast (IR_FixedDef_out&,p).ptr_;
-  return *this;
-}
-
-ACE_INLINE IR_FixedDef_out &
-IR_FixedDef_out::operator= (const IR_FixedDef_var &p)
-{
-  this->ptr_ = IR_FixedDef::_duplicate (p.ptr ());
-  return *this;
-}
-
-ACE_INLINE IR_FixedDef_out &
-IR_FixedDef_out::operator= (IR_FixedDef_ptr p)
-{
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE 
-IR_FixedDef_out::operator IR_FixedDef_ptr &() // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_FixedDef_ptr &
-IR_FixedDef_out::ptr (void) // ptr
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_FixedDef_ptr 
-IR_FixedDef_out::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE
-IR_ComponentRepository::IR_ComponentRepository (
-    TAO_Stub *objref,
-    CORBA::Boolean _tao_collocated,
-    TAO_Abstract_ServantBase *servant
-  )
-  : CORBA_Object (objref, _tao_collocated, servant)
-{
-  this->IR_ComponentRepository_setup_collocation (_tao_collocated);
-}
-
-// *************************************************************
-// Inline operations for class IR_ComponentRepository_var
-// *************************************************************
-
-ACE_INLINE
-IR_ComponentRepository_var::IR_ComponentRepository_var (void) // default constructor
-  : ptr_ (IR_ComponentRepository::_nil ())
-{}
-
-ACE_INLINE ::IR_ComponentRepository_ptr
-IR_ComponentRepository_var::ptr (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE
-IR_ComponentRepository_var::IR_ComponentRepository_var (const ::IR_ComponentRepository_var &p) // copy constructor
-  : TAO_Base_var (),
-    ptr_ (IR_ComponentRepository::_duplicate (p.ptr ()))
-{}
-
-ACE_INLINE
-IR_ComponentRepository_var::~IR_ComponentRepository_var (void) // destructor
-{
-  CORBA::release (this->ptr_);
-}
-
-ACE_INLINE IR_ComponentRepository_var &
-IR_ComponentRepository_var::operator= (IR_ComponentRepository_ptr p)
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE IR_ComponentRepository_var &
-IR_ComponentRepository_var::operator= (const ::IR_ComponentRepository_var &p)
-{
-  if (this != &p)
-  {
-    CORBA::release (this->ptr_);
-    this->ptr_ = ::IR_ComponentRepository::_duplicate (p.ptr ());
-  }
-  return *this;
-}
-
-ACE_INLINE 
-IR_ComponentRepository_var::operator const ::IR_ComponentRepository_ptr &() const // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE 
-IR_ComponentRepository_var::operator ::IR_ComponentRepository_ptr &() // cast 
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_ComponentRepository_ptr
-IR_ComponentRepository_var::operator-> (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_ComponentRepository_ptr
-IR_ComponentRepository_var::in (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_ComponentRepository_ptr &
-IR_ComponentRepository_var::inout (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_ComponentRepository_ptr &
-IR_ComponentRepository_var::out (void)
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = ::IR_ComponentRepository::_nil ();
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_ComponentRepository_ptr
-IR_ComponentRepository_var::_retn (void)
-{
-  // yield ownership of managed obj reference
-  ::IR_ComponentRepository_ptr val = this->ptr_;
-  this->ptr_ = ::IR_ComponentRepository::_nil ();
-  return val;
-}
-
-// *************************************************************
-// Inline operations for class IR_ComponentRepository_out
-// *************************************************************
-
-ACE_INLINE
-IR_ComponentRepository_out::IR_ComponentRepository_out (IR_ComponentRepository_ptr &p)
-  : ptr_ (p)
-{
-  this->ptr_ = ::IR_ComponentRepository::_nil ();
-}
-
-ACE_INLINE
-IR_ComponentRepository_out::IR_ComponentRepository_out (IR_ComponentRepository_var &p) // constructor from _var
-  : ptr_ (p.out ())
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = ::IR_ComponentRepository::_nil ();
-}
-
-ACE_INLINE
-IR_ComponentRepository_out::IR_ComponentRepository_out (const ::IR_ComponentRepository_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (IR_ComponentRepository_out &, p).ptr_)
-{}
-
-ACE_INLINE ::IR_ComponentRepository_out &
-IR_ComponentRepository_out::operator= (const ::IR_ComponentRepository_out &p)
-{
-  this->ptr_ = ACE_const_cast (IR_ComponentRepository_out&, p).ptr_;
-  return *this;
-}
-
-ACE_INLINE IR_ComponentRepository_out &
-IR_ComponentRepository_out::operator= (const ::IR_ComponentRepository_var &p)
-{
-  this->ptr_ = ::IR_ComponentRepository::_duplicate (p.ptr ());
-  return *this;
-}
-
-ACE_INLINE IR_ComponentRepository_out &
-IR_ComponentRepository_out::operator= (IR_ComponentRepository_ptr p)
-{
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE 
-IR_ComponentRepository_out::operator ::IR_ComponentRepository_ptr &() // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_ComponentRepository_ptr &
-IR_ComponentRepository_out::ptr (void) // ptr
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_ComponentRepository_ptr
-IR_ComponentRepository_out::operator-> (void)
-{
-  return this->ptr_;
-}
-
-// *************************************************************
-// Inline operations for class IR_ModuleDescription_var
-// *************************************************************
-
-ACE_INLINE
-IR_ModuleDescription_var::IR_ModuleDescription_var (void) // default constructor
-  : ptr_ (0)
-{}
-
-ACE_INLINE
-IR_ModuleDescription_var::IR_ModuleDescription_var (IR_ModuleDescription *p)
-  : ptr_ (p)
-{}
-
-ACE_INLINE
-IR_ModuleDescription_var::IR_ModuleDescription_var (const ::IR_ModuleDescription_var &p) // copy constructor
-{
-  if (p.ptr_)
-    ACE_NEW (this->ptr_, ::IR_ModuleDescription (*p.ptr_));
-  else
-    this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_ModuleDescription_var::~IR_ModuleDescription_var (void) // destructor
-{
-  delete this->ptr_;
-}
-
-ACE_INLINE IR_ModuleDescription_var &
-IR_ModuleDescription_var::operator= (IR_ModuleDescription *p)
-{
-  delete this->ptr_;
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE ::IR_ModuleDescription_var &
-IR_ModuleDescription_var::operator= (const ::IR_ModuleDescription_var &p)
-{
-  if (this != &p)
-    {
-      if (p.ptr_ == 0)
-        {
-          delete this->ptr_;
-          this->ptr_ = 0;
-        }
-      else
-        {
-          IR_ModuleDescription *deep_copy = 
-            new IR_ModuleDescription (*p.ptr_);
-          
-          if (deep_copy != 0)
-            {
-              IR_ModuleDescription *tmp = deep_copy;
-              deep_copy = this->ptr_;
-              this->ptr_ = tmp;
-              delete deep_copy;
-            }
-        }
-    }
-  
-  return *this;
-}
-
-ACE_INLINE const ::IR_ModuleDescription *
-IR_ModuleDescription_var::operator-> (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_ModuleDescription *
-IR_ModuleDescription_var::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE
-IR_ModuleDescription_var::operator const ::IR_ModuleDescription &() const // cast
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE
-IR_ModuleDescription_var::operator ::IR_ModuleDescription &() // cast 
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE
-IR_ModuleDescription_var::operator ::IR_ModuleDescription &() const // cast 
-{
-  return *this->ptr_;
-}
-
-// variable-size types only
-ACE_INLINE
-IR_ModuleDescription_var::operator ::IR_ModuleDescription *&() // cast 
-{
-  return this->ptr_;
-}
-
-ACE_INLINE const ::IR_ModuleDescription &
-IR_ModuleDescription_var::in (void) const
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE ::IR_ModuleDescription &
-IR_ModuleDescription_var::inout (void)
-{
-  return *this->ptr_;
-}
-
-// mapping for variable size 
-ACE_INLINE ::IR_ModuleDescription *&
-IR_ModuleDescription_var::out (void)
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_ModuleDescription *
-IR_ModuleDescription_var::_retn (void)
-{
-  ::IR_ModuleDescription *tmp = this->ptr_;
-  this->ptr_ = 0;
-  return tmp;
-}
-
-ACE_INLINE ::IR_ModuleDescription *
-IR_ModuleDescription_var::ptr (void) const
-{
-  return this->ptr_;
-}
-
-// *************************************************************
-// Inline operations for class IR_ModuleDescription_out
-// *************************************************************
-
-ACE_INLINE
-IR_ModuleDescription_out::IR_ModuleDescription_out (::IR_ModuleDescription *&p)
-  : ptr_ (p)
-{
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_ModuleDescription_out::IR_ModuleDescription_out (IR_ModuleDescription_var &p) // constructor from _var
-  : ptr_ (p.out ())
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_ModuleDescription_out::IR_ModuleDescription_out (const ::IR_ModuleDescription_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (IR_ModuleDescription_out&, p).ptr_)
-{}
-
-ACE_INLINE IR_ModuleDescription_out &
-IR_ModuleDescription_out::operator= (const ::IR_ModuleDescription_out &p)
-{
-  this->ptr_ = ACE_const_cast (IR_ModuleDescription_out&, p).ptr_;
-  return *this;
-}
-
-ACE_INLINE IR_ModuleDescription_out &
-IR_ModuleDescription_out::operator= (IR_ModuleDescription *p)
-{
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE 
-IR_ModuleDescription_out::operator ::IR_ModuleDescription *&() // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_ModuleDescription *&
-IR_ModuleDescription_out::ptr (void) // ptr
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_ModuleDescription *
-IR_ModuleDescription_out::operator-> (void)
-{
-  return this->ptr_;
-}
-
-// *************************************************************
-// Inline operations for class IR_ConstantDescription_var
-// *************************************************************
-
-ACE_INLINE
-IR_ConstantDescription_var::IR_ConstantDescription_var (void) // default constructor
-  : ptr_ (0)
-{}
-
-ACE_INLINE
-IR_ConstantDescription_var::IR_ConstantDescription_var (IR_ConstantDescription *p)
-  : ptr_ (p)
-{}
-
-ACE_INLINE
-IR_ConstantDescription_var::IR_ConstantDescription_var (const ::IR_ConstantDescription_var &p) // copy constructor
-{
-  if (p.ptr_)
-    ACE_NEW (this->ptr_, ::IR_ConstantDescription (*p.ptr_));
-  else
-    this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_ConstantDescription_var::~IR_ConstantDescription_var (void) // destructor
-{
-  delete this->ptr_;
-}
-
-ACE_INLINE IR_ConstantDescription_var &
-IR_ConstantDescription_var::operator= (IR_ConstantDescription *p)
-{
-  delete this->ptr_;
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE ::IR_ConstantDescription_var &
-IR_ConstantDescription_var::operator= (const ::IR_ConstantDescription_var &p)
-{
-  if (this != &p)
-    {
-      if (p.ptr_ == 0)
-        {
-          delete this->ptr_;
-          this->ptr_ = 0;
-        }
-      else
-        {
-          IR_ConstantDescription *deep_copy = 
-            new IR_ConstantDescription (*p.ptr_);
-          
-          if (deep_copy != 0)
-            {
-              IR_ConstantDescription *tmp = deep_copy;
-              deep_copy = this->ptr_;
-              this->ptr_ = tmp;
-              delete deep_copy;
-            }
-        }
-    }
-  
-  return *this;
-}
-
-ACE_INLINE const ::IR_ConstantDescription *
-IR_ConstantDescription_var::operator-> (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_ConstantDescription *
-IR_ConstantDescription_var::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE
-IR_ConstantDescription_var::operator const ::IR_ConstantDescription &() const // cast
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE
-IR_ConstantDescription_var::operator ::IR_ConstantDescription &() // cast 
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE
-IR_ConstantDescription_var::operator ::IR_ConstantDescription &() const // cast 
-{
-  return *this->ptr_;
-}
-
-// variable-size types only
-ACE_INLINE
-IR_ConstantDescription_var::operator ::IR_ConstantDescription *&() // cast 
-{
-  return this->ptr_;
-}
-
-ACE_INLINE const ::IR_ConstantDescription &
-IR_ConstantDescription_var::in (void) const
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE ::IR_ConstantDescription &
-IR_ConstantDescription_var::inout (void)
-{
-  return *this->ptr_;
-}
-
-// mapping for variable size 
-ACE_INLINE ::IR_ConstantDescription *&
-IR_ConstantDescription_var::out (void)
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_ConstantDescription *
-IR_ConstantDescription_var::_retn (void)
-{
-  ::IR_ConstantDescription *tmp = this->ptr_;
-  this->ptr_ = 0;
-  return tmp;
-}
-
-ACE_INLINE ::IR_ConstantDescription *
-IR_ConstantDescription_var::ptr (void) const
-{
-  return this->ptr_;
-}
-
-// *************************************************************
-// Inline operations for class IR_ConstantDescription_out
-// *************************************************************
-
-ACE_INLINE
-IR_ConstantDescription_out::IR_ConstantDescription_out (::IR_ConstantDescription *&p)
-  : ptr_ (p)
-{
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_ConstantDescription_out::IR_ConstantDescription_out (IR_ConstantDescription_var &p) // constructor from _var
-  : ptr_ (p.out ())
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_ConstantDescription_out::IR_ConstantDescription_out (const ::IR_ConstantDescription_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (IR_ConstantDescription_out&, p).ptr_)
-{}
-
-ACE_INLINE IR_ConstantDescription_out &
-IR_ConstantDescription_out::operator= (const ::IR_ConstantDescription_out &p)
-{
-  this->ptr_ = ACE_const_cast (IR_ConstantDescription_out&, p).ptr_;
-  return *this;
-}
-
-ACE_INLINE IR_ConstantDescription_out &
-IR_ConstantDescription_out::operator= (IR_ConstantDescription *p)
-{
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE 
-IR_ConstantDescription_out::operator ::IR_ConstantDescription *&() // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_ConstantDescription *&
-IR_ConstantDescription_out::ptr (void) // ptr
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_ConstantDescription *
-IR_ConstantDescription_out::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE
-IR_TypedefDef::IR_TypedefDef (
-    TAO_Stub *objref,
-    CORBA::Boolean _tao_collocated,
-    TAO_Abstract_ServantBase *servant
-  )
-  : CORBA_Object (objref, _tao_collocated, servant)
-{
-  this->IR_TypedefDef_setup_collocation (_tao_collocated);
-}
-
-// *************************************************************
-// Inline operations for class IR_TypedefDef_var
-// *************************************************************
-
-ACE_INLINE
-IR_TypedefDef_var::IR_TypedefDef_var (void) // default constructor
-  : ptr_ (IR_TypedefDef::_nil ())
-{}
-
-ACE_INLINE ::IR_TypedefDef_ptr
-IR_TypedefDef_var::ptr (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE
-IR_TypedefDef_var::IR_TypedefDef_var (const ::IR_TypedefDef_var &p) // copy constructor
-  : TAO_Base_var (),
-    ptr_ (IR_TypedefDef::_duplicate (p.ptr ()))
-{}
-
-ACE_INLINE
-IR_TypedefDef_var::~IR_TypedefDef_var (void) // destructor
-{
-  CORBA::release (this->ptr_);
-}
-
-ACE_INLINE IR_TypedefDef_var &
-IR_TypedefDef_var::operator= (IR_TypedefDef_ptr p)
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE IR_TypedefDef_var &
-IR_TypedefDef_var::operator= (const ::IR_TypedefDef_var &p)
-{
-  if (this != &p)
-  {
-    CORBA::release (this->ptr_);
-    this->ptr_ = ::IR_TypedefDef::_duplicate (p.ptr ());
-  }
-  return *this;
-}
-
-ACE_INLINE 
-IR_TypedefDef_var::operator const ::IR_TypedefDef_ptr &() const // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE 
-IR_TypedefDef_var::operator ::IR_TypedefDef_ptr &() // cast 
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_TypedefDef_ptr
-IR_TypedefDef_var::operator-> (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_TypedefDef_ptr
-IR_TypedefDef_var::in (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_TypedefDef_ptr &
-IR_TypedefDef_var::inout (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_TypedefDef_ptr &
-IR_TypedefDef_var::out (void)
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = ::IR_TypedefDef::_nil ();
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_TypedefDef_ptr
-IR_TypedefDef_var::_retn (void)
-{
-  // yield ownership of managed obj reference
-  ::IR_TypedefDef_ptr val = this->ptr_;
-  this->ptr_ = ::IR_TypedefDef::_nil ();
-  return val;
-}
-
-// *************************************************************
-// Inline operations for class IR_TypedefDef_out
-// *************************************************************
-
-ACE_INLINE
-IR_TypedefDef_out::IR_TypedefDef_out (IR_TypedefDef_ptr &p)
-  : ptr_ (p)
-{
-  this->ptr_ = ::IR_TypedefDef::_nil ();
-}
-
-ACE_INLINE
-IR_TypedefDef_out::IR_TypedefDef_out (IR_TypedefDef_var &p) // constructor from _var
-  : ptr_ (p.out ())
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = ::IR_TypedefDef::_nil ();
-}
-
-ACE_INLINE
-IR_TypedefDef_out::IR_TypedefDef_out (const ::IR_TypedefDef_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (IR_TypedefDef_out &, p).ptr_)
-{}
-
-ACE_INLINE ::IR_TypedefDef_out &
-IR_TypedefDef_out::operator= (const ::IR_TypedefDef_out &p)
-{
-  this->ptr_ = ACE_const_cast (IR_TypedefDef_out&, p).ptr_;
-  return *this;
-}
-
-ACE_INLINE IR_TypedefDef_out &
-IR_TypedefDef_out::operator= (const ::IR_TypedefDef_var &p)
-{
-  this->ptr_ = ::IR_TypedefDef::_duplicate (p.ptr ());
-  return *this;
-}
-
-ACE_INLINE IR_TypedefDef_out &
-IR_TypedefDef_out::operator= (IR_TypedefDef_ptr p)
-{
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE 
-IR_TypedefDef_out::operator ::IR_TypedefDef_ptr &() // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_TypedefDef_ptr &
-IR_TypedefDef_out::ptr (void) // ptr
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_TypedefDef_ptr
-IR_TypedefDef_out::operator-> (void)
-{
-  return this->ptr_;
-}
-
-// *************************************************************
-// Inline operations for class IR_TypeDescription_var
-// *************************************************************
-
-ACE_INLINE
-IR_TypeDescription_var::IR_TypeDescription_var (void) // default constructor
-  : ptr_ (0)
-{}
-
-ACE_INLINE
-IR_TypeDescription_var::IR_TypeDescription_var (IR_TypeDescription *p)
-  : ptr_ (p)
-{}
-
-ACE_INLINE
-IR_TypeDescription_var::IR_TypeDescription_var (const ::IR_TypeDescription_var &p) // copy constructor
-{
-  if (p.ptr_)
-    ACE_NEW (this->ptr_, ::IR_TypeDescription (*p.ptr_));
-  else
-    this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_TypeDescription_var::~IR_TypeDescription_var (void) // destructor
-{
-  delete this->ptr_;
-}
-
-ACE_INLINE IR_TypeDescription_var &
-IR_TypeDescription_var::operator= (IR_TypeDescription *p)
-{
-  delete this->ptr_;
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE ::IR_TypeDescription_var &
-IR_TypeDescription_var::operator= (const ::IR_TypeDescription_var &p)
-{
-  if (this != &p)
-    {
-      if (p.ptr_ == 0)
-        {
-          delete this->ptr_;
-          this->ptr_ = 0;
-        }
-      else
-        {
-          IR_TypeDescription *deep_copy = 
-            new IR_TypeDescription (*p.ptr_);
-          
-          if (deep_copy != 0)
-            {
-              IR_TypeDescription *tmp = deep_copy;
-              deep_copy = this->ptr_;
-              this->ptr_ = tmp;
-              delete deep_copy;
-            }
-        }
-    }
-  
-  return *this;
-}
-
-ACE_INLINE const ::IR_TypeDescription *
-IR_TypeDescription_var::operator-> (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_TypeDescription *
-IR_TypeDescription_var::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE
-IR_TypeDescription_var::operator const ::IR_TypeDescription &() const // cast
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE
-IR_TypeDescription_var::operator ::IR_TypeDescription &() // cast 
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE
-IR_TypeDescription_var::operator ::IR_TypeDescription &() const // cast 
-{
-  return *this->ptr_;
-}
-
-// variable-size types only
-ACE_INLINE
-IR_TypeDescription_var::operator ::IR_TypeDescription *&() // cast 
-{
-  return this->ptr_;
-}
-
-ACE_INLINE const ::IR_TypeDescription &
-IR_TypeDescription_var::in (void) const
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE ::IR_TypeDescription &
-IR_TypeDescription_var::inout (void)
-{
-  return *this->ptr_;
-}
-
-// mapping for variable size 
-ACE_INLINE ::IR_TypeDescription *&
-IR_TypeDescription_var::out (void)
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_TypeDescription *
-IR_TypeDescription_var::_retn (void)
-{
-  ::IR_TypeDescription *tmp = this->ptr_;
-  this->ptr_ = 0;
-  return tmp;
-}
-
-ACE_INLINE ::IR_TypeDescription *
-IR_TypeDescription_var::ptr (void) const
-{
-  return this->ptr_;
-}
-
-// *************************************************************
-// Inline operations for class IR_TypeDescription_out
-// *************************************************************
-
-ACE_INLINE
-IR_TypeDescription_out::IR_TypeDescription_out (::IR_TypeDescription *&p)
-  : ptr_ (p)
-{
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_TypeDescription_out::IR_TypeDescription_out (IR_TypeDescription_var &p) // constructor from _var
-  : ptr_ (p.out ())
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_TypeDescription_out::IR_TypeDescription_out (const ::IR_TypeDescription_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (IR_TypeDescription_out&, p).ptr_)
-{}
-
-ACE_INLINE IR_TypeDescription_out &
-IR_TypeDescription_out::operator= (const ::IR_TypeDescription_out &p)
-{
-  this->ptr_ = ACE_const_cast (IR_TypeDescription_out&, p).ptr_;
-  return *this;
-}
-
-ACE_INLINE IR_TypeDescription_out &
-IR_TypeDescription_out::operator= (IR_TypeDescription *p)
-{
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE 
-IR_TypeDescription_out::operator ::IR_TypeDescription *&() // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_TypeDescription *&
-IR_TypeDescription_out::ptr (void) // ptr
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_TypeDescription *
-IR_TypeDescription_out::operator-> (void)
-{
-  return this->ptr_;
-}
-
-// *************************************************************
-// Inline operations for class IR_ExceptionDescription_var
-// *************************************************************
-
-ACE_INLINE
-IR_ExceptionDescription_var::IR_ExceptionDescription_var (void) // default constructor
-  : ptr_ (0)
-{}
-
-ACE_INLINE
-IR_ExceptionDescription_var::IR_ExceptionDescription_var (IR_ExceptionDescription *p)
-  : ptr_ (p)
-{}
-
-ACE_INLINE
-IR_ExceptionDescription_var::IR_ExceptionDescription_var (const ::IR_ExceptionDescription_var &p) // copy constructor
-{
-  if (p.ptr_)
-    ACE_NEW (this->ptr_, ::IR_ExceptionDescription (*p.ptr_));
-  else
-    this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_ExceptionDescription_var::~IR_ExceptionDescription_var (void) // destructor
-{
-  delete this->ptr_;
-}
-
-ACE_INLINE IR_ExceptionDescription_var &
-IR_ExceptionDescription_var::operator= (IR_ExceptionDescription *p)
-{
-  delete this->ptr_;
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE ::IR_ExceptionDescription_var &
-IR_ExceptionDescription_var::operator= (const ::IR_ExceptionDescription_var &p)
-{
-  if (this != &p)
-    {
-      if (p.ptr_ == 0)
-        {
-          delete this->ptr_;
-          this->ptr_ = 0;
-        }
-      else
-        {
-          IR_ExceptionDescription *deep_copy = 
-            new IR_ExceptionDescription (*p.ptr_);
-          
-          if (deep_copy != 0)
-            {
-              IR_ExceptionDescription *tmp = deep_copy;
-              deep_copy = this->ptr_;
-              this->ptr_ = tmp;
-              delete deep_copy;
-            }
-        }
-    }
-  
-  return *this;
-}
-
-ACE_INLINE const ::IR_ExceptionDescription *
-IR_ExceptionDescription_var::operator-> (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_ExceptionDescription *
-IR_ExceptionDescription_var::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE
-IR_ExceptionDescription_var::operator const ::IR_ExceptionDescription &() const // cast
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE
-IR_ExceptionDescription_var::operator ::IR_ExceptionDescription &() // cast 
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE
-IR_ExceptionDescription_var::operator ::IR_ExceptionDescription &() const // cast 
-{
-  return *this->ptr_;
-}
-
-// variable-size types only
-ACE_INLINE
-IR_ExceptionDescription_var::operator ::IR_ExceptionDescription *&() // cast 
-{
-  return this->ptr_;
-}
-
-ACE_INLINE const ::IR_ExceptionDescription &
-IR_ExceptionDescription_var::in (void) const
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE ::IR_ExceptionDescription &
-IR_ExceptionDescription_var::inout (void)
-{
-  return *this->ptr_;
-}
-
-// mapping for variable size 
-ACE_INLINE ::IR_ExceptionDescription *&
-IR_ExceptionDescription_var::out (void)
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_ExceptionDescription *
-IR_ExceptionDescription_var::_retn (void)
-{
-  ::IR_ExceptionDescription *tmp = this->ptr_;
-  this->ptr_ = 0;
-  return tmp;
-}
-
-ACE_INLINE ::IR_ExceptionDescription *
-IR_ExceptionDescription_var::ptr (void) const
-{
-  return this->ptr_;
-}
-
-// *************************************************************
-// Inline operations for class IR_ExceptionDescription_out
-// *************************************************************
-
-ACE_INLINE
-IR_ExceptionDescription_out::IR_ExceptionDescription_out (::IR_ExceptionDescription *&p)
-  : ptr_ (p)
-{
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_ExceptionDescription_out::IR_ExceptionDescription_out (IR_ExceptionDescription_var &p) // constructor from _var
-  : ptr_ (p.out ())
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_ExceptionDescription_out::IR_ExceptionDescription_out (const ::IR_ExceptionDescription_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (IR_ExceptionDescription_out&, p).ptr_)
-{}
-
-ACE_INLINE IR_ExceptionDescription_out &
-IR_ExceptionDescription_out::operator= (const ::IR_ExceptionDescription_out &p)
-{
-  this->ptr_ = ACE_const_cast (IR_ExceptionDescription_out&, p).ptr_;
-  return *this;
-}
-
-ACE_INLINE IR_ExceptionDescription_out &
-IR_ExceptionDescription_out::operator= (IR_ExceptionDescription *p)
-{
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE 
-IR_ExceptionDescription_out::operator ::IR_ExceptionDescription *&() // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_ExceptionDescription *&
-IR_ExceptionDescription_out::ptr (void) // ptr
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_ExceptionDescription *
-IR_ExceptionDescription_out::operator-> (void)
-{
-  return this->ptr_;
-}
-
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  
-  ACE_INLINE IR_ExceptionDef **
-  _TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq::allocbuf (CORBA::ULong nelems)
-  {
-    IR_ExceptionDef **buf = 0;
-    
-    ACE_NEW_RETURN (buf, IR_ExceptionDef*[nelems], 0);
-    
-    for (CORBA::ULong i = 0; i < nelems; i++)
-      buf[i] = IR_ExceptionDef::_nil ();
-    
-    return buf;
-  }
-  
-  ACE_INLINE void 
-  _TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq::freebuf (IR_ExceptionDef **buffer)
-  {
-    if (buffer == 0)
-      return;
-    delete[] buffer;
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq::_TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq (void)
-  {
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq::_TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq (CORBA::ULong maximum)
-    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq::allocbuf (maximum))
-  {
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq::_TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq (CORBA::ULong maximum,
-    CORBA::ULong length,
-    IR_ExceptionDef* *value,
-    CORBA::Boolean release)
-  : TAO_Unbounded_Base_Sequence (maximum, length, value, release)
-  {
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq::_TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq(const _TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq &rhs)
-    : TAO_Unbounded_Base_Sequence (rhs)
-  {
-    if (rhs.buffer_ != 0)
-    {
-      IR_ExceptionDef **tmp1 = _TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq::allocbuf (this->maximum_);
-      IR_ExceptionDef ** const tmp2 = ACE_reinterpret_cast (IR_ExceptionDef ** ACE_CAST_CONST, rhs.buffer_);
-      
-      for (CORBA::ULong i = 0; i < rhs.length_; ++i)
-        tmp1[i] = IR_ExceptionDef::_duplicate (tmp2[i]);
-      
-      this->buffer_ = tmp1;
-    }
-    else
-    {
-      this->buffer_ = 0;
-    }
-  }
-  
-  ACE_INLINE _TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq &
-  _TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq::operator= (const _TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq &rhs)
-  {
-    if (this == &rhs)
-      return *this;
-    
-    if (this->release_)
-    {
-      IR_ExceptionDef **tmp = ACE_reinterpret_cast (IR_ExceptionDef **, this->buffer_);
-      
-      for (CORBA::ULong i = 0; i < this->length_; ++i)
-      {
-        CORBA::release (tmp[i]);
-        tmp[i] = IR_ExceptionDef::_nil ();
-      }
-      if (this->maximum_ < rhs.maximum_)
-      {
-        _TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq::freebuf (tmp);
-        this->buffer_ = _TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq::allocbuf (rhs.maximum_);
-      }
-    }
-    else
-      this->buffer_ = _TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq::allocbuf (rhs.maximum_);
-    
-    TAO_Unbounded_Base_Sequence::operator= (rhs);
-    
-    IR_ExceptionDef **tmp1 = ACE_reinterpret_cast (IR_ExceptionDef **, this->buffer_);
-    IR_ExceptionDef ** const tmp2 = ACE_reinterpret_cast (IR_ExceptionDef ** ACE_CAST_CONST, rhs.buffer_);
-    
-    for (CORBA::ULong i = 0; i < rhs.length_; ++i)
-      tmp1[i] = IR_ExceptionDef::_duplicate (tmp2[i]);
-    
-    return *this;
-  }
-  
-  ACE_INLINE TAO_Object_Manager<IR_ExceptionDef,IR_ExceptionDef_var>
-  _TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq::operator[] (CORBA::ULong index) const
-  // read-write accessor
-  {
-    ACE_ASSERT (index < this->maximum_);
-    IR_ExceptionDef ** const tmp = ACE_reinterpret_cast (IR_ExceptionDef ** ACE_CAST_CONST, this->buffer_);
-    return TAO_Object_Manager<IR_ExceptionDef,IR_ExceptionDef_var> (tmp + index, this->release_);
-  }
-  
-  ACE_INLINE IR_ExceptionDef* *
-  _TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq::get_buffer (CORBA::Boolean orphan)
-  {
-    IR_ExceptionDef **result = 0;
-    if (orphan == 0)
-    {
-      // We retain ownership.
-      if (this->buffer_ == 0)
-      {
-        result = _TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq::allocbuf (this->maximum_);
-        this->buffer_ = result;
-        this->release_ = 1;
-      }
-      else
-      {
-        result = ACE_reinterpret_cast (IR_ExceptionDef**, this->buffer_);
-      }
-    }
-    else // if (orphan == 1)
-    {
-      if (this->release_ != 0)
-      {
-        // We set the state back to default and relinquish
-        // ownership.
-        result = ACE_reinterpret_cast(IR_ExceptionDef**,this->buffer_);
-        this->maximum_ = 0;
-        this->length_ = 0;
-        this->buffer_ = 0;
-        this->release_ = 0;
-      }
-    }
-    return result;
-  }
-  
-  ACE_INLINE const IR_ExceptionDef* *
-  _TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq::get_buffer (void) const
-  {
-    return ACE_reinterpret_cast(const IR_ExceptionDef ** ACE_CAST_CONST, this->buffer_);
-  }
-  
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
-
-// *************************************************************
-// Inline operations for class IR_ExceptionDefSeq_var
-// *************************************************************
-
-ACE_INLINE
-IR_ExceptionDefSeq_var::IR_ExceptionDefSeq_var (void) // default constructor
-  : ptr_ (0)
-{}
-
-ACE_INLINE
-IR_ExceptionDefSeq_var::IR_ExceptionDefSeq_var (IR_ExceptionDefSeq *p)
-  : ptr_ (p)
-{}
-
-ACE_INLINE
-IR_ExceptionDefSeq_var::IR_ExceptionDefSeq_var (const ::IR_ExceptionDefSeq_var &p) // copy constructor
-{
-  if (p.ptr_)
-    ACE_NEW (this->ptr_, ::IR_ExceptionDefSeq (*p.ptr_));
-  else
-    this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_ExceptionDefSeq_var::~IR_ExceptionDefSeq_var (void) // destructor
-{
-  delete this->ptr_;
-}
-
-ACE_INLINE IR_ExceptionDefSeq_var &
-IR_ExceptionDefSeq_var::operator= (IR_ExceptionDefSeq *p)
-{
-  delete this->ptr_;
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE IR_ExceptionDefSeq_var &
-IR_ExceptionDefSeq_var::operator= (const ::IR_ExceptionDefSeq_var &p) // deep copy
-{
-  if (this != &p)
-    {
-      if (p.ptr_ == 0)
-        {
-          delete this->ptr_;
-          this->ptr_ = 0;
-        }
-      else
-        {
-          IR_ExceptionDefSeq *deep_copy = 
-            new IR_ExceptionDefSeq (*p.ptr_);
-          
-          if (deep_copy != 0)
-            {
-              IR_ExceptionDefSeq *tmp = deep_copy;
-              deep_copy = this->ptr_;
-              this->ptr_ = tmp;
-              delete deep_copy;
-            }
-        }
-    }
-  
-  return *this;
-}
-
-ACE_INLINE const ::IR_ExceptionDefSeq *
-IR_ExceptionDefSeq_var::operator-> (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_ExceptionDefSeq *
-IR_ExceptionDefSeq_var::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE 
-IR_ExceptionDefSeq_var::operator const ::IR_ExceptionDefSeq &() const // cast
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE 
-IR_ExceptionDefSeq_var::operator ::IR_ExceptionDefSeq &() // cast 
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE 
-IR_ExceptionDefSeq_var::operator ::IR_ExceptionDefSeq &() const // cast 
-{
-  return *this->ptr_;
-}
-
-// variable-size types only
-ACE_INLINE
-IR_ExceptionDefSeq_var::operator ::IR_ExceptionDefSeq *&() // cast 
-{
-  return this->ptr_;
-}
-
-ACE_INLINE TAO_Object_Manager<IR_ExceptionDef, IR_ExceptionDef_var>
-IR_ExceptionDefSeq_var::operator[] (CORBA::ULong index)
-{
-  return this->ptr_->operator[] (index);
-}
-
-ACE_INLINE const ::IR_ExceptionDefSeq &
-IR_ExceptionDefSeq_var::in (void) const
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE ::IR_ExceptionDefSeq &
-IR_ExceptionDefSeq_var::inout (void)
-{
-  return *this->ptr_;
-}
-
-// mapping for variable size 
-ACE_INLINE ::IR_ExceptionDefSeq *&
-IR_ExceptionDefSeq_var::out (void)
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_ExceptionDefSeq *
-IR_ExceptionDefSeq_var::_retn (void)
-{
-  ::IR_ExceptionDefSeq *tmp = this->ptr_;
-  this->ptr_ = 0;
-  return tmp;
-}
-
-ACE_INLINE ::IR_ExceptionDefSeq *
-IR_ExceptionDefSeq_var::ptr (void) const
-{
-  return this->ptr_;
-}
-
-// *************************************************************
-// Inline operations for class IR_ExceptionDefSeq_out
-// *************************************************************
-
-ACE_INLINE
-IR_ExceptionDefSeq_out::IR_ExceptionDefSeq_out (IR_ExceptionDefSeq *&p)
-  : ptr_ (p)
-{
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_ExceptionDefSeq_out::IR_ExceptionDefSeq_out (IR_ExceptionDefSeq_var &p) // constructor from _var
-  : ptr_ (p.out ())
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_ExceptionDefSeq_out::IR_ExceptionDefSeq_out (const ::IR_ExceptionDefSeq_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (IR_ExceptionDefSeq_out&, p).ptr_)
-{}
-
-ACE_INLINE ::IR_ExceptionDefSeq_out &
-IR_ExceptionDefSeq_out::operator= (const ::IR_ExceptionDefSeq_out &p)
-{
-  this->ptr_ = ACE_const_cast (IR_ExceptionDefSeq_out&, p).ptr_;
-  return *this;
-}
-
-ACE_INLINE ::IR_ExceptionDefSeq_out &
-IR_ExceptionDefSeq_out::operator= (IR_ExceptionDefSeq *p)
-{
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE 
-IR_ExceptionDefSeq_out::operator ::IR_ExceptionDefSeq *&() // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_ExceptionDefSeq *&
-IR_ExceptionDefSeq_out::ptr (void) // ptr
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_ExceptionDefSeq *
-IR_ExceptionDefSeq_out::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE TAO_Object_Manager<IR_ExceptionDef, IR_ExceptionDef_var>
-IR_ExceptionDefSeq_out::operator[] (CORBA::ULong index)
-{
-  return this->ptr_->operator[] (index);
-}
-
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  
-  // = Static operations.
-  ACE_INLINE IR_ExceptionDescription *
-  _TAO_Unbounded_Sequence_IR_ExcDescriptionSeq::allocbuf (CORBA::ULong size)
-  // Allocate storage for the sequence.
-  {
-    IR_ExceptionDescription *retval = 0;
-    ACE_NEW_RETURN (retval, IR_ExceptionDescription[size], 0);
-    return retval;
-  }
-  
-  ACE_INLINE void _TAO_Unbounded_Sequence_IR_ExcDescriptionSeq::freebuf (IR_ExceptionDescription *buffer)
-  // Free the sequence.
-  {
-    delete [] buffer;
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Sequence_IR_ExcDescriptionSeq::_TAO_Unbounded_Sequence_IR_ExcDescriptionSeq (void) // Default constructor.
-  {
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Sequence_IR_ExcDescriptionSeq::_TAO_Unbounded_Sequence_IR_ExcDescriptionSeq (CORBA::ULong maximum) // Constructor using a maximum length value.
-    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Sequence_IR_ExcDescriptionSeq::allocbuf (maximum))
-  {
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Sequence_IR_ExcDescriptionSeq::_TAO_Unbounded_Sequence_IR_ExcDescriptionSeq (CORBA::ULong maximum,
-    CORBA::ULong length,
-    IR_ExceptionDescription *data,
-    CORBA::Boolean release)
-  : TAO_Unbounded_Base_Sequence (maximum, length, data, release)
-  {
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Sequence_IR_ExcDescriptionSeq::_TAO_Unbounded_Sequence_IR_ExcDescriptionSeq (const _TAO_Unbounded_Sequence_IR_ExcDescriptionSeq &rhs)
-  // Copy constructor.
-    : TAO_Unbounded_Base_Sequence (rhs)
-  {
-    if (rhs.buffer_ != 0)
-    {
-      IR_ExceptionDescription *tmp1 = _TAO_Unbounded_Sequence_IR_ExcDescriptionSeq::allocbuf (this->maximum_);
-      IR_ExceptionDescription * const tmp2 = ACE_reinterpret_cast (IR_ExceptionDescription * ACE_CAST_CONST, rhs.buffer_);
-      
-      for (CORBA::ULong i = 0; i < this->length_; ++i)
-        tmp1[i] = tmp2[i];
-      
-      this->buffer_ = tmp1;
-    }
-    else
-    {
-      this->buffer_ = 0;
-    }
-  }
-  
-  ACE_INLINE _TAO_Unbounded_Sequence_IR_ExcDescriptionSeq &
-  _TAO_Unbounded_Sequence_IR_ExcDescriptionSeq::operator= (const _TAO_Unbounded_Sequence_IR_ExcDescriptionSeq &rhs)
-  // Assignment operator.
-  {
-    if (this == &rhs)
-      return *this;
-    
-    if (this->release_)
-    {
-      if (this->maximum_ < rhs.maximum_)
-      {
-        // free the old buffer
-        IR_ExceptionDescription *tmp = ACE_reinterpret_cast (IR_ExceptionDescription *, this->buffer_);
-        _TAO_Unbounded_Sequence_IR_ExcDescriptionSeq::freebuf (tmp);
-        this->buffer_ = _TAO_Unbounded_Sequence_IR_ExcDescriptionSeq::allocbuf (rhs.maximum_);
-      }
-    }
-    else
-      this->buffer_ = _TAO_Unbounded_Sequence_IR_ExcDescriptionSeq::allocbuf (rhs.maximum_);
-    
-    TAO_Unbounded_Base_Sequence::operator= (rhs);
-    
-    IR_ExceptionDescription *tmp1 = ACE_reinterpret_cast (IR_ExceptionDescription *, this->buffer_);
-    IR_ExceptionDescription * const tmp2 = ACE_reinterpret_cast (IR_ExceptionDescription * ACE_CAST_CONST, rhs.buffer_);
-    
-    for (CORBA::ULong i = 0; i < this->length_; ++i)
-      tmp1[i] = tmp2[i];
-    
-    return *this;
-  }
-  
-  // = Accessors.
-  ACE_INLINE IR_ExceptionDescription &
-  _TAO_Unbounded_Sequence_IR_ExcDescriptionSeq::operator[] (CORBA::ULong i)
-  // operator []
-  {
-    ACE_ASSERT (i < this->maximum_);
-    IR_ExceptionDescription* tmp = ACE_reinterpret_cast(IR_ExceptionDescription*,this->buffer_);
-    return tmp[i];
-  }
-  
-  ACE_INLINE const IR_ExceptionDescription &
-  _TAO_Unbounded_Sequence_IR_ExcDescriptionSeq::operator[] (CORBA::ULong i) const
-  // operator []
-  {
-    ACE_ASSERT (i < this->maximum_);
-    IR_ExceptionDescription * const tmp = ACE_reinterpret_cast (IR_ExceptionDescription* ACE_CAST_CONST, this->buffer_);
-    return tmp[i];
-  }
-  
-  // Implement the TAO_Base_Sequence methods (see Sequence.h)
-  
-  ACE_INLINE IR_ExceptionDescription *
-  _TAO_Unbounded_Sequence_IR_ExcDescriptionSeq::get_buffer (CORBA::Boolean orphan)
-  {
-    IR_ExceptionDescription *result = 0;
-    if (orphan == 0)
-    {
-      // We retain ownership.
-      if (this->buffer_ == 0)
-      {
-        result = _TAO_Unbounded_Sequence_IR_ExcDescriptionSeq::allocbuf (this->length_);
-        this->buffer_ = result;
-        this->release_ = 1;
-      }
-      else
-      {
-        result = ACE_reinterpret_cast (IR_ExceptionDescription*, this->buffer_);
-      }
-    }
-    else // if (orphan == 1)
-    {
-      if (this->release_ != 0)
-      {
-        // We set the state back to default and relinquish
-        // ownership.
-        result = ACE_reinterpret_cast(IR_ExceptionDescription*,this->buffer_);
-        this->maximum_ = 0;
-        this->length_ = 0;
-        this->buffer_ = 0;
-        this->release_ = 0;
-      }
-    }
-    return result;
-  }
-  
-  ACE_INLINE const IR_ExceptionDescription *
-  _TAO_Unbounded_Sequence_IR_ExcDescriptionSeq::get_buffer (void) const
-  {
-    return ACE_reinterpret_cast(const IR_ExceptionDescription * ACE_CAST_CONST, this->buffer_);
-  }
-  
-  ACE_INLINE void
-  _TAO_Unbounded_Sequence_IR_ExcDescriptionSeq::replace (CORBA::ULong max,
-  CORBA::ULong length,
-  IR_ExceptionDescription *data,
-  CORBA::Boolean release)
-  {
-    this->maximum_ = max;
-    this->length_ = length;
-    if (this->buffer_ && this->release_ == 1)
-    {
-      IR_ExceptionDescription *tmp = ACE_reinterpret_cast(IR_ExceptionDescription*,this->buffer_);
-      _TAO_Unbounded_Sequence_IR_ExcDescriptionSeq::freebuf (tmp);
-    }
-    this->buffer_ = data;
-    this->release_ = release;
-  }
-  
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
-
-// *************************************************************
-// Inline operations for class IR_ExcDescriptionSeq_var
-// *************************************************************
-
-ACE_INLINE
-IR_ExcDescriptionSeq_var::IR_ExcDescriptionSeq_var (void) // default constructor
-  : ptr_ (0)
-{}
-
-ACE_INLINE
-IR_ExcDescriptionSeq_var::IR_ExcDescriptionSeq_var (IR_ExcDescriptionSeq *p)
-  : ptr_ (p)
-{}
-
-ACE_INLINE
-IR_ExcDescriptionSeq_var::IR_ExcDescriptionSeq_var (const ::IR_ExcDescriptionSeq_var &p) // copy constructor
-{
-  if (p.ptr_)
-    ACE_NEW (this->ptr_, ::IR_ExcDescriptionSeq (*p.ptr_));
-  else
-    this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_ExcDescriptionSeq_var::~IR_ExcDescriptionSeq_var (void) // destructor
-{
-  delete this->ptr_;
-}
-
-ACE_INLINE IR_ExcDescriptionSeq_var &
-IR_ExcDescriptionSeq_var::operator= (IR_ExcDescriptionSeq *p)
-{
-  delete this->ptr_;
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE IR_ExcDescriptionSeq_var &
-IR_ExcDescriptionSeq_var::operator= (const ::IR_ExcDescriptionSeq_var &p) // deep copy
-{
-  if (this != &p)
-    {
-      if (p.ptr_ == 0)
-        {
-          delete this->ptr_;
-          this->ptr_ = 0;
-        }
-      else
-        {
-          IR_ExcDescriptionSeq *deep_copy = 
-            new IR_ExcDescriptionSeq (*p.ptr_);
-          
-          if (deep_copy != 0)
-            {
-              IR_ExcDescriptionSeq *tmp = deep_copy;
-              deep_copy = this->ptr_;
-              this->ptr_ = tmp;
-              delete deep_copy;
-            }
-        }
-    }
-  
-  return *this;
-}
-
-ACE_INLINE const ::IR_ExcDescriptionSeq *
-IR_ExcDescriptionSeq_var::operator-> (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_ExcDescriptionSeq *
-IR_ExcDescriptionSeq_var::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE 
-IR_ExcDescriptionSeq_var::operator const ::IR_ExcDescriptionSeq &() const // cast
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE 
-IR_ExcDescriptionSeq_var::operator ::IR_ExcDescriptionSeq &() // cast 
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE 
-IR_ExcDescriptionSeq_var::operator ::IR_ExcDescriptionSeq &() const // cast 
-{
-  return *this->ptr_;
-}
-
-// variable-size types only
-ACE_INLINE
-IR_ExcDescriptionSeq_var::operator ::IR_ExcDescriptionSeq *&() // cast 
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_ExceptionDescription &
-IR_ExcDescriptionSeq_var::operator[] (CORBA::ULong index)
-{
-  return this->ptr_->operator[] (index);
-}
-
-ACE_INLINE const IR_ExceptionDescription &
-IR_ExcDescriptionSeq_var::operator[] (CORBA::ULong index) const
-{
-  return ACE_const_cast (const IR_ExceptionDescription &, this->ptr_->operator[] (index));
-}
-
-ACE_INLINE const ::IR_ExcDescriptionSeq &
-IR_ExcDescriptionSeq_var::in (void) const
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE ::IR_ExcDescriptionSeq &
-IR_ExcDescriptionSeq_var::inout (void)
-{
-  return *this->ptr_;
-}
-
-// mapping for variable size 
-ACE_INLINE ::IR_ExcDescriptionSeq *&
-IR_ExcDescriptionSeq_var::out (void)
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_ExcDescriptionSeq *
-IR_ExcDescriptionSeq_var::_retn (void)
-{
-  ::IR_ExcDescriptionSeq *tmp = this->ptr_;
-  this->ptr_ = 0;
-  return tmp;
-}
-
-ACE_INLINE ::IR_ExcDescriptionSeq *
-IR_ExcDescriptionSeq_var::ptr (void) const
-{
-  return this->ptr_;
-}
-
-// *************************************************************
-// Inline operations for class IR_ExcDescriptionSeq_out
-// *************************************************************
-
-ACE_INLINE
-IR_ExcDescriptionSeq_out::IR_ExcDescriptionSeq_out (IR_ExcDescriptionSeq *&p)
-  : ptr_ (p)
-{
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_ExcDescriptionSeq_out::IR_ExcDescriptionSeq_out (IR_ExcDescriptionSeq_var &p) // constructor from _var
-  : ptr_ (p.out ())
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_ExcDescriptionSeq_out::IR_ExcDescriptionSeq_out (const ::IR_ExcDescriptionSeq_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (IR_ExcDescriptionSeq_out&, p).ptr_)
-{}
-
-ACE_INLINE ::IR_ExcDescriptionSeq_out &
-IR_ExcDescriptionSeq_out::operator= (const ::IR_ExcDescriptionSeq_out &p)
-{
-  this->ptr_ = ACE_const_cast (IR_ExcDescriptionSeq_out&, p).ptr_;
-  return *this;
-}
-
-ACE_INLINE ::IR_ExcDescriptionSeq_out &
-IR_ExcDescriptionSeq_out::operator= (IR_ExcDescriptionSeq *p)
-{
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE 
-IR_ExcDescriptionSeq_out::operator ::IR_ExcDescriptionSeq *&() // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_ExcDescriptionSeq *&
-IR_ExcDescriptionSeq_out::ptr (void) // ptr
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_ExcDescriptionSeq *
-IR_ExcDescriptionSeq_out::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_ExceptionDescription &
-IR_ExcDescriptionSeq_out::operator[] (CORBA::ULong index)
-{
-  return this->ptr_->operator[] (index);
-}
-
-ACE_INLINE
-IR_AttributeDef::IR_AttributeDef (
-    TAO_Stub *objref,
-    CORBA::Boolean _tao_collocated,
-    TAO_Abstract_ServantBase *servant
-  )
-  : CORBA_Object (objref, _tao_collocated, servant)
-{
-  this->IR_AttributeDef_setup_collocation (_tao_collocated);
-}
-
-// *************************************************************
-// Inline operations for class IR_AttributeDef_var
-// *************************************************************
-
-ACE_INLINE
-IR_AttributeDef_var::IR_AttributeDef_var (void) // default constructor
-  : ptr_ (IR_AttributeDef::_nil ())
-{}
-
-ACE_INLINE ::IR_AttributeDef_ptr
-IR_AttributeDef_var::ptr (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE
-IR_AttributeDef_var::IR_AttributeDef_var (const ::IR_AttributeDef_var &p) // copy constructor
-  : TAO_Base_var (),
-    ptr_ (IR_AttributeDef::_duplicate (p.ptr ()))
-{}
-
-ACE_INLINE
-IR_AttributeDef_var::~IR_AttributeDef_var (void) // destructor
-{
-  CORBA::release (this->ptr_);
-}
-
-ACE_INLINE IR_AttributeDef_var &
-IR_AttributeDef_var::operator= (IR_AttributeDef_ptr p)
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE IR_AttributeDef_var &
-IR_AttributeDef_var::operator= (const ::IR_AttributeDef_var &p)
-{
-  if (this != &p)
-  {
-    CORBA::release (this->ptr_);
-    this->ptr_ = ::IR_AttributeDef::_duplicate (p.ptr ());
-  }
-  return *this;
-}
-
-ACE_INLINE 
-IR_AttributeDef_var::operator const ::IR_AttributeDef_ptr &() const // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE 
-IR_AttributeDef_var::operator ::IR_AttributeDef_ptr &() // cast 
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_AttributeDef_ptr
-IR_AttributeDef_var::operator-> (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_AttributeDef_ptr
-IR_AttributeDef_var::in (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_AttributeDef_ptr &
-IR_AttributeDef_var::inout (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_AttributeDef_ptr &
-IR_AttributeDef_var::out (void)
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = ::IR_AttributeDef::_nil ();
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_AttributeDef_ptr
-IR_AttributeDef_var::_retn (void)
-{
-  // yield ownership of managed obj reference
-  ::IR_AttributeDef_ptr val = this->ptr_;
-  this->ptr_ = ::IR_AttributeDef::_nil ();
-  return val;
-}
-
-// *************************************************************
-// Inline operations for class IR_AttributeDef_out
-// *************************************************************
-
-ACE_INLINE
-IR_AttributeDef_out::IR_AttributeDef_out (IR_AttributeDef_ptr &p)
-  : ptr_ (p)
-{
-  this->ptr_ = ::IR_AttributeDef::_nil ();
-}
-
-ACE_INLINE
-IR_AttributeDef_out::IR_AttributeDef_out (IR_AttributeDef_var &p) // constructor from _var
-  : ptr_ (p.out ())
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = ::IR_AttributeDef::_nil ();
-}
-
-ACE_INLINE
-IR_AttributeDef_out::IR_AttributeDef_out (const ::IR_AttributeDef_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (IR_AttributeDef_out &, p).ptr_)
-{}
-
-ACE_INLINE ::IR_AttributeDef_out &
-IR_AttributeDef_out::operator= (const ::IR_AttributeDef_out &p)
-{
-  this->ptr_ = ACE_const_cast (IR_AttributeDef_out&, p).ptr_;
-  return *this;
-}
-
-ACE_INLINE IR_AttributeDef_out &
-IR_AttributeDef_out::operator= (const ::IR_AttributeDef_var &p)
-{
-  this->ptr_ = ::IR_AttributeDef::_duplicate (p.ptr ());
-  return *this;
-}
-
-ACE_INLINE IR_AttributeDef_out &
-IR_AttributeDef_out::operator= (IR_AttributeDef_ptr p)
-{
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE 
-IR_AttributeDef_out::operator ::IR_AttributeDef_ptr &() // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_AttributeDef_ptr &
-IR_AttributeDef_out::ptr (void) // ptr
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_AttributeDef_ptr
-IR_AttributeDef_out::operator-> (void)
-{
-  return this->ptr_;
-}
-
-// *************************************************************
-// Inline operations for class IR_AttributeDescription_var
-// *************************************************************
-
-ACE_INLINE
-IR_AttributeDescription_var::IR_AttributeDescription_var (void) // default constructor
-  : ptr_ (0)
-{}
-
-ACE_INLINE
-IR_AttributeDescription_var::IR_AttributeDescription_var (IR_AttributeDescription *p)
-  : ptr_ (p)
-{}
-
-ACE_INLINE
-IR_AttributeDescription_var::IR_AttributeDescription_var (const ::IR_AttributeDescription_var &p) // copy constructor
-{
-  if (p.ptr_)
-    ACE_NEW (this->ptr_, ::IR_AttributeDescription (*p.ptr_));
-  else
-    this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_AttributeDescription_var::~IR_AttributeDescription_var (void) // destructor
-{
-  delete this->ptr_;
-}
-
-ACE_INLINE IR_AttributeDescription_var &
-IR_AttributeDescription_var::operator= (IR_AttributeDescription *p)
-{
-  delete this->ptr_;
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE ::IR_AttributeDescription_var &
-IR_AttributeDescription_var::operator= (const ::IR_AttributeDescription_var &p)
-{
-  if (this != &p)
-    {
-      if (p.ptr_ == 0)
-        {
-          delete this->ptr_;
-          this->ptr_ = 0;
-        }
-      else
-        {
-          IR_AttributeDescription *deep_copy = 
-            new IR_AttributeDescription (*p.ptr_);
-          
-          if (deep_copy != 0)
-            {
-              IR_AttributeDescription *tmp = deep_copy;
-              deep_copy = this->ptr_;
-              this->ptr_ = tmp;
-              delete deep_copy;
-            }
-        }
-    }
-  
-  return *this;
-}
-
-ACE_INLINE const ::IR_AttributeDescription *
-IR_AttributeDescription_var::operator-> (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_AttributeDescription *
-IR_AttributeDescription_var::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE
-IR_AttributeDescription_var::operator const ::IR_AttributeDescription &() const // cast
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE
-IR_AttributeDescription_var::operator ::IR_AttributeDescription &() // cast 
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE
-IR_AttributeDescription_var::operator ::IR_AttributeDescription &() const // cast 
-{
-  return *this->ptr_;
-}
-
-// variable-size types only
-ACE_INLINE
-IR_AttributeDescription_var::operator ::IR_AttributeDescription *&() // cast 
-{
-  return this->ptr_;
-}
-
-ACE_INLINE const ::IR_AttributeDescription &
-IR_AttributeDescription_var::in (void) const
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE ::IR_AttributeDescription &
-IR_AttributeDescription_var::inout (void)
-{
-  return *this->ptr_;
-}
-
-// mapping for variable size 
-ACE_INLINE ::IR_AttributeDescription *&
-IR_AttributeDescription_var::out (void)
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_AttributeDescription *
-IR_AttributeDescription_var::_retn (void)
-{
-  ::IR_AttributeDescription *tmp = this->ptr_;
-  this->ptr_ = 0;
-  return tmp;
-}
-
-ACE_INLINE ::IR_AttributeDescription *
-IR_AttributeDescription_var::ptr (void) const
-{
-  return this->ptr_;
-}
-
-// *************************************************************
-// Inline operations for class IR_AttributeDescription_out
-// *************************************************************
-
-ACE_INLINE
-IR_AttributeDescription_out::IR_AttributeDescription_out (::IR_AttributeDescription *&p)
-  : ptr_ (p)
-{
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_AttributeDescription_out::IR_AttributeDescription_out (IR_AttributeDescription_var &p) // constructor from _var
-  : ptr_ (p.out ())
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_AttributeDescription_out::IR_AttributeDescription_out (const ::IR_AttributeDescription_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (IR_AttributeDescription_out&, p).ptr_)
-{}
-
-ACE_INLINE IR_AttributeDescription_out &
-IR_AttributeDescription_out::operator= (const ::IR_AttributeDescription_out &p)
-{
-  this->ptr_ = ACE_const_cast (IR_AttributeDescription_out&, p).ptr_;
-  return *this;
-}
-
-ACE_INLINE IR_AttributeDescription_out &
-IR_AttributeDescription_out::operator= (IR_AttributeDescription *p)
-{
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE 
-IR_AttributeDescription_out::operator ::IR_AttributeDescription *&() // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_AttributeDescription *&
-IR_AttributeDescription_out::ptr (void) // ptr
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_AttributeDescription *
-IR_AttributeDescription_out::operator-> (void)
-{
-  return this->ptr_;
-}
-
-// *************************************************************
-// Inline operations for class IR_ParameterDescription_var
-// *************************************************************
-
-ACE_INLINE
-IR_ParameterDescription_var::IR_ParameterDescription_var (void) // default constructor
-  : ptr_ (0)
-{}
-
-ACE_INLINE
-IR_ParameterDescription_var::IR_ParameterDescription_var (IR_ParameterDescription *p)
-  : ptr_ (p)
-{}
-
-ACE_INLINE
-IR_ParameterDescription_var::IR_ParameterDescription_var (const ::IR_ParameterDescription_var &p) // copy constructor
-{
-  if (p.ptr_)
-    ACE_NEW (this->ptr_, ::IR_ParameterDescription (*p.ptr_));
-  else
-    this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_ParameterDescription_var::~IR_ParameterDescription_var (void) // destructor
-{
-  delete this->ptr_;
-}
-
-ACE_INLINE IR_ParameterDescription_var &
-IR_ParameterDescription_var::operator= (IR_ParameterDescription *p)
-{
-  delete this->ptr_;
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE ::IR_ParameterDescription_var &
-IR_ParameterDescription_var::operator= (const ::IR_ParameterDescription_var &p)
-{
-  if (this != &p)
-    {
-      if (p.ptr_ == 0)
-        {
-          delete this->ptr_;
-          this->ptr_ = 0;
-        }
-      else
-        {
-          IR_ParameterDescription *deep_copy = 
-            new IR_ParameterDescription (*p.ptr_);
-          
-          if (deep_copy != 0)
-            {
-              IR_ParameterDescription *tmp = deep_copy;
-              deep_copy = this->ptr_;
-              this->ptr_ = tmp;
-              delete deep_copy;
-            }
-        }
-    }
-  
-  return *this;
-}
-
-ACE_INLINE const ::IR_ParameterDescription *
-IR_ParameterDescription_var::operator-> (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_ParameterDescription *
-IR_ParameterDescription_var::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE
-IR_ParameterDescription_var::operator const ::IR_ParameterDescription &() const // cast
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE
-IR_ParameterDescription_var::operator ::IR_ParameterDescription &() // cast 
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE
-IR_ParameterDescription_var::operator ::IR_ParameterDescription &() const // cast 
-{
-  return *this->ptr_;
-}
-
-// variable-size types only
-ACE_INLINE
-IR_ParameterDescription_var::operator ::IR_ParameterDescription *&() // cast 
-{
-  return this->ptr_;
-}
-
-ACE_INLINE const ::IR_ParameterDescription &
-IR_ParameterDescription_var::in (void) const
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE ::IR_ParameterDescription &
-IR_ParameterDescription_var::inout (void)
-{
-  return *this->ptr_;
-}
-
-// mapping for variable size 
-ACE_INLINE ::IR_ParameterDescription *&
-IR_ParameterDescription_var::out (void)
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_ParameterDescription *
-IR_ParameterDescription_var::_retn (void)
-{
-  ::IR_ParameterDescription *tmp = this->ptr_;
-  this->ptr_ = 0;
-  return tmp;
-}
-
-ACE_INLINE ::IR_ParameterDescription *
-IR_ParameterDescription_var::ptr (void) const
-{
-  return this->ptr_;
-}
-
-// *************************************************************
-// Inline operations for class IR_ParameterDescription_out
-// *************************************************************
-
-ACE_INLINE
-IR_ParameterDescription_out::IR_ParameterDescription_out (::IR_ParameterDescription *&p)
-  : ptr_ (p)
-{
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_ParameterDescription_out::IR_ParameterDescription_out (IR_ParameterDescription_var &p) // constructor from _var
-  : ptr_ (p.out ())
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_ParameterDescription_out::IR_ParameterDescription_out (const ::IR_ParameterDescription_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (IR_ParameterDescription_out&, p).ptr_)
-{}
-
-ACE_INLINE IR_ParameterDescription_out &
-IR_ParameterDescription_out::operator= (const ::IR_ParameterDescription_out &p)
-{
-  this->ptr_ = ACE_const_cast (IR_ParameterDescription_out&, p).ptr_;
-  return *this;
-}
-
-ACE_INLINE IR_ParameterDescription_out &
-IR_ParameterDescription_out::operator= (IR_ParameterDescription *p)
-{
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE 
-IR_ParameterDescription_out::operator ::IR_ParameterDescription *&() // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_ParameterDescription *&
-IR_ParameterDescription_out::ptr (void) // ptr
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_ParameterDescription *
-IR_ParameterDescription_out::operator-> (void)
-{
-  return this->ptr_;
-}
-
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  
-  // = Static operations.
-  ACE_INLINE IR_ParameterDescription *
-  _TAO_Unbounded_Sequence_IR_ParDescriptionSeq::allocbuf (CORBA::ULong size)
-  // Allocate storage for the sequence.
-  {
-    IR_ParameterDescription *retval = 0;
-    ACE_NEW_RETURN (retval, IR_ParameterDescription[size], 0);
-    return retval;
-  }
-  
-  ACE_INLINE void _TAO_Unbounded_Sequence_IR_ParDescriptionSeq::freebuf (IR_ParameterDescription *buffer)
-  // Free the sequence.
-  {
-    delete [] buffer;
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Sequence_IR_ParDescriptionSeq::_TAO_Unbounded_Sequence_IR_ParDescriptionSeq (void) // Default constructor.
-  {
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Sequence_IR_ParDescriptionSeq::_TAO_Unbounded_Sequence_IR_ParDescriptionSeq (CORBA::ULong maximum) // Constructor using a maximum length value.
-    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Sequence_IR_ParDescriptionSeq::allocbuf (maximum))
-  {
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Sequence_IR_ParDescriptionSeq::_TAO_Unbounded_Sequence_IR_ParDescriptionSeq (CORBA::ULong maximum,
-    CORBA::ULong length,
-    IR_ParameterDescription *data,
-    CORBA::Boolean release)
-  : TAO_Unbounded_Base_Sequence (maximum, length, data, release)
-  {
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Sequence_IR_ParDescriptionSeq::_TAO_Unbounded_Sequence_IR_ParDescriptionSeq (const _TAO_Unbounded_Sequence_IR_ParDescriptionSeq &rhs)
-  // Copy constructor.
-    : TAO_Unbounded_Base_Sequence (rhs)
-  {
-    if (rhs.buffer_ != 0)
-    {
-      IR_ParameterDescription *tmp1 = _TAO_Unbounded_Sequence_IR_ParDescriptionSeq::allocbuf (this->maximum_);
-      IR_ParameterDescription * const tmp2 = ACE_reinterpret_cast (IR_ParameterDescription * ACE_CAST_CONST, rhs.buffer_);
-      
-      for (CORBA::ULong i = 0; i < this->length_; ++i)
-        tmp1[i] = tmp2[i];
-      
-      this->buffer_ = tmp1;
-    }
-    else
-    {
-      this->buffer_ = 0;
-    }
-  }
-  
-  ACE_INLINE _TAO_Unbounded_Sequence_IR_ParDescriptionSeq &
-  _TAO_Unbounded_Sequence_IR_ParDescriptionSeq::operator= (const _TAO_Unbounded_Sequence_IR_ParDescriptionSeq &rhs)
-  // Assignment operator.
-  {
-    if (this == &rhs)
-      return *this;
-    
-    if (this->release_)
-    {
-      if (this->maximum_ < rhs.maximum_)
-      {
-        // free the old buffer
-        IR_ParameterDescription *tmp = ACE_reinterpret_cast (IR_ParameterDescription *, this->buffer_);
-        _TAO_Unbounded_Sequence_IR_ParDescriptionSeq::freebuf (tmp);
-        this->buffer_ = _TAO_Unbounded_Sequence_IR_ParDescriptionSeq::allocbuf (rhs.maximum_);
-      }
-    }
-    else
-      this->buffer_ = _TAO_Unbounded_Sequence_IR_ParDescriptionSeq::allocbuf (rhs.maximum_);
-    
-    TAO_Unbounded_Base_Sequence::operator= (rhs);
-    
-    IR_ParameterDescription *tmp1 = ACE_reinterpret_cast (IR_ParameterDescription *, this->buffer_);
-    IR_ParameterDescription * const tmp2 = ACE_reinterpret_cast (IR_ParameterDescription * ACE_CAST_CONST, rhs.buffer_);
-    
-    for (CORBA::ULong i = 0; i < this->length_; ++i)
-      tmp1[i] = tmp2[i];
-    
-    return *this;
-  }
-  
-  // = Accessors.
-  ACE_INLINE IR_ParameterDescription &
-  _TAO_Unbounded_Sequence_IR_ParDescriptionSeq::operator[] (CORBA::ULong i)
-  // operator []
-  {
-    ACE_ASSERT (i < this->maximum_);
-    IR_ParameterDescription* tmp = ACE_reinterpret_cast(IR_ParameterDescription*,this->buffer_);
-    return tmp[i];
-  }
-  
-  ACE_INLINE const IR_ParameterDescription &
-  _TAO_Unbounded_Sequence_IR_ParDescriptionSeq::operator[] (CORBA::ULong i) const
-  // operator []
-  {
-    ACE_ASSERT (i < this->maximum_);
-    IR_ParameterDescription * const tmp = ACE_reinterpret_cast (IR_ParameterDescription* ACE_CAST_CONST, this->buffer_);
-    return tmp[i];
-  }
-  
-  // Implement the TAO_Base_Sequence methods (see Sequence.h)
-  
-  ACE_INLINE IR_ParameterDescription *
-  _TAO_Unbounded_Sequence_IR_ParDescriptionSeq::get_buffer (CORBA::Boolean orphan)
-  {
-    IR_ParameterDescription *result = 0;
-    if (orphan == 0)
-    {
-      // We retain ownership.
-      if (this->buffer_ == 0)
-      {
-        result = _TAO_Unbounded_Sequence_IR_ParDescriptionSeq::allocbuf (this->length_);
-        this->buffer_ = result;
-        this->release_ = 1;
-      }
-      else
-      {
-        result = ACE_reinterpret_cast (IR_ParameterDescription*, this->buffer_);
-      }
-    }
-    else // if (orphan == 1)
-    {
-      if (this->release_ != 0)
-      {
-        // We set the state back to default and relinquish
-        // ownership.
-        result = ACE_reinterpret_cast(IR_ParameterDescription*,this->buffer_);
-        this->maximum_ = 0;
-        this->length_ = 0;
-        this->buffer_ = 0;
-        this->release_ = 0;
-      }
-    }
-    return result;
-  }
-  
-  ACE_INLINE const IR_ParameterDescription *
-  _TAO_Unbounded_Sequence_IR_ParDescriptionSeq::get_buffer (void) const
-  {
-    return ACE_reinterpret_cast(const IR_ParameterDescription * ACE_CAST_CONST, this->buffer_);
-  }
-  
-  ACE_INLINE void
-  _TAO_Unbounded_Sequence_IR_ParDescriptionSeq::replace (CORBA::ULong max,
-  CORBA::ULong length,
-  IR_ParameterDescription *data,
-  CORBA::Boolean release)
-  {
-    this->maximum_ = max;
-    this->length_ = length;
-    if (this->buffer_ && this->release_ == 1)
-    {
-      IR_ParameterDescription *tmp = ACE_reinterpret_cast(IR_ParameterDescription*,this->buffer_);
-      _TAO_Unbounded_Sequence_IR_ParDescriptionSeq::freebuf (tmp);
-    }
-    this->buffer_ = data;
-    this->release_ = release;
-  }
-  
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
-
-// *************************************************************
-// Inline operations for class IR_ParDescriptionSeq_var
-// *************************************************************
-
-ACE_INLINE
-IR_ParDescriptionSeq_var::IR_ParDescriptionSeq_var (void) // default constructor
-  : ptr_ (0)
-{}
-
-ACE_INLINE
-IR_ParDescriptionSeq_var::IR_ParDescriptionSeq_var (IR_ParDescriptionSeq *p)
-  : ptr_ (p)
-{}
-
-ACE_INLINE
-IR_ParDescriptionSeq_var::IR_ParDescriptionSeq_var (const ::IR_ParDescriptionSeq_var &p) // copy constructor
-{
-  if (p.ptr_)
-    ACE_NEW (this->ptr_, ::IR_ParDescriptionSeq (*p.ptr_));
-  else
-    this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_ParDescriptionSeq_var::~IR_ParDescriptionSeq_var (void) // destructor
-{
-  delete this->ptr_;
-}
-
-ACE_INLINE IR_ParDescriptionSeq_var &
-IR_ParDescriptionSeq_var::operator= (IR_ParDescriptionSeq *p)
-{
-  delete this->ptr_;
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE IR_ParDescriptionSeq_var &
-IR_ParDescriptionSeq_var::operator= (const ::IR_ParDescriptionSeq_var &p) // deep copy
-{
-  if (this != &p)
-    {
-      if (p.ptr_ == 0)
-        {
-          delete this->ptr_;
-          this->ptr_ = 0;
-        }
-      else
-        {
-          IR_ParDescriptionSeq *deep_copy = 
-            new IR_ParDescriptionSeq (*p.ptr_);
-          
-          if (deep_copy != 0)
-            {
-              IR_ParDescriptionSeq *tmp = deep_copy;
-              deep_copy = this->ptr_;
-              this->ptr_ = tmp;
-              delete deep_copy;
-            }
-        }
-    }
-  
-  return *this;
-}
-
-ACE_INLINE const ::IR_ParDescriptionSeq *
-IR_ParDescriptionSeq_var::operator-> (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_ParDescriptionSeq *
-IR_ParDescriptionSeq_var::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE 
-IR_ParDescriptionSeq_var::operator const ::IR_ParDescriptionSeq &() const // cast
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE 
-IR_ParDescriptionSeq_var::operator ::IR_ParDescriptionSeq &() // cast 
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE 
-IR_ParDescriptionSeq_var::operator ::IR_ParDescriptionSeq &() const // cast 
-{
-  return *this->ptr_;
-}
-
-// variable-size types only
-ACE_INLINE
-IR_ParDescriptionSeq_var::operator ::IR_ParDescriptionSeq *&() // cast 
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_ParameterDescription &
-IR_ParDescriptionSeq_var::operator[] (CORBA::ULong index)
-{
-  return this->ptr_->operator[] (index);
-}
-
-ACE_INLINE const IR_ParameterDescription &
-IR_ParDescriptionSeq_var::operator[] (CORBA::ULong index) const
-{
-  return ACE_const_cast (const IR_ParameterDescription &, this->ptr_->operator[] (index));
-}
-
-ACE_INLINE const ::IR_ParDescriptionSeq &
-IR_ParDescriptionSeq_var::in (void) const
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE ::IR_ParDescriptionSeq &
-IR_ParDescriptionSeq_var::inout (void)
-{
-  return *this->ptr_;
-}
-
-// mapping for variable size 
-ACE_INLINE ::IR_ParDescriptionSeq *&
-IR_ParDescriptionSeq_var::out (void)
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_ParDescriptionSeq *
-IR_ParDescriptionSeq_var::_retn (void)
-{
-  ::IR_ParDescriptionSeq *tmp = this->ptr_;
-  this->ptr_ = 0;
-  return tmp;
-}
-
-ACE_INLINE ::IR_ParDescriptionSeq *
-IR_ParDescriptionSeq_var::ptr (void) const
-{
-  return this->ptr_;
-}
-
-// *************************************************************
-// Inline operations for class IR_ParDescriptionSeq_out
-// *************************************************************
-
-ACE_INLINE
-IR_ParDescriptionSeq_out::IR_ParDescriptionSeq_out (IR_ParDescriptionSeq *&p)
-  : ptr_ (p)
-{
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_ParDescriptionSeq_out::IR_ParDescriptionSeq_out (IR_ParDescriptionSeq_var &p) // constructor from _var
-  : ptr_ (p.out ())
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_ParDescriptionSeq_out::IR_ParDescriptionSeq_out (const ::IR_ParDescriptionSeq_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (IR_ParDescriptionSeq_out&, p).ptr_)
-{}
-
-ACE_INLINE ::IR_ParDescriptionSeq_out &
-IR_ParDescriptionSeq_out::operator= (const ::IR_ParDescriptionSeq_out &p)
-{
-  this->ptr_ = ACE_const_cast (IR_ParDescriptionSeq_out&, p).ptr_;
-  return *this;
-}
-
-ACE_INLINE ::IR_ParDescriptionSeq_out &
-IR_ParDescriptionSeq_out::operator= (IR_ParDescriptionSeq *p)
-{
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE 
-IR_ParDescriptionSeq_out::operator ::IR_ParDescriptionSeq *&() // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_ParDescriptionSeq *&
-IR_ParDescriptionSeq_out::ptr (void) // ptr
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_ParDescriptionSeq *
-IR_ParDescriptionSeq_out::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_ParameterDescription &
-IR_ParDescriptionSeq_out::operator[] (CORBA::ULong index)
-{
-  return this->ptr_->operator[] (index);
-}
-
-// *************************************************************
-// Inline operations for class IR_ContextIdSeq_var
-// *************************************************************
-
-ACE_INLINE
-IR_ContextIdSeq_var::IR_ContextIdSeq_var (void) // default constructor
-  : ptr_ (0)
-{}
-
-ACE_INLINE
-IR_ContextIdSeq_var::IR_ContextIdSeq_var (IR_ContextIdSeq *p)
-  : ptr_ (p)
-{}
-
-ACE_INLINE
-IR_ContextIdSeq_var::IR_ContextIdSeq_var (const ::IR_ContextIdSeq_var &p) // copy constructor
-{
-  if (p.ptr_)
-    ACE_NEW (this->ptr_, ::IR_ContextIdSeq (*p.ptr_));
-  else
-    this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_ContextIdSeq_var::~IR_ContextIdSeq_var (void) // destructor
-{
-  delete this->ptr_;
-}
-
-ACE_INLINE IR_ContextIdSeq_var &
-IR_ContextIdSeq_var::operator= (IR_ContextIdSeq *p)
-{
-  delete this->ptr_;
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE IR_ContextIdSeq_var &
-IR_ContextIdSeq_var::operator= (const ::IR_ContextIdSeq_var &p) // deep copy
-{
-  if (this != &p)
-    {
-      if (p.ptr_ == 0)
-        {
-          delete this->ptr_;
-          this->ptr_ = 0;
-        }
-      else
-        {
-          IR_ContextIdSeq *deep_copy = 
-            new IR_ContextIdSeq (*p.ptr_);
-          
-          if (deep_copy != 0)
-            {
-              IR_ContextIdSeq *tmp = deep_copy;
-              deep_copy = this->ptr_;
-              this->ptr_ = tmp;
-              delete deep_copy;
-            }
-        }
-    }
-  
-  return *this;
-}
-
-ACE_INLINE const ::IR_ContextIdSeq *
-IR_ContextIdSeq_var::operator-> (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_ContextIdSeq *
-IR_ContextIdSeq_var::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE 
-IR_ContextIdSeq_var::operator const ::IR_ContextIdSeq &() const // cast
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE 
-IR_ContextIdSeq_var::operator ::IR_ContextIdSeq &() // cast 
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE 
-IR_ContextIdSeq_var::operator ::IR_ContextIdSeq &() const // cast 
-{
-  return *this->ptr_;
-}
-
-// variable-size types only
-ACE_INLINE
-IR_ContextIdSeq_var::operator ::IR_ContextIdSeq *&() // cast 
-{
-  return this->ptr_;
-}
-
-ACE_INLINE TAO_SeqElem_String_Manager
-IR_ContextIdSeq_var::operator[] (CORBA::ULong index)
-{
-  return this->ptr_->operator[] (index);
-}
-
-ACE_INLINE const ::IR_ContextIdSeq &
-IR_ContextIdSeq_var::in (void) const
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE ::IR_ContextIdSeq &
-IR_ContextIdSeq_var::inout (void)
-{
-  return *this->ptr_;
-}
-
-// mapping for variable size 
-ACE_INLINE ::IR_ContextIdSeq *&
-IR_ContextIdSeq_var::out (void)
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_ContextIdSeq *
-IR_ContextIdSeq_var::_retn (void)
-{
-  ::IR_ContextIdSeq *tmp = this->ptr_;
-  this->ptr_ = 0;
-  return tmp;
-}
-
-ACE_INLINE ::IR_ContextIdSeq *
-IR_ContextIdSeq_var::ptr (void) const
-{
-  return this->ptr_;
-}
-
-// *************************************************************
-// Inline operations for class IR_ContextIdSeq_out
-// *************************************************************
-
-ACE_INLINE
-IR_ContextIdSeq_out::IR_ContextIdSeq_out (IR_ContextIdSeq *&p)
-  : ptr_ (p)
-{
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_ContextIdSeq_out::IR_ContextIdSeq_out (IR_ContextIdSeq_var &p) // constructor from _var
-  : ptr_ (p.out ())
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_ContextIdSeq_out::IR_ContextIdSeq_out (const ::IR_ContextIdSeq_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (IR_ContextIdSeq_out&, p).ptr_)
-{}
-
-ACE_INLINE ::IR_ContextIdSeq_out &
-IR_ContextIdSeq_out::operator= (const ::IR_ContextIdSeq_out &p)
-{
-  this->ptr_ = ACE_const_cast (IR_ContextIdSeq_out&, p).ptr_;
-  return *this;
-}
-
-ACE_INLINE ::IR_ContextIdSeq_out &
-IR_ContextIdSeq_out::operator= (IR_ContextIdSeq *p)
-{
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE 
-IR_ContextIdSeq_out::operator ::IR_ContextIdSeq *&() // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_ContextIdSeq *&
-IR_ContextIdSeq_out::ptr (void) // ptr
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_ContextIdSeq *
-IR_ContextIdSeq_out::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE TAO_SeqElem_String_Manager
-IR_ContextIdSeq_out::operator[] (CORBA::ULong index)
-{
-  return this->ptr_->operator[] (index);
-}
-
-ACE_INLINE
-IR_OperationDef::IR_OperationDef (
-    TAO_Stub *objref,
-    CORBA::Boolean _tao_collocated,
-    TAO_Abstract_ServantBase *servant
-  )
-  : CORBA_Object (objref, _tao_collocated, servant)
-{
-  this->IR_OperationDef_setup_collocation (_tao_collocated);
-}
-
-// *************************************************************
-// Inline operations for class IR_OperationDef_var
-// *************************************************************
-
-ACE_INLINE
-IR_OperationDef_var::IR_OperationDef_var (void) // default constructor
-  : ptr_ (IR_OperationDef::_nil ())
-{}
-
-ACE_INLINE ::IR_OperationDef_ptr
-IR_OperationDef_var::ptr (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE
-IR_OperationDef_var::IR_OperationDef_var (const ::IR_OperationDef_var &p) // copy constructor
-  : TAO_Base_var (),
-    ptr_ (IR_OperationDef::_duplicate (p.ptr ()))
-{}
-
-ACE_INLINE
-IR_OperationDef_var::~IR_OperationDef_var (void) // destructor
-{
-  CORBA::release (this->ptr_);
-}
-
-ACE_INLINE IR_OperationDef_var &
-IR_OperationDef_var::operator= (IR_OperationDef_ptr p)
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE IR_OperationDef_var &
-IR_OperationDef_var::operator= (const ::IR_OperationDef_var &p)
-{
-  if (this != &p)
-  {
-    CORBA::release (this->ptr_);
-    this->ptr_ = ::IR_OperationDef::_duplicate (p.ptr ());
-  }
-  return *this;
-}
-
-ACE_INLINE 
-IR_OperationDef_var::operator const ::IR_OperationDef_ptr &() const // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE 
-IR_OperationDef_var::operator ::IR_OperationDef_ptr &() // cast 
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_OperationDef_ptr
-IR_OperationDef_var::operator-> (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_OperationDef_ptr
-IR_OperationDef_var::in (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_OperationDef_ptr &
-IR_OperationDef_var::inout (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_OperationDef_ptr &
-IR_OperationDef_var::out (void)
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = ::IR_OperationDef::_nil ();
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_OperationDef_ptr
-IR_OperationDef_var::_retn (void)
-{
-  // yield ownership of managed obj reference
-  ::IR_OperationDef_ptr val = this->ptr_;
-  this->ptr_ = ::IR_OperationDef::_nil ();
-  return val;
-}
-
-// *************************************************************
-// Inline operations for class IR_OperationDef_out
-// *************************************************************
-
-ACE_INLINE
-IR_OperationDef_out::IR_OperationDef_out (IR_OperationDef_ptr &p)
-  : ptr_ (p)
-{
-  this->ptr_ = ::IR_OperationDef::_nil ();
-}
-
-ACE_INLINE
-IR_OperationDef_out::IR_OperationDef_out (IR_OperationDef_var &p) // constructor from _var
-  : ptr_ (p.out ())
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = ::IR_OperationDef::_nil ();
-}
-
-ACE_INLINE
-IR_OperationDef_out::IR_OperationDef_out (const ::IR_OperationDef_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (IR_OperationDef_out &, p).ptr_)
-{}
-
-ACE_INLINE ::IR_OperationDef_out &
-IR_OperationDef_out::operator= (const ::IR_OperationDef_out &p)
-{
-  this->ptr_ = ACE_const_cast (IR_OperationDef_out&, p).ptr_;
-  return *this;
-}
-
-ACE_INLINE IR_OperationDef_out &
-IR_OperationDef_out::operator= (const ::IR_OperationDef_var &p)
-{
-  this->ptr_ = ::IR_OperationDef::_duplicate (p.ptr ());
-  return *this;
-}
-
-ACE_INLINE IR_OperationDef_out &
-IR_OperationDef_out::operator= (IR_OperationDef_ptr p)
-{
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE 
-IR_OperationDef_out::operator ::IR_OperationDef_ptr &() // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_OperationDef_ptr &
-IR_OperationDef_out::ptr (void) // ptr
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_OperationDef_ptr
-IR_OperationDef_out::operator-> (void)
-{
-  return this->ptr_;
-}
-
-// *************************************************************
-// Inline operations for class IR_OperationDescription_var
-// *************************************************************
-
-ACE_INLINE
-IR_OperationDescription_var::IR_OperationDescription_var (void) // default constructor
-  : ptr_ (0)
-{}
-
-ACE_INLINE
-IR_OperationDescription_var::IR_OperationDescription_var (IR_OperationDescription *p)
-  : ptr_ (p)
-{}
-
-ACE_INLINE
-IR_OperationDescription_var::IR_OperationDescription_var (const ::IR_OperationDescription_var &p) // copy constructor
-{
-  if (p.ptr_)
-    ACE_NEW (this->ptr_, ::IR_OperationDescription (*p.ptr_));
-  else
-    this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_OperationDescription_var::~IR_OperationDescription_var (void) // destructor
-{
-  delete this->ptr_;
-}
-
-ACE_INLINE IR_OperationDescription_var &
-IR_OperationDescription_var::operator= (IR_OperationDescription *p)
-{
-  delete this->ptr_;
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE ::IR_OperationDescription_var &
-IR_OperationDescription_var::operator= (const ::IR_OperationDescription_var &p)
-{
-  if (this != &p)
-    {
-      if (p.ptr_ == 0)
-        {
-          delete this->ptr_;
-          this->ptr_ = 0;
-        }
-      else
-        {
-          IR_OperationDescription *deep_copy = 
-            new IR_OperationDescription (*p.ptr_);
-          
-          if (deep_copy != 0)
-            {
-              IR_OperationDescription *tmp = deep_copy;
-              deep_copy = this->ptr_;
-              this->ptr_ = tmp;
-              delete deep_copy;
-            }
-        }
-    }
-  
-  return *this;
-}
-
-ACE_INLINE const ::IR_OperationDescription *
-IR_OperationDescription_var::operator-> (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_OperationDescription *
-IR_OperationDescription_var::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE
-IR_OperationDescription_var::operator const ::IR_OperationDescription &() const // cast
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE
-IR_OperationDescription_var::operator ::IR_OperationDescription &() // cast 
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE
-IR_OperationDescription_var::operator ::IR_OperationDescription &() const // cast 
-{
-  return *this->ptr_;
-}
-
-// variable-size types only
-ACE_INLINE
-IR_OperationDescription_var::operator ::IR_OperationDescription *&() // cast 
-{
-  return this->ptr_;
-}
-
-ACE_INLINE const ::IR_OperationDescription &
-IR_OperationDescription_var::in (void) const
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE ::IR_OperationDescription &
-IR_OperationDescription_var::inout (void)
-{
-  return *this->ptr_;
-}
-
-// mapping for variable size 
-ACE_INLINE ::IR_OperationDescription *&
-IR_OperationDescription_var::out (void)
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_OperationDescription *
-IR_OperationDescription_var::_retn (void)
-{
-  ::IR_OperationDescription *tmp = this->ptr_;
-  this->ptr_ = 0;
-  return tmp;
-}
-
-ACE_INLINE ::IR_OperationDescription *
-IR_OperationDescription_var::ptr (void) const
-{
-  return this->ptr_;
-}
-
-// *************************************************************
-// Inline operations for class IR_OperationDescription_out
-// *************************************************************
-
-ACE_INLINE
-IR_OperationDescription_out::IR_OperationDescription_out (::IR_OperationDescription *&p)
-  : ptr_ (p)
-{
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_OperationDescription_out::IR_OperationDescription_out (IR_OperationDescription_var &p) // constructor from _var
-  : ptr_ (p.out ())
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_OperationDescription_out::IR_OperationDescription_out (const ::IR_OperationDescription_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (IR_OperationDescription_out&, p).ptr_)
-{}
-
-ACE_INLINE IR_OperationDescription_out &
-IR_OperationDescription_out::operator= (const ::IR_OperationDescription_out &p)
-{
-  this->ptr_ = ACE_const_cast (IR_OperationDescription_out&, p).ptr_;
-  return *this;
-}
-
-ACE_INLINE IR_OperationDescription_out &
-IR_OperationDescription_out::operator= (IR_OperationDescription *p)
-{
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE 
-IR_OperationDescription_out::operator ::IR_OperationDescription *&() // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_OperationDescription *&
-IR_OperationDescription_out::ptr (void) // ptr
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_OperationDescription *
-IR_OperationDescription_out::operator-> (void)
-{
-  return this->ptr_;
-}
-
-// *************************************************************
-// Inline operations for class IR_RepositoryIdSeq_var
-// *************************************************************
-
-ACE_INLINE
-IR_RepositoryIdSeq_var::IR_RepositoryIdSeq_var (void) // default constructor
-  : ptr_ (0)
-{}
-
-ACE_INLINE
-IR_RepositoryIdSeq_var::IR_RepositoryIdSeq_var (IR_RepositoryIdSeq *p)
-  : ptr_ (p)
-{}
-
-ACE_INLINE
-IR_RepositoryIdSeq_var::IR_RepositoryIdSeq_var (const ::IR_RepositoryIdSeq_var &p) // copy constructor
-{
-  if (p.ptr_)
-    ACE_NEW (this->ptr_, ::IR_RepositoryIdSeq (*p.ptr_));
-  else
-    this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_RepositoryIdSeq_var::~IR_RepositoryIdSeq_var (void) // destructor
-{
-  delete this->ptr_;
-}
-
-ACE_INLINE IR_RepositoryIdSeq_var &
-IR_RepositoryIdSeq_var::operator= (IR_RepositoryIdSeq *p)
-{
-  delete this->ptr_;
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE IR_RepositoryIdSeq_var &
-IR_RepositoryIdSeq_var::operator= (const ::IR_RepositoryIdSeq_var &p) // deep copy
-{
-  if (this != &p)
-    {
-      if (p.ptr_ == 0)
-        {
-          delete this->ptr_;
-          this->ptr_ = 0;
-        }
-      else
-        {
-          IR_RepositoryIdSeq *deep_copy = 
-            new IR_RepositoryIdSeq (*p.ptr_);
-          
-          if (deep_copy != 0)
-            {
-              IR_RepositoryIdSeq *tmp = deep_copy;
-              deep_copy = this->ptr_;
-              this->ptr_ = tmp;
-              delete deep_copy;
-            }
-        }
-    }
-  
-  return *this;
-}
-
-ACE_INLINE const ::IR_RepositoryIdSeq *
-IR_RepositoryIdSeq_var::operator-> (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_RepositoryIdSeq *
-IR_RepositoryIdSeq_var::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE 
-IR_RepositoryIdSeq_var::operator const ::IR_RepositoryIdSeq &() const // cast
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE 
-IR_RepositoryIdSeq_var::operator ::IR_RepositoryIdSeq &() // cast 
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE 
-IR_RepositoryIdSeq_var::operator ::IR_RepositoryIdSeq &() const // cast 
-{
-  return *this->ptr_;
-}
-
-// variable-size types only
-ACE_INLINE
-IR_RepositoryIdSeq_var::operator ::IR_RepositoryIdSeq *&() // cast 
-{
-  return this->ptr_;
-}
-
-ACE_INLINE TAO_SeqElem_String_Manager
-IR_RepositoryIdSeq_var::operator[] (CORBA::ULong index)
-{
-  return this->ptr_->operator[] (index);
-}
-
-ACE_INLINE const ::IR_RepositoryIdSeq &
-IR_RepositoryIdSeq_var::in (void) const
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE ::IR_RepositoryIdSeq &
-IR_RepositoryIdSeq_var::inout (void)
-{
-  return *this->ptr_;
-}
-
-// mapping for variable size 
-ACE_INLINE ::IR_RepositoryIdSeq *&
-IR_RepositoryIdSeq_var::out (void)
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_RepositoryIdSeq *
-IR_RepositoryIdSeq_var::_retn (void)
-{
-  ::IR_RepositoryIdSeq *tmp = this->ptr_;
-  this->ptr_ = 0;
-  return tmp;
-}
-
-ACE_INLINE ::IR_RepositoryIdSeq *
-IR_RepositoryIdSeq_var::ptr (void) const
-{
-  return this->ptr_;
-}
-
-// *************************************************************
-// Inline operations for class IR_RepositoryIdSeq_out
-// *************************************************************
-
-ACE_INLINE
-IR_RepositoryIdSeq_out::IR_RepositoryIdSeq_out (IR_RepositoryIdSeq *&p)
-  : ptr_ (p)
-{
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_RepositoryIdSeq_out::IR_RepositoryIdSeq_out (IR_RepositoryIdSeq_var &p) // constructor from _var
-  : ptr_ (p.out ())
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_RepositoryIdSeq_out::IR_RepositoryIdSeq_out (const ::IR_RepositoryIdSeq_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (IR_RepositoryIdSeq_out&, p).ptr_)
-{}
-
-ACE_INLINE ::IR_RepositoryIdSeq_out &
-IR_RepositoryIdSeq_out::operator= (const ::IR_RepositoryIdSeq_out &p)
-{
-  this->ptr_ = ACE_const_cast (IR_RepositoryIdSeq_out&, p).ptr_;
-  return *this;
-}
-
-ACE_INLINE ::IR_RepositoryIdSeq_out &
-IR_RepositoryIdSeq_out::operator= (IR_RepositoryIdSeq *p)
-{
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE 
-IR_RepositoryIdSeq_out::operator ::IR_RepositoryIdSeq *&() // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_RepositoryIdSeq *&
-IR_RepositoryIdSeq_out::ptr (void) // ptr
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_RepositoryIdSeq *
-IR_RepositoryIdSeq_out::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE TAO_SeqElem_String_Manager
-IR_RepositoryIdSeq_out::operator[] (CORBA::ULong index)
-{
-  return this->ptr_->operator[] (index);
-}
-
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  
-  // = Static operations.
-  ACE_INLINE IR_OperationDescription *
-  _TAO_Unbounded_Sequence_IR_OpDescriptionSeq::allocbuf (CORBA::ULong size)
-  // Allocate storage for the sequence.
-  {
-    IR_OperationDescription *retval = 0;
-    ACE_NEW_RETURN (retval, IR_OperationDescription[size], 0);
-    return retval;
-  }
-  
-  ACE_INLINE void _TAO_Unbounded_Sequence_IR_OpDescriptionSeq::freebuf (IR_OperationDescription *buffer)
-  // Free the sequence.
-  {
-    delete [] buffer;
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Sequence_IR_OpDescriptionSeq::_TAO_Unbounded_Sequence_IR_OpDescriptionSeq (void) // Default constructor.
-  {
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Sequence_IR_OpDescriptionSeq::_TAO_Unbounded_Sequence_IR_OpDescriptionSeq (CORBA::ULong maximum) // Constructor using a maximum length value.
-    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Sequence_IR_OpDescriptionSeq::allocbuf (maximum))
-  {
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Sequence_IR_OpDescriptionSeq::_TAO_Unbounded_Sequence_IR_OpDescriptionSeq (CORBA::ULong maximum,
-    CORBA::ULong length,
-    IR_OperationDescription *data,
-    CORBA::Boolean release)
-  : TAO_Unbounded_Base_Sequence (maximum, length, data, release)
-  {
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Sequence_IR_OpDescriptionSeq::_TAO_Unbounded_Sequence_IR_OpDescriptionSeq (const _TAO_Unbounded_Sequence_IR_OpDescriptionSeq &rhs)
-  // Copy constructor.
-    : TAO_Unbounded_Base_Sequence (rhs)
-  {
-    if (rhs.buffer_ != 0)
-    {
-      IR_OperationDescription *tmp1 = _TAO_Unbounded_Sequence_IR_OpDescriptionSeq::allocbuf (this->maximum_);
-      IR_OperationDescription * const tmp2 = ACE_reinterpret_cast (IR_OperationDescription * ACE_CAST_CONST, rhs.buffer_);
-      
-      for (CORBA::ULong i = 0; i < this->length_; ++i)
-        tmp1[i] = tmp2[i];
-      
-      this->buffer_ = tmp1;
-    }
-    else
-    {
-      this->buffer_ = 0;
-    }
-  }
-  
-  ACE_INLINE _TAO_Unbounded_Sequence_IR_OpDescriptionSeq &
-  _TAO_Unbounded_Sequence_IR_OpDescriptionSeq::operator= (const _TAO_Unbounded_Sequence_IR_OpDescriptionSeq &rhs)
-  // Assignment operator.
-  {
-    if (this == &rhs)
-      return *this;
-    
-    if (this->release_)
-    {
-      if (this->maximum_ < rhs.maximum_)
-      {
-        // free the old buffer
-        IR_OperationDescription *tmp = ACE_reinterpret_cast (IR_OperationDescription *, this->buffer_);
-        _TAO_Unbounded_Sequence_IR_OpDescriptionSeq::freebuf (tmp);
-        this->buffer_ = _TAO_Unbounded_Sequence_IR_OpDescriptionSeq::allocbuf (rhs.maximum_);
-      }
-    }
-    else
-      this->buffer_ = _TAO_Unbounded_Sequence_IR_OpDescriptionSeq::allocbuf (rhs.maximum_);
-    
-    TAO_Unbounded_Base_Sequence::operator= (rhs);
-    
-    IR_OperationDescription *tmp1 = ACE_reinterpret_cast (IR_OperationDescription *, this->buffer_);
-    IR_OperationDescription * const tmp2 = ACE_reinterpret_cast (IR_OperationDescription * ACE_CAST_CONST, rhs.buffer_);
-    
-    for (CORBA::ULong i = 0; i < this->length_; ++i)
-      tmp1[i] = tmp2[i];
-    
-    return *this;
-  }
-  
-  // = Accessors.
-  ACE_INLINE IR_OperationDescription &
-  _TAO_Unbounded_Sequence_IR_OpDescriptionSeq::operator[] (CORBA::ULong i)
-  // operator []
-  {
-    ACE_ASSERT (i < this->maximum_);
-    IR_OperationDescription* tmp = ACE_reinterpret_cast(IR_OperationDescription*,this->buffer_);
-    return tmp[i];
-  }
-  
-  ACE_INLINE const IR_OperationDescription &
-  _TAO_Unbounded_Sequence_IR_OpDescriptionSeq::operator[] (CORBA::ULong i) const
-  // operator []
-  {
-    ACE_ASSERT (i < this->maximum_);
-    IR_OperationDescription * const tmp = ACE_reinterpret_cast (IR_OperationDescription* ACE_CAST_CONST, this->buffer_);
-    return tmp[i];
-  }
-  
-  // Implement the TAO_Base_Sequence methods (see Sequence.h)
-  
-  ACE_INLINE IR_OperationDescription *
-  _TAO_Unbounded_Sequence_IR_OpDescriptionSeq::get_buffer (CORBA::Boolean orphan)
-  {
-    IR_OperationDescription *result = 0;
-    if (orphan == 0)
-    {
-      // We retain ownership.
-      if (this->buffer_ == 0)
-      {
-        result = _TAO_Unbounded_Sequence_IR_OpDescriptionSeq::allocbuf (this->length_);
-        this->buffer_ = result;
-        this->release_ = 1;
-      }
-      else
-      {
-        result = ACE_reinterpret_cast (IR_OperationDescription*, this->buffer_);
-      }
-    }
-    else // if (orphan == 1)
-    {
-      if (this->release_ != 0)
-      {
-        // We set the state back to default and relinquish
-        // ownership.
-        result = ACE_reinterpret_cast(IR_OperationDescription*,this->buffer_);
-        this->maximum_ = 0;
-        this->length_ = 0;
-        this->buffer_ = 0;
-        this->release_ = 0;
-      }
-    }
-    return result;
-  }
-  
-  ACE_INLINE const IR_OperationDescription *
-  _TAO_Unbounded_Sequence_IR_OpDescriptionSeq::get_buffer (void) const
-  {
-    return ACE_reinterpret_cast(const IR_OperationDescription * ACE_CAST_CONST, this->buffer_);
-  }
-  
-  ACE_INLINE void
-  _TAO_Unbounded_Sequence_IR_OpDescriptionSeq::replace (CORBA::ULong max,
-  CORBA::ULong length,
-  IR_OperationDescription *data,
-  CORBA::Boolean release)
-  {
-    this->maximum_ = max;
-    this->length_ = length;
-    if (this->buffer_ && this->release_ == 1)
-    {
-      IR_OperationDescription *tmp = ACE_reinterpret_cast(IR_OperationDescription*,this->buffer_);
-      _TAO_Unbounded_Sequence_IR_OpDescriptionSeq::freebuf (tmp);
-    }
-    this->buffer_ = data;
-    this->release_ = release;
-  }
-  
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
-
-// *************************************************************
-// Inline operations for class IR_OpDescriptionSeq_var
-// *************************************************************
-
-ACE_INLINE
-IR_OpDescriptionSeq_var::IR_OpDescriptionSeq_var (void) // default constructor
-  : ptr_ (0)
-{}
-
-ACE_INLINE
-IR_OpDescriptionSeq_var::IR_OpDescriptionSeq_var (IR_OpDescriptionSeq *p)
-  : ptr_ (p)
-{}
-
-ACE_INLINE
-IR_OpDescriptionSeq_var::IR_OpDescriptionSeq_var (const ::IR_OpDescriptionSeq_var &p) // copy constructor
-{
-  if (p.ptr_)
-    ACE_NEW (this->ptr_, ::IR_OpDescriptionSeq (*p.ptr_));
-  else
-    this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_OpDescriptionSeq_var::~IR_OpDescriptionSeq_var (void) // destructor
-{
-  delete this->ptr_;
-}
-
-ACE_INLINE IR_OpDescriptionSeq_var &
-IR_OpDescriptionSeq_var::operator= (IR_OpDescriptionSeq *p)
-{
-  delete this->ptr_;
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE IR_OpDescriptionSeq_var &
-IR_OpDescriptionSeq_var::operator= (const ::IR_OpDescriptionSeq_var &p) // deep copy
-{
-  if (this != &p)
-    {
-      if (p.ptr_ == 0)
-        {
-          delete this->ptr_;
-          this->ptr_ = 0;
-        }
-      else
-        {
-          IR_OpDescriptionSeq *deep_copy = 
-            new IR_OpDescriptionSeq (*p.ptr_);
-          
-          if (deep_copy != 0)
-            {
-              IR_OpDescriptionSeq *tmp = deep_copy;
-              deep_copy = this->ptr_;
-              this->ptr_ = tmp;
-              delete deep_copy;
-            }
-        }
-    }
-  
-  return *this;
-}
-
-ACE_INLINE const ::IR_OpDescriptionSeq *
-IR_OpDescriptionSeq_var::operator-> (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_OpDescriptionSeq *
-IR_OpDescriptionSeq_var::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE 
-IR_OpDescriptionSeq_var::operator const ::IR_OpDescriptionSeq &() const // cast
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE 
-IR_OpDescriptionSeq_var::operator ::IR_OpDescriptionSeq &() // cast 
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE 
-IR_OpDescriptionSeq_var::operator ::IR_OpDescriptionSeq &() const // cast 
-{
-  return *this->ptr_;
-}
-
-// variable-size types only
-ACE_INLINE
-IR_OpDescriptionSeq_var::operator ::IR_OpDescriptionSeq *&() // cast 
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_OperationDescription &
-IR_OpDescriptionSeq_var::operator[] (CORBA::ULong index)
-{
-  return this->ptr_->operator[] (index);
-}
-
-ACE_INLINE const IR_OperationDescription &
-IR_OpDescriptionSeq_var::operator[] (CORBA::ULong index) const
-{
-  return ACE_const_cast (const IR_OperationDescription &, this->ptr_->operator[] (index));
-}
-
-ACE_INLINE const ::IR_OpDescriptionSeq &
-IR_OpDescriptionSeq_var::in (void) const
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE ::IR_OpDescriptionSeq &
-IR_OpDescriptionSeq_var::inout (void)
-{
-  return *this->ptr_;
-}
-
-// mapping for variable size 
-ACE_INLINE ::IR_OpDescriptionSeq *&
-IR_OpDescriptionSeq_var::out (void)
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_OpDescriptionSeq *
-IR_OpDescriptionSeq_var::_retn (void)
-{
-  ::IR_OpDescriptionSeq *tmp = this->ptr_;
-  this->ptr_ = 0;
-  return tmp;
-}
-
-ACE_INLINE ::IR_OpDescriptionSeq *
-IR_OpDescriptionSeq_var::ptr (void) const
-{
-  return this->ptr_;
-}
-
-// *************************************************************
-// Inline operations for class IR_OpDescriptionSeq_out
-// *************************************************************
-
-ACE_INLINE
-IR_OpDescriptionSeq_out::IR_OpDescriptionSeq_out (IR_OpDescriptionSeq *&p)
-  : ptr_ (p)
-{
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_OpDescriptionSeq_out::IR_OpDescriptionSeq_out (IR_OpDescriptionSeq_var &p) // constructor from _var
-  : ptr_ (p.out ())
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_OpDescriptionSeq_out::IR_OpDescriptionSeq_out (const ::IR_OpDescriptionSeq_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (IR_OpDescriptionSeq_out&, p).ptr_)
-{}
-
-ACE_INLINE ::IR_OpDescriptionSeq_out &
-IR_OpDescriptionSeq_out::operator= (const ::IR_OpDescriptionSeq_out &p)
-{
-  this->ptr_ = ACE_const_cast (IR_OpDescriptionSeq_out&, p).ptr_;
-  return *this;
-}
-
-ACE_INLINE ::IR_OpDescriptionSeq_out &
-IR_OpDescriptionSeq_out::operator= (IR_OpDescriptionSeq *p)
-{
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE 
-IR_OpDescriptionSeq_out::operator ::IR_OpDescriptionSeq *&() // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_OpDescriptionSeq *&
-IR_OpDescriptionSeq_out::ptr (void) // ptr
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_OpDescriptionSeq *
-IR_OpDescriptionSeq_out::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_OperationDescription &
-IR_OpDescriptionSeq_out::operator[] (CORBA::ULong index)
-{
-  return this->ptr_->operator[] (index);
-}
-
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  
-  // = Static operations.
-  ACE_INLINE IR_AttributeDescription *
-  _TAO_Unbounded_Sequence_IR_AttrDescriptionSeq::allocbuf (CORBA::ULong size)
-  // Allocate storage for the sequence.
-  {
-    IR_AttributeDescription *retval = 0;
-    ACE_NEW_RETURN (retval, IR_AttributeDescription[size], 0);
-    return retval;
-  }
-  
-  ACE_INLINE void _TAO_Unbounded_Sequence_IR_AttrDescriptionSeq::freebuf (IR_AttributeDescription *buffer)
-  // Free the sequence.
-  {
-    delete [] buffer;
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Sequence_IR_AttrDescriptionSeq::_TAO_Unbounded_Sequence_IR_AttrDescriptionSeq (void) // Default constructor.
-  {
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Sequence_IR_AttrDescriptionSeq::_TAO_Unbounded_Sequence_IR_AttrDescriptionSeq (CORBA::ULong maximum) // Constructor using a maximum length value.
-    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Sequence_IR_AttrDescriptionSeq::allocbuf (maximum))
-  {
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Sequence_IR_AttrDescriptionSeq::_TAO_Unbounded_Sequence_IR_AttrDescriptionSeq (CORBA::ULong maximum,
-    CORBA::ULong length,
-    IR_AttributeDescription *data,
-    CORBA::Boolean release)
-  : TAO_Unbounded_Base_Sequence (maximum, length, data, release)
-  {
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Sequence_IR_AttrDescriptionSeq::_TAO_Unbounded_Sequence_IR_AttrDescriptionSeq (const _TAO_Unbounded_Sequence_IR_AttrDescriptionSeq &rhs)
-  // Copy constructor.
-    : TAO_Unbounded_Base_Sequence (rhs)
-  {
-    if (rhs.buffer_ != 0)
-    {
-      IR_AttributeDescription *tmp1 = _TAO_Unbounded_Sequence_IR_AttrDescriptionSeq::allocbuf (this->maximum_);
-      IR_AttributeDescription * const tmp2 = ACE_reinterpret_cast (IR_AttributeDescription * ACE_CAST_CONST, rhs.buffer_);
-      
-      for (CORBA::ULong i = 0; i < this->length_; ++i)
-        tmp1[i] = tmp2[i];
-      
-      this->buffer_ = tmp1;
-    }
-    else
-    {
-      this->buffer_ = 0;
-    }
-  }
-  
-  ACE_INLINE _TAO_Unbounded_Sequence_IR_AttrDescriptionSeq &
-  _TAO_Unbounded_Sequence_IR_AttrDescriptionSeq::operator= (const _TAO_Unbounded_Sequence_IR_AttrDescriptionSeq &rhs)
-  // Assignment operator.
-  {
-    if (this == &rhs)
-      return *this;
-    
-    if (this->release_)
-    {
-      if (this->maximum_ < rhs.maximum_)
-      {
-        // free the old buffer
-        IR_AttributeDescription *tmp = ACE_reinterpret_cast (IR_AttributeDescription *, this->buffer_);
-        _TAO_Unbounded_Sequence_IR_AttrDescriptionSeq::freebuf (tmp);
-        this->buffer_ = _TAO_Unbounded_Sequence_IR_AttrDescriptionSeq::allocbuf (rhs.maximum_);
-      }
-    }
-    else
-      this->buffer_ = _TAO_Unbounded_Sequence_IR_AttrDescriptionSeq::allocbuf (rhs.maximum_);
-    
-    TAO_Unbounded_Base_Sequence::operator= (rhs);
-    
-    IR_AttributeDescription *tmp1 = ACE_reinterpret_cast (IR_AttributeDescription *, this->buffer_);
-    IR_AttributeDescription * const tmp2 = ACE_reinterpret_cast (IR_AttributeDescription * ACE_CAST_CONST, rhs.buffer_);
-    
-    for (CORBA::ULong i = 0; i < this->length_; ++i)
-      tmp1[i] = tmp2[i];
-    
-    return *this;
-  }
-  
-  // = Accessors.
-  ACE_INLINE IR_AttributeDescription &
-  _TAO_Unbounded_Sequence_IR_AttrDescriptionSeq::operator[] (CORBA::ULong i)
-  // operator []
-  {
-    ACE_ASSERT (i < this->maximum_);
-    IR_AttributeDescription* tmp = ACE_reinterpret_cast(IR_AttributeDescription*,this->buffer_);
-    return tmp[i];
-  }
-  
-  ACE_INLINE const IR_AttributeDescription &
-  _TAO_Unbounded_Sequence_IR_AttrDescriptionSeq::operator[] (CORBA::ULong i) const
-  // operator []
-  {
-    ACE_ASSERT (i < this->maximum_);
-    IR_AttributeDescription * const tmp = ACE_reinterpret_cast (IR_AttributeDescription* ACE_CAST_CONST, this->buffer_);
-    return tmp[i];
-  }
-  
-  // Implement the TAO_Base_Sequence methods (see Sequence.h)
-  
-  ACE_INLINE IR_AttributeDescription *
-  _TAO_Unbounded_Sequence_IR_AttrDescriptionSeq::get_buffer (CORBA::Boolean orphan)
-  {
-    IR_AttributeDescription *result = 0;
-    if (orphan == 0)
-    {
-      // We retain ownership.
-      if (this->buffer_ == 0)
-      {
-        result = _TAO_Unbounded_Sequence_IR_AttrDescriptionSeq::allocbuf (this->length_);
-        this->buffer_ = result;
-        this->release_ = 1;
-      }
-      else
-      {
-        result = ACE_reinterpret_cast (IR_AttributeDescription*, this->buffer_);
-      }
-    }
-    else // if (orphan == 1)
-    {
-      if (this->release_ != 0)
-      {
-        // We set the state back to default and relinquish
-        // ownership.
-        result = ACE_reinterpret_cast(IR_AttributeDescription*,this->buffer_);
-        this->maximum_ = 0;
-        this->length_ = 0;
-        this->buffer_ = 0;
-        this->release_ = 0;
-      }
-    }
-    return result;
-  }
-  
-  ACE_INLINE const IR_AttributeDescription *
-  _TAO_Unbounded_Sequence_IR_AttrDescriptionSeq::get_buffer (void) const
-  {
-    return ACE_reinterpret_cast(const IR_AttributeDescription * ACE_CAST_CONST, this->buffer_);
-  }
-  
-  ACE_INLINE void
-  _TAO_Unbounded_Sequence_IR_AttrDescriptionSeq::replace (CORBA::ULong max,
-  CORBA::ULong length,
-  IR_AttributeDescription *data,
-  CORBA::Boolean release)
-  {
-    this->maximum_ = max;
-    this->length_ = length;
-    if (this->buffer_ && this->release_ == 1)
-    {
-      IR_AttributeDescription *tmp = ACE_reinterpret_cast(IR_AttributeDescription*,this->buffer_);
-      _TAO_Unbounded_Sequence_IR_AttrDescriptionSeq::freebuf (tmp);
-    }
-    this->buffer_ = data;
-    this->release_ = release;
-  }
-  
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
-
-// *************************************************************
-// Inline operations for class IR_AttrDescriptionSeq_var
-// *************************************************************
-
-ACE_INLINE
-IR_AttrDescriptionSeq_var::IR_AttrDescriptionSeq_var (void) // default constructor
-  : ptr_ (0)
-{}
-
-ACE_INLINE
-IR_AttrDescriptionSeq_var::IR_AttrDescriptionSeq_var (IR_AttrDescriptionSeq *p)
-  : ptr_ (p)
-{}
-
-ACE_INLINE
-IR_AttrDescriptionSeq_var::IR_AttrDescriptionSeq_var (const ::IR_AttrDescriptionSeq_var &p) // copy constructor
-{
-  if (p.ptr_)
-    ACE_NEW (this->ptr_, ::IR_AttrDescriptionSeq (*p.ptr_));
-  else
-    this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_AttrDescriptionSeq_var::~IR_AttrDescriptionSeq_var (void) // destructor
-{
-  delete this->ptr_;
-}
-
-ACE_INLINE IR_AttrDescriptionSeq_var &
-IR_AttrDescriptionSeq_var::operator= (IR_AttrDescriptionSeq *p)
-{
-  delete this->ptr_;
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE IR_AttrDescriptionSeq_var &
-IR_AttrDescriptionSeq_var::operator= (const ::IR_AttrDescriptionSeq_var &p) // deep copy
-{
-  if (this != &p)
-    {
-      if (p.ptr_ == 0)
-        {
-          delete this->ptr_;
-          this->ptr_ = 0;
-        }
-      else
-        {
-          IR_AttrDescriptionSeq *deep_copy = 
-            new IR_AttrDescriptionSeq (*p.ptr_);
-          
-          if (deep_copy != 0)
-            {
-              IR_AttrDescriptionSeq *tmp = deep_copy;
-              deep_copy = this->ptr_;
-              this->ptr_ = tmp;
-              delete deep_copy;
-            }
-        }
-    }
-  
-  return *this;
-}
-
-ACE_INLINE const ::IR_AttrDescriptionSeq *
-IR_AttrDescriptionSeq_var::operator-> (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_AttrDescriptionSeq *
-IR_AttrDescriptionSeq_var::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE 
-IR_AttrDescriptionSeq_var::operator const ::IR_AttrDescriptionSeq &() const // cast
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE 
-IR_AttrDescriptionSeq_var::operator ::IR_AttrDescriptionSeq &() // cast 
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE 
-IR_AttrDescriptionSeq_var::operator ::IR_AttrDescriptionSeq &() const // cast 
-{
-  return *this->ptr_;
-}
-
-// variable-size types only
-ACE_INLINE
-IR_AttrDescriptionSeq_var::operator ::IR_AttrDescriptionSeq *&() // cast 
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_AttributeDescription &
-IR_AttrDescriptionSeq_var::operator[] (CORBA::ULong index)
-{
-  return this->ptr_->operator[] (index);
-}
-
-ACE_INLINE const IR_AttributeDescription &
-IR_AttrDescriptionSeq_var::operator[] (CORBA::ULong index) const
-{
-  return ACE_const_cast (const IR_AttributeDescription &, this->ptr_->operator[] (index));
-}
-
-ACE_INLINE const ::IR_AttrDescriptionSeq &
-IR_AttrDescriptionSeq_var::in (void) const
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE ::IR_AttrDescriptionSeq &
-IR_AttrDescriptionSeq_var::inout (void)
-{
-  return *this->ptr_;
-}
-
-// mapping for variable size 
-ACE_INLINE ::IR_AttrDescriptionSeq *&
-IR_AttrDescriptionSeq_var::out (void)
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_AttrDescriptionSeq *
-IR_AttrDescriptionSeq_var::_retn (void)
-{
-  ::IR_AttrDescriptionSeq *tmp = this->ptr_;
-  this->ptr_ = 0;
-  return tmp;
-}
-
-ACE_INLINE ::IR_AttrDescriptionSeq *
-IR_AttrDescriptionSeq_var::ptr (void) const
-{
-  return this->ptr_;
-}
-
-// *************************************************************
-// Inline operations for class IR_AttrDescriptionSeq_out
-// *************************************************************
-
-ACE_INLINE
-IR_AttrDescriptionSeq_out::IR_AttrDescriptionSeq_out (IR_AttrDescriptionSeq *&p)
-  : ptr_ (p)
-{
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_AttrDescriptionSeq_out::IR_AttrDescriptionSeq_out (IR_AttrDescriptionSeq_var &p) // constructor from _var
-  : ptr_ (p.out ())
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_AttrDescriptionSeq_out::IR_AttrDescriptionSeq_out (const ::IR_AttrDescriptionSeq_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (IR_AttrDescriptionSeq_out&, p).ptr_)
-{}
-
-ACE_INLINE ::IR_AttrDescriptionSeq_out &
-IR_AttrDescriptionSeq_out::operator= (const ::IR_AttrDescriptionSeq_out &p)
-{
-  this->ptr_ = ACE_const_cast (IR_AttrDescriptionSeq_out&, p).ptr_;
-  return *this;
-}
-
-ACE_INLINE ::IR_AttrDescriptionSeq_out &
-IR_AttrDescriptionSeq_out::operator= (IR_AttrDescriptionSeq *p)
-{
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE 
-IR_AttrDescriptionSeq_out::operator ::IR_AttrDescriptionSeq *&() // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_AttrDescriptionSeq *&
-IR_AttrDescriptionSeq_out::ptr (void) // ptr
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_AttrDescriptionSeq *
-IR_AttrDescriptionSeq_out::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_AttributeDescription &
-IR_AttrDescriptionSeq_out::operator[] (CORBA::ULong index)
-{
-  return this->ptr_->operator[] (index);
-}
-
-// *************************************************************
-// Inline operations for class IR_InterfaceDescription_var
-// *************************************************************
-
-ACE_INLINE
-IR_InterfaceDescription_var::IR_InterfaceDescription_var (void) // default constructor
-  : ptr_ (0)
-{}
-
-ACE_INLINE
-IR_InterfaceDescription_var::IR_InterfaceDescription_var (IR_InterfaceDescription *p)
-  : ptr_ (p)
-{}
-
-ACE_INLINE
-IR_InterfaceDescription_var::IR_InterfaceDescription_var (const ::IR_InterfaceDescription_var &p) // copy constructor
-{
-  if (p.ptr_)
-    ACE_NEW (this->ptr_, ::IR_InterfaceDescription (*p.ptr_));
-  else
-    this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_InterfaceDescription_var::~IR_InterfaceDescription_var (void) // destructor
-{
-  delete this->ptr_;
-}
-
-ACE_INLINE IR_InterfaceDescription_var &
-IR_InterfaceDescription_var::operator= (IR_InterfaceDescription *p)
-{
-  delete this->ptr_;
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE ::IR_InterfaceDescription_var &
-IR_InterfaceDescription_var::operator= (const ::IR_InterfaceDescription_var &p)
-{
-  if (this != &p)
-    {
-      if (p.ptr_ == 0)
-        {
-          delete this->ptr_;
-          this->ptr_ = 0;
-        }
-      else
-        {
-          IR_InterfaceDescription *deep_copy = 
-            new IR_InterfaceDescription (*p.ptr_);
-          
-          if (deep_copy != 0)
-            {
-              IR_InterfaceDescription *tmp = deep_copy;
-              deep_copy = this->ptr_;
-              this->ptr_ = tmp;
-              delete deep_copy;
-            }
-        }
-    }
-  
-  return *this;
-}
-
-ACE_INLINE const ::IR_InterfaceDescription *
-IR_InterfaceDescription_var::operator-> (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_InterfaceDescription *
-IR_InterfaceDescription_var::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE
-IR_InterfaceDescription_var::operator const ::IR_InterfaceDescription &() const // cast
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE
-IR_InterfaceDescription_var::operator ::IR_InterfaceDescription &() // cast 
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE
-IR_InterfaceDescription_var::operator ::IR_InterfaceDescription &() const // cast 
-{
-  return *this->ptr_;
-}
-
-// variable-size types only
-ACE_INLINE
-IR_InterfaceDescription_var::operator ::IR_InterfaceDescription *&() // cast 
-{
-  return this->ptr_;
-}
-
-ACE_INLINE const ::IR_InterfaceDescription &
-IR_InterfaceDescription_var::in (void) const
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE ::IR_InterfaceDescription &
-IR_InterfaceDescription_var::inout (void)
-{
-  return *this->ptr_;
-}
-
-// mapping for variable size 
-ACE_INLINE ::IR_InterfaceDescription *&
-IR_InterfaceDescription_var::out (void)
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_InterfaceDescription *
-IR_InterfaceDescription_var::_retn (void)
-{
-  ::IR_InterfaceDescription *tmp = this->ptr_;
-  this->ptr_ = 0;
-  return tmp;
-}
-
-ACE_INLINE ::IR_InterfaceDescription *
-IR_InterfaceDescription_var::ptr (void) const
-{
-  return this->ptr_;
-}
-
-// *************************************************************
-// Inline operations for class IR_InterfaceDescription_out
-// *************************************************************
-
-ACE_INLINE
-IR_InterfaceDescription_out::IR_InterfaceDescription_out (::IR_InterfaceDescription *&p)
-  : ptr_ (p)
-{
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_InterfaceDescription_out::IR_InterfaceDescription_out (IR_InterfaceDescription_var &p) // constructor from _var
-  : ptr_ (p.out ())
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_InterfaceDescription_out::IR_InterfaceDescription_out (const ::IR_InterfaceDescription_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (IR_InterfaceDescription_out&, p).ptr_)
-{}
-
-ACE_INLINE IR_InterfaceDescription_out &
-IR_InterfaceDescription_out::operator= (const ::IR_InterfaceDescription_out &p)
-{
-  this->ptr_ = ACE_const_cast (IR_InterfaceDescription_out&, p).ptr_;
-  return *this;
-}
-
-ACE_INLINE IR_InterfaceDescription_out &
-IR_InterfaceDescription_out::operator= (IR_InterfaceDescription *p)
-{
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE 
-IR_InterfaceDescription_out::operator ::IR_InterfaceDescription *&() // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_InterfaceDescription *&
-IR_InterfaceDescription_out::ptr (void) // ptr
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_InterfaceDescription *
-IR_InterfaceDescription_out::operator-> (void)
-{
-  return this->ptr_;
-}
-
-// *************************************************************
-// Inline operations for class IR_ValueMember_var
-// *************************************************************
-
-ACE_INLINE
-IR_ValueMember_var::IR_ValueMember_var (void) // default constructor
-  : ptr_ (0)
-{}
-
-ACE_INLINE
-IR_ValueMember_var::IR_ValueMember_var (IR_ValueMember *p)
-  : ptr_ (p)
-{}
-
-ACE_INLINE
-IR_ValueMember_var::IR_ValueMember_var (const ::IR_ValueMember_var &p) // copy constructor
-{
-  if (p.ptr_)
-    ACE_NEW (this->ptr_, ::IR_ValueMember (*p.ptr_));
-  else
-    this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_ValueMember_var::~IR_ValueMember_var (void) // destructor
-{
-  delete this->ptr_;
-}
-
-ACE_INLINE IR_ValueMember_var &
-IR_ValueMember_var::operator= (IR_ValueMember *p)
-{
-  delete this->ptr_;
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE ::IR_ValueMember_var &
-IR_ValueMember_var::operator= (const ::IR_ValueMember_var &p)
-{
-  if (this != &p)
-    {
-      if (p.ptr_ == 0)
-        {
-          delete this->ptr_;
-          this->ptr_ = 0;
-        }
-      else
-        {
-          IR_ValueMember *deep_copy = 
-            new IR_ValueMember (*p.ptr_);
-          
-          if (deep_copy != 0)
-            {
-              IR_ValueMember *tmp = deep_copy;
-              deep_copy = this->ptr_;
-              this->ptr_ = tmp;
-              delete deep_copy;
-            }
-        }
-    }
-  
-  return *this;
-}
-
-ACE_INLINE const ::IR_ValueMember *
-IR_ValueMember_var::operator-> (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_ValueMember *
-IR_ValueMember_var::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE
-IR_ValueMember_var::operator const ::IR_ValueMember &() const // cast
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE
-IR_ValueMember_var::operator ::IR_ValueMember &() // cast 
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE
-IR_ValueMember_var::operator ::IR_ValueMember &() const // cast 
-{
-  return *this->ptr_;
-}
-
-// variable-size types only
-ACE_INLINE
-IR_ValueMember_var::operator ::IR_ValueMember *&() // cast 
-{
-  return this->ptr_;
-}
-
-ACE_INLINE const ::IR_ValueMember &
-IR_ValueMember_var::in (void) const
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE ::IR_ValueMember &
-IR_ValueMember_var::inout (void)
-{
-  return *this->ptr_;
-}
-
-// mapping for variable size 
-ACE_INLINE ::IR_ValueMember *&
-IR_ValueMember_var::out (void)
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_ValueMember *
-IR_ValueMember_var::_retn (void)
-{
-  ::IR_ValueMember *tmp = this->ptr_;
-  this->ptr_ = 0;
-  return tmp;
-}
-
-ACE_INLINE ::IR_ValueMember *
-IR_ValueMember_var::ptr (void) const
-{
-  return this->ptr_;
-}
-
-// *************************************************************
-// Inline operations for class IR_ValueMember_out
-// *************************************************************
-
-ACE_INLINE
-IR_ValueMember_out::IR_ValueMember_out (::IR_ValueMember *&p)
-  : ptr_ (p)
-{
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_ValueMember_out::IR_ValueMember_out (IR_ValueMember_var &p) // constructor from _var
-  : ptr_ (p.out ())
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_ValueMember_out::IR_ValueMember_out (const ::IR_ValueMember_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (IR_ValueMember_out&, p).ptr_)
-{}
-
-ACE_INLINE IR_ValueMember_out &
-IR_ValueMember_out::operator= (const ::IR_ValueMember_out &p)
-{
-  this->ptr_ = ACE_const_cast (IR_ValueMember_out&, p).ptr_;
-  return *this;
-}
-
-ACE_INLINE IR_ValueMember_out &
-IR_ValueMember_out::operator= (IR_ValueMember *p)
-{
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE 
-IR_ValueMember_out::operator ::IR_ValueMember *&() // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_ValueMember *&
-IR_ValueMember_out::ptr (void) // ptr
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_ValueMember *
-IR_ValueMember_out::operator-> (void)
-{
-  return this->ptr_;
-}
-
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  
-  // = Static operations.
-  ACE_INLINE IR_ValueMember *
-  _TAO_Unbounded_Sequence_IR_ValueMemberSeq::allocbuf (CORBA::ULong size)
-  // Allocate storage for the sequence.
-  {
-    IR_ValueMember *retval = 0;
-    ACE_NEW_RETURN (retval, IR_ValueMember[size], 0);
-    return retval;
-  }
-  
-  ACE_INLINE void _TAO_Unbounded_Sequence_IR_ValueMemberSeq::freebuf (IR_ValueMember *buffer)
-  // Free the sequence.
-  {
-    delete [] buffer;
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Sequence_IR_ValueMemberSeq::_TAO_Unbounded_Sequence_IR_ValueMemberSeq (void) // Default constructor.
-  {
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Sequence_IR_ValueMemberSeq::_TAO_Unbounded_Sequence_IR_ValueMemberSeq (CORBA::ULong maximum) // Constructor using a maximum length value.
-    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Sequence_IR_ValueMemberSeq::allocbuf (maximum))
-  {
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Sequence_IR_ValueMemberSeq::_TAO_Unbounded_Sequence_IR_ValueMemberSeq (CORBA::ULong maximum,
-    CORBA::ULong length,
-    IR_ValueMember *data,
-    CORBA::Boolean release)
-  : TAO_Unbounded_Base_Sequence (maximum, length, data, release)
-  {
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Sequence_IR_ValueMemberSeq::_TAO_Unbounded_Sequence_IR_ValueMemberSeq (const _TAO_Unbounded_Sequence_IR_ValueMemberSeq &rhs)
-  // Copy constructor.
-    : TAO_Unbounded_Base_Sequence (rhs)
-  {
-    if (rhs.buffer_ != 0)
-    {
-      IR_ValueMember *tmp1 = _TAO_Unbounded_Sequence_IR_ValueMemberSeq::allocbuf (this->maximum_);
-      IR_ValueMember * const tmp2 = ACE_reinterpret_cast (IR_ValueMember * ACE_CAST_CONST, rhs.buffer_);
-      
-      for (CORBA::ULong i = 0; i < this->length_; ++i)
-        tmp1[i] = tmp2[i];
-      
-      this->buffer_ = tmp1;
-    }
-    else
-    {
-      this->buffer_ = 0;
-    }
-  }
-  
-  ACE_INLINE _TAO_Unbounded_Sequence_IR_ValueMemberSeq &
-  _TAO_Unbounded_Sequence_IR_ValueMemberSeq::operator= (const _TAO_Unbounded_Sequence_IR_ValueMemberSeq &rhs)
-  // Assignment operator.
-  {
-    if (this == &rhs)
-      return *this;
-    
-    if (this->release_)
-    {
-      if (this->maximum_ < rhs.maximum_)
-      {
-        // free the old buffer
-        IR_ValueMember *tmp = ACE_reinterpret_cast (IR_ValueMember *, this->buffer_);
-        _TAO_Unbounded_Sequence_IR_ValueMemberSeq::freebuf (tmp);
-        this->buffer_ = _TAO_Unbounded_Sequence_IR_ValueMemberSeq::allocbuf (rhs.maximum_);
-      }
-    }
-    else
-      this->buffer_ = _TAO_Unbounded_Sequence_IR_ValueMemberSeq::allocbuf (rhs.maximum_);
-    
-    TAO_Unbounded_Base_Sequence::operator= (rhs);
-    
-    IR_ValueMember *tmp1 = ACE_reinterpret_cast (IR_ValueMember *, this->buffer_);
-    IR_ValueMember * const tmp2 = ACE_reinterpret_cast (IR_ValueMember * ACE_CAST_CONST, rhs.buffer_);
-    
-    for (CORBA::ULong i = 0; i < this->length_; ++i)
-      tmp1[i] = tmp2[i];
-    
-    return *this;
-  }
-  
-  // = Accessors.
-  ACE_INLINE IR_ValueMember &
-  _TAO_Unbounded_Sequence_IR_ValueMemberSeq::operator[] (CORBA::ULong i)
-  // operator []
-  {
-    ACE_ASSERT (i < this->maximum_);
-    IR_ValueMember* tmp = ACE_reinterpret_cast(IR_ValueMember*,this->buffer_);
-    return tmp[i];
-  }
-  
-  ACE_INLINE const IR_ValueMember &
-  _TAO_Unbounded_Sequence_IR_ValueMemberSeq::operator[] (CORBA::ULong i) const
-  // operator []
-  {
-    ACE_ASSERT (i < this->maximum_);
-    IR_ValueMember * const tmp = ACE_reinterpret_cast (IR_ValueMember* ACE_CAST_CONST, this->buffer_);
-    return tmp[i];
-  }
-  
-  // Implement the TAO_Base_Sequence methods (see Sequence.h)
-  
-  ACE_INLINE IR_ValueMember *
-  _TAO_Unbounded_Sequence_IR_ValueMemberSeq::get_buffer (CORBA::Boolean orphan)
-  {
-    IR_ValueMember *result = 0;
-    if (orphan == 0)
-    {
-      // We retain ownership.
-      if (this->buffer_ == 0)
-      {
-        result = _TAO_Unbounded_Sequence_IR_ValueMemberSeq::allocbuf (this->length_);
-        this->buffer_ = result;
-        this->release_ = 1;
-      }
-      else
-      {
-        result = ACE_reinterpret_cast (IR_ValueMember*, this->buffer_);
-      }
-    }
-    else // if (orphan == 1)
-    {
-      if (this->release_ != 0)
-      {
-        // We set the state back to default and relinquish
-        // ownership.
-        result = ACE_reinterpret_cast(IR_ValueMember*,this->buffer_);
-        this->maximum_ = 0;
-        this->length_ = 0;
-        this->buffer_ = 0;
-        this->release_ = 0;
-      }
-    }
-    return result;
-  }
-  
-  ACE_INLINE const IR_ValueMember *
-  _TAO_Unbounded_Sequence_IR_ValueMemberSeq::get_buffer (void) const
-  {
-    return ACE_reinterpret_cast(const IR_ValueMember * ACE_CAST_CONST, this->buffer_);
-  }
-  
-  ACE_INLINE void
-  _TAO_Unbounded_Sequence_IR_ValueMemberSeq::replace (CORBA::ULong max,
-  CORBA::ULong length,
-  IR_ValueMember *data,
-  CORBA::Boolean release)
-  {
-    this->maximum_ = max;
-    this->length_ = length;
-    if (this->buffer_ && this->release_ == 1)
-    {
-      IR_ValueMember *tmp = ACE_reinterpret_cast(IR_ValueMember*,this->buffer_);
-      _TAO_Unbounded_Sequence_IR_ValueMemberSeq::freebuf (tmp);
-    }
-    this->buffer_ = data;
-    this->release_ = release;
-  }
-  
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
-
-// *************************************************************
-// Inline operations for class IR_ValueMemberSeq_var
-// *************************************************************
-
-ACE_INLINE
-IR_ValueMemberSeq_var::IR_ValueMemberSeq_var (void) // default constructor
-  : ptr_ (0)
-{}
-
-ACE_INLINE
-IR_ValueMemberSeq_var::IR_ValueMemberSeq_var (IR_ValueMemberSeq *p)
-  : ptr_ (p)
-{}
-
-ACE_INLINE
-IR_ValueMemberSeq_var::IR_ValueMemberSeq_var (const ::IR_ValueMemberSeq_var &p) // copy constructor
-{
-  if (p.ptr_)
-    ACE_NEW (this->ptr_, ::IR_ValueMemberSeq (*p.ptr_));
-  else
-    this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_ValueMemberSeq_var::~IR_ValueMemberSeq_var (void) // destructor
-{
-  delete this->ptr_;
-}
-
-ACE_INLINE IR_ValueMemberSeq_var &
-IR_ValueMemberSeq_var::operator= (IR_ValueMemberSeq *p)
-{
-  delete this->ptr_;
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE IR_ValueMemberSeq_var &
-IR_ValueMemberSeq_var::operator= (const ::IR_ValueMemberSeq_var &p) // deep copy
-{
-  if (this != &p)
-    {
-      if (p.ptr_ == 0)
-        {
-          delete this->ptr_;
-          this->ptr_ = 0;
-        }
-      else
-        {
-          IR_ValueMemberSeq *deep_copy = 
-            new IR_ValueMemberSeq (*p.ptr_);
-          
-          if (deep_copy != 0)
-            {
-              IR_ValueMemberSeq *tmp = deep_copy;
-              deep_copy = this->ptr_;
-              this->ptr_ = tmp;
-              delete deep_copy;
-            }
-        }
-    }
-  
-  return *this;
-}
-
-ACE_INLINE const ::IR_ValueMemberSeq *
-IR_ValueMemberSeq_var::operator-> (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_ValueMemberSeq *
-IR_ValueMemberSeq_var::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE 
-IR_ValueMemberSeq_var::operator const ::IR_ValueMemberSeq &() const // cast
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE 
-IR_ValueMemberSeq_var::operator ::IR_ValueMemberSeq &() // cast 
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE 
-IR_ValueMemberSeq_var::operator ::IR_ValueMemberSeq &() const // cast 
-{
-  return *this->ptr_;
-}
-
-// variable-size types only
-ACE_INLINE
-IR_ValueMemberSeq_var::operator ::IR_ValueMemberSeq *&() // cast 
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_ValueMember &
-IR_ValueMemberSeq_var::operator[] (CORBA::ULong index)
-{
-  return this->ptr_->operator[] (index);
-}
-
-ACE_INLINE const IR_ValueMember &
-IR_ValueMemberSeq_var::operator[] (CORBA::ULong index) const
-{
-  return ACE_const_cast (const IR_ValueMember &, this->ptr_->operator[] (index));
-}
-
-ACE_INLINE const ::IR_ValueMemberSeq &
-IR_ValueMemberSeq_var::in (void) const
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE ::IR_ValueMemberSeq &
-IR_ValueMemberSeq_var::inout (void)
-{
-  return *this->ptr_;
-}
-
-// mapping for variable size 
-ACE_INLINE ::IR_ValueMemberSeq *&
-IR_ValueMemberSeq_var::out (void)
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_ValueMemberSeq *
-IR_ValueMemberSeq_var::_retn (void)
-{
-  ::IR_ValueMemberSeq *tmp = this->ptr_;
-  this->ptr_ = 0;
-  return tmp;
-}
-
-ACE_INLINE ::IR_ValueMemberSeq *
-IR_ValueMemberSeq_var::ptr (void) const
-{
-  return this->ptr_;
-}
-
-// *************************************************************
-// Inline operations for class IR_ValueMemberSeq_out
-// *************************************************************
-
-ACE_INLINE
-IR_ValueMemberSeq_out::IR_ValueMemberSeq_out (IR_ValueMemberSeq *&p)
-  : ptr_ (p)
-{
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_ValueMemberSeq_out::IR_ValueMemberSeq_out (IR_ValueMemberSeq_var &p) // constructor from _var
-  : ptr_ (p.out ())
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_ValueMemberSeq_out::IR_ValueMemberSeq_out (const ::IR_ValueMemberSeq_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (IR_ValueMemberSeq_out&, p).ptr_)
-{}
-
-ACE_INLINE ::IR_ValueMemberSeq_out &
-IR_ValueMemberSeq_out::operator= (const ::IR_ValueMemberSeq_out &p)
-{
-  this->ptr_ = ACE_const_cast (IR_ValueMemberSeq_out&, p).ptr_;
-  return *this;
-}
-
-ACE_INLINE ::IR_ValueMemberSeq_out &
-IR_ValueMemberSeq_out::operator= (IR_ValueMemberSeq *p)
-{
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE 
-IR_ValueMemberSeq_out::operator ::IR_ValueMemberSeq *&() // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_ValueMemberSeq *&
-IR_ValueMemberSeq_out::ptr (void) // ptr
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_ValueMemberSeq *
-IR_ValueMemberSeq_out::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_ValueMember &
-IR_ValueMemberSeq_out::operator[] (CORBA::ULong index)
-{
-  return this->ptr_->operator[] (index);
-}
-
-ACE_INLINE
-IR_ValueMemberDef::IR_ValueMemberDef (
-    TAO_Stub *objref,
-    CORBA::Boolean _tao_collocated,
-    TAO_Abstract_ServantBase *servant
-  )
-  : CORBA_Object (objref, _tao_collocated, servant)
-{
-  this->IR_ValueMemberDef_setup_collocation (_tao_collocated);
-}
-
-// *************************************************************
-// Inline operations for class IR_ValueMemberDef_var
-// *************************************************************
-
-ACE_INLINE
-IR_ValueMemberDef_var::IR_ValueMemberDef_var (void) // default constructor
-  : ptr_ (IR_ValueMemberDef::_nil ())
-{}
-
-ACE_INLINE ::IR_ValueMemberDef_ptr
-IR_ValueMemberDef_var::ptr (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE
-IR_ValueMemberDef_var::IR_ValueMemberDef_var (const ::IR_ValueMemberDef_var &p) // copy constructor
-  : TAO_Base_var (),
-    ptr_ (IR_ValueMemberDef::_duplicate (p.ptr ()))
-{}
-
-ACE_INLINE
-IR_ValueMemberDef_var::~IR_ValueMemberDef_var (void) // destructor
-{
-  CORBA::release (this->ptr_);
-}
-
-ACE_INLINE IR_ValueMemberDef_var &
-IR_ValueMemberDef_var::operator= (IR_ValueMemberDef_ptr p)
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE IR_ValueMemberDef_var &
-IR_ValueMemberDef_var::operator= (const ::IR_ValueMemberDef_var &p)
-{
-  if (this != &p)
-  {
-    CORBA::release (this->ptr_);
-    this->ptr_ = ::IR_ValueMemberDef::_duplicate (p.ptr ());
-  }
-  return *this;
-}
-
-ACE_INLINE 
-IR_ValueMemberDef_var::operator const ::IR_ValueMemberDef_ptr &() const // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE 
-IR_ValueMemberDef_var::operator ::IR_ValueMemberDef_ptr &() // cast 
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_ValueMemberDef_ptr
-IR_ValueMemberDef_var::operator-> (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_ValueMemberDef_ptr
-IR_ValueMemberDef_var::in (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_ValueMemberDef_ptr &
-IR_ValueMemberDef_var::inout (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_ValueMemberDef_ptr &
-IR_ValueMemberDef_var::out (void)
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = ::IR_ValueMemberDef::_nil ();
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_ValueMemberDef_ptr
-IR_ValueMemberDef_var::_retn (void)
-{
-  // yield ownership of managed obj reference
-  ::IR_ValueMemberDef_ptr val = this->ptr_;
-  this->ptr_ = ::IR_ValueMemberDef::_nil ();
-  return val;
-}
-
-// *************************************************************
-// Inline operations for class IR_ValueMemberDef_out
-// *************************************************************
-
-ACE_INLINE
-IR_ValueMemberDef_out::IR_ValueMemberDef_out (IR_ValueMemberDef_ptr &p)
-  : ptr_ (p)
-{
-  this->ptr_ = ::IR_ValueMemberDef::_nil ();
-}
-
-ACE_INLINE
-IR_ValueMemberDef_out::IR_ValueMemberDef_out (IR_ValueMemberDef_var &p) // constructor from _var
-  : ptr_ (p.out ())
-{
-  CORBA::release (this->ptr_);
-  this->ptr_ = ::IR_ValueMemberDef::_nil ();
-}
-
-ACE_INLINE
-IR_ValueMemberDef_out::IR_ValueMemberDef_out (const ::IR_ValueMemberDef_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (IR_ValueMemberDef_out &, p).ptr_)
-{}
-
-ACE_INLINE ::IR_ValueMemberDef_out &
-IR_ValueMemberDef_out::operator= (const ::IR_ValueMemberDef_out &p)
-{
-  this->ptr_ = ACE_const_cast (IR_ValueMemberDef_out&, p).ptr_;
-  return *this;
-}
-
-ACE_INLINE IR_ValueMemberDef_out &
-IR_ValueMemberDef_out::operator= (const ::IR_ValueMemberDef_var &p)
-{
-  this->ptr_ = ::IR_ValueMemberDef::_duplicate (p.ptr ());
-  return *this;
-}
-
-ACE_INLINE IR_ValueMemberDef_out &
-IR_ValueMemberDef_out::operator= (IR_ValueMemberDef_ptr p)
-{
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE 
-IR_ValueMemberDef_out::operator ::IR_ValueMemberDef_ptr &() // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_ValueMemberDef_ptr &
-IR_ValueMemberDef_out::ptr (void) // ptr
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_ValueMemberDef_ptr
-IR_ValueMemberDef_out::operator-> (void)
-{
-  return this->ptr_;
-}
-
-// *************************************************************
-// Inline operations for class IR_ValueDescription_var
-// *************************************************************
-
-ACE_INLINE
-IR_ValueDescription_var::IR_ValueDescription_var (void) // default constructor
-  : ptr_ (0)
-{}
-
-ACE_INLINE
-IR_ValueDescription_var::IR_ValueDescription_var (IR_ValueDescription *p)
-  : ptr_ (p)
-{}
-
-ACE_INLINE
-IR_ValueDescription_var::IR_ValueDescription_var (const ::IR_ValueDescription_var &p) // copy constructor
-{
-  if (p.ptr_)
-    ACE_NEW (this->ptr_, ::IR_ValueDescription (*p.ptr_));
-  else
-    this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_ValueDescription_var::~IR_ValueDescription_var (void) // destructor
-{
-  delete this->ptr_;
-}
-
-ACE_INLINE IR_ValueDescription_var &
-IR_ValueDescription_var::operator= (IR_ValueDescription *p)
-{
-  delete this->ptr_;
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE ::IR_ValueDescription_var &
-IR_ValueDescription_var::operator= (const ::IR_ValueDescription_var &p)
-{
-  if (this != &p)
-    {
-      if (p.ptr_ == 0)
-        {
-          delete this->ptr_;
-          this->ptr_ = 0;
-        }
-      else
-        {
-          IR_ValueDescription *deep_copy = 
-            new IR_ValueDescription (*p.ptr_);
-          
-          if (deep_copy != 0)
-            {
-              IR_ValueDescription *tmp = deep_copy;
-              deep_copy = this->ptr_;
-              this->ptr_ = tmp;
-              delete deep_copy;
-            }
-        }
-    }
-  
-  return *this;
-}
-
-ACE_INLINE const ::IR_ValueDescription *
-IR_ValueDescription_var::operator-> (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_ValueDescription *
-IR_ValueDescription_var::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE
-IR_ValueDescription_var::operator const ::IR_ValueDescription &() const // cast
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE
-IR_ValueDescription_var::operator ::IR_ValueDescription &() // cast 
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE
-IR_ValueDescription_var::operator ::IR_ValueDescription &() const // cast 
-{
-  return *this->ptr_;
-}
-
-// variable-size types only
-ACE_INLINE
-IR_ValueDescription_var::operator ::IR_ValueDescription *&() // cast 
-{
-  return this->ptr_;
-}
-
-ACE_INLINE const ::IR_ValueDescription &
-IR_ValueDescription_var::in (void) const
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE ::IR_ValueDescription &
-IR_ValueDescription_var::inout (void)
-{
-  return *this->ptr_;
-}
-
-// mapping for variable size 
-ACE_INLINE ::IR_ValueDescription *&
-IR_ValueDescription_var::out (void)
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_ValueDescription *
-IR_ValueDescription_var::_retn (void)
-{
-  ::IR_ValueDescription *tmp = this->ptr_;
-  this->ptr_ = 0;
-  return tmp;
-}
-
-ACE_INLINE ::IR_ValueDescription *
-IR_ValueDescription_var::ptr (void) const
-{
-  return this->ptr_;
-}
-
-// *************************************************************
-// Inline operations for class IR_ValueDescription_out
-// *************************************************************
-
-ACE_INLINE
-IR_ValueDescription_out::IR_ValueDescription_out (::IR_ValueDescription *&p)
-  : ptr_ (p)
-{
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_ValueDescription_out::IR_ValueDescription_out (IR_ValueDescription_var &p) // constructor from _var
-  : ptr_ (p.out ())
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_ValueDescription_out::IR_ValueDescription_out (const ::IR_ValueDescription_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (IR_ValueDescription_out&, p).ptr_)
-{}
-
-ACE_INLINE IR_ValueDescription_out &
-IR_ValueDescription_out::operator= (const ::IR_ValueDescription_out &p)
-{
-  this->ptr_ = ACE_const_cast (IR_ValueDescription_out&, p).ptr_;
-  return *this;
-}
-
-ACE_INLINE IR_ValueDescription_out &
-IR_ValueDescription_out::operator= (IR_ValueDescription *p)
-{
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE 
-IR_ValueDescription_out::operator ::IR_ValueDescription *&() // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_ValueDescription *&
-IR_ValueDescription_out::ptr (void) // ptr
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_ValueDescription *
-IR_ValueDescription_out::operator-> (void)
-{
-  return this->ptr_;
-}
-
-// *************************************************************
-// Inline operations for class IR_ProvidesDescription_var
-// *************************************************************
-
-ACE_INLINE
-IR_ProvidesDescription_var::IR_ProvidesDescription_var (void) // default constructor
-  : ptr_ (0)
-{}
-
-ACE_INLINE
-IR_ProvidesDescription_var::IR_ProvidesDescription_var (IR_ProvidesDescription *p)
-  : ptr_ (p)
-{}
-
-ACE_INLINE
-IR_ProvidesDescription_var::IR_ProvidesDescription_var (const ::IR_ProvidesDescription_var &p) // copy constructor
-{
-  if (p.ptr_)
-    ACE_NEW (this->ptr_, ::IR_ProvidesDescription (*p.ptr_));
-  else
-    this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_ProvidesDescription_var::~IR_ProvidesDescription_var (void) // destructor
-{
-  delete this->ptr_;
-}
-
-ACE_INLINE IR_ProvidesDescription_var &
-IR_ProvidesDescription_var::operator= (IR_ProvidesDescription *p)
-{
-  delete this->ptr_;
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE ::IR_ProvidesDescription_var &
-IR_ProvidesDescription_var::operator= (const ::IR_ProvidesDescription_var &p)
-{
-  if (this != &p)
-    {
-      if (p.ptr_ == 0)
-        {
-          delete this->ptr_;
-          this->ptr_ = 0;
-        }
-      else
-        {
-          IR_ProvidesDescription *deep_copy = 
-            new IR_ProvidesDescription (*p.ptr_);
-          
-          if (deep_copy != 0)
-            {
-              IR_ProvidesDescription *tmp = deep_copy;
-              deep_copy = this->ptr_;
-              this->ptr_ = tmp;
-              delete deep_copy;
-            }
-        }
-    }
-  
-  return *this;
-}
-
-ACE_INLINE const ::IR_ProvidesDescription *
-IR_ProvidesDescription_var::operator-> (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_ProvidesDescription *
-IR_ProvidesDescription_var::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE
-IR_ProvidesDescription_var::operator const ::IR_ProvidesDescription &() const // cast
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE
-IR_ProvidesDescription_var::operator ::IR_ProvidesDescription &() // cast 
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE
-IR_ProvidesDescription_var::operator ::IR_ProvidesDescription &() const // cast 
-{
-  return *this->ptr_;
-}
-
-// variable-size types only
-ACE_INLINE
-IR_ProvidesDescription_var::operator ::IR_ProvidesDescription *&() // cast 
-{
-  return this->ptr_;
-}
-
-ACE_INLINE const ::IR_ProvidesDescription &
-IR_ProvidesDescription_var::in (void) const
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE ::IR_ProvidesDescription &
-IR_ProvidesDescription_var::inout (void)
-{
-  return *this->ptr_;
-}
-
-// mapping for variable size 
-ACE_INLINE ::IR_ProvidesDescription *&
-IR_ProvidesDescription_var::out (void)
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_ProvidesDescription *
-IR_ProvidesDescription_var::_retn (void)
-{
-  ::IR_ProvidesDescription *tmp = this->ptr_;
-  this->ptr_ = 0;
-  return tmp;
-}
-
-ACE_INLINE ::IR_ProvidesDescription *
-IR_ProvidesDescription_var::ptr (void) const
-{
-  return this->ptr_;
-}
-
-// *************************************************************
-// Inline operations for class IR_ProvidesDescription_out
-// *************************************************************
-
-ACE_INLINE
-IR_ProvidesDescription_out::IR_ProvidesDescription_out (::IR_ProvidesDescription *&p)
-  : ptr_ (p)
-{
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_ProvidesDescription_out::IR_ProvidesDescription_out (IR_ProvidesDescription_var &p) // constructor from _var
-  : ptr_ (p.out ())
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_ProvidesDescription_out::IR_ProvidesDescription_out (const ::IR_ProvidesDescription_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (IR_ProvidesDescription_out&, p).ptr_)
-{}
-
-ACE_INLINE IR_ProvidesDescription_out &
-IR_ProvidesDescription_out::operator= (const ::IR_ProvidesDescription_out &p)
-{
-  this->ptr_ = ACE_const_cast (IR_ProvidesDescription_out&, p).ptr_;
-  return *this;
-}
-
-ACE_INLINE IR_ProvidesDescription_out &
-IR_ProvidesDescription_out::operator= (IR_ProvidesDescription *p)
-{
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE 
-IR_ProvidesDescription_out::operator ::IR_ProvidesDescription *&() // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_ProvidesDescription *&
-IR_ProvidesDescription_out::ptr (void) // ptr
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_ProvidesDescription *
-IR_ProvidesDescription_out::operator-> (void)
-{
-  return this->ptr_;
-}
-
-// *************************************************************
-// Inline operations for class IR_UsesDescription_var
-// *************************************************************
-
-ACE_INLINE
-IR_UsesDescription_var::IR_UsesDescription_var (void) // default constructor
-  : ptr_ (0)
-{}
-
-ACE_INLINE
-IR_UsesDescription_var::IR_UsesDescription_var (IR_UsesDescription *p)
-  : ptr_ (p)
-{}
-
-ACE_INLINE
-IR_UsesDescription_var::IR_UsesDescription_var (const ::IR_UsesDescription_var &p) // copy constructor
-{
-  if (p.ptr_)
-    ACE_NEW (this->ptr_, ::IR_UsesDescription (*p.ptr_));
-  else
-    this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_UsesDescription_var::~IR_UsesDescription_var (void) // destructor
-{
-  delete this->ptr_;
-}
-
-ACE_INLINE IR_UsesDescription_var &
-IR_UsesDescription_var::operator= (IR_UsesDescription *p)
-{
-  delete this->ptr_;
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE ::IR_UsesDescription_var &
-IR_UsesDescription_var::operator= (const ::IR_UsesDescription_var &p)
-{
-  if (this != &p)
-    {
-      if (p.ptr_ == 0)
-        {
-          delete this->ptr_;
-          this->ptr_ = 0;
-        }
-      else
-        {
-          IR_UsesDescription *deep_copy = 
-            new IR_UsesDescription (*p.ptr_);
-          
-          if (deep_copy != 0)
-            {
-              IR_UsesDescription *tmp = deep_copy;
-              deep_copy = this->ptr_;
-              this->ptr_ = tmp;
-              delete deep_copy;
-            }
-        }
-    }
-  
-  return *this;
-}
-
-ACE_INLINE const ::IR_UsesDescription *
-IR_UsesDescription_var::operator-> (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_UsesDescription *
-IR_UsesDescription_var::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE
-IR_UsesDescription_var::operator const ::IR_UsesDescription &() const // cast
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE
-IR_UsesDescription_var::operator ::IR_UsesDescription &() // cast 
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE
-IR_UsesDescription_var::operator ::IR_UsesDescription &() const // cast 
-{
-  return *this->ptr_;
-}
-
-// variable-size types only
-ACE_INLINE
-IR_UsesDescription_var::operator ::IR_UsesDescription *&() // cast 
-{
-  return this->ptr_;
-}
-
-ACE_INLINE const ::IR_UsesDescription &
-IR_UsesDescription_var::in (void) const
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE ::IR_UsesDescription &
-IR_UsesDescription_var::inout (void)
-{
-  return *this->ptr_;
-}
-
-// mapping for variable size 
-ACE_INLINE ::IR_UsesDescription *&
-IR_UsesDescription_var::out (void)
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_UsesDescription *
-IR_UsesDescription_var::_retn (void)
-{
-  ::IR_UsesDescription *tmp = this->ptr_;
-  this->ptr_ = 0;
-  return tmp;
-}
-
-ACE_INLINE ::IR_UsesDescription *
-IR_UsesDescription_var::ptr (void) const
-{
-  return this->ptr_;
-}
-
-// *************************************************************
-// Inline operations for class IR_UsesDescription_out
-// *************************************************************
-
-ACE_INLINE
-IR_UsesDescription_out::IR_UsesDescription_out (::IR_UsesDescription *&p)
-  : ptr_ (p)
-{
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_UsesDescription_out::IR_UsesDescription_out (IR_UsesDescription_var &p) // constructor from _var
-  : ptr_ (p.out ())
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_UsesDescription_out::IR_UsesDescription_out (const ::IR_UsesDescription_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (IR_UsesDescription_out&, p).ptr_)
-{}
-
-ACE_INLINE IR_UsesDescription_out &
-IR_UsesDescription_out::operator= (const ::IR_UsesDescription_out &p)
-{
-  this->ptr_ = ACE_const_cast (IR_UsesDescription_out&, p).ptr_;
-  return *this;
-}
-
-ACE_INLINE IR_UsesDescription_out &
-IR_UsesDescription_out::operator= (IR_UsesDescription *p)
-{
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE 
-IR_UsesDescription_out::operator ::IR_UsesDescription *&() // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_UsesDescription *&
-IR_UsesDescription_out::ptr (void) // ptr
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_UsesDescription *
-IR_UsesDescription_out::operator-> (void)
-{
-  return this->ptr_;
-}
-
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  
-  // = Static operations.
-  ACE_INLINE IR_ProvidesDescription *
-  _TAO_Unbounded_Sequence_IR_ProvidesDescSeq::allocbuf (CORBA::ULong size)
-  // Allocate storage for the sequence.
-  {
-    IR_ProvidesDescription *retval = 0;
-    ACE_NEW_RETURN (retval, IR_ProvidesDescription[size], 0);
-    return retval;
-  }
-  
-  ACE_INLINE void _TAO_Unbounded_Sequence_IR_ProvidesDescSeq::freebuf (IR_ProvidesDescription *buffer)
-  // Free the sequence.
-  {
-    delete [] buffer;
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Sequence_IR_ProvidesDescSeq::_TAO_Unbounded_Sequence_IR_ProvidesDescSeq (void) // Default constructor.
-  {
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Sequence_IR_ProvidesDescSeq::_TAO_Unbounded_Sequence_IR_ProvidesDescSeq (CORBA::ULong maximum) // Constructor using a maximum length value.
-    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Sequence_IR_ProvidesDescSeq::allocbuf (maximum))
-  {
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Sequence_IR_ProvidesDescSeq::_TAO_Unbounded_Sequence_IR_ProvidesDescSeq (CORBA::ULong maximum,
-    CORBA::ULong length,
-    IR_ProvidesDescription *data,
-    CORBA::Boolean release)
-  : TAO_Unbounded_Base_Sequence (maximum, length, data, release)
-  {
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Sequence_IR_ProvidesDescSeq::_TAO_Unbounded_Sequence_IR_ProvidesDescSeq (const _TAO_Unbounded_Sequence_IR_ProvidesDescSeq &rhs)
-  // Copy constructor.
-    : TAO_Unbounded_Base_Sequence (rhs)
-  {
-    if (rhs.buffer_ != 0)
-    {
-      IR_ProvidesDescription *tmp1 = _TAO_Unbounded_Sequence_IR_ProvidesDescSeq::allocbuf (this->maximum_);
-      IR_ProvidesDescription * const tmp2 = ACE_reinterpret_cast (IR_ProvidesDescription * ACE_CAST_CONST, rhs.buffer_);
-      
-      for (CORBA::ULong i = 0; i < this->length_; ++i)
-        tmp1[i] = tmp2[i];
-      
-      this->buffer_ = tmp1;
-    }
-    else
-    {
-      this->buffer_ = 0;
-    }
-  }
-  
-  ACE_INLINE _TAO_Unbounded_Sequence_IR_ProvidesDescSeq &
-  _TAO_Unbounded_Sequence_IR_ProvidesDescSeq::operator= (const _TAO_Unbounded_Sequence_IR_ProvidesDescSeq &rhs)
-  // Assignment operator.
-  {
-    if (this == &rhs)
-      return *this;
-    
-    if (this->release_)
-    {
-      if (this->maximum_ < rhs.maximum_)
-      {
-        // free the old buffer
-        IR_ProvidesDescription *tmp = ACE_reinterpret_cast (IR_ProvidesDescription *, this->buffer_);
-        _TAO_Unbounded_Sequence_IR_ProvidesDescSeq::freebuf (tmp);
-        this->buffer_ = _TAO_Unbounded_Sequence_IR_ProvidesDescSeq::allocbuf (rhs.maximum_);
-      }
-    }
-    else
-      this->buffer_ = _TAO_Unbounded_Sequence_IR_ProvidesDescSeq::allocbuf (rhs.maximum_);
-    
-    TAO_Unbounded_Base_Sequence::operator= (rhs);
-    
-    IR_ProvidesDescription *tmp1 = ACE_reinterpret_cast (IR_ProvidesDescription *, this->buffer_);
-    IR_ProvidesDescription * const tmp2 = ACE_reinterpret_cast (IR_ProvidesDescription * ACE_CAST_CONST, rhs.buffer_);
-    
-    for (CORBA::ULong i = 0; i < this->length_; ++i)
-      tmp1[i] = tmp2[i];
-    
-    return *this;
-  }
-  
-  // = Accessors.
-  ACE_INLINE IR_ProvidesDescription &
-  _TAO_Unbounded_Sequence_IR_ProvidesDescSeq::operator[] (CORBA::ULong i)
-  // operator []
-  {
-    ACE_ASSERT (i < this->maximum_);
-    IR_ProvidesDescription* tmp = ACE_reinterpret_cast(IR_ProvidesDescription*,this->buffer_);
-    return tmp[i];
-  }
-  
-  ACE_INLINE const IR_ProvidesDescription &
-  _TAO_Unbounded_Sequence_IR_ProvidesDescSeq::operator[] (CORBA::ULong i) const
-  // operator []
-  {
-    ACE_ASSERT (i < this->maximum_);
-    IR_ProvidesDescription * const tmp = ACE_reinterpret_cast (IR_ProvidesDescription* ACE_CAST_CONST, this->buffer_);
-    return tmp[i];
-  }
-  
-  // Implement the TAO_Base_Sequence methods (see Sequence.h)
-  
-  ACE_INLINE IR_ProvidesDescription *
-  _TAO_Unbounded_Sequence_IR_ProvidesDescSeq::get_buffer (CORBA::Boolean orphan)
-  {
-    IR_ProvidesDescription *result = 0;
-    if (orphan == 0)
-    {
-      // We retain ownership.
-      if (this->buffer_ == 0)
-      {
-        result = _TAO_Unbounded_Sequence_IR_ProvidesDescSeq::allocbuf (this->length_);
-        this->buffer_ = result;
-        this->release_ = 1;
-      }
-      else
-      {
-        result = ACE_reinterpret_cast (IR_ProvidesDescription*, this->buffer_);
-      }
-    }
-    else // if (orphan == 1)
-    {
-      if (this->release_ != 0)
-      {
-        // We set the state back to default and relinquish
-        // ownership.
-        result = ACE_reinterpret_cast(IR_ProvidesDescription*,this->buffer_);
-        this->maximum_ = 0;
-        this->length_ = 0;
-        this->buffer_ = 0;
-        this->release_ = 0;
-      }
-    }
-    return result;
-  }
-  
-  ACE_INLINE const IR_ProvidesDescription *
-  _TAO_Unbounded_Sequence_IR_ProvidesDescSeq::get_buffer (void) const
-  {
-    return ACE_reinterpret_cast(const IR_ProvidesDescription * ACE_CAST_CONST, this->buffer_);
-  }
-  
-  ACE_INLINE void
-  _TAO_Unbounded_Sequence_IR_ProvidesDescSeq::replace (CORBA::ULong max,
-  CORBA::ULong length,
-  IR_ProvidesDescription *data,
-  CORBA::Boolean release)
-  {
-    this->maximum_ = max;
-    this->length_ = length;
-    if (this->buffer_ && this->release_ == 1)
-    {
-      IR_ProvidesDescription *tmp = ACE_reinterpret_cast(IR_ProvidesDescription*,this->buffer_);
-      _TAO_Unbounded_Sequence_IR_ProvidesDescSeq::freebuf (tmp);
-    }
-    this->buffer_ = data;
-    this->release_ = release;
-  }
-  
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
-
-// *************************************************************
-// Inline operations for class IR_ProvidesDescSeq_var
-// *************************************************************
-
-ACE_INLINE
-IR_ProvidesDescSeq_var::IR_ProvidesDescSeq_var (void) // default constructor
-  : ptr_ (0)
-{}
-
-ACE_INLINE
-IR_ProvidesDescSeq_var::IR_ProvidesDescSeq_var (IR_ProvidesDescSeq *p)
-  : ptr_ (p)
-{}
-
-ACE_INLINE
-IR_ProvidesDescSeq_var::IR_ProvidesDescSeq_var (const ::IR_ProvidesDescSeq_var &p) // copy constructor
-{
-  if (p.ptr_)
-    ACE_NEW (this->ptr_, ::IR_ProvidesDescSeq (*p.ptr_));
-  else
-    this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_ProvidesDescSeq_var::~IR_ProvidesDescSeq_var (void) // destructor
-{
-  delete this->ptr_;
-}
-
-ACE_INLINE IR_ProvidesDescSeq_var &
-IR_ProvidesDescSeq_var::operator= (IR_ProvidesDescSeq *p)
-{
-  delete this->ptr_;
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE IR_ProvidesDescSeq_var &
-IR_ProvidesDescSeq_var::operator= (const ::IR_ProvidesDescSeq_var &p) // deep copy
-{
-  if (this != &p)
-    {
-      if (p.ptr_ == 0)
-        {
-          delete this->ptr_;
-          this->ptr_ = 0;
-        }
-      else
-        {
-          IR_ProvidesDescSeq *deep_copy = 
-            new IR_ProvidesDescSeq (*p.ptr_);
-          
-          if (deep_copy != 0)
-            {
-              IR_ProvidesDescSeq *tmp = deep_copy;
-              deep_copy = this->ptr_;
-              this->ptr_ = tmp;
-              delete deep_copy;
-            }
-        }
-    }
-  
-  return *this;
-}
-
-ACE_INLINE const ::IR_ProvidesDescSeq *
-IR_ProvidesDescSeq_var::operator-> (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_ProvidesDescSeq *
-IR_ProvidesDescSeq_var::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE 
-IR_ProvidesDescSeq_var::operator const ::IR_ProvidesDescSeq &() const // cast
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE 
-IR_ProvidesDescSeq_var::operator ::IR_ProvidesDescSeq &() // cast 
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE 
-IR_ProvidesDescSeq_var::operator ::IR_ProvidesDescSeq &() const // cast 
-{
-  return *this->ptr_;
-}
-
-// variable-size types only
-ACE_INLINE
-IR_ProvidesDescSeq_var::operator ::IR_ProvidesDescSeq *&() // cast 
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_ProvidesDescription &
-IR_ProvidesDescSeq_var::operator[] (CORBA::ULong index)
-{
-  return this->ptr_->operator[] (index);
-}
-
-ACE_INLINE const IR_ProvidesDescription &
-IR_ProvidesDescSeq_var::operator[] (CORBA::ULong index) const
-{
-  return ACE_const_cast (const IR_ProvidesDescription &, this->ptr_->operator[] (index));
-}
-
-ACE_INLINE const ::IR_ProvidesDescSeq &
-IR_ProvidesDescSeq_var::in (void) const
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE ::IR_ProvidesDescSeq &
-IR_ProvidesDescSeq_var::inout (void)
-{
-  return *this->ptr_;
-}
-
-// mapping for variable size 
-ACE_INLINE ::IR_ProvidesDescSeq *&
-IR_ProvidesDescSeq_var::out (void)
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_ProvidesDescSeq *
-IR_ProvidesDescSeq_var::_retn (void)
-{
-  ::IR_ProvidesDescSeq *tmp = this->ptr_;
-  this->ptr_ = 0;
-  return tmp;
-}
-
-ACE_INLINE ::IR_ProvidesDescSeq *
-IR_ProvidesDescSeq_var::ptr (void) const
-{
-  return this->ptr_;
-}
-
-// *************************************************************
-// Inline operations for class IR_ProvidesDescSeq_out
-// *************************************************************
-
-ACE_INLINE
-IR_ProvidesDescSeq_out::IR_ProvidesDescSeq_out (IR_ProvidesDescSeq *&p)
-  : ptr_ (p)
-{
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_ProvidesDescSeq_out::IR_ProvidesDescSeq_out (IR_ProvidesDescSeq_var &p) // constructor from _var
-  : ptr_ (p.out ())
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_ProvidesDescSeq_out::IR_ProvidesDescSeq_out (const ::IR_ProvidesDescSeq_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (IR_ProvidesDescSeq_out&, p).ptr_)
-{}
-
-ACE_INLINE ::IR_ProvidesDescSeq_out &
-IR_ProvidesDescSeq_out::operator= (const ::IR_ProvidesDescSeq_out &p)
-{
-  this->ptr_ = ACE_const_cast (IR_ProvidesDescSeq_out&, p).ptr_;
-  return *this;
-}
-
-ACE_INLINE ::IR_ProvidesDescSeq_out &
-IR_ProvidesDescSeq_out::operator= (IR_ProvidesDescSeq *p)
-{
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE 
-IR_ProvidesDescSeq_out::operator ::IR_ProvidesDescSeq *&() // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_ProvidesDescSeq *&
-IR_ProvidesDescSeq_out::ptr (void) // ptr
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_ProvidesDescSeq *
-IR_ProvidesDescSeq_out::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_ProvidesDescription &
-IR_ProvidesDescSeq_out::operator[] (CORBA::ULong index)
-{
-  return this->ptr_->operator[] (index);
-}
-
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  
-  // = Static operations.
-  ACE_INLINE IR_UsesDescription *
-  _TAO_Unbounded_Sequence_IR_UsesDescSeq::allocbuf (CORBA::ULong size)
-  // Allocate storage for the sequence.
-  {
-    IR_UsesDescription *retval = 0;
-    ACE_NEW_RETURN (retval, IR_UsesDescription[size], 0);
-    return retval;
-  }
-  
-  ACE_INLINE void _TAO_Unbounded_Sequence_IR_UsesDescSeq::freebuf (IR_UsesDescription *buffer)
-  // Free the sequence.
-  {
-    delete [] buffer;
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Sequence_IR_UsesDescSeq::_TAO_Unbounded_Sequence_IR_UsesDescSeq (void) // Default constructor.
-  {
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Sequence_IR_UsesDescSeq::_TAO_Unbounded_Sequence_IR_UsesDescSeq (CORBA::ULong maximum) // Constructor using a maximum length value.
-    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Sequence_IR_UsesDescSeq::allocbuf (maximum))
-  {
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Sequence_IR_UsesDescSeq::_TAO_Unbounded_Sequence_IR_UsesDescSeq (CORBA::ULong maximum,
-    CORBA::ULong length,
-    IR_UsesDescription *data,
-    CORBA::Boolean release)
-  : TAO_Unbounded_Base_Sequence (maximum, length, data, release)
-  {
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Sequence_IR_UsesDescSeq::_TAO_Unbounded_Sequence_IR_UsesDescSeq (const _TAO_Unbounded_Sequence_IR_UsesDescSeq &rhs)
-  // Copy constructor.
-    : TAO_Unbounded_Base_Sequence (rhs)
-  {
-    if (rhs.buffer_ != 0)
-    {
-      IR_UsesDescription *tmp1 = _TAO_Unbounded_Sequence_IR_UsesDescSeq::allocbuf (this->maximum_);
-      IR_UsesDescription * const tmp2 = ACE_reinterpret_cast (IR_UsesDescription * ACE_CAST_CONST, rhs.buffer_);
-      
-      for (CORBA::ULong i = 0; i < this->length_; ++i)
-        tmp1[i] = tmp2[i];
-      
-      this->buffer_ = tmp1;
-    }
-    else
-    {
-      this->buffer_ = 0;
-    }
-  }
-  
-  ACE_INLINE _TAO_Unbounded_Sequence_IR_UsesDescSeq &
-  _TAO_Unbounded_Sequence_IR_UsesDescSeq::operator= (const _TAO_Unbounded_Sequence_IR_UsesDescSeq &rhs)
-  // Assignment operator.
-  {
-    if (this == &rhs)
-      return *this;
-    
-    if (this->release_)
-    {
-      if (this->maximum_ < rhs.maximum_)
-      {
-        // free the old buffer
-        IR_UsesDescription *tmp = ACE_reinterpret_cast (IR_UsesDescription *, this->buffer_);
-        _TAO_Unbounded_Sequence_IR_UsesDescSeq::freebuf (tmp);
-        this->buffer_ = _TAO_Unbounded_Sequence_IR_UsesDescSeq::allocbuf (rhs.maximum_);
-      }
-    }
-    else
-      this->buffer_ = _TAO_Unbounded_Sequence_IR_UsesDescSeq::allocbuf (rhs.maximum_);
-    
-    TAO_Unbounded_Base_Sequence::operator= (rhs);
-    
-    IR_UsesDescription *tmp1 = ACE_reinterpret_cast (IR_UsesDescription *, this->buffer_);
-    IR_UsesDescription * const tmp2 = ACE_reinterpret_cast (IR_UsesDescription * ACE_CAST_CONST, rhs.buffer_);
-    
-    for (CORBA::ULong i = 0; i < this->length_; ++i)
-      tmp1[i] = tmp2[i];
-    
-    return *this;
-  }
-  
-  // = Accessors.
-  ACE_INLINE IR_UsesDescription &
-  _TAO_Unbounded_Sequence_IR_UsesDescSeq::operator[] (CORBA::ULong i)
-  // operator []
-  {
-    ACE_ASSERT (i < this->maximum_);
-    IR_UsesDescription* tmp = ACE_reinterpret_cast(IR_UsesDescription*,this->buffer_);
-    return tmp[i];
-  }
-  
-  ACE_INLINE const IR_UsesDescription &
-  _TAO_Unbounded_Sequence_IR_UsesDescSeq::operator[] (CORBA::ULong i) const
-  // operator []
-  {
-    ACE_ASSERT (i < this->maximum_);
-    IR_UsesDescription * const tmp = ACE_reinterpret_cast (IR_UsesDescription* ACE_CAST_CONST, this->buffer_);
-    return tmp[i];
-  }
-  
-  // Implement the TAO_Base_Sequence methods (see Sequence.h)
-  
-  ACE_INLINE IR_UsesDescription *
-  _TAO_Unbounded_Sequence_IR_UsesDescSeq::get_buffer (CORBA::Boolean orphan)
-  {
-    IR_UsesDescription *result = 0;
-    if (orphan == 0)
-    {
-      // We retain ownership.
-      if (this->buffer_ == 0)
-      {
-        result = _TAO_Unbounded_Sequence_IR_UsesDescSeq::allocbuf (this->length_);
-        this->buffer_ = result;
-        this->release_ = 1;
-      }
-      else
-      {
-        result = ACE_reinterpret_cast (IR_UsesDescription*, this->buffer_);
-      }
-    }
-    else // if (orphan == 1)
-    {
-      if (this->release_ != 0)
-      {
-        // We set the state back to default and relinquish
-        // ownership.
-        result = ACE_reinterpret_cast(IR_UsesDescription*,this->buffer_);
-        this->maximum_ = 0;
-        this->length_ = 0;
-        this->buffer_ = 0;
-        this->release_ = 0;
-      }
-    }
-    return result;
-  }
-  
-  ACE_INLINE const IR_UsesDescription *
-  _TAO_Unbounded_Sequence_IR_UsesDescSeq::get_buffer (void) const
-  {
-    return ACE_reinterpret_cast(const IR_UsesDescription * ACE_CAST_CONST, this->buffer_);
-  }
-  
-  ACE_INLINE void
-  _TAO_Unbounded_Sequence_IR_UsesDescSeq::replace (CORBA::ULong max,
-  CORBA::ULong length,
-  IR_UsesDescription *data,
-  CORBA::Boolean release)
-  {
-    this->maximum_ = max;
-    this->length_ = length;
-    if (this->buffer_ && this->release_ == 1)
-    {
-      IR_UsesDescription *tmp = ACE_reinterpret_cast(IR_UsesDescription*,this->buffer_);
-      _TAO_Unbounded_Sequence_IR_UsesDescSeq::freebuf (tmp);
-    }
-    this->buffer_ = data;
-    this->release_ = release;
-  }
-  
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
-
-// *************************************************************
-// Inline operations for class IR_UsesDescSeq_var
-// *************************************************************
-
-ACE_INLINE
-IR_UsesDescSeq_var::IR_UsesDescSeq_var (void) // default constructor
-  : ptr_ (0)
-{}
-
-ACE_INLINE
-IR_UsesDescSeq_var::IR_UsesDescSeq_var (IR_UsesDescSeq *p)
-  : ptr_ (p)
-{}
-
-ACE_INLINE
-IR_UsesDescSeq_var::IR_UsesDescSeq_var (const ::IR_UsesDescSeq_var &p) // copy constructor
-{
-  if (p.ptr_)
-    ACE_NEW (this->ptr_, ::IR_UsesDescSeq (*p.ptr_));
-  else
-    this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_UsesDescSeq_var::~IR_UsesDescSeq_var (void) // destructor
-{
-  delete this->ptr_;
-}
-
-ACE_INLINE IR_UsesDescSeq_var &
-IR_UsesDescSeq_var::operator= (IR_UsesDescSeq *p)
-{
-  delete this->ptr_;
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE IR_UsesDescSeq_var &
-IR_UsesDescSeq_var::operator= (const ::IR_UsesDescSeq_var &p) // deep copy
-{
-  if (this != &p)
-    {
-      if (p.ptr_ == 0)
-        {
-          delete this->ptr_;
-          this->ptr_ = 0;
-        }
-      else
-        {
-          IR_UsesDescSeq *deep_copy = 
-            new IR_UsesDescSeq (*p.ptr_);
-          
-          if (deep_copy != 0)
-            {
-              IR_UsesDescSeq *tmp = deep_copy;
-              deep_copy = this->ptr_;
-              this->ptr_ = tmp;
-              delete deep_copy;
-            }
-        }
-    }
-  
-  return *this;
-}
-
-ACE_INLINE const ::IR_UsesDescSeq *
-IR_UsesDescSeq_var::operator-> (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_UsesDescSeq *
-IR_UsesDescSeq_var::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE 
-IR_UsesDescSeq_var::operator const ::IR_UsesDescSeq &() const // cast
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE 
-IR_UsesDescSeq_var::operator ::IR_UsesDescSeq &() // cast 
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE 
-IR_UsesDescSeq_var::operator ::IR_UsesDescSeq &() const // cast 
-{
-  return *this->ptr_;
-}
-
-// variable-size types only
-ACE_INLINE
-IR_UsesDescSeq_var::operator ::IR_UsesDescSeq *&() // cast 
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_UsesDescription &
-IR_UsesDescSeq_var::operator[] (CORBA::ULong index)
-{
-  return this->ptr_->operator[] (index);
-}
-
-ACE_INLINE const IR_UsesDescription &
-IR_UsesDescSeq_var::operator[] (CORBA::ULong index) const
-{
-  return ACE_const_cast (const IR_UsesDescription &, this->ptr_->operator[] (index));
-}
-
-ACE_INLINE const ::IR_UsesDescSeq &
-IR_UsesDescSeq_var::in (void) const
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE ::IR_UsesDescSeq &
-IR_UsesDescSeq_var::inout (void)
-{
-  return *this->ptr_;
-}
-
-// mapping for variable size 
-ACE_INLINE ::IR_UsesDescSeq *&
-IR_UsesDescSeq_var::out (void)
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_UsesDescSeq *
-IR_UsesDescSeq_var::_retn (void)
-{
-  ::IR_UsesDescSeq *tmp = this->ptr_;
-  this->ptr_ = 0;
-  return tmp;
-}
-
-ACE_INLINE ::IR_UsesDescSeq *
-IR_UsesDescSeq_var::ptr (void) const
-{
-  return this->ptr_;
-}
-
-// *************************************************************
-// Inline operations for class IR_UsesDescSeq_out
-// *************************************************************
-
-ACE_INLINE
-IR_UsesDescSeq_out::IR_UsesDescSeq_out (IR_UsesDescSeq *&p)
-  : ptr_ (p)
-{
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_UsesDescSeq_out::IR_UsesDescSeq_out (IR_UsesDescSeq_var &p) // constructor from _var
-  : ptr_ (p.out ())
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_UsesDescSeq_out::IR_UsesDescSeq_out (const ::IR_UsesDescSeq_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (IR_UsesDescSeq_out&, p).ptr_)
-{}
-
-ACE_INLINE ::IR_UsesDescSeq_out &
-IR_UsesDescSeq_out::operator= (const ::IR_UsesDescSeq_out &p)
-{
-  this->ptr_ = ACE_const_cast (IR_UsesDescSeq_out&, p).ptr_;
-  return *this;
-}
-
-ACE_INLINE ::IR_UsesDescSeq_out &
-IR_UsesDescSeq_out::operator= (IR_UsesDescSeq *p)
-{
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE 
-IR_UsesDescSeq_out::operator ::IR_UsesDescSeq *&() // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_UsesDescSeq *&
-IR_UsesDescSeq_out::ptr (void) // ptr
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_UsesDescSeq *
-IR_UsesDescSeq_out::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE IR_UsesDescription &
-IR_UsesDescSeq_out::operator[] (CORBA::ULong index)
-{
-  return this->ptr_->operator[] (index);
-}
-
-// *************************************************************
-// Inline operations for class IR_EventDescription_var
-// *************************************************************
-
-ACE_INLINE
-IR_EventDescription_var::IR_EventDescription_var (void) // default constructor
-  : ptr_ (0)
-{}
-
-ACE_INLINE
-IR_EventDescription_var::IR_EventDescription_var (IR_EventDescription *p)
-  : ptr_ (p)
-{}
-
-ACE_INLINE
-IR_EventDescription_var::IR_EventDescription_var (const ::IR_EventDescription_var &p) // copy constructor
-{
-  if (p.ptr_)
-    ACE_NEW (this->ptr_, ::IR_EventDescription (*p.ptr_));
-  else
-    this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_EventDescription_var::~IR_EventDescription_var (void) // destructor
-{
-  delete this->ptr_;
-}
-
-ACE_INLINE IR_EventDescription_var &
-IR_EventDescription_var::operator= (IR_EventDescription *p)
-{
-  delete this->ptr_;
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE ::IR_EventDescription_var &
-IR_EventDescription_var::operator= (const ::IR_EventDescription_var &p)
-{
-  if (this != &p)
-    {
-      if (p.ptr_ == 0)
-        {
-          delete this->ptr_;
-          this->ptr_ = 0;
-        }
-      else
-        {
-          IR_EventDescription *deep_copy = 
-            new IR_EventDescription (*p.ptr_);
-          
-          if (deep_copy != 0)
-            {
-              IR_EventDescription *tmp = deep_copy;
-              deep_copy = this->ptr_;
-              this->ptr_ = tmp;
-              delete deep_copy;
-            }
-        }
-    }
-  
-  return *this;
-}
-
-ACE_INLINE const ::IR_EventDescription *
-IR_EventDescription_var::operator-> (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_EventDescription *
-IR_EventDescription_var::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE
-IR_EventDescription_var::operator const ::IR_EventDescription &() const // cast
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE
-IR_EventDescription_var::operator ::IR_EventDescription &() // cast 
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE
-IR_EventDescription_var::operator ::IR_EventDescription &() const // cast 
-{
-  return *this->ptr_;
-}
-
-// variable-size types only
-ACE_INLINE
-IR_EventDescription_var::operator ::IR_EventDescription *&() // cast 
-{
-  return this->ptr_;
-}
-
-ACE_INLINE const ::IR_EventDescription &
-IR_EventDescription_var::in (void) const
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE ::IR_EventDescription &
-IR_EventDescription_var::inout (void)
-{
-  return *this->ptr_;
-}
-
-// mapping for variable size 
-ACE_INLINE ::IR_EventDescription *&
-IR_EventDescription_var::out (void)
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_EventDescription *
-IR_EventDescription_var::_retn (void)
-{
-  ::IR_EventDescription *tmp = this->ptr_;
-  this->ptr_ = 0;
-  return tmp;
-}
-
-ACE_INLINE ::IR_EventDescription *
-IR_EventDescription_var::ptr (void) const
-{
-  return this->ptr_;
-}
-
-// *************************************************************
-// Inline operations for class IR_EventDescription_out
-// *************************************************************
-
-ACE_INLINE
-IR_EventDescription_out::IR_EventDescription_out (::IR_EventDescription *&p)
-  : ptr_ (p)
-{
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_EventDescription_out::IR_EventDescription_out (IR_EventDescription_var &p) // constructor from _var
-  : ptr_ (p.out ())
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_EventDescription_out::IR_EventDescription_out (const ::IR_EventDescription_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (IR_EventDescription_out&, p).ptr_)
-{}
-
-ACE_INLINE IR_EventDescription_out &
-IR_EventDescription_out::operator= (const ::IR_EventDescription_out &p)
-{
-  this->ptr_ = ACE_const_cast (IR_EventDescription_out&, p).ptr_;
-  return *this;
-}
-
-ACE_INLINE IR_EventDescription_out &
-IR_EventDescription_out::operator= (IR_EventDescription *p)
-{
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE 
-IR_EventDescription_out::operator ::IR_EventDescription *&() // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_EventDescription *&
-IR_EventDescription_out::ptr (void) // ptr
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_EventDescription *
-IR_EventDescription_out::operator-> (void)
-{
-  return this->ptr_;
-}
-
-// *************************************************************
-// Inline operations for class IR_ComponentDescription_var
-// *************************************************************
-
-ACE_INLINE
-IR_ComponentDescription_var::IR_ComponentDescription_var (void) // default constructor
-  : ptr_ (0)
-{}
-
-ACE_INLINE
-IR_ComponentDescription_var::IR_ComponentDescription_var (IR_ComponentDescription *p)
-  : ptr_ (p)
-{}
-
-ACE_INLINE
-IR_ComponentDescription_var::IR_ComponentDescription_var (const ::IR_ComponentDescription_var &p) // copy constructor
-{
-  if (p.ptr_)
-    ACE_NEW (this->ptr_, ::IR_ComponentDescription (*p.ptr_));
-  else
-    this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_ComponentDescription_var::~IR_ComponentDescription_var (void) // destructor
-{
-  delete this->ptr_;
-}
-
-ACE_INLINE IR_ComponentDescription_var &
-IR_ComponentDescription_var::operator= (IR_ComponentDescription *p)
-{
-  delete this->ptr_;
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE ::IR_ComponentDescription_var &
-IR_ComponentDescription_var::operator= (const ::IR_ComponentDescription_var &p)
-{
-  if (this != &p)
-    {
-      if (p.ptr_ == 0)
-        {
-          delete this->ptr_;
-          this->ptr_ = 0;
-        }
-      else
-        {
-          IR_ComponentDescription *deep_copy = 
-            new IR_ComponentDescription (*p.ptr_);
-          
-          if (deep_copy != 0)
-            {
-              IR_ComponentDescription *tmp = deep_copy;
-              deep_copy = this->ptr_;
-              this->ptr_ = tmp;
-              delete deep_copy;
-            }
-        }
-    }
-  
-  return *this;
-}
-
-ACE_INLINE const ::IR_ComponentDescription *
-IR_ComponentDescription_var::operator-> (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_ComponentDescription *
-IR_ComponentDescription_var::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE
-IR_ComponentDescription_var::operator const ::IR_ComponentDescription &() const // cast
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE
-IR_ComponentDescription_var::operator ::IR_ComponentDescription &() // cast 
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE
-IR_ComponentDescription_var::operator ::IR_ComponentDescription &() const // cast 
-{
-  return *this->ptr_;
-}
-
-// variable-size types only
-ACE_INLINE
-IR_ComponentDescription_var::operator ::IR_ComponentDescription *&() // cast 
-{
-  return this->ptr_;
-}
-
-ACE_INLINE const ::IR_ComponentDescription &
-IR_ComponentDescription_var::in (void) const
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE ::IR_ComponentDescription &
-IR_ComponentDescription_var::inout (void)
-{
-  return *this->ptr_;
-}
-
-// mapping for variable size 
-ACE_INLINE ::IR_ComponentDescription *&
-IR_ComponentDescription_var::out (void)
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_ComponentDescription *
-IR_ComponentDescription_var::_retn (void)
-{
-  ::IR_ComponentDescription *tmp = this->ptr_;
-  this->ptr_ = 0;
-  return tmp;
-}
-
-ACE_INLINE ::IR_ComponentDescription *
-IR_ComponentDescription_var::ptr (void) const
-{
-  return this->ptr_;
-}
-
-// *************************************************************
-// Inline operations for class IR_ComponentDescription_out
-// *************************************************************
-
-ACE_INLINE
-IR_ComponentDescription_out::IR_ComponentDescription_out (::IR_ComponentDescription *&p)
-  : ptr_ (p)
-{
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_ComponentDescription_out::IR_ComponentDescription_out (IR_ComponentDescription_var &p) // constructor from _var
-  : ptr_ (p.out ())
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_ComponentDescription_out::IR_ComponentDescription_out (const ::IR_ComponentDescription_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (IR_ComponentDescription_out&, p).ptr_)
-{}
-
-ACE_INLINE IR_ComponentDescription_out &
-IR_ComponentDescription_out::operator= (const ::IR_ComponentDescription_out &p)
-{
-  this->ptr_ = ACE_const_cast (IR_ComponentDescription_out&, p).ptr_;
-  return *this;
-}
-
-ACE_INLINE IR_ComponentDescription_out &
-IR_ComponentDescription_out::operator= (IR_ComponentDescription *p)
-{
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE 
-IR_ComponentDescription_out::operator ::IR_ComponentDescription *&() // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_ComponentDescription *&
-IR_ComponentDescription_out::ptr (void) // ptr
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_ComponentDescription *
-IR_ComponentDescription_out::operator-> (void)
-{
-  return this->ptr_;
-}
-
-// *************************************************************
-// Inline operations for class IR_PrimaryKeyDescription_var
-// *************************************************************
-
-ACE_INLINE
-IR_PrimaryKeyDescription_var::IR_PrimaryKeyDescription_var (void) // default constructor
-  : ptr_ (0)
-{}
-
-ACE_INLINE
-IR_PrimaryKeyDescription_var::IR_PrimaryKeyDescription_var (IR_PrimaryKeyDescription *p)
-  : ptr_ (p)
-{}
-
-ACE_INLINE
-IR_PrimaryKeyDescription_var::IR_PrimaryKeyDescription_var (const ::IR_PrimaryKeyDescription_var &p) // copy constructor
-{
-  if (p.ptr_)
-    ACE_NEW (this->ptr_, ::IR_PrimaryKeyDescription (*p.ptr_));
-  else
-    this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_PrimaryKeyDescription_var::~IR_PrimaryKeyDescription_var (void) // destructor
-{
-  delete this->ptr_;
-}
-
-ACE_INLINE IR_PrimaryKeyDescription_var &
-IR_PrimaryKeyDescription_var::operator= (IR_PrimaryKeyDescription *p)
-{
-  delete this->ptr_;
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE ::IR_PrimaryKeyDescription_var &
-IR_PrimaryKeyDescription_var::operator= (const ::IR_PrimaryKeyDescription_var &p)
-{
-  if (this != &p)
-    {
-      if (p.ptr_ == 0)
-        {
-          delete this->ptr_;
-          this->ptr_ = 0;
-        }
-      else
-        {
-          IR_PrimaryKeyDescription *deep_copy = 
-            new IR_PrimaryKeyDescription (*p.ptr_);
-          
-          if (deep_copy != 0)
-            {
-              IR_PrimaryKeyDescription *tmp = deep_copy;
-              deep_copy = this->ptr_;
-              this->ptr_ = tmp;
-              delete deep_copy;
-            }
-        }
-    }
-  
-  return *this;
-}
-
-ACE_INLINE const ::IR_PrimaryKeyDescription *
-IR_PrimaryKeyDescription_var::operator-> (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_PrimaryKeyDescription *
-IR_PrimaryKeyDescription_var::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE
-IR_PrimaryKeyDescription_var::operator const ::IR_PrimaryKeyDescription &() const // cast
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE
-IR_PrimaryKeyDescription_var::operator ::IR_PrimaryKeyDescription &() // cast 
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE
-IR_PrimaryKeyDescription_var::operator ::IR_PrimaryKeyDescription &() const // cast 
-{
-  return *this->ptr_;
-}
-
-// variable-size types only
-ACE_INLINE
-IR_PrimaryKeyDescription_var::operator ::IR_PrimaryKeyDescription *&() // cast 
-{
-  return this->ptr_;
-}
-
-ACE_INLINE const ::IR_PrimaryKeyDescription &
-IR_PrimaryKeyDescription_var::in (void) const
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE ::IR_PrimaryKeyDescription &
-IR_PrimaryKeyDescription_var::inout (void)
-{
-  return *this->ptr_;
-}
-
-// mapping for variable size 
-ACE_INLINE ::IR_PrimaryKeyDescription *&
-IR_PrimaryKeyDescription_var::out (void)
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_PrimaryKeyDescription *
-IR_PrimaryKeyDescription_var::_retn (void)
-{
-  ::IR_PrimaryKeyDescription *tmp = this->ptr_;
-  this->ptr_ = 0;
-  return tmp;
-}
-
-ACE_INLINE ::IR_PrimaryKeyDescription *
-IR_PrimaryKeyDescription_var::ptr (void) const
-{
-  return this->ptr_;
-}
-
-// *************************************************************
-// Inline operations for class IR_PrimaryKeyDescription_out
-// *************************************************************
-
-ACE_INLINE
-IR_PrimaryKeyDescription_out::IR_PrimaryKeyDescription_out (::IR_PrimaryKeyDescription *&p)
-  : ptr_ (p)
-{
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_PrimaryKeyDescription_out::IR_PrimaryKeyDescription_out (IR_PrimaryKeyDescription_var &p) // constructor from _var
-  : ptr_ (p.out ())
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_PrimaryKeyDescription_out::IR_PrimaryKeyDescription_out (const ::IR_PrimaryKeyDescription_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (IR_PrimaryKeyDescription_out&, p).ptr_)
-{}
-
-ACE_INLINE IR_PrimaryKeyDescription_out &
-IR_PrimaryKeyDescription_out::operator= (const ::IR_PrimaryKeyDescription_out &p)
-{
-  this->ptr_ = ACE_const_cast (IR_PrimaryKeyDescription_out&, p).ptr_;
-  return *this;
-}
-
-ACE_INLINE IR_PrimaryKeyDescription_out &
-IR_PrimaryKeyDescription_out::operator= (IR_PrimaryKeyDescription *p)
-{
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE 
-IR_PrimaryKeyDescription_out::operator ::IR_PrimaryKeyDescription *&() // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_PrimaryKeyDescription *&
-IR_PrimaryKeyDescription_out::ptr (void) // ptr
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_PrimaryKeyDescription *
-IR_PrimaryKeyDescription_out::operator-> (void)
-{
-  return this->ptr_;
-}
-
-// *************************************************************
-// Inline operations for class IR_HomeDescription_var
-// *************************************************************
-
-ACE_INLINE
-IR_HomeDescription_var::IR_HomeDescription_var (void) // default constructor
-  : ptr_ (0)
-{}
-
-ACE_INLINE
-IR_HomeDescription_var::IR_HomeDescription_var (IR_HomeDescription *p)
-  : ptr_ (p)
-{}
-
-ACE_INLINE
-IR_HomeDescription_var::IR_HomeDescription_var (const ::IR_HomeDescription_var &p) // copy constructor
-{
-  if (p.ptr_)
-    ACE_NEW (this->ptr_, ::IR_HomeDescription (*p.ptr_));
-  else
-    this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_HomeDescription_var::~IR_HomeDescription_var (void) // destructor
-{
-  delete this->ptr_;
-}
-
-ACE_INLINE IR_HomeDescription_var &
-IR_HomeDescription_var::operator= (IR_HomeDescription *p)
-{
-  delete this->ptr_;
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE ::IR_HomeDescription_var &
-IR_HomeDescription_var::operator= (const ::IR_HomeDescription_var &p)
-{
-  if (this != &p)
-    {
-      if (p.ptr_ == 0)
-        {
-          delete this->ptr_;
-          this->ptr_ = 0;
-        }
-      else
-        {
-          IR_HomeDescription *deep_copy = 
-            new IR_HomeDescription (*p.ptr_);
-          
-          if (deep_copy != 0)
-            {
-              IR_HomeDescription *tmp = deep_copy;
-              deep_copy = this->ptr_;
-              this->ptr_ = tmp;
-              delete deep_copy;
-            }
-        }
-    }
-  
-  return *this;
-}
-
-ACE_INLINE const ::IR_HomeDescription *
-IR_HomeDescription_var::operator-> (void) const
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_HomeDescription *
-IR_HomeDescription_var::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE
-IR_HomeDescription_var::operator const ::IR_HomeDescription &() const // cast
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE
-IR_HomeDescription_var::operator ::IR_HomeDescription &() // cast 
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE
-IR_HomeDescription_var::operator ::IR_HomeDescription &() const // cast 
-{
-  return *this->ptr_;
-}
-
-// variable-size types only
-ACE_INLINE
-IR_HomeDescription_var::operator ::IR_HomeDescription *&() // cast 
-{
-  return this->ptr_;
-}
-
-ACE_INLINE const ::IR_HomeDescription &
-IR_HomeDescription_var::in (void) const
-{
-  return *this->ptr_;
-}
-
-ACE_INLINE ::IR_HomeDescription &
-IR_HomeDescription_var::inout (void)
-{
-  return *this->ptr_;
-}
-
-// mapping for variable size 
-ACE_INLINE ::IR_HomeDescription *&
-IR_HomeDescription_var::out (void)
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_HomeDescription *
-IR_HomeDescription_var::_retn (void)
-{
-  ::IR_HomeDescription *tmp = this->ptr_;
-  this->ptr_ = 0;
-  return tmp;
-}
-
-ACE_INLINE ::IR_HomeDescription *
-IR_HomeDescription_var::ptr (void) const
-{
-  return this->ptr_;
-}
-
-// *************************************************************
-// Inline operations for class IR_HomeDescription_out
-// *************************************************************
-
-ACE_INLINE
-IR_HomeDescription_out::IR_HomeDescription_out (::IR_HomeDescription *&p)
-  : ptr_ (p)
-{
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_HomeDescription_out::IR_HomeDescription_out (IR_HomeDescription_var &p) // constructor from _var
-  : ptr_ (p.out ())
-{
-  delete this->ptr_;
-  this->ptr_ = 0;
-}
-
-ACE_INLINE
-IR_HomeDescription_out::IR_HomeDescription_out (const ::IR_HomeDescription_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (IR_HomeDescription_out&, p).ptr_)
-{}
-
-ACE_INLINE IR_HomeDescription_out &
-IR_HomeDescription_out::operator= (const ::IR_HomeDescription_out &p)
-{
-  this->ptr_ = ACE_const_cast (IR_HomeDescription_out&, p).ptr_;
-  return *this;
-}
-
-ACE_INLINE IR_HomeDescription_out &
-IR_HomeDescription_out::operator= (IR_HomeDescription *p)
-{
-  this->ptr_ = p;
-  return *this;
-}
-
-ACE_INLINE 
-IR_HomeDescription_out::operator ::IR_HomeDescription *&() // cast
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_HomeDescription *&
-IR_HomeDescription_out::ptr (void) // ptr
-{
-  return this->ptr_;
-}
-
-ACE_INLINE ::IR_HomeDescription *
-IR_HomeDescription_out::operator-> (void)
-{
-  return this->ptr_;
-}
-
-ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const IR_DefinitionKind &_tao_enumval)
-{
-  CORBA::ULong _tao_temp = _tao_enumval;
-  return strm << _tao_temp;
-}
-
-ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, IR_DefinitionKind &_tao_enumval)
-{
-  CORBA::ULong _tao_temp = 0;
-  CORBA::Boolean _tao_result = strm >> _tao_temp;
-  
-  if (_tao_result == 1)
-    {
-      _tao_enumval = ACE_static_cast (IR_DefinitionKind, _tao_temp);
-    }
-  
-  return _tao_result;
-}
-
-ACE_INLINE CORBA::Boolean
-operator<< (
-    TAO_OutputCDR &strm,
-    const CORBA_IRObject_ptr _tao_objref
-  )
-{
-  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
-  return (strm << _tao_corba_obj);
-}
-
-ACE_INLINE CORBA::Boolean
-operator>> (
-    TAO_InputCDR &strm,
-    CORBA_IRObject_ptr &_tao_objref
-  )
-{
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::Object_var obj;
-    if ((strm >> obj.inout ()) == 0)
-      return 0;
-    // narrow to the right type
-    _tao_objref =
-      CORBA_IRObject::_unchecked_narrow (
-          obj.in (),
-          ACE_TRY_ENV
-        );
-    ACE_TRY_CHECK;
-    return 1;
-  }
-  ACE_CATCHANY
-  {
-    // do nothing
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const IR_Contained::Description &_tao_aggregate)
-{
-  if (
-    (strm << _tao_aggregate.kind) &&
-    (strm << _tao_aggregate.value)
-  )
-    return 1;
-  else
-    return 0;
-  
-}
-
-ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, IR_Contained::Description &_tao_aggregate)
-{
-  if (
-    (strm >> _tao_aggregate.kind) &&
-    (strm >> _tao_aggregate.value)
-  )
-    return 1;
-  else
-    return 0;
-  
-}
-
-ACE_INLINE CORBA::Boolean
-operator<< (
-    TAO_OutputCDR &strm,
-    const IR_Contained_ptr _tao_objref
-  )
-{
-  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
-  return (strm << _tao_corba_obj);
-}
-
-ACE_INLINE CORBA::Boolean
-operator>> (
-    TAO_InputCDR &strm,
-    IR_Contained_ptr &_tao_objref
-  )
-{
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::Object_var obj;
-    if ((strm >> obj.inout ()) == 0)
-      return 0;
-    // narrow to the right type
-    _tao_objref =
-      IR_Contained::_unchecked_narrow (
-          obj.in (),
-          ACE_TRY_ENV
-        );
-    ACE_TRY_CHECK;
-    return 1;
-  }
-  ACE_CATCHANY
-  {
-    // do nothing
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-CORBA::Boolean TAO_IFR_Client_Export operator<< (
-    TAO_OutputCDR &,
-    const IR_InterfaceDefSeq &
-  );
-
-CORBA::Boolean TAO_IFR_Client_Export operator>> (
-    TAO_InputCDR &,
-    IR_InterfaceDefSeq &
-  );
-
-CORBA::Boolean TAO_IFR_Client_Export operator<< (
-    TAO_OutputCDR &,
-    const IR_ValueDefSeq &
-  );
-
-CORBA::Boolean TAO_IFR_Client_Export operator>> (
-    TAO_InputCDR &,
-    IR_ValueDefSeq &
-  );
-
-CORBA::Boolean TAO_IFR_Client_Export operator<< (
-    TAO_OutputCDR &,
-    const IR_ComponentDefSeq &
-  );
-
-CORBA::Boolean TAO_IFR_Client_Export operator>> (
-    TAO_InputCDR &,
-    IR_ComponentDefSeq &
-  );
-
-CORBA::Boolean TAO_IFR_Client_Export operator<< (
-    TAO_OutputCDR &,
-    const IR_ProvidesDefSeq &
-  );
-
-CORBA::Boolean TAO_IFR_Client_Export operator>> (
-    TAO_InputCDR &,
-    IR_ProvidesDefSeq &
-  );
-
-CORBA::Boolean TAO_IFR_Client_Export operator<< (
-    TAO_OutputCDR &,
-    const IR_UsesDefSeq &
-  );
-
-CORBA::Boolean TAO_IFR_Client_Export operator>> (
-    TAO_InputCDR &,
-    IR_UsesDefSeq &
-  );
-
-CORBA::Boolean TAO_IFR_Client_Export operator<< (
-    TAO_OutputCDR &,
-    const IR_HomeDefSeq &
-  );
-
-CORBA::Boolean TAO_IFR_Client_Export operator>> (
-    TAO_InputCDR &,
-    IR_HomeDefSeq &
-  );
-
-CORBA::Boolean TAO_IFR_Client_Export operator<< (
-    TAO_OutputCDR &,
-    const IR_EmitsDefSeq &
-  );
-CORBA::Boolean TAO_IFR_Client_Export operator>> (
-    TAO_InputCDR &,
-    IR_EmitsDefSeq &
-  );
-
-CORBA::Boolean TAO_IFR_Client_Export operator<< (
-    TAO_OutputCDR &,
-    const IR_PublishesDefSeq &
-  );
-CORBA::Boolean TAO_IFR_Client_Export operator>> (
-    TAO_InputCDR &,
-    IR_PublishesDefSeq &
-  );
-
-CORBA::Boolean TAO_IFR_Client_Export operator<< (
-    TAO_OutputCDR &,
-    const IR_ConsumesDefSeq &
-  );
-CORBA::Boolean TAO_IFR_Client_Export operator>> (
-    TAO_InputCDR &,
-    IR_ConsumesDefSeq &
-  );
-
-CORBA::Boolean TAO_IFR_Client_Export operator<< (
-    TAO_OutputCDR &,
-    const IR_FactoryDefSeq &
-  );
-CORBA::Boolean TAO_IFR_Client_Export operator>> (
-    TAO_InputCDR &,
-    IR_FactoryDefSeq &
-  );
-
-CORBA::Boolean TAO_IFR_Client_Export operator<< (
-    TAO_OutputCDR &,
-    const IR_FinderDefSeq &
-  );
-CORBA::Boolean TAO_IFR_Client_Export operator>> (
-    TAO_InputCDR &,
-    IR_FinderDefSeq &
-  );
-
-CORBA::Boolean TAO_IFR_Client_Export operator<< (
-    TAO_OutputCDR &,
-    const IR_ContainedSeq &
-  );
-CORBA::Boolean TAO_IFR_Client_Export operator>> (
-    TAO_InputCDR &,
-    IR_ContainedSeq &
-  );
-
-ACE_INLINE CORBA::Boolean
-operator<< (
-    TAO_OutputCDR &,
-    const IR_IDLType_ptr
-  );
-
-ACE_INLINE CORBA::Boolean
-operator>> (
-    TAO_InputCDR &,
-    IR_IDLType_ptr &
-  );
-
-ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const IR_StructMember &_tao_aggregate)
-{
-  if (
-    (strm << _tao_aggregate.name.in ()) &&
-    (strm << _tao_aggregate.type.in ()) &&
-    (strm << _tao_aggregate.type_def.in ())
-  )
-    return 1;
-  else
-    return 0;
-  
-}
-
-ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, IR_StructMember &_tao_aggregate)
-{
-  if (
-    (strm >> _tao_aggregate.name.out ()) &&
-    (strm >> _tao_aggregate.type.out ()) &&
-    (strm >> _tao_aggregate.type_def.out ())
-  )
-    return 1;
-  else
-    return 0;
-  
-}
-
-CORBA::Boolean TAO_IFR_Client_Export operator<< (
-    TAO_OutputCDR &,
-    const IR_StructMemberSeq &
-  );
-CORBA::Boolean TAO_IFR_Client_Export operator>> (
-    TAO_InputCDR &,
-    IR_StructMemberSeq &
-  );
-
-ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const IR_Initializer &_tao_aggregate)
-{
-  if (
-    (strm << _tao_aggregate.members) &&
-    (strm << _tao_aggregate.name.in ())
-  )
-    return 1;
-  else
-    return 0;
-  
-}
-
-ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, IR_Initializer &_tao_aggregate)
-{
-  if (
-    (strm >> _tao_aggregate.members) &&
-    (strm >> _tao_aggregate.name.out ())
-  )
-    return 1;
-  else
-    return 0;
-  
-}
-
-CORBA::Boolean TAO_IFR_Client_Export operator<< (
-    TAO_OutputCDR &,
-    const IR_InitializerSeq &
-  );
-CORBA::Boolean TAO_IFR_Client_Export operator>> (
-    TAO_InputCDR &,
-    IR_InitializerSeq &
-  );
-
-ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const IR_UnionMember &_tao_aggregate)
-{
-  if (
-    (strm << _tao_aggregate.name.in ()) &&
-    (strm << _tao_aggregate.label) &&
-    (strm << _tao_aggregate.type.in ()) &&
-    (strm << _tao_aggregate.type_def.in ())
-  )
-    return 1;
-  else
-    return 0;
-  
-}
-
-ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, IR_UnionMember &_tao_aggregate)
-{
-  if (
-    (strm >> _tao_aggregate.name.out ()) &&
-    (strm >> _tao_aggregate.label) &&
-    (strm >> _tao_aggregate.type.out ()) &&
-    (strm >> _tao_aggregate.type_def.out ())
-  )
-    return 1;
-  else
-    return 0;
-  
-}
-
-CORBA::Boolean TAO_IFR_Client_Export operator<< (
-    TAO_OutputCDR &,
-    const IR_UnionMemberSeq &
-  );
-CORBA::Boolean TAO_IFR_Client_Export operator>> (
-    TAO_InputCDR &,
-    IR_UnionMemberSeq &
-  );
-
-CORBA::Boolean TAO_IFR_Client_Export operator<< (
-    TAO_OutputCDR &,
-    const IR_EnumMemberSeq &
-  );
-CORBA::Boolean TAO_IFR_Client_Export operator>> (
-    TAO_InputCDR &,
-    IR_EnumMemberSeq &
-  );
-
-ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const IR_Container::Description &_tao_aggregate)
-{
-  if (
-    (strm << _tao_aggregate.contained_object.in ()) &&
-    (strm << _tao_aggregate.kind) &&
-    (strm << _tao_aggregate.value)
-  )
-    return 1;
-  else
-    return 0;
-  
-}
-
-ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, IR_Container::Description &_tao_aggregate)
-{
-  if (
-    (strm >> _tao_aggregate.contained_object.out ()) &&
-    (strm >> _tao_aggregate.kind) &&
-    (strm >> _tao_aggregate.value)
-  )
-    return 1;
-  else
-    return 0;
-  
-}
-
-CORBA::Boolean TAO_IFR_Client_Export operator<< (
-    TAO_OutputCDR &,
-    const IR_Container::DescriptionSeq &
-  );
-CORBA::Boolean TAO_IFR_Client_Export operator>> (
-    TAO_InputCDR &,
-    IR_Container::DescriptionSeq &
-  );
-
-ACE_INLINE CORBA::Boolean
-operator<< (
-    TAO_OutputCDR &strm,
-    const IR_Container_ptr _tao_objref
-  )
-{
-  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
-  return (strm << _tao_corba_obj);
-}
-
-ACE_INLINE CORBA::Boolean
-operator>> (
-    TAO_InputCDR &strm,
-    IR_Container_ptr &_tao_objref
-  )
-{
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::Object_var obj;
-    if ((strm >> obj.inout ()) == 0)
-      return 0;
-    // narrow to the right type
-    _tao_objref =
-      IR_Container::_unchecked_narrow (
-          obj.in (),
-          ACE_TRY_ENV
-        );
-    ACE_TRY_CHECK;
-    return 1;
-  }
-  ACE_CATCHANY
-  {
-    // do nothing
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-ACE_INLINE CORBA::Boolean
-operator<< (
-    TAO_OutputCDR &strm,
-    const IR_IDLType_ptr _tao_objref
-  )
-{
-  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
-  return (strm << _tao_corba_obj);
-}
-
-ACE_INLINE CORBA::Boolean
-operator>> (
-    TAO_InputCDR &strm,
-    IR_IDLType_ptr &_tao_objref
-  )
-{
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::Object_var obj;
-    if ((strm >> obj.inout ()) == 0)
-      return 0;
-    // narrow to the right type
-    _tao_objref =
-      IR_IDLType::_unchecked_narrow (
-          obj.in (),
-          ACE_TRY_ENV
-        );
-    ACE_TRY_CHECK;
-    return 1;
-  }
-  ACE_CATCHANY
-  {
-    // do nothing
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const IR_PrimitiveKind &_tao_enumval)
-{
-  CORBA::ULong _tao_temp = _tao_enumval;
-  return strm << _tao_temp;
-}
-
-ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, IR_PrimitiveKind &_tao_enumval)
-{
-  CORBA::ULong _tao_temp = 0;
-  CORBA::Boolean _tao_result = strm >> _tao_temp;
-  
-  if (_tao_result == 1)
-    {
-      _tao_enumval = ACE_static_cast (IR_PrimitiveKind, _tao_temp);
-    }
-  
-  return _tao_result;
-}
-
-ACE_INLINE CORBA::Boolean
-operator<< (
-    TAO_OutputCDR &strm,
-    const IR_Repository_ptr _tao_objref
-  )
-{
-  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
-  return (strm << _tao_corba_obj);
-}
-
-ACE_INLINE CORBA::Boolean
-operator>> (
-    TAO_InputCDR &strm,
-    IR_Repository_ptr &_tao_objref
-  )
-{
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::Object_var obj;
-    if ((strm >> obj.inout ()) == 0)
-      return 0;
-    // narrow to the right type
-    _tao_objref =
-      IR_Repository::_unchecked_narrow (
-          obj.in (),
-          ACE_TRY_ENV
-        );
-    ACE_TRY_CHECK;
-    return 1;
-  }
-  ACE_CATCHANY
-  {
-    // do nothing
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-ACE_INLINE CORBA::Boolean
-operator<< (
-    TAO_OutputCDR &strm,
-    const IR_ComponentRepository_ptr _tao_objref
-  )
-{
-  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
-  return (strm << _tao_corba_obj);
-}
-
-ACE_INLINE CORBA::Boolean
-operator>> (
-    TAO_InputCDR &strm,
-    IR_ComponentRepository_ptr &_tao_objref
-  )
-{
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::Object_var obj;
-    if ((strm >> obj.inout ()) == 0)
-      return 0;
-    // narrow to the right type
-    _tao_objref =
-      IR_ComponentRepository::_unchecked_narrow (
-          obj.in (),
-          ACE_TRY_ENV
-        );
-    ACE_TRY_CHECK;
-    return 1;
-  }
-  ACE_CATCHANY
-  {
-    // do nothing
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-ACE_INLINE CORBA::Boolean
-operator<< (
-    TAO_OutputCDR &strm,
-    const IR_ModuleDef_ptr _tao_objref
-  )
-{
-  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
-  return (strm << _tao_corba_obj);
-}
-
-ACE_INLINE CORBA::Boolean
-operator>> (
-    TAO_InputCDR &strm,
-    IR_ModuleDef_ptr &_tao_objref
-  )
-{
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::Object_var obj;
-    if ((strm >> obj.inout ()) == 0)
-      return 0;
-    // narrow to the right type
-    _tao_objref =
-      IR_ModuleDef::_unchecked_narrow (
-          obj.in (),
-          ACE_TRY_ENV
-        );
-    ACE_TRY_CHECK;
-    return 1;
-  }
-  ACE_CATCHANY
-  {
-    // do nothing
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const IR_ModuleDescription &_tao_aggregate)
-{
-  if (
-    (strm << _tao_aggregate.name.in ()) &&
-    (strm << _tao_aggregate.id.in ()) &&
-    (strm << _tao_aggregate.defined_in.in ()) &&
-    (strm << _tao_aggregate.version.in ())
-  )
-    return 1;
-  else
-    return 0;
-  
-}
-
-ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, IR_ModuleDescription &_tao_aggregate)
-{
-  if (
-    (strm >> _tao_aggregate.name.out ()) &&
-    (strm >> _tao_aggregate.id.out ()) &&
-    (strm >> _tao_aggregate.defined_in.out ()) &&
-    (strm >> _tao_aggregate.version.out ())
-  )
-    return 1;
-  else
-    return 0;
-  
-}
-
-ACE_INLINE CORBA::Boolean
-operator<< (
-    TAO_OutputCDR &strm,
-    const IR_ConstantDef_ptr _tao_objref
-  )
-{
-  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
-  return (strm << _tao_corba_obj);
-}
-
-ACE_INLINE CORBA::Boolean
-operator>> (
-    TAO_InputCDR &strm,
-    IR_ConstantDef_ptr &_tao_objref
-  )
-{
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::Object_var obj;
-    if ((strm >> obj.inout ()) == 0)
-      return 0;
-    // narrow to the right type
-    _tao_objref =
-      IR_ConstantDef::_unchecked_narrow (
-          obj.in (),
-          ACE_TRY_ENV
-        );
-    ACE_TRY_CHECK;
-    return 1;
-  }
-  ACE_CATCHANY
-  {
-    // do nothing
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const IR_ConstantDescription &_tao_aggregate)
-{
-  if (
-    (strm << _tao_aggregate.name.in ()) &&
-    (strm << _tao_aggregate.id.in ()) &&
-    (strm << _tao_aggregate.defined_in.in ()) &&
-    (strm << _tao_aggregate.version.in ()) &&
-    (strm << _tao_aggregate.type.in ()) &&
-    (strm << _tao_aggregate.value)
-  )
-    return 1;
-  else
-    return 0;
-  
-}
-
-ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, IR_ConstantDescription &_tao_aggregate)
-{
-  if (
-    (strm >> _tao_aggregate.name.out ()) &&
-    (strm >> _tao_aggregate.id.out ()) &&
-    (strm >> _tao_aggregate.defined_in.out ()) &&
-    (strm >> _tao_aggregate.version.out ()) &&
-    (strm >> _tao_aggregate.type.out ()) &&
-    (strm >> _tao_aggregate.value)
-  )
-    return 1;
-  else
-    return 0;
-  
-}
-
-ACE_INLINE CORBA::Boolean
-operator<< (
-    TAO_OutputCDR &strm,
-    const IR_TypedefDef_ptr _tao_objref
-  )
-{
-  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
-  return (strm << _tao_corba_obj);
-}
-
-ACE_INLINE CORBA::Boolean
-operator>> (
-    TAO_InputCDR &strm,
-    IR_TypedefDef_ptr &_tao_objref
-  )
-{
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::Object_var obj;
-    if ((strm >> obj.inout ()) == 0)
-      return 0;
-    // narrow to the right type
-    _tao_objref =
-      IR_TypedefDef::_unchecked_narrow (
-          obj.in (),
-          ACE_TRY_ENV
-        );
-    ACE_TRY_CHECK;
-    return 1;
-  }
-  ACE_CATCHANY
-  {
-    // do nothing
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const IR_TypeDescription &_tao_aggregate)
-{
-  if (
-    (strm << _tao_aggregate.name.in ()) &&
-    (strm << _tao_aggregate.id.in ()) &&
-    (strm << _tao_aggregate.defined_in.in ()) &&
-    (strm << _tao_aggregate.version.in ()) &&
-    (strm << _tao_aggregate.type.in ())
-  )
-    return 1;
-  else
-    return 0;
-  
-}
-
-ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, IR_TypeDescription &_tao_aggregate)
-{
-  if (
-    (strm >> _tao_aggregate.name.out ()) &&
-    (strm >> _tao_aggregate.id.out ()) &&
-    (strm >> _tao_aggregate.defined_in.out ()) &&
-    (strm >> _tao_aggregate.version.out ()) &&
-    (strm >> _tao_aggregate.type.out ())
-  )
-    return 1;
-  else
-    return 0;
-  
-}
-
-ACE_INLINE CORBA::Boolean
-operator<< (
-    TAO_OutputCDR &strm,
-    const IR_StructDef_ptr _tao_objref
-  )
-{
-  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
-  return (strm << _tao_corba_obj);
-}
-
-ACE_INLINE CORBA::Boolean
-operator>> (
-    TAO_InputCDR &strm,
-    IR_StructDef_ptr &_tao_objref
-  )
-{
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::Object_var obj;
-    if ((strm >> obj.inout ()) == 0)
-      return 0;
-    // narrow to the right type
-    _tao_objref =
-      IR_StructDef::_unchecked_narrow (
-          obj.in (),
-          ACE_TRY_ENV
-        );
-    ACE_TRY_CHECK;
-    return 1;
-  }
-  ACE_CATCHANY
-  {
-    // do nothing
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-ACE_INLINE CORBA::Boolean
-operator<< (
-    TAO_OutputCDR &strm,
-    const IR_UnionDef_ptr _tao_objref
-  )
-{
-  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
-  return (strm << _tao_corba_obj);
-}
-
-ACE_INLINE CORBA::Boolean
-operator>> (
-    TAO_InputCDR &strm,
-    IR_UnionDef_ptr &_tao_objref
-  )
-{
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::Object_var obj;
-    if ((strm >> obj.inout ()) == 0)
-      return 0;
-    // narrow to the right type
-    _tao_objref =
-      IR_UnionDef::_unchecked_narrow (
-          obj.in (),
-          ACE_TRY_ENV
-        );
-    ACE_TRY_CHECK;
-    return 1;
-  }
-  ACE_CATCHANY
-  {
-    // do nothing
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-ACE_INLINE CORBA::Boolean
-operator<< (
-    TAO_OutputCDR &strm,
-    const IR_EnumDef_ptr _tao_objref
-  )
-{
-  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
-  return (strm << _tao_corba_obj);
-}
-
-ACE_INLINE CORBA::Boolean
-operator>> (
-    TAO_InputCDR &strm,
-    IR_EnumDef_ptr &_tao_objref
-  )
-{
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::Object_var obj;
-    if ((strm >> obj.inout ()) == 0)
-      return 0;
-    // narrow to the right type
-    _tao_objref =
-      IR_EnumDef::_unchecked_narrow (
-          obj.in (),
-          ACE_TRY_ENV
-        );
-    ACE_TRY_CHECK;
-    return 1;
-  }
-  ACE_CATCHANY
-  {
-    // do nothing
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-ACE_INLINE CORBA::Boolean
-operator<< (
-    TAO_OutputCDR &strm,
-    const IR_AliasDef_ptr _tao_objref
-  )
-{
-  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
-  return (strm << _tao_corba_obj);
-}
-
-ACE_INLINE CORBA::Boolean
-operator>> (
-    TAO_InputCDR &strm,
-    IR_AliasDef_ptr &_tao_objref
-  )
-{
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::Object_var obj;
-    if ((strm >> obj.inout ()) == 0)
-      return 0;
-    // narrow to the right type
-    _tao_objref =
-      IR_AliasDef::_unchecked_narrow (
-          obj.in (),
-          ACE_TRY_ENV
-        );
-    ACE_TRY_CHECK;
-    return 1;
-  }
-  ACE_CATCHANY
-  {
-    // do nothing
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-ACE_INLINE CORBA::Boolean
-operator<< (
-    TAO_OutputCDR &strm,
-    const IR_NativeDef_ptr _tao_objref
-  )
-{
-  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
-  return (strm << _tao_corba_obj);
-}
-
-ACE_INLINE CORBA::Boolean
-operator>> (
-    TAO_InputCDR &strm,
-    IR_NativeDef_ptr &_tao_objref
-  )
-{
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::Object_var obj;
-    if ((strm >> obj.inout ()) == 0)
-      return 0;
-    // narrow to the right type
-    _tao_objref =
-      IR_NativeDef::_unchecked_narrow (
-          obj.in (),
-          ACE_TRY_ENV
-        );
-    ACE_TRY_CHECK;
-    return 1;
-  }
-  ACE_CATCHANY
-  {
-    // do nothing
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-ACE_INLINE CORBA::Boolean
-operator<< (
-    TAO_OutputCDR &strm,
-    const IR_PrimitiveDef_ptr _tao_objref
-  )
-{
-  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
-  return (strm << _tao_corba_obj);
-}
-
-ACE_INLINE CORBA::Boolean
-operator>> (
-    TAO_InputCDR &strm,
-    IR_PrimitiveDef_ptr &_tao_objref
-  )
-{
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::Object_var obj;
-    if ((strm >> obj.inout ()) == 0)
-      return 0;
-    // narrow to the right type
-    _tao_objref =
-      IR_PrimitiveDef::_unchecked_narrow (
-          obj.in (),
-          ACE_TRY_ENV
-        );
-    ACE_TRY_CHECK;
-    return 1;
-  }
-  ACE_CATCHANY
-  {
-    // do nothing
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-ACE_INLINE CORBA::Boolean
-operator<< (
-    TAO_OutputCDR &strm,
-    const IR_StringDef_ptr _tao_objref
-  )
-{
-  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
-  return (strm << _tao_corba_obj);
-}
-
-ACE_INLINE CORBA::Boolean
-operator>> (
-    TAO_InputCDR &strm,
-    IR_StringDef_ptr &_tao_objref
-  )
-{
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::Object_var obj;
-    if ((strm >> obj.inout ()) == 0)
-      return 0;
-    // narrow to the right type
-    _tao_objref =
-      IR_StringDef::_unchecked_narrow (
-          obj.in (),
-          ACE_TRY_ENV
-        );
-    ACE_TRY_CHECK;
-    return 1;
-  }
-  ACE_CATCHANY
-  {
-    // do nothing
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-ACE_INLINE CORBA::Boolean
-operator<< (
-    TAO_OutputCDR &strm,
-    const IR_WstringDef_ptr _tao_objref
-  )
-{
-  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
-  return (strm << _tao_corba_obj);
-}
-
-ACE_INLINE CORBA::Boolean
-operator>> (
-    TAO_InputCDR &strm,
-    IR_WstringDef_ptr &_tao_objref
-  )
-{
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::Object_var obj;
-    if ((strm >> obj.inout ()) == 0)
-      return 0;
-    // narrow to the right type
-    _tao_objref =
-      IR_WstringDef::_unchecked_narrow (
-          obj.in (),
-          ACE_TRY_ENV
-        );
-    ACE_TRY_CHECK;
-    return 1;
-  }
-  ACE_CATCHANY
-  {
-    // do nothing
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-ACE_INLINE CORBA::Boolean
-operator<< (
-    TAO_OutputCDR &strm,
-    const IR_FixedDef_ptr _tao_objref
-  )
-{
-  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
-  return (strm << _tao_corba_obj);
-}
-
-ACE_INLINE CORBA::Boolean
-operator>> (
-    TAO_InputCDR &strm,
-    IR_FixedDef_ptr &_tao_objref
-  )
-{
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::Object_var obj;
-    if ((strm >> obj.inout ()) == 0)
-      return 0;
-    // narrow to the right type
-    _tao_objref =
-      IR_FixedDef::_unchecked_narrow (
-          obj.in (),
-          ACE_TRY_ENV
-        );
-    ACE_TRY_CHECK;
-    return 1;
-  }
-  ACE_CATCHANY
-  {
-    // do nothing
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-ACE_INLINE CORBA::Boolean
-operator<< (
-    TAO_OutputCDR &strm,
-    const IR_SequenceDef_ptr _tao_objref
-  )
-{
-  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
-  return (strm << _tao_corba_obj);
-}
-
-ACE_INLINE CORBA::Boolean
-operator>> (
-    TAO_InputCDR &strm,
-    IR_SequenceDef_ptr &_tao_objref
-  )
-{
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::Object_var obj;
-    if ((strm >> obj.inout ()) == 0)
-      return 0;
-    // narrow to the right type
-    _tao_objref =
-      IR_SequenceDef::_unchecked_narrow (
-          obj.in (),
-          ACE_TRY_ENV
-        );
-    ACE_TRY_CHECK;
-    return 1;
-  }
-  ACE_CATCHANY
-  {
-    // do nothing
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-ACE_INLINE CORBA::Boolean
-operator<< (
-    TAO_OutputCDR &strm,
-    const IR_ArrayDef_ptr _tao_objref
-  )
-{
-  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
-  return (strm << _tao_corba_obj);
-}
-
-ACE_INLINE CORBA::Boolean
-operator>> (
-    TAO_InputCDR &strm,
-    IR_ArrayDef_ptr &_tao_objref
-  )
-{
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::Object_var obj;
-    if ((strm >> obj.inout ()) == 0)
-      return 0;
-    // narrow to the right type
-    _tao_objref =
-      IR_ArrayDef::_unchecked_narrow (
-          obj.in (),
-          ACE_TRY_ENV
-        );
-    ACE_TRY_CHECK;
-    return 1;
-  }
-  ACE_CATCHANY
-  {
-    // do nothing
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-ACE_INLINE CORBA::Boolean
-operator<< (
-    TAO_OutputCDR &strm,
-    const IR_ExceptionDef_ptr _tao_objref
-  )
-{
-  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
-  return (strm << _tao_corba_obj);
-}
-
-ACE_INLINE CORBA::Boolean
-operator>> (
-    TAO_InputCDR &strm,
-    IR_ExceptionDef_ptr &_tao_objref
-  )
-{
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::Object_var obj;
-    if ((strm >> obj.inout ()) == 0)
-      return 0;
-    // narrow to the right type
-    _tao_objref =
-      IR_ExceptionDef::_unchecked_narrow (
-          obj.in (),
-          ACE_TRY_ENV
-        );
-    ACE_TRY_CHECK;
-    return 1;
-  }
-  ACE_CATCHANY
-  {
-    // do nothing
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const IR_ExceptionDescription &_tao_aggregate)
-{
-  if (
-    (strm << _tao_aggregate.name.in ()) &&
-    (strm << _tao_aggregate.id.in ()) &&
-    (strm << _tao_aggregate.defined_in.in ()) &&
-    (strm << _tao_aggregate.version.in ()) &&
-    (strm << _tao_aggregate.type.in ())
-  )
-    return 1;
-  else
-    return 0;
-  
-}
-
-ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, IR_ExceptionDescription &_tao_aggregate)
-{
-  if (
-    (strm >> _tao_aggregate.name.out ()) &&
-    (strm >> _tao_aggregate.id.out ()) &&
-    (strm >> _tao_aggregate.defined_in.out ()) &&
-    (strm >> _tao_aggregate.version.out ()) &&
-    (strm >> _tao_aggregate.type.out ())
-  )
-    return 1;
-  else
-    return 0;
-  
-}
-
-CORBA::Boolean TAO_IFR_Client_Export operator<< (
-    TAO_OutputCDR &,
-    const IR_ExceptionDefSeq &
-  );
-CORBA::Boolean TAO_IFR_Client_Export operator>> (
-    TAO_InputCDR &,
-    IR_ExceptionDefSeq &
-  );
-
-CORBA::Boolean TAO_IFR_Client_Export operator<< (
-    TAO_OutputCDR &,
-    const IR_ExcDescriptionSeq &
-  );
-CORBA::Boolean TAO_IFR_Client_Export operator>> (
-    TAO_InputCDR &,
-    IR_ExcDescriptionSeq &
-  );
-
-ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const IR_AttributeMode &_tao_enumval)
-{
-  CORBA::ULong _tao_temp = _tao_enumval;
-  return strm << _tao_temp;
-}
-
-ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, IR_AttributeMode &_tao_enumval)
-{
-  CORBA::ULong _tao_temp = 0;
-  CORBA::Boolean _tao_result = strm >> _tao_temp;
-  
-  if (_tao_result == 1)
-    {
-      _tao_enumval = ACE_static_cast (IR_AttributeMode, _tao_temp);
-    }
-  
-  return _tao_result;
-}
-
-ACE_INLINE CORBA::Boolean
-operator<< (
-    TAO_OutputCDR &strm,
-    const IR_AttributeDef_ptr _tao_objref
-  )
-{
-  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
-  return (strm << _tao_corba_obj);
-}
-
-ACE_INLINE CORBA::Boolean
-operator>> (
-    TAO_InputCDR &strm,
-    IR_AttributeDef_ptr &_tao_objref
-  )
-{
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::Object_var obj;
-    if ((strm >> obj.inout ()) == 0)
-      return 0;
-    // narrow to the right type
-    _tao_objref =
-      IR_AttributeDef::_unchecked_narrow (
-          obj.in (),
-          ACE_TRY_ENV
-        );
-    ACE_TRY_CHECK;
-    return 1;
-  }
-  ACE_CATCHANY
-  {
-    // do nothing
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const IR_AttributeDescription &_tao_aggregate)
-{
-  if (
-    (strm << _tao_aggregate.name.in ()) &&
-    (strm << _tao_aggregate.id.in ()) &&
-    (strm << _tao_aggregate.defined_in.in ()) &&
-    (strm << _tao_aggregate.version.in ()) &&
-    (strm << _tao_aggregate.type.in ()) &&
-    (strm << _tao_aggregate.mode) &&
-    (strm << _tao_aggregate.get_exceptions) &&
-    (strm << _tao_aggregate.put_exceptions)
-  )
-    return 1;
-  else
-    return 0;
-  
-}
-
-ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, IR_AttributeDescription &_tao_aggregate)
-{
-  if (
-    (strm >> _tao_aggregate.name.out ()) &&
-    (strm >> _tao_aggregate.id.out ()) &&
-    (strm >> _tao_aggregate.defined_in.out ()) &&
-    (strm >> _tao_aggregate.version.out ()) &&
-    (strm >> _tao_aggregate.type.out ()) &&
-    (strm >> _tao_aggregate.mode) &&
-    (strm >> _tao_aggregate.get_exceptions) &&
-    (strm >> _tao_aggregate.put_exceptions)
-  )
-    return 1;
-  else
-    return 0;
-  
-}
-
-ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const IR_OperationMode &_tao_enumval)
-{
-  CORBA::ULong _tao_temp = _tao_enumval;
-  return strm << _tao_temp;
-}
-
-ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, IR_OperationMode &_tao_enumval)
-{
-  CORBA::ULong _tao_temp = 0;
-  CORBA::Boolean _tao_result = strm >> _tao_temp;
-  
-  if (_tao_result == 1)
-    {
-      _tao_enumval = ACE_static_cast (IR_OperationMode, _tao_temp);
-    }
-  
-  return _tao_result;
-}
-
-ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const IR_ParameterMode &_tao_enumval)
-{
-  CORBA::ULong _tao_temp = _tao_enumval;
-  return strm << _tao_temp;
-}
-
-ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, IR_ParameterMode &_tao_enumval)
-{
-  CORBA::ULong _tao_temp = 0;
-  CORBA::Boolean _tao_result = strm >> _tao_temp;
-  
-  if (_tao_result == 1)
-    {
-      _tao_enumval = ACE_static_cast (IR_ParameterMode, _tao_temp);
-    }
-  
-  return _tao_result;
-}
-
-ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const IR_ParameterDescription &_tao_aggregate)
-{
-  if (
-    (strm << _tao_aggregate.name.in ()) &&
-    (strm << _tao_aggregate.type.in ()) &&
-    (strm << _tao_aggregate.type_def.in ()) &&
-    (strm << _tao_aggregate.mode)
-  )
-    return 1;
-  else
-    return 0;
-  
-}
-
-ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, IR_ParameterDescription &_tao_aggregate)
-{
-  if (
-    (strm >> _tao_aggregate.name.out ()) &&
-    (strm >> _tao_aggregate.type.out ()) &&
-    (strm >> _tao_aggregate.type_def.out ()) &&
-    (strm >> _tao_aggregate.mode)
-  )
-    return 1;
-  else
-    return 0;
-  
-}
-
-CORBA::Boolean TAO_IFR_Client_Export operator<< (
-    TAO_OutputCDR &,
-    const IR_ParDescriptionSeq &
-  );
-CORBA::Boolean TAO_IFR_Client_Export operator>> (
-    TAO_InputCDR &,
-    IR_ParDescriptionSeq &
-  );
-
-CORBA::Boolean TAO_IFR_Client_Export operator<< (
-    TAO_OutputCDR &,
-    const IR_ContextIdSeq &
-  );
-CORBA::Boolean TAO_IFR_Client_Export operator>> (
-    TAO_InputCDR &,
-    IR_ContextIdSeq &
-  );
-
-ACE_INLINE CORBA::Boolean
-operator<< (
-    TAO_OutputCDR &strm,
-    const IR_OperationDef_ptr _tao_objref
-  )
-{
-  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
-  return (strm << _tao_corba_obj);
-}
-
-ACE_INLINE CORBA::Boolean
-operator>> (
-    TAO_InputCDR &strm,
-    IR_OperationDef_ptr &_tao_objref
-  )
-{
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::Object_var obj;
-    if ((strm >> obj.inout ()) == 0)
-      return 0;
-    // narrow to the right type
-    _tao_objref =
-      IR_OperationDef::_unchecked_narrow (
-          obj.in (),
-          ACE_TRY_ENV
-        );
-    ACE_TRY_CHECK;
-    return 1;
-  }
-  ACE_CATCHANY
-  {
-    // do nothing
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const IR_OperationDescription &_tao_aggregate)
-{
-  if (
-    (strm << _tao_aggregate.name.in ()) &&
-    (strm << _tao_aggregate.id.in ()) &&
-    (strm << _tao_aggregate.defined_in.in ()) &&
-    (strm << _tao_aggregate.version.in ()) &&
-    (strm << _tao_aggregate.result.in ()) &&
-    (strm << _tao_aggregate.mode) &&
-    (strm << _tao_aggregate.contexts) &&
-    (strm << _tao_aggregate.parameters) &&
-    (strm << _tao_aggregate.exceptions)
-  )
-    return 1;
-  else
-    return 0;
-  
-}
-
-ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, IR_OperationDescription &_tao_aggregate)
-{
-  if (
-    (strm >> _tao_aggregate.name.out ()) &&
-    (strm >> _tao_aggregate.id.out ()) &&
-    (strm >> _tao_aggregate.defined_in.out ()) &&
-    (strm >> _tao_aggregate.version.out ()) &&
-    (strm >> _tao_aggregate.result.out ()) &&
-    (strm >> _tao_aggregate.mode) &&
-    (strm >> _tao_aggregate.contexts) &&
-    (strm >> _tao_aggregate.parameters) &&
-    (strm >> _tao_aggregate.exceptions)
-  )
-    return 1;
-  else
-    return 0;
-  
-}
-
-CORBA::Boolean TAO_IFR_Client_Export operator<< (
-    TAO_OutputCDR &,
-    const IR_RepositoryIdSeq &
-  );
-CORBA::Boolean TAO_IFR_Client_Export operator>> (
-    TAO_InputCDR &,
-    IR_RepositoryIdSeq &
-  );
-
-CORBA::Boolean TAO_IFR_Client_Export operator<< (
-    TAO_OutputCDR &,
-    const IR_OpDescriptionSeq &
-  );
-CORBA::Boolean TAO_IFR_Client_Export operator>> (
-    TAO_InputCDR &,
-    IR_OpDescriptionSeq &
-  );
-
-CORBA::Boolean TAO_IFR_Client_Export operator<< (
-    TAO_OutputCDR &,
-    const IR_AttrDescriptionSeq &
-  );
-CORBA::Boolean TAO_IFR_Client_Export operator>> (
-    TAO_InputCDR &,
-    IR_AttrDescriptionSeq &
-  );
-
-ACE_INLINE CORBA::Boolean
-operator<< (
-    TAO_OutputCDR &strm,
-    const IR_InterfaceDef_ptr _tao_objref
-  )
-{
-  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
-  return (strm << _tao_corba_obj);
-}
-
-ACE_INLINE CORBA::Boolean
-operator>> (
-    TAO_InputCDR &strm,
-    IR_InterfaceDef_ptr &_tao_objref
-  )
-{
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::Object_var obj;
-    if ((strm >> obj.inout ()) == 0)
-      return 0;
-    // narrow to the right type
-    _tao_objref =
-      IR_InterfaceDef::_unchecked_narrow (
-          obj.in (),
-          ACE_TRY_ENV
-        );
-    ACE_TRY_CHECK;
-    return 1;
-  }
-  ACE_CATCHANY
-  {
-    // do nothing
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const IR_InterfaceDescription &_tao_aggregate)
-{
-  if (
-    (strm << _tao_aggregate.name.in ()) &&
-    (strm << _tao_aggregate.id.in ()) &&
-    (strm << _tao_aggregate.defined_in.in ()) &&
-    (strm << _tao_aggregate.version.in ()) &&
-    (strm << _tao_aggregate.operations) &&
-    (strm << _tao_aggregate.attributes) &&
-    (strm << _tao_aggregate.base_interfaces) &&
-    (strm << _tao_aggregate.type.in ()) &&
-    (strm << CORBA::Any::from_boolean (_tao_aggregate.is_abstract)) &&
-    (strm << CORBA::Any::from_boolean (_tao_aggregate.is_local))
-  )
-    return 1;
-  else
-    return 0;
-  
-}
-
-ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, IR_InterfaceDescription &_tao_aggregate)
-{
-  if (
-    (strm >> _tao_aggregate.name.out ()) &&
-    (strm >> _tao_aggregate.id.out ()) &&
-    (strm >> _tao_aggregate.defined_in.out ()) &&
-    (strm >> _tao_aggregate.version.out ()) &&
-    (strm >> _tao_aggregate.operations) &&
-    (strm >> _tao_aggregate.attributes) &&
-    (strm >> _tao_aggregate.base_interfaces) &&
-    (strm >> _tao_aggregate.type.out ()) &&
-    (strm >> CORBA::Any::to_boolean (_tao_aggregate.is_abstract)) &&
-    (strm >> CORBA::Any::to_boolean (_tao_aggregate.is_local))
-  )
-    return 1;
-  else
-    return 0;
-  
-}
-
-ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const IR_ValueMember &_tao_aggregate)
-{
-  if (
-    (strm << _tao_aggregate.name.in ()) &&
-    (strm << _tao_aggregate.id.in ()) &&
-    (strm << _tao_aggregate.defined_in.in ()) &&
-    (strm << _tao_aggregate.version.in ()) &&
-    (strm << _tao_aggregate.type.in ()) &&
-    (strm << _tao_aggregate.type_def.in ()) &&
-    (strm << _tao_aggregate.access)
-  )
-    return 1;
-  else
-    return 0;
-  
-}
-
-ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, IR_ValueMember &_tao_aggregate)
-{
-  if (
-    (strm >> _tao_aggregate.name.out ()) &&
-    (strm >> _tao_aggregate.id.out ()) &&
-    (strm >> _tao_aggregate.defined_in.out ()) &&
-    (strm >> _tao_aggregate.version.out ()) &&
-    (strm >> _tao_aggregate.type.out ()) &&
-    (strm >> _tao_aggregate.type_def.out ()) &&
-    (strm >> _tao_aggregate.access)
-  )
-    return 1;
-  else
-    return 0;
-  
-}
-
-CORBA::Boolean TAO_IFR_Client_Export operator<< (
-    TAO_OutputCDR &,
-    const IR_ValueMemberSeq &
-  );
-CORBA::Boolean TAO_IFR_Client_Export operator>> (
-    TAO_InputCDR &,
-    IR_ValueMemberSeq &
-  );
-
-ACE_INLINE CORBA::Boolean
-operator<< (
-    TAO_OutputCDR &strm,
-    const IR_ValueMemberDef_ptr _tao_objref
-  )
-{
-  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
-  return (strm << _tao_corba_obj);
-}
-
-ACE_INLINE CORBA::Boolean
-operator>> (
-    TAO_InputCDR &strm,
-    IR_ValueMemberDef_ptr &_tao_objref
-  )
-{
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::Object_var obj;
-    if ((strm >> obj.inout ()) == 0)
-      return 0;
-    // narrow to the right type
-    _tao_objref =
-      IR_ValueMemberDef::_unchecked_narrow (
-          obj.in (),
-          ACE_TRY_ENV
-        );
-    ACE_TRY_CHECK;
-    return 1;
-  }
-  ACE_CATCHANY
-  {
-    // do nothing
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-ACE_INLINE CORBA::Boolean
-operator<< (
-    TAO_OutputCDR &strm,
-    const IR_ValueDef_ptr _tao_objref
-  )
-{
-  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
-  return (strm << _tao_corba_obj);
-}
-
-ACE_INLINE CORBA::Boolean
-operator>> (
-    TAO_InputCDR &strm,
-    IR_ValueDef_ptr &_tao_objref
-  )
-{
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::Object_var obj;
-    if ((strm >> obj.inout ()) == 0)
-      return 0;
-    // narrow to the right type
-    _tao_objref =
-      IR_ValueDef::_unchecked_narrow (
-          obj.in (),
-          ACE_TRY_ENV
-        );
-    ACE_TRY_CHECK;
-    return 1;
-  }
-  ACE_CATCHANY
-  {
-    // do nothing
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const IR_ValueDescription &_tao_aggregate)
-{
-  if (
-    (strm << _tao_aggregate.name.in ()) &&
-    (strm << _tao_aggregate.id.in ()) &&
-    (strm << CORBA::Any::from_boolean (_tao_aggregate.is_abstract)) &&
-    (strm << CORBA::Any::from_boolean (_tao_aggregate.is_custom)) &&
-    (strm << _tao_aggregate.defined_in.in ()) &&
-    (strm << _tao_aggregate.version.in ()) &&
-    (strm << _tao_aggregate.operations) &&
-    (strm << _tao_aggregate.attributes) &&
-    (strm << _tao_aggregate.members) &&
-    (strm << _tao_aggregate.initializers) &&
-    (strm << _tao_aggregate.supported_interfaces) &&
-    (strm << _tao_aggregate.abstract_base_values) &&
-    (strm << CORBA::Any::from_boolean (_tao_aggregate.is_truncatable)) &&
-    (strm << _tao_aggregate.base_value.in ()) &&
-    (strm << _tao_aggregate.type.in ())
-  )
-    return 1;
-  else
-    return 0;
-  
-}
-
-ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, IR_ValueDescription &_tao_aggregate)
-{
-  if (
-    (strm >> _tao_aggregate.name.out ()) &&
-    (strm >> _tao_aggregate.id.out ()) &&
-    (strm >> CORBA::Any::to_boolean (_tao_aggregate.is_abstract)) &&
-    (strm >> CORBA::Any::to_boolean (_tao_aggregate.is_custom)) &&
-    (strm >> _tao_aggregate.defined_in.out ()) &&
-    (strm >> _tao_aggregate.version.out ()) &&
-    (strm >> _tao_aggregate.operations) &&
-    (strm >> _tao_aggregate.attributes) &&
-    (strm >> _tao_aggregate.members) &&
-    (strm >> _tao_aggregate.initializers) &&
-    (strm >> _tao_aggregate.supported_interfaces) &&
-    (strm >> _tao_aggregate.abstract_base_values) &&
-    (strm >> CORBA::Any::to_boolean (_tao_aggregate.is_truncatable)) &&
-    (strm >> _tao_aggregate.base_value.out ()) &&
-    (strm >> _tao_aggregate.type.out ())
-  )
-    return 1;
-  else
-    return 0;
-  
-}
-
-ACE_INLINE CORBA::Boolean
-operator<< (
-    TAO_OutputCDR &strm,
-    const IR_ValueBoxDef_ptr _tao_objref
-  )
-{
-  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
-  return (strm << _tao_corba_obj);
-}
-
-ACE_INLINE CORBA::Boolean
-operator>> (
-    TAO_InputCDR &strm,
-    IR_ValueBoxDef_ptr &_tao_objref
-  )
-{
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::Object_var obj;
-    if ((strm >> obj.inout ()) == 0)
-      return 0;
-    // narrow to the right type
-    _tao_objref =
-      IR_ValueBoxDef::_unchecked_narrow (
-          obj.in (),
-          ACE_TRY_ENV
-        );
-    ACE_TRY_CHECK;
-    return 1;
-  }
-  ACE_CATCHANY
-  {
-    // do nothing
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-ACE_INLINE CORBA::Boolean
-operator<< (
-    TAO_OutputCDR &strm,
-    const IR_ProvidesDef_ptr _tao_objref
-  )
-{
-  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
-  return (strm << _tao_corba_obj);
-}
-
-ACE_INLINE CORBA::Boolean
-operator>> (
-    TAO_InputCDR &strm,
-    IR_ProvidesDef_ptr &_tao_objref
-  )
-{
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::Object_var obj;
-    if ((strm >> obj.inout ()) == 0)
-      return 0;
-    // narrow to the right type
-    _tao_objref =
-      IR_ProvidesDef::_unchecked_narrow (
-          obj.in (),
-          ACE_TRY_ENV
-        );
-    ACE_TRY_CHECK;
-    return 1;
-  }
-  ACE_CATCHANY
-  {
-    // do nothing
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const IR_ProvidesDescription &_tao_aggregate)
-{
-  if (
-    (strm << _tao_aggregate.name.in ()) &&
-    (strm << _tao_aggregate.id.in ()) &&
-    (strm << _tao_aggregate.defined_in.in ()) &&
-    (strm << _tao_aggregate.version.in ()) &&
-    (strm << _tao_aggregate.interface_type.in ())
-  )
-    return 1;
-  else
-    return 0;
-  
-}
-
-ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, IR_ProvidesDescription &_tao_aggregate)
-{
-  if (
-    (strm >> _tao_aggregate.name.out ()) &&
-    (strm >> _tao_aggregate.id.out ()) &&
-    (strm >> _tao_aggregate.defined_in.out ()) &&
-    (strm >> _tao_aggregate.version.out ()) &&
-    (strm >> _tao_aggregate.interface_type.out ())
-  )
-    return 1;
-  else
-    return 0;
-  
-}
-
-ACE_INLINE CORBA::Boolean
-operator<< (
-    TAO_OutputCDR &strm,
-    const IR_UsesDef_ptr _tao_objref
-  )
-{
-  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
-  return (strm << _tao_corba_obj);
-}
-
-ACE_INLINE CORBA::Boolean
-operator>> (
-    TAO_InputCDR &strm,
-    IR_UsesDef_ptr &_tao_objref
-  )
-{
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::Object_var obj;
-    if ((strm >> obj.inout ()) == 0)
-      return 0;
-    // narrow to the right type
-    _tao_objref =
-      IR_UsesDef::_unchecked_narrow (
-          obj.in (),
-          ACE_TRY_ENV
-        );
-    ACE_TRY_CHECK;
-    return 1;
-  }
-  ACE_CATCHANY
-  {
-    // do nothing
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const IR_UsesDescription &_tao_aggregate)
-{
-  if (
-    (strm << _tao_aggregate.name.in ()) &&
-    (strm << _tao_aggregate.id.in ()) &&
-    (strm << _tao_aggregate.defined_in.in ()) &&
-    (strm << _tao_aggregate.version.in ()) &&
-    (strm << _tao_aggregate.interface_type.in ()) &&
-    (strm << CORBA::Any::from_boolean (_tao_aggregate.is_multiple))
-  )
-    return 1;
-  else
-    return 0;
-  
-}
-
-ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, IR_UsesDescription &_tao_aggregate)
-{
-  if (
-    (strm >> _tao_aggregate.name.out ()) &&
-    (strm >> _tao_aggregate.id.out ()) &&
-    (strm >> _tao_aggregate.defined_in.out ()) &&
-    (strm >> _tao_aggregate.version.out ()) &&
-    (strm >> _tao_aggregate.interface_type.out ()) &&
-    (strm >> CORBA::Any::to_boolean (_tao_aggregate.is_multiple))
-  )
-    return 1;
-  else
-    return 0;
-  
-}
-
-CORBA::Boolean TAO_IFR_Client_Export operator<< (
-    TAO_OutputCDR &,
-    const IR_ProvidesDescSeq &
-  );
-CORBA::Boolean TAO_IFR_Client_Export operator>> (
-    TAO_InputCDR &,
-    IR_ProvidesDescSeq &
-  );
-
-CORBA::Boolean TAO_IFR_Client_Export operator<< (
-    TAO_OutputCDR &,
-    const IR_UsesDescSeq &
-  );
-CORBA::Boolean TAO_IFR_Client_Export operator>> (
-    TAO_InputCDR &,
-    IR_UsesDescSeq &
-  );
-
-ACE_INLINE CORBA::Boolean
-operator<< (
-    TAO_OutputCDR &strm,
-    const IR_EventDef_ptr _tao_objref
-  )
-{
-  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
-  return (strm << _tao_corba_obj);
-}
-
-ACE_INLINE CORBA::Boolean
-operator>> (
-    TAO_InputCDR &strm,
-    IR_EventDef_ptr &_tao_objref
-  )
-{
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::Object_var obj;
-    if ((strm >> obj.inout ()) == 0)
-      return 0;
-    // narrow to the right type
-    _tao_objref =
-      IR_EventDef::_unchecked_narrow (
-          obj.in (),
-          ACE_TRY_ENV
-        );
-    ACE_TRY_CHECK;
-    return 1;
-  }
-  ACE_CATCHANY
-  {
-    // do nothing
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const IR_EventDescription &_tao_aggregate)
-{
-  if (
-    (strm << _tao_aggregate.name.in ()) &&
-    (strm << _tao_aggregate.id.in ()) &&
-    (strm << _tao_aggregate.defined_in.in ()) &&
-    (strm << _tao_aggregate.version.in ()) &&
-    (strm << _tao_aggregate.value.in ())
-  )
-    return 1;
-  else
-    return 0;
-  
-}
-
-ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, IR_EventDescription &_tao_aggregate)
-{
-  if (
-    (strm >> _tao_aggregate.name.out ()) &&
-    (strm >> _tao_aggregate.id.out ()) &&
-    (strm >> _tao_aggregate.defined_in.out ()) &&
-    (strm >> _tao_aggregate.version.out ()) &&
-    (strm >> _tao_aggregate.value.out ())
-  )
-    return 1;
-  else
-    return 0;
-  
-}
-
-ACE_INLINE CORBA::Boolean
-operator<< (
-    TAO_OutputCDR &strm,
-    const IR_EmitsDef_ptr _tao_objref
-  )
-{
-  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
-  return (strm << _tao_corba_obj);
-}
-
-ACE_INLINE CORBA::Boolean
-operator>> (
-    TAO_InputCDR &strm,
-    IR_EmitsDef_ptr &_tao_objref
-  )
-{
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::Object_var obj;
-    if ((strm >> obj.inout ()) == 0)
-      return 0;
-    // narrow to the right type
-    _tao_objref =
-      IR_EmitsDef::_unchecked_narrow (
-          obj.in (),
-          ACE_TRY_ENV
-        );
-    ACE_TRY_CHECK;
-    return 1;
-  }
-  ACE_CATCHANY
-  {
-    // do nothing
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-ACE_INLINE CORBA::Boolean
-operator<< (
-    TAO_OutputCDR &strm,
-    const IR_PublishesDef_ptr _tao_objref
-  )
-{
-  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
-  return (strm << _tao_corba_obj);
-}
-
-ACE_INLINE CORBA::Boolean
-operator>> (
-    TAO_InputCDR &strm,
-    IR_PublishesDef_ptr &_tao_objref
-  )
-{
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::Object_var obj;
-    if ((strm >> obj.inout ()) == 0)
-      return 0;
-    // narrow to the right type
-    _tao_objref =
-      IR_PublishesDef::_unchecked_narrow (
-          obj.in (),
-          ACE_TRY_ENV
-        );
-    ACE_TRY_CHECK;
-    return 1;
-  }
-  ACE_CATCHANY
-  {
-    // do nothing
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-ACE_INLINE CORBA::Boolean
-operator<< (
-    TAO_OutputCDR &strm,
-    const IR_ConsumesDef_ptr _tao_objref
-  )
-{
-  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
-  return (strm << _tao_corba_obj);
-}
-
-ACE_INLINE CORBA::Boolean
-operator>> (
-    TAO_InputCDR &strm,
-    IR_ConsumesDef_ptr &_tao_objref
-  )
-{
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::Object_var obj;
-    if ((strm >> obj.inout ()) == 0)
-      return 0;
-    // narrow to the right type
-    _tao_objref =
-      IR_ConsumesDef::_unchecked_narrow (
-          obj.in (),
-          ACE_TRY_ENV
-        );
-    ACE_TRY_CHECK;
-    return 1;
-  }
-  ACE_CATCHANY
-  {
-    // do nothing
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-ACE_INLINE CORBA::Boolean
-operator<< (
-    TAO_OutputCDR &strm,
-    const IR_ComponentDef_ptr _tao_objref
-  )
-{
-  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
-  return (strm << _tao_corba_obj);
-}
-
-ACE_INLINE CORBA::Boolean
-operator>> (
-    TAO_InputCDR &strm,
-    IR_ComponentDef_ptr &_tao_objref
-  )
-{
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::Object_var obj;
-    if ((strm >> obj.inout ()) == 0)
-      return 0;
-    // narrow to the right type
-    _tao_objref =
-      IR_ComponentDef::_unchecked_narrow (
-          obj.in (),
-          ACE_TRY_ENV
-        );
-    ACE_TRY_CHECK;
-    return 1;
-  }
-  ACE_CATCHANY
-  {
-    // do nothing
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const IR_ComponentDescription &_tao_aggregate)
-{
-  if (
-    (strm << _tao_aggregate.name.in ()) &&
-    (strm << _tao_aggregate.id.in ()) &&
-    (strm << _tao_aggregate.defined_in.in ()) &&
-    (strm << _tao_aggregate.version.in ()) &&
-    (strm << _tao_aggregate.base_component.in ()) &&
-    (strm << _tao_aggregate.supports_interfaces) &&
-    (strm << _tao_aggregate.provides_interfaces) &&
-    (strm << _tao_aggregate.uses_interfaces) &&
-    (strm << _tao_aggregate.attributes) &&
-    (strm << _tao_aggregate.emits_events) &&
-    (strm << _tao_aggregate.publishes_events) &&
-    (strm << _tao_aggregate.consumes_events) &&
-    (strm << CORBA::Any::from_boolean (_tao_aggregate.is_basic))
-  )
-    return 1;
-  else
-    return 0;
-  
-}
-
-ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, IR_ComponentDescription &_tao_aggregate)
-{
-  if (
-    (strm >> _tao_aggregate.name.out ()) &&
-    (strm >> _tao_aggregate.id.out ()) &&
-    (strm >> _tao_aggregate.defined_in.out ()) &&
-    (strm >> _tao_aggregate.version.out ()) &&
-    (strm >> _tao_aggregate.base_component.out ()) &&
-    (strm >> _tao_aggregate.supports_interfaces) &&
-    (strm >> _tao_aggregate.provides_interfaces) &&
-    (strm >> _tao_aggregate.uses_interfaces) &&
-    (strm >> _tao_aggregate.attributes) &&
-    (strm >> _tao_aggregate.emits_events) &&
-    (strm >> _tao_aggregate.publishes_events) &&
-    (strm >> _tao_aggregate.consumes_events) &&
-    (strm >> CORBA::Any::to_boolean (_tao_aggregate.is_basic))
-  )
-    return 1;
-  else
-    return 0;
-  
-}
-
-ACE_INLINE CORBA::Boolean
-operator<< (
-    TAO_OutputCDR &strm,
-    const IR_PrimaryKeyDef_ptr _tao_objref
-  )
-{
-  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
-  return (strm << _tao_corba_obj);
-}
-
-ACE_INLINE CORBA::Boolean
-operator>> (
-    TAO_InputCDR &strm,
-    IR_PrimaryKeyDef_ptr &_tao_objref
-  )
-{
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::Object_var obj;
-    if ((strm >> obj.inout ()) == 0)
-      return 0;
-    // narrow to the right type
-    _tao_objref =
-      IR_PrimaryKeyDef::_unchecked_narrow (
-          obj.in (),
-          ACE_TRY_ENV
-        );
-    ACE_TRY_CHECK;
-    return 1;
-  }
-  ACE_CATCHANY
-  {
-    // do nothing
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const IR_PrimaryKeyDescription &_tao_aggregate)
-{
-  if (
-    (strm << _tao_aggregate.name.in ()) &&
-    (strm << _tao_aggregate.id.in ()) &&
-    (strm << _tao_aggregate.defined_in.in ()) &&
-    (strm << _tao_aggregate.version.in ()) &&
-    (strm << _tao_aggregate.primary_key.in ())
-  )
-    return 1;
-  else
-    return 0;
-  
-}
-
-ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, IR_PrimaryKeyDescription &_tao_aggregate)
-{
-  if (
-    (strm >> _tao_aggregate.name.out ()) &&
-    (strm >> _tao_aggregate.id.out ()) &&
-    (strm >> _tao_aggregate.defined_in.out ()) &&
-    (strm >> _tao_aggregate.version.out ()) &&
-    (strm >> _tao_aggregate.primary_key.out ())
-  )
-    return 1;
-  else
-    return 0;
-  
-}
-
-ACE_INLINE CORBA::Boolean
-operator<< (
-    TAO_OutputCDR &strm,
-    const IR_FactoryDef_ptr _tao_objref
-  )
-{
-  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
-  return (strm << _tao_corba_obj);
-}
-
-ACE_INLINE CORBA::Boolean
-operator>> (
-    TAO_InputCDR &strm,
-    IR_FactoryDef_ptr &_tao_objref
-  )
-{
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::Object_var obj;
-    if ((strm >> obj.inout ()) == 0)
-      return 0;
-    // narrow to the right type
-    _tao_objref =
-      IR_FactoryDef::_unchecked_narrow (
-          obj.in (),
-          ACE_TRY_ENV
-        );
-    ACE_TRY_CHECK;
-    return 1;
-  }
-  ACE_CATCHANY
-  {
-    // do nothing
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-ACE_INLINE CORBA::Boolean
-operator<< (
-    TAO_OutputCDR &strm,
-    const IR_FinderDef_ptr _tao_objref
-  )
-{
-  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
-  return (strm << _tao_corba_obj);
-}
-
-ACE_INLINE CORBA::Boolean
-operator>> (
-    TAO_InputCDR &strm,
-    IR_FinderDef_ptr &_tao_objref
-  )
-{
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::Object_var obj;
-    if ((strm >> obj.inout ()) == 0)
-      return 0;
-    // narrow to the right type
-    _tao_objref =
-      IR_FinderDef::_unchecked_narrow (
-          obj.in (),
-          ACE_TRY_ENV
-        );
-    ACE_TRY_CHECK;
-    return 1;
-  }
-  ACE_CATCHANY
-  {
-    // do nothing
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-ACE_INLINE CORBA::Boolean
-operator<< (
-    TAO_OutputCDR &strm,
-    const IR_HomeDef_ptr _tao_objref
-  )
-{
-  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
-  return (strm << _tao_corba_obj);
-}
-
-ACE_INLINE CORBA::Boolean
-operator>> (
-    TAO_InputCDR &strm,
-    IR_HomeDef_ptr &_tao_objref
-  )
-{
-  ACE_TRY_NEW_ENV
-  {
-    CORBA::Object_var obj;
-    if ((strm >> obj.inout ()) == 0)
-      return 0;
-    // narrow to the right type
-    _tao_objref =
-      IR_HomeDef::_unchecked_narrow (
-          obj.in (),
-          ACE_TRY_ENV
-        );
-    ACE_TRY_CHECK;
-    return 1;
-  }
-  ACE_CATCHANY
-  {
-    // do nothing
-  }
-  ACE_ENDTRY;
-  return 0;
-}
-
-ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const IR_HomeDescription &_tao_aggregate)
-{
-  if (
-    (strm << _tao_aggregate.name.in ()) &&
-    (strm << _tao_aggregate.id.in ()) &&
-    (strm << _tao_aggregate.defined_in.in ()) &&
-    (strm << _tao_aggregate.version.in ()) &&
-    (strm << _tao_aggregate.base_home.in ()) &&
-    (strm << _tao_aggregate.managed_component.in ()) &&
-    (strm << _tao_aggregate.primary_key_def.in ()) &&
-    (strm << _tao_aggregate.factories) &&
-    (strm << _tao_aggregate.finders) &&
-    (strm << _tao_aggregate.operations) &&
-    (strm << _tao_aggregate.attributes) &&
-    (strm << CORBA::Any::from_boolean (_tao_aggregate.is_basic))
-  )
-    return 1;
-  else
-    return 0;
-  
-}
-
-ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, IR_HomeDescription &_tao_aggregate)
-{
-  if (
-    (strm >> _tao_aggregate.name.out ()) &&
-    (strm >> _tao_aggregate.id.out ()) &&
-    (strm >> _tao_aggregate.defined_in.out ()) &&
-    (strm >> _tao_aggregate.version.out ()) &&
-    (strm >> _tao_aggregate.base_home.out ()) &&
-    (strm >> _tao_aggregate.managed_component.out ()) &&
-    (strm >> _tao_aggregate.primary_key_def.out ()) &&
-    (strm >> _tao_aggregate.factories) &&
-    (strm >> _tao_aggregate.finders) &&
-    (strm >> _tao_aggregate.operations) &&
-    (strm >> _tao_aggregate.attributes) &&
-    (strm >> CORBA::Any::to_boolean (_tao_aggregate.is_basic))
-  )
-    return 1;
-  else
-    return 0;
-  
-}
-
diff --git a/TAO/tao/IFR_Client/Makefile b/TAO/tao/IFR_Client/Makefile
index a265f5f1fdd..8f9139e86b1 100644
--- a/TAO/tao/IFR_Client/Makefile
+++ b/TAO/tao/IFR_Client/Makefile
@@ -15,7 +15,11 @@ SHLIB    = $(LIBNAME).$(SOEXT)
 ACE_SHLIBS = -lTAO -lACE
 
 
-CPP_SRCS += InterfaceC IFR_Client_Adapter_Impl
+CPP_SRCS += IFR_BaseC \
+            IFR_BasicC \
+            IFR_ExtendedC \
+            IFR_ComponentsC \
+            IFR_Client_Adapter_Impl
 
 FILES = $(CPP_SRCS)
 DEFS  = $(addsuffix .h,$(FILES))
diff --git a/TAO/tao/IFR_Client/Makefile.bor b/TAO/tao/IFR_Client/Makefile.bor
index 36b2cd46cf6..31287dc6bc8 100644
--- a/TAO/tao/IFR_Client/Makefile.bor
+++ b/TAO/tao/IFR_Client/Makefile.bor
@@ -5,7 +5,10 @@
 NAME = TAO_IFR_Client
 
 OBJFILES = \
-	$(OBJDIR)\InterfaceC.obj \
+	$(OBJDIR)\IFR_BaseC.obj \
+	$(OBJDIR)\IFR_BasicC.obj \
+	$(OBJDIR)\IFR_ExtendedC.obj \
+	$(OBJDIR)\IFR_ComponentsC.obj \
         $(OBJDIR)\IFR_Client_Adapter_Impl.obj
 
 !ifdef STATIC
diff --git a/TAO/tao/IFR_Client/TAO_IFR_Client.dsp b/TAO/tao/IFR_Client/TAO_IFR_Client.dsp
index bc636429020..bec5c7810d5 100644
--- a/TAO/tao/IFR_Client/TAO_IFR_Client.dsp
+++ b/TAO/tao/IFR_Client/TAO_IFR_Client.dsp
@@ -92,11 +92,23 @@ LINK32=link.exe
 # PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"

 # Begin Source File

 

+SOURCE=.\IFR_BaseC.cpp

+# End Source File

+# Begin Source File

+

+SOURCE=.\IFR_BasicC.cpp

+# End Source File

+# Begin Source File

+

 SOURCE=.\IFR_Client_Adapter_Impl.cpp

 # End Source File

 # Begin Source File

 

-SOURCE=.\InterfaceC.cpp

+SOURCE=.\IFR_ComponentsC.cpp

+# End Source File

+# Begin Source File

+

+SOURCE=.\IFR_ExtendedC.cpp

 # End Source File

 # End Group

 # Begin Group "Header Files"

@@ -104,6 +116,14 @@ SOURCE=.\InterfaceC.cpp
 # PROP Default_Filter "h;hpp;hxx;hm;inl"

 # Begin Source File

 

+SOURCE=.\IFR_BaseC.h

+# End Source File

+# Begin Source File

+

+SOURCE=.\IFR_BasicC.h

+# End Source File

+# Begin Source File

+

 SOURCE=.\IFR_Client_Adapter_Impl.h

 # End Source File

 # Begin Source File

@@ -112,11 +132,11 @@ SOURCE=.\ifr_client_export.h
 # End Source File

 # Begin Source File

 

-SOURCE=.\ifrfwd.h

+SOURCE=.\IFR_ComponentsC.h

 # End Source File

 # Begin Source File

 

-SOURCE=.\InterfaceC.h

+SOURCE=.\IFR_ExtendedC.h

 # End Source File

 # End Group

 # Begin Group "Inline Files"

@@ -124,7 +144,19 @@ SOURCE=.\InterfaceC.h
 # PROP Default_Filter "i"

 # Begin Source File

 

-SOURCE=.\InterfaceC.i

+SOURCE=.\IFR_BaseC.i

+# End Source File

+# Begin Source File

+

+SOURCE=.\IFR_BasicC.i

+# End Source File

+# Begin Source File

+

+SOURCE=.\IFR_ComponentsC.i

+# End Source File

+# Begin Source File

+

+SOURCE=.\IFR_ExtendedC.i

 # End Source File

 # End Group

 # End Target

diff --git a/TAO/tao/IFR_Client/ifrfwd.h b/TAO/tao/IFR_Client/ifrfwd.h
deleted file mode 100644
index 8a834912642..00000000000
--- a/TAO/tao/IFR_Client/ifrfwd.h
+++ /dev/null
@@ -1,930 +0,0 @@
-// -*- C++ -*-
-
-//=============================================================================
-/**
- *  @file    ifrfwd.h
- *
- *  $Id$
- *
- *  Forward declare the basic types used in the IR
- *  implementation. This file should be included in
- *  ORB file headers that use one or more IR namespace
- *  types. The corresponding source files will include
- *  InterfaceC.h.
- *
- *
- *  @author Jeff Parsons
- */
-//=============================================================================
-
-
-#ifndef TAO_IFRFWD_H
-#define TAO_IFRFWD_H
-#include "ace/pre.h"
-
-#include "ifr_client_export.h"
-#include "tao/corbafwd.h"
-
-#if !defined (ACE_LACKS_PRAGMA_ONCE)
-# pragma once
-#endif /* ACE_LACKS_PRAGMA_ONCE */
-
-#if defined (TAO_EXPORT_MACRO)
-#undef TAO_EXPORT_MACRO
-#endif
-#define TAO_EXPORT_MACRO TAO_IFR_Client_Export
-
-#if defined(_MSC_VER)
-#if (_MSC_VER >= 1200)
-#pragma warning(push)
-#endif /* _MSC_VER >= 1200 */
-#pragma warning(disable:4250)
-#endif /* _MSC_VER */
-
-// Forward declarations of some data types are needed.
-class IR_Contained;
-class IR_Contained_var;
-class IR_Contained_out;
-typedef IR_Contained *IR_Contained_ptr;
-
-class IR_ContainedSeq;
-class IR_ContainedSeq_var;
-class IR_ContainedSeq_out;
-
-class IR_Repository;
-class IR_Repository_var;
-class IR_Repository_out;
-typedef IR_Repository *IR_Repository_ptr;
-
-class IR_ComponentRepository;
-class IR_ComponentRepository_var;
-class IR_ComponentRepository_out;
-typedef IR_ComponentRepository *IR_ComponentRepository_ptr;
-
-class IR_Container;
-class IR_Container_var;
-class IR_Container_out;
-typedef IR_Container *IR_Container_ptr;
-
-class IR_ModuleDef;
-class IR_ModuleDef_var;
-class IR_ModuleDef_out;
-typedef IR_ModuleDef *IR_ModuleDef_ptr;
-
-class IR_ConstantDef;
-class IR_ConstantDef_var;
-class IR_ConstantDef_out;
-typedef IR_ConstantDef *IR_ConstantDef_ptr;
-
-class IR_IDLType;
-class IR_IDLType_var;
-class IR_IDLType_out;
-typedef IR_IDLType *IR_IDLType_ptr;
-
-class IR_StructDef;
-class IR_StructDef_var;
-class IR_StructDef_out;
-typedef IR_StructDef *IR_StructDef_ptr;
-
-class IR_UnionDef;
-class IR_UnionDef_var;
-class IR_UnionDef_out;
-typedef IR_UnionDef *IR_UnionDef_ptr;
-
-class IR_EnumDef;
-class IR_EnumDef_var;
-class IR_EnumDef_out;
-typedef IR_EnumDef *IR_EnumDef_ptr;
-
-class IR_AliasDef;
-class IR_AliasDef_var;
-class IR_AliasDef_out;
-typedef IR_AliasDef *IR_AliasDef_ptr;
-
-class IR_InterfaceDef;
-class IR_InterfaceDef_var;
-class IR_InterfaceDef_out;
-typedef IR_InterfaceDef *IR_InterfaceDef_ptr;
-
-class IR_ExceptionDef;
-class IR_ExceptionDef_var;
-class IR_ExceptionDef_out;
-typedef IR_ExceptionDef *IR_ExceptionDef_ptr;
-
-class IR_NativeDef;
-class IR_NativeDef_var;
-class IR_NativeDef_out;
-typedef IR_NativeDef *IR_NativeDef_ptr;
-
-class IR_InterfaceDefSeq;
-class IR_InterfaceDefSeq_var;
-class IR_InterfaceDefSeq_out;
-
-class IR_ValueDef;
-class IR_ValueDef_var;
-class IR_ValueDef_out;
-typedef IR_ValueDef *IR_ValueDef_ptr;
-
-class IR_ValueDefSeq;
-class IR_ValueDefSeq_var;
-class IR_ValueDefSeq_out;
-
-class IR_ValueBoxDef;
-class IR_ValueBoxDef_var;
-class IR_ValueBoxDef_out;
-typedef IR_ValueBoxDef *IR_ValueBoxDef_ptr;
-
-class IR_ComponentDef;
-class IR_ComponentDef_var;
-class IR_ComponentDef_out;
-typedef IR_ComponentDef *IR_ComponentDef_ptr;
-
-class IR_ComponentDefSeq;
-class IR_ComponentDefSeq_var;
-class IR_ComponentDefSeq_out;
-
-class IR_ProvidesDef;
-class IR_ProvidesDef_var;
-class IR_ProvidesDef_out;
-typedef IR_ProvidesDef *IR_ProvidesDef_ptr;
-
-class IR_ProvidesDefSeq;
-class IR_ProvidesDefSeq_var;
-class IR_ProvidesDefSeq_out;
-
-class IR_UsesDef;
-class IR_UsesDef_var;
-class IR_UsesDef_out;
-typedef IR_UsesDef *IR_UsesDef_ptr;
-
-class IR_UsesDefSeq;
-class IR_UsesDefSeq_var;
-class IR_UsesDefSeq_out;
-
-class IR_HomeDef;
-class IR_HomeDef_var;
-class IR_HomeDef_out;
-typedef IR_HomeDef *IR_HomeDef_ptr;
-
-class IR_HomeDefSeq;
-class IR_HomeDefSeq_var;
-class IR_HomeDefSeq_out;
-
-class IR_EventDef;
-class IR_EventDef_var;
-class IR_EventDef_out;
-typedef IR_EventDef *IR_EventDef_ptr;
-
-class IR_EmitsDef;
-class IR_EmitsDef_var;
-class IR_EmitsDef_out;
-typedef IR_EmitsDef *IR_EmitsDef_ptr;
-
-class IR_EmitsDefSeq;
-class IR_EmitsDefSeq_var;
-class IR_EmitsDefSeq_out;
-
-class IR_PublishesDef;
-class IR_PublishesDef_var;
-class IR_PublishesDef_out;
-typedef IR_PublishesDef *IR_PublishesDef_ptr;
-
-class IR_PublishesDefSeq;
-class IR_PublishesDefSeq_var;
-class IR_PublishesDefSeq_out;
-
-class IR_ConsumesDef;
-class IR_ConsumesDef_var;
-class IR_ConsumesDef_out;
-typedef IR_ConsumesDef *IR_ConsumesDef_ptr;
-
-class IR_ConsumesDefSeq;
-class IR_ConsumesDefSeq_var;
-class IR_ConsumesDefSeq_out;
-
-class IR_FactoryDef;
-class IR_FactoryDef_var;
-class IR_FactoryDef_out;
-typedef IR_FactoryDef *IR_FactoryDef_ptr;
-
-class IR_FactoryDefSeq;
-class IR_FactoryDefSeq_var;
-class IR_FactoryDefSeq_out;
-
-class IR_FinderDef;
-class IR_FinderDef_var;
-class IR_FinderDef_out;
-typedef IR_FinderDef *IR_FinderDef_ptr;
-
-class IR_FinderDefSeq;
-class IR_FinderDefSeq_var;
-class IR_FinderDefSeq_out;
-
-class IR_PrimaryKeyDef;
-class IR_PrimaryKeyDef_var;
-class IR_PrimaryKeyDef_out;
-typedef IR_PrimaryKeyDef *IR_PrimaryKeyDef_ptr;
-
-struct IR_StructMember;
-class IR_StructMember_var;
-class IR_StructMember_out;
-
-class IR_StructMemberSeq;
-class IR_StructMemberSeq_var;
-class IR_StructMemberSeq_out;
-
-struct IR_Initializer;
-class IR_Initializer_var;
-class IR_Initializer_out;
-
-class IR_InitializerSeq;
-class IR_InitializerSeq_var;
-class IR_InitializerSeq_out;
-
-struct IR_UnionMember;
-class IR_UnionMember_var;
-class IR_UnionMember_out;
-
-class IR_UnionMemberSeq;
-class IR_UnionMemberSeq_var;
-class IR_UnionMemberSeq_out;
-
-class IR_EnumMemberSeq;
-class IR_EnumMemberSeq_var;
-class IR_EnumMemberSeq_out;
-
-struct IR_ModuleDescription;
-class IR_ModuleDescription_var;
-class IR_ModuleDescription_out;
-
-struct IR_ConstantDescription;
-class IR_ConstantDescription_var;
-class IR_ConstantDescription_out;
-
-class IR_TypedefDef;
-class IR_TypedefDef_var;
-class IR_TypedefDef_out;
-typedef IR_TypedefDef *IR_TypedefDef_ptr;
-
-struct IR_TypeDescription;
-class IR_TypeDescription_var;
-class IR_TypeDescription_out;
-
-class IR_PrimitiveDef;
-class IR_PrimitiveDef_var;
-class IR_PrimitiveDef_out;
-typedef IR_PrimitiveDef *IR_PrimitiveDef_ptr;
-
-class IR_StringDef;
-class IR_StringDef_var;
-class IR_StringDef_out;
-typedef IR_StringDef *IR_StringDef_ptr;
-
-class IR_WstringDef;
-class IR_WstringDef_var;
-class IR_WstringDef_out;
-typedef IR_WstringDef *IR_WstringDef_ptr;
-
-class IR_FixedDef;
-class IR_FixedDef_var;
-class IR_FixedDef_out;
-typedef IR_FixedDef *IR_FixedDef_ptr;
-
-class IR_SequenceDef;
-class IR_SequenceDef_var;
-class IR_SequenceDef_out;
-typedef IR_SequenceDef *IR_SequenceDef_ptr;
-
-class IR_ArrayDef;
-class IR_ArrayDef_var;
-class IR_ArrayDef_out;
-typedef IR_ArrayDef *IR_ArrayDef_ptr;
-
-struct IR_ExceptionDescription;
-class IR_ExceptionDescription_var;
-class IR_ExceptionDescription_out;
-
-class IR_ExceptionDefSeq;
-class IR_ExceptionDefSeq_var;
-class IR_ExceptionDefSeq_out;
-
-class IR_ExcDescriptionSeq;
-class IR_ExcDescriptionSeq_var;
-class IR_ExcDescriptionSeq_out;
-
-class IR_AttributeDef;
-class IR_AttributeDef_var;
-class IR_AttributeDef_out;
-typedef IR_AttributeDef *IR_AttributeDef_ptr;
-
-struct IR_AttributeDescription;
-class IR_AttributeDescription_var;
-class IR_AttributeDescription_out;
-
-struct IR_ParameterDescription;
-class IR_ParameterDescription_var;
-class IR_ParameterDescription_out;
-
-class IR_ParDescriptionSeq;
-class IR_ParDescriptionSeq_var;
-class IR_ParDescriptionSeq_out;
-
-class IR_ContextIdSeq;
-class IR_ContextIdSeq_var;
-class IR_ContextIdSeq_out;
-
-class IR_OperationDef;
-class IR_OperationDef_var;
-class IR_OperationDef_out;
-typedef IR_OperationDef *IR_OperationDef_ptr;
-
-struct IR_OperationDescription;
-class IR_OperationDescription_var;
-class IR_OperationDescription_out;
-
-struct IR_ParameterDescription;
-class IR_ParameterDescription_var;
-class IR_ParameterDescription_out;
-
-class IR_RepositoryIdSeq;
-class IR_RepositoryIdSeq_var;
-class IR_RepositoryIdSeq_out;
-
-class IR_OpDescriptionSeq;
-class IR_OpDescriptionSeq_var;
-class IR_OpDescriptionSeq_out;
-
-class IR_AttrDescriptionSeq;
-class IR_AttrDescriptionSeq_var;
-class IR_AttrDescriptionSeq_out;
-
-struct IR_InterfaceDescription;
-class IR_InterfaceDescription_var;
-class IR_InterfaceDescription_out;
-
-struct IR_ValueMember;
-class IR_ValueMember_var;
-class IR_ValueMember_out;
-
-class IR_ValueMemberSeq;
-class IR_ValueMemberSeq_var;
-class IR_ValueMemberSeq_out;
-
-class IR_ValueMemberDef;
-class IR_ValueMemberDef_var;
-class IR_ValueMemberDef_out;
-typedef IR_ValueMemberDef *IR_ValueMemberDef_ptr;
-
-struct IR_ValueDescription;
-class IR_ValueDescription_var;
-class IR_ValueDescription_out;
-
-struct IR_ProvidesDescription;
-class IR_ProvidesDescription_var;
-class IR_ProvidesDescription_out;
-
-struct IR_UsesDescription;
-class IR_UsesDescription_var;
-class IR_UsesDescription_out;
-
-class IR_ProvidesDescSeq;
-class IR_ProvidesDescSeq_var;
-class IR_ProvidesDescSeq_out;
-
-class IR_UsesDescSeq;
-class IR_UsesDescSeq_var;
-class IR_UsesDescSeq_out;
-
-struct IR_EventDescription;
-class IR_EventDescription_var;
-class IR_EventDescription_out;
-
-struct IR_ValueDescription;
-class IR_ValueDescription_var;
-class IR_ValueDescription_out;
-
-struct IR_ComponentDescription;
-class IR_ComponentDescription_var;
-class IR_ComponentDescription_out;
-
-struct IR_PrimaryKeyDescription;
-class IR_PrimaryKeyDescription_var;
-class IR_PrimaryKeyDescription_out;
-
-struct IR_HomeDescription;
-class IR_HomeDescription_var;
-class IR_HomeDescription_out;
-
-TAO_NAMESPACE  IR
-{
-  // = TITLE
-  //    Provides the IR namespace.
-  //
-  // = DESCRIPTION
-  //    This class allows the use of IR::Foo, as well as IR_Foo
-  //    for all standard types Foo.
-
-  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;
-
-  typedef char * ContextIdentifier;
-  typedef CORBA::String_var ContextIdentifier_var;
-  typedef CORBA::String_out ContextIdentifier_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ContextIdentifier;
-
-  typedef IR_DefinitionKind DefinitionKind;
-  typedef IR_DefinitionKind &DefinitionKind_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_DefinitionKind;
-
-
-  typedef IR_Contained Contained;
-  typedef IR_Contained *Contained_ptr;
-  typedef IR_Contained_var Contained_var;
-  typedef IR_Contained_out Contained_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_Contained;
-
-  typedef IR_ContainedSeq ContainedSeq;
-  typedef IR_ContainedSeq_var ContainedSeq_var;
-  typedef IR_ContainedSeq_out ContainedSeq_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ContainedSeq;
-
-  typedef IR_Repository Repository;
-  typedef IR_Repository *Repository_ptr;
-  typedef IR_Repository_var Repository_var;
-  typedef IR_Repository_out Repository_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_Repository;
-
-  typedef IR_ComponentRepository ComponentRepository;
-  typedef IR_ComponentRepository *ComponentRepository_ptr;
-  typedef IR_ComponentRepository_var ComponentRepository_var;
-  typedef IR_ComponentRepository_out ComponentRepository_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ComponentRepository;
-
-  typedef IR_Container Container;
-  typedef IR_Container *Container_ptr;
-  typedef IR_Container_var Container_var;
-  typedef IR_Container_out Container_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_Container;
-
-  typedef IR_ModuleDef ModuleDef;
-  typedef IR_ModuleDef *ModuleDef_ptr;
-  typedef IR_ModuleDef_var ModuleDef_var;
-  typedef IR_ModuleDef_out ModuleDef_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ModuleDef;
-
-  typedef IR_ConstantDef ConstantDef;
-  typedef IR_ConstantDef *ConstantDef_ptr;
-  typedef IR_ConstantDef_var ConstantDef_var;
-  typedef IR_ConstantDef_out ConstantDef_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ConstantDef;
-
-  typedef IR_IDLType IDLType;
-  typedef IR_IDLType *IDLType_ptr;
-  typedef IR_IDLType_var IDLType_var;
-  typedef IR_IDLType_out IDLType_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_IDLType;
-
-  typedef IR_StructDef StructDef;
-  typedef IR_StructDef *StructDef_ptr;
-  typedef IR_StructDef_var StructDef_var;
-  typedef IR_StructDef_out StructDef_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_StructDef;
-
-  typedef IR_UnionDef UnionDef;
-  typedef IR_UnionDef *UnionDef_ptr;
-  typedef IR_UnionDef_var UnionDef_var;
-  typedef IR_UnionDef_out UnionDef_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_UnionDef;
-
-  typedef IR_EnumDef EnumDef;
-  typedef IR_EnumDef *EnumDef_ptr;
-  typedef IR_EnumDef_var EnumDef_var;
-  typedef IR_EnumDef_out EnumDef_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_EnumDef;
-
-  typedef IR_AliasDef AliasDef;
-  typedef IR_AliasDef *AliasDef_ptr;
-  typedef IR_AliasDef_var AliasDef_var;
-  typedef IR_AliasDef_out AliasDef_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_AliasDef;
-
-  typedef IR_InterfaceDef InterfaceDef;
-  typedef IR_InterfaceDef *InterfaceDef_ptr;
-  typedef IR_InterfaceDef_var InterfaceDef_var;
-  typedef IR_InterfaceDef_out InterfaceDef_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_InterfaceDef;
-
-  typedef IR_ExceptionDef ExceptionDef;
-  typedef IR_ExceptionDef *ExceptionDef_ptr;
-  typedef IR_ExceptionDef_var ExceptionDef_var;
-  typedef IR_ExceptionDef_out ExceptionDef_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ExceptionDef;
-
-  typedef IR_NativeDef NativeDef;
-  typedef IR_NativeDef *NativeDef_ptr;
-  typedef IR_NativeDef_var NativeDef_var;
-  typedef IR_NativeDef_out NativeDef_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_NativeDef;
-
-  typedef IR_InterfaceDefSeq InterfaceDefSeq;
-  typedef IR_InterfaceDefSeq_var InterfaceDefSeq_var;
-  typedef IR_InterfaceDefSeq_out InterfaceDefSeq_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_InterfaceDefSeq;
-
-  typedef IR_ValueDef ValueDef;
-  typedef IR_ValueDef *ValueDef_ptr;
-  typedef IR_ValueDef_var ValueDef_var;
-  typedef IR_ValueDef_out ValueDef_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ValueDef;
-
-  typedef IR_ValueDefSeq ValueDefSeq;
-  typedef IR_ValueDefSeq_var ValueDefSeq_var;
-  typedef IR_ValueDefSeq_out ValueDefSeq_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ValueDefSeq;
-
-  typedef IR_ValueBoxDef ValueBoxDef;
-  typedef IR_ValueBoxDef *ValueBoxDef_ptr;
-  typedef IR_ValueBoxDef_var ValueBoxDef_var;
-  typedef IR_ValueBoxDef_out ValueBoxDef_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ValueBoxDef;
-
-  typedef IR_ComponentDef ComponentDef;
-  typedef IR_ComponentDef *ComponentDef_ptr;
-  typedef IR_ComponentDef_var ComponentDef_var;
-  typedef IR_ComponentDef_out ComponentDef_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ComponentDef;
-
-  typedef IR_ComponentDefSeq ComponentDefSeq;
-  typedef IR_ComponentDefSeq_var ComponentDefSeq_var;
-  typedef IR_ComponentDefSeq_out ComponentDefSeq_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ComponentDefSeq;
-
-  typedef IR_ProvidesDef ProvidesDef;
-  typedef IR_ProvidesDef *ProvidesDef_ptr;
-  typedef IR_ProvidesDef_var ProvidesDef_var;
-  typedef IR_ProvidesDef_out ProvidesDef_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ProvidesDef;
-
-  typedef IR_ProvidesDefSeq ProvidesDefSeq;
-  typedef IR_ProvidesDefSeq_var ProvidesDefSeq_var;
-  typedef IR_ProvidesDefSeq_out ProvidesDefSeq_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ProvidesDefSeq;
-
-  typedef IR_UsesDef UsesDef;
-  typedef IR_UsesDef *UsesDef_ptr;
-  typedef IR_UsesDef_var UsesDef_var;
-  typedef IR_UsesDef_out UsesDef_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_UsesDef;
-
-  typedef IR_UsesDefSeq UsesDefSeq;
-  typedef IR_UsesDefSeq_var UsesDefSeq_var;
-  typedef IR_UsesDefSeq_out UsesDefSeq_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_UsesDefSeq;
-
-  typedef IR_HomeDef HomeDef;
-  typedef IR_HomeDef *HomeDef_ptr;
-  typedef IR_HomeDef_var HomeDef_var;
-  typedef IR_HomeDef_out HomeDef_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_HomeDef;
-
-  typedef IR_HomeDefSeq HomeDefSeq;
-  typedef IR_HomeDefSeq_var HomeDefSeq_var;
-  typedef IR_HomeDefSeq_out HomeDefSeq_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_HomeDefSeq;
-
-  typedef IR_EventDef EventDef;
-  typedef IR_EventDef *EventDef_ptr;
-  typedef IR_EventDef_var EventDef_var;
-  typedef IR_EventDef_out EventDef_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_EventDef;
-
-  typedef IR_EmitsDef EmitsDef;
-  typedef IR_EmitsDef *EmitsDef_ptr;
-  typedef IR_EmitsDef_var EmitsDef_var;
-  typedef IR_EmitsDef_out EmitsDef_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_EmitsDef;
-
-  typedef IR_EmitsDefSeq EmitsDefSeq;
-  typedef IR_EmitsDefSeq_var EmitsDefSeq_var;
-  typedef IR_EmitsDefSeq_out EmitsDefSeq_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_EmitsDefSeq;
-
-  typedef IR_PublishesDef PublishesDef;
-  typedef IR_PublishesDef *PublishesDef_ptr;
-  typedef IR_PublishesDef_var PublishesDef_var;
-  typedef IR_PublishesDef_out PublishesDef_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_PublishesDef;
-
-  typedef IR_PublishesDefSeq PublishesDefSeq;
-  typedef IR_PublishesDefSeq_var PublishesDefSeq_var;
-  typedef IR_PublishesDefSeq_out PublishesDefSeq_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_PublishesDefSeq;
-
-  typedef IR_ConsumesDef ConsumesDef;
-  typedef IR_ConsumesDef *ConsumesDef_ptr;
-  typedef IR_ConsumesDef_var ConsumesDef_var;
-  typedef IR_ConsumesDef_out ConsumesDef_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ConsumesDef;
-
-  typedef IR_ConsumesDefSeq ConsumesDefSeq;
-  typedef IR_ConsumesDefSeq_var ConsumesDefSeq_var;
-  typedef IR_ConsumesDefSeq_out ConsumesDefSeq_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ConsumesDefSeq;
-
-  typedef IR_FactoryDef FactoryDef;
-  typedef IR_FactoryDef *FactoryDef_ptr;
-  typedef IR_FactoryDef_var FactoryDef_var;
-  typedef IR_FactoryDef_out FactoryDef_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_FactoryDef;
-
-  typedef IR_FactoryDefSeq FactoryDefSeq;
-  typedef IR_FactoryDefSeq_var FactoryDefSeq_var;
-  typedef IR_FactoryDefSeq_out FactoryDefSeq_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_FactoryDefSeq;
-
-  typedef IR_FinderDef FinderDef;
-  typedef IR_FinderDef *FinderDef_ptr;
-  typedef IR_FinderDef_var FinderDef_var;
-  typedef IR_FinderDef_out FinderDef_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_FinderDef;
-
-  typedef IR_FinderDefSeq FinderDefSeq;
-  typedef IR_FinderDefSeq_var FinderDefSeq_var;
-  typedef IR_FinderDefSeq_out FinderDefSeq_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_FinderDefSeq;
-
-  typedef IR_PrimaryKeyDef PrimaryKeyDef;
-  typedef IR_PrimaryKeyDef *PrimaryKeyDef_ptr;
-  typedef IR_PrimaryKeyDef_var PrimaryKeyDef_var;
-  typedef IR_PrimaryKeyDef_out PrimaryKeyDef_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_PrimaryKeyDef;
-
-  typedef IR_StructMember StructMember;
-  typedef IR_StructMember_var StructMember_var;
-  typedef IR_StructMember_out StructMember_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_StructMember;
-
-  typedef IR_StructMemberSeq StructMemberSeq;
-  typedef IR_StructMemberSeq_var StructMemberSeq_var;
-  typedef IR_StructMemberSeq_out StructMemberSeq_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_StructMemberSeq;
-
-  typedef IR_Initializer Initializer;
-  typedef IR_Initializer_var Initializer_var;
-  typedef IR_Initializer_out Initializer_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_Initializer;
-
-  typedef IR_InitializerSeq InitializerSeq;
-  typedef IR_InitializerSeq_var InitializerSeq_var;
-  typedef IR_InitializerSeq_out InitializerSeq_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_InitializerSeq;
-
-  typedef IR_UnionMember UnionMember;
-  typedef IR_UnionMember_var UnionMember_var;
-  typedef IR_UnionMember_out UnionMember_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_UnionMember;
-
-  typedef IR_UnionMemberSeq UnionMemberSeq;
-  typedef IR_UnionMemberSeq_var UnionMemberSeq_var;
-  typedef IR_UnionMemberSeq_out UnionMemberSeq_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_UnionMemberSeq;
-
-  typedef IR_EnumMemberSeq EnumMemberSeq;
-  typedef IR_EnumMemberSeq_var EnumMemberSeq_var;
-  typedef IR_EnumMemberSeq_out EnumMemberSeq_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_EnumMemberSeq;
-
-  typedef IR_ModuleDescription ModuleDescription;
-  typedef IR_ModuleDescription_var ModuleDescription_var;
-  typedef IR_ModuleDescription_out ModuleDescription_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ModuleDescription;
-
-  typedef IR_ConstantDescription ConstantDescription;
-  typedef IR_ConstantDescription_var ConstantDescription_var;
-  typedef IR_ConstantDescription_out ConstantDescription_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ConstantDescription;
-
-  typedef IR_TypedefDef TypedefDef;
-  typedef IR_TypedefDef *TypedefDef_ptr;
-  typedef IR_TypedefDef_var TypedefDef_var;
-  typedef IR_TypedefDef_out TypedefDef_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_TypedefDef;
-
-  typedef IR_TypeDescription TypeDescription;
-  typedef IR_TypeDescription_var TypeDescription_var;
-  typedef IR_TypeDescription_out TypeDescription_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_TypeDescription;
-
-  typedef IR_PrimitiveDef PrimitiveDef;
-  typedef IR_PrimitiveDef *PrimitiveDef_ptr;
-  typedef IR_PrimitiveDef_var PrimitiveDef_var;
-  typedef IR_PrimitiveDef_out PrimitiveDef_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_PrimitiveDef;
-
-  typedef IR_StringDef StringDef;
-  typedef IR_StringDef *StringDef_ptr;
-  typedef IR_StringDef_var StringDef_var;
-  typedef IR_StringDef_out StringDef_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_StringDef;
-
-  typedef IR_WstringDef WstringDef;
-  typedef IR_WstringDef *WstringDef_ptr;
-  typedef IR_WstringDef_var WstringDef_var;
-  typedef IR_WstringDef_out WstringDef_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_WstringDef;
-
-  typedef IR_FixedDef FixedDef;
-  typedef IR_FixedDef *FixedDef_ptr;
-  typedef IR_FixedDef_var FixedDef_var;
-  typedef IR_FixedDef_out FixedDef_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_FixedDef;
-
-  typedef IR_SequenceDef SequenceDef;
-  typedef IR_SequenceDef *SequenceDef_ptr;
-  typedef IR_SequenceDef_var SequenceDef_var;
-  typedef IR_SequenceDef_out SequenceDef_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_SequenceDef;
-
-  typedef IR_ArrayDef ArrayDef;
-  typedef IR_ArrayDef *ArrayDef_ptr;
-  typedef IR_ArrayDef_var ArrayDef_var;
-  typedef IR_ArrayDef_out ArrayDef_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ArrayDef;
-
-  typedef IR_ExceptionDescription ExceptionDescription;
-  typedef IR_ExceptionDescription_var ExceptionDescription_var;
-  typedef IR_ExceptionDescription_out ExceptionDescription_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ExceptionDescription;
-
-  typedef IR_ExceptionDefSeq ExceptionDefSeq;
-  typedef IR_ExceptionDefSeq_var ExceptionDefSeq_var;
-  typedef IR_ExceptionDefSeq_out ExceptionDefSeq_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ExceptionDefSeq;
-
-  typedef IR_ExcDescriptionSeq ExcDescriptionSeq;
-  typedef IR_ExcDescriptionSeq_var ExcDescriptionSeq_var;
-  typedef IR_ExcDescriptionSeq_out ExcDescriptionSeq_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ExcDescriptionSeq;
-
-  typedef IR_AttributeMode AttributeMode;
-  typedef IR_AttributeMode &AttributeMode_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_AttributeMode;
-
-  typedef IR_AttributeDef AttributeDef;
-  typedef IR_AttributeDef *AttributeDef_ptr;
-  typedef IR_AttributeDef_var AttributeDef_var;
-  typedef IR_AttributeDef_out AttributeDef_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_AttributeDef;
-
-  typedef IR_AttributeDescription AttributeDescription;
-  typedef IR_AttributeDescription_var AttributeDescription_var;
-  typedef IR_AttributeDescription_out AttributeDescription_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_AttributeDescription;
-
-  typedef IR_PrimitiveKind PrimitiveKind;
-  typedef IR_PrimitiveKind &PrimitiveKind_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_PrimitiveKind;
-
-  typedef IR_ParameterMode ParameterMode;
-  typedef IR_ParameterMode &ParameterMode_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ParameterMode;
-
-  typedef IR_ParameterDescription ParameterDescription;
-  typedef IR_ParameterDescription_var ParameterDescription_var;
-  typedef IR_ParameterDescription_out ParameterDescription_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ParameterDescription;
-
-  typedef IR_ParDescriptionSeq ParDescriptionSeq;
-  typedef IR_ParDescriptionSeq_var ParDescriptionSeq_var;
-  typedef IR_ParDescriptionSeq_out ParDescriptionSeq_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ParDescriptionSeq;
-
-  typedef IR_ContextIdSeq ContextIdSeq;
-  typedef IR_ContextIdSeq_var ContextIdSeq_var;
-  typedef IR_ContextIdSeq_out ContextIdSeq_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ContextIdSeq;
-
-  typedef IR_OperationDef OperationDef;
-  typedef IR_OperationDef *OperationDef_ptr;
-  typedef IR_OperationDef_var OperationDef_var;
-  typedef IR_OperationDef_out OperationDef_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_OperationDef;
-
-  typedef IR_OperationMode OperationMode;
-  typedef IR_OperationMode &OperationMode_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_OperationMode;
-
-  typedef IR_OperationDescription OperationDescription;
-  typedef IR_OperationDescription_var OperationDescription_var;
-  typedef IR_OperationDescription_out OperationDescription_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_OperationDescription;
-
-  typedef IR_RepositoryIdSeq RepositoryIdSeq;
-  typedef IR_RepositoryIdSeq_var RepositoryIdSeq_var;
-  typedef IR_RepositoryIdSeq_out RepositoryIdSeq_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_RepositoryIdSeq;
-
-  typedef IR_OpDescriptionSeq OpDescriptionSeq;
-  typedef IR_OpDescriptionSeq_var OpDescriptionSeq_var;
-  typedef IR_OpDescriptionSeq_out OpDescriptionSeq_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_OpDescriptionSeq;
-
-  typedef IR_AttrDescriptionSeq AttrDescriptionSeq;
-  typedef IR_AttrDescriptionSeq_var AttrDescriptionSeq_var;
-  typedef IR_AttrDescriptionSeq_out AttrDescriptionSeq_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_AttrDescriptionSeq;
-
-  typedef IR_InterfaceDescription InterfaceDescription;
-  typedef IR_InterfaceDescription_var InterfaceDescription_var;
-  typedef IR_InterfaceDescription_out InterfaceDescription_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_InterfaceDescription;
-
-  typedef IR_ValueMember ValueMember;
-  typedef IR_ValueMember_var ValueMember_var;
-  typedef IR_ValueMember_out ValueMember_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ValueMember;
-
-  typedef IR_ValueMemberSeq ValueMemberSeq;
-  typedef IR_ValueMemberSeq_var ValueMemberSeq_var;
-  typedef IR_ValueMemberSeq_out ValueMemberSeq_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ValueMemberSeq;
-
-  typedef IR_ValueMemberDef ValueMemberDef;
-  typedef IR_ValueMemberDef *ValueMemberDef_ptr;
-  typedef IR_ValueMemberDef_var ValueMemberDef_var;
-  typedef IR_ValueMemberDef_out ValueMemberDef_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ValueMemberDef;
-
-  typedef IR_ValueDescription ValueDescription;
-  typedef IR_ValueDescription_var ValueDescription_var;
-  typedef IR_ValueDescription_out ValueDescription_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ValueDescription;
-
-  typedef IR_ProvidesDescription ProvidesDescription;
-  typedef IR_ProvidesDescription_var ProvidesDescription_var;
-  typedef IR_ProvidesDescription_out ProvidesDescription_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ProvidesDescription;
-
-  typedef IR_UsesDescription UsesDescription;
-  typedef IR_UsesDescription_var UsesDescription_var;
-  typedef IR_UsesDescription_out UsesDescription_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_UsesDescription;
-
-  typedef IR_ProvidesDescSeq ProvidesDescSeq;
-  typedef IR_ProvidesDescSeq_var ProvidesDescSeq_var;
-  typedef IR_ProvidesDescSeq_out ProvidesDescSeq_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ProvidesDescSeq;
-
-  typedef IR_UsesDescSeq UsesDescSeq;
-  typedef IR_UsesDescSeq_var UsesDescSeq_var;
-  typedef IR_UsesDescSeq_out UsesDescSeq_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_UsesDescSeq;
-
-  typedef IR_EventDescription EventDescription;
-  typedef IR_EventDescription_var EventDescription_var;
-  typedef IR_EventDescription_out EventDescription_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_EventDescription;
-
-  typedef IR_ComponentDescription ComponentDescription;
-  typedef IR_ComponentDescription_var ComponentDescription_var;
-  typedef IR_ComponentDescription_out ComponentDescription_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ComponentDescription;
-
-  typedef IR_PrimaryKeyDescription PrimaryKeyDescription;
-  typedef IR_PrimaryKeyDescription_var PrimaryKeyDescription_var;
-  typedef IR_PrimaryKeyDescription_out PrimaryKeyDescription_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_PrimaryKeyDescription;
-
-  typedef IR_HomeDescription HomeDescription;
-  typedef IR_HomeDescription_var HomeDescription_var;
-  typedef IR_HomeDescription_out HomeDescription_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_HomeDescription;
-
-}
-TAO_NAMESPACE_CLOSE // module IR
-
-
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-#pragma warning(pop)
-#endif /* _MSC_VER */
-
-#include "ace/post.h"
-#endif /* TAO_IFRFWD_H */
diff --git a/TAO/tao/IFR_Client_Adapter.cpp b/TAO/tao/IFR_Client_Adapter.cpp
index 8f91080644a..6889ec13661 100644
--- a/TAO/tao/IFR_Client_Adapter.cpp
+++ b/TAO/tao/IFR_Client_Adapter.cpp
@@ -13,18 +13,23 @@ TAO_IFR_Client_Adapter::~TAO_IFR_Client_Adapter (void)
 
 CORBA::Boolean 
 TAO_IFR_Client_Adapter::interfacedef_cdr_insert (TAO_OutputCDR &,
-                                                 IR_InterfaceDef *)
+                                                 CORBA_InterfaceDef_ptr)
 {
   return 0;
 }
 
 void 
 TAO_IFR_Client_Adapter::interfacedef_any_insert (CORBA_Any &,
-                                                 IR_InterfaceDef *)
+                                                 CORBA_InterfaceDef_ptr)
 {
 }
 
-IR_InterfaceDef * 
+void
+TAO_IFR_Client_Adapter::dispose (CORBA_InterfaceDef_ptr)
+{
+}
+
+CORBA_InterfaceDef_ptr
 TAO_IFR_Client_Adapter::get_interface (CORBA::ORB_ptr,
                                        const char *,
                                        CORBA::Environment &)
@@ -32,10 +37,9 @@ TAO_IFR_Client_Adapter::get_interface (CORBA::ORB_ptr,
   return 0;
 }
 
-CORBA_IRObject_ptr
-TAO_IFR_Client_Adapter::get_interface_def (CORBA::ORB_ptr,
-                                           const char *,
-                                           CORBA::Environment &)
+CORBA_InterfaceDef_ptr
+TAO_IFR_Client_Adapter::get_interface_remote (const CORBA::Object_ptr,
+                                              CORBA_Environment &)
 {
   return 0;
 }
diff --git a/TAO/tao/IFR_Client_Adapter.h b/TAO/tao/IFR_Client_Adapter.h
index c81ee3052e2..08c200e4c4e 100644
--- a/TAO/tao/IFR_Client_Adapter.h
+++ b/TAO/tao/IFR_Client_Adapter.h
@@ -23,8 +23,6 @@
 
 #include "ace/Service_Object.h"
 
-class IR_InterfaceDef;
-
 /**
  * @class TAO_IFR_Client_Adapter
  *
@@ -32,7 +30,7 @@ class IR_InterfaceDef;
  *
  * Class that adapts various functions in the CORBA namespace
  * which use the Interface Repository. This is a base class for 
- * the actual implementation in the IFR_Basic library.
+ * the actual implementation in the TAO_IFR_Client library.
  */
 class TAO_Export TAO_IFR_Client_Adapter : public ACE_Service_Object
 {
@@ -41,27 +39,29 @@ public:
 
   virtual CORBA::Boolean interfacedef_cdr_insert (
       TAO_OutputCDR &cdr,
-      IR_InterfaceDef *object_type
+      CORBA_InterfaceDef_ptr object_type
     );
 
   virtual void interfacedef_any_insert (
       CORBA_Any &any,
-      IR_InterfaceDef *object_type
+      CORBA_InterfaceDef_ptr object_type
     );
 
-  virtual IR_InterfaceDef *get_interface (
-      CORBA::ORB_ptr orb,
-      const char *repo_id,
-      CORBA::Environment &ACE_TRY_ENV = 
-        TAO_default_environment ()
+  virtual void dispose (
+      CORBA_InterfaceDef_ptr orphan
     );
 
-  virtual CORBA_IRObject_ptr get_interface_def (
+  virtual CORBA_InterfaceDef_ptr get_interface (
       CORBA::ORB_ptr orb,
       const char *repo_id,
       CORBA::Environment &ACE_TRY_ENV = 
         TAO_default_environment ()
     );
+
+  virtual CORBA_InterfaceDef_ptr get_interface_remote (
+      const CORBA::Object_ptr target,
+      CORBA_Environment &ACE_TRY_ENV
+    );
 };
 
 #include "ace/post.h"
diff --git a/TAO/tao/IFR_TypeCodes.cpp b/TAO/tao/IFR_TypeCodes.cpp
index e5b0759346f..8bf507c9835 100644
--- a/TAO/tao/IFR_TypeCodes.cpp
+++ b/TAO/tao/IFR_TypeCodes.cpp
@@ -14,22 +14,22 @@ ACE_RCSID(tao, IFR_TypeCodes, "$Id$")
 
 TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
 TAO_NAMESPACE_BEGIN (CORBA)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_Identifier, 0)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_RepositoryId, 0)
 TAO_NAMESPACE_END
 
 TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
 TAO_NAMESPACE_BEGIN (CORBA)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ScopedName, 0)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_Identifier, 0)
 TAO_NAMESPACE_END
 
 TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
 TAO_NAMESPACE_BEGIN (CORBA)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_RepositoryId, 0)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ScopedName, 0)
 TAO_NAMESPACE_END
 
 TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
 TAO_NAMESPACE_BEGIN (CORBA)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_IRObject, 0)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_VersionSpec, 0)
 TAO_NAMESPACE_END
 
 TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
@@ -67,3 +67,324 @@ TAO_NAMESPACE_TYPE (const CORBA::ValueModifier)
 TAO_NAMESPACE_BEGIN (CORBA)
 TAO_NAMESPACE_DEFINE (const CORBA::ValueModifier, VM_TRUNCATABLE, 3)
 TAO_NAMESPACE_END
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (CORBA)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ContextIdentifier, 0)
+TAO_NAMESPACE_END
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (CORBA)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_IRObject, 0)
+TAO_NAMESPACE_END
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (CORBA)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_DefinitionKind, 0)
+TAO_NAMESPACE_END
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (CORBA)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_Contained, 0)
+TAO_NAMESPACE_END
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (CORBA)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ContainedSeq, 0)
+TAO_NAMESPACE_END
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (CORBA)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_Repository, 0)
+TAO_NAMESPACE_END
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (CORBA)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_Container, 0)
+TAO_NAMESPACE_END
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (CORBA)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ModuleDef, 0)
+TAO_NAMESPACE_END
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (CORBA)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ConstantDef, 0)
+TAO_NAMESPACE_END
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (CORBA)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_IDLType, 0)
+TAO_NAMESPACE_END
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (CORBA)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_StructDef, 0)
+TAO_NAMESPACE_END
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (CORBA)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_UnionDef, 0)
+TAO_NAMESPACE_END
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (CORBA)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_EnumDef, 0)
+TAO_NAMESPACE_END
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (CORBA)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_AliasDef, 0)
+TAO_NAMESPACE_END
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (CORBA)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_InterfaceDef, 0)
+TAO_NAMESPACE_END
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (CORBA)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_AbstractInterfaceDef, 0)
+TAO_NAMESPACE_END
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (CORBA)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_LocalInterfaceDef, 0)
+TAO_NAMESPACE_END
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (CORBA)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ExceptionDef, 0)
+TAO_NAMESPACE_END
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (CORBA)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_NativeDef, 0)
+TAO_NAMESPACE_END
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (CORBA)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_InterfaceDefSeq, 0)
+TAO_NAMESPACE_END
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (CORBA)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_AbstractInterfaceDefSeq, 0)
+TAO_NAMESPACE_END
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (CORBA)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_LocalInterfaceDefSeq, 0)
+TAO_NAMESPACE_END
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (CORBA)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ValueDef, 0)
+TAO_NAMESPACE_END
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (CORBA)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ValueDefSeq, 0)
+TAO_NAMESPACE_END
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (CORBA)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ValueBoxDef, 0)
+TAO_NAMESPACE_END
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (CORBA)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_StructMember, 0)
+TAO_NAMESPACE_END
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (CORBA)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_StructMemberSeq, 0)
+TAO_NAMESPACE_END
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (CORBA)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_Initializer, 0)
+TAO_NAMESPACE_END
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (CORBA)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_InitializerSeq, 0)
+TAO_NAMESPACE_END
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (CORBA)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_UnionMember, 0)
+TAO_NAMESPACE_END
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (CORBA)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_UnionMemberSeq, 0)
+TAO_NAMESPACE_END
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (CORBA)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_EnumMemberSeq, 0)
+TAO_NAMESPACE_END
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (CORBA)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ModuleDescription, 0)
+TAO_NAMESPACE_END
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (CORBA)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ConstantDescription, 0)
+TAO_NAMESPACE_END
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (CORBA)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_TypedefDef, 0)
+TAO_NAMESPACE_END
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (CORBA)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_TypeDescription, 0)
+TAO_NAMESPACE_END
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (CORBA)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_PrimitiveDef, 0)
+TAO_NAMESPACE_END
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (CORBA)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_StringDef, 0)
+TAO_NAMESPACE_END
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (CORBA)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_WstringDef, 0)
+TAO_NAMESPACE_END
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (CORBA)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_FixedDef, 0)
+TAO_NAMESPACE_END
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (CORBA)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_SequenceDef, 0)
+TAO_NAMESPACE_END
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (CORBA)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ArrayDef, 0)
+TAO_NAMESPACE_END
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (CORBA)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ExceptionDescription, 0)
+TAO_NAMESPACE_END
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (CORBA)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ExceptionDefSeq, 0)
+TAO_NAMESPACE_END
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (CORBA)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ExcDescriptionSeq, 0)
+TAO_NAMESPACE_END
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (CORBA)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_AttributeMode, 0)
+TAO_NAMESPACE_END
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (CORBA)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_AttributeDef, 0)
+TAO_NAMESPACE_END
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (CORBA)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_AttributeDescription, 0)
+TAO_NAMESPACE_END
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (CORBA)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_PrimitiveKind, 0)
+TAO_NAMESPACE_END
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (CORBA)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ParameterMode, 0)
+TAO_NAMESPACE_END
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (CORBA)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ParameterDescription, 0)
+TAO_NAMESPACE_END
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (CORBA)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ParDescriptionSeq, 0)
+TAO_NAMESPACE_END
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (CORBA)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ContextIdSeq, 0)
+TAO_NAMESPACE_END
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (CORBA)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_OperationDef, 0)
+TAO_NAMESPACE_END
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (CORBA)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_OperationMode, 0)
+TAO_NAMESPACE_END
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (CORBA)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_OperationDescription, 0)
+TAO_NAMESPACE_END
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (CORBA)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_RepositoryIdSeq, 0)
+TAO_NAMESPACE_END
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (CORBA)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_OpDescriptionSeq, 0)
+TAO_NAMESPACE_END
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (CORBA)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_AttrDescriptionSeq, 0)
+TAO_NAMESPACE_END
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (CORBA)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_InterfaceDescription, 0)
+TAO_NAMESPACE_END
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (CORBA)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ValueMember, 0)
+TAO_NAMESPACE_END
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (CORBA)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ValueMemberSeq, 0)
+TAO_NAMESPACE_END
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (CORBA)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ValueMemberDef, 0)
+TAO_NAMESPACE_END
+
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (CORBA)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ValueDescription, 0)
+TAO_NAMESPACE_END
+
diff --git a/TAO/tao/LocalObject.cpp b/TAO/tao/LocalObject.cpp
index 605e60c2e20..87e479d5867 100644
--- a/TAO/tao/LocalObject.cpp
+++ b/TAO/tao/LocalObject.cpp
@@ -131,22 +131,7 @@ CORBA_LocalObject::_request (const CORBA::Char *,
   ACE_THROW_RETURN (CORBA::NO_IMPLEMENT (), 0);
 }
 
-CORBA_IRObject_ptr
-CORBA_LocalObject::_get_interface_def (CORBA_Environment &ACE_TRY_ENV)
-{
-  TAO_IFR_Client_Adapter *adapter =
-    ACE_Dynamic_Service<TAO_IFR_Client_Adapter>::instance (
-        TAO_ORB_Core::ifr_client_adapter_name ()
-      );
-
-  CORBA::ORB_var orb = this->_stubobj ()->servant_orb_var ();
-
-  return adapter->get_interface_def (orb.in (),
-                                     this->_interface_repository_id (),
-                                     ACE_TRY_ENV);
-}
-
-IR_InterfaceDef *
+CORBA_InterfaceDef_ptr
 CORBA_LocalObject::_get_interface (CORBA_Environment &ACE_TRY_ENV)
 {
   TAO_IFR_Client_Adapter *adapter =
diff --git a/TAO/tao/LocalObject.h b/TAO/tao/LocalObject.h
index c513483fd53..a28279b84c7 100644
--- a/TAO/tao/LocalObject.h
+++ b/TAO/tao/LocalObject.h
@@ -72,13 +72,8 @@ public:
       _get_implementation (CORBA_Environment &ACE_TRY_ENV =
                              TAO_default_environment ());
 
-  /// From CORBA 2.x version of Interface Repository spec.
-  virtual CORBA_IRObject_ptr _get_interface_def (
-      CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-    );
-
-  /// From CORBA 3.x (CORBA Components) version of IFR spec.
-  virtual IR_InterfaceDef *_get_interface (
+  /// Gets info about object from the Interface Repository.
+  virtual CORBA_InterfaceDef_ptr _get_interface (
       CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
     );
 
@@ -108,7 +103,7 @@ public:
   /// throws NO_IMPLEMENT.
   virtual CORBA::Request_ptr _request (const CORBA::Char *operation,
                                        CORBA_Environment &ACE_TRY_ENV =
-                                        TAO_default_environment ());
+                                         TAO_default_environment ());
 
 #endif /* TAO_HAS_MINIMUM_CORBA */
 
diff --git a/TAO/tao/Makefile b/TAO/tao/Makefile
index cf781c11eec..6f8a50bb04f 100644
--- a/TAO/tao/Makefile
+++ b/TAO/tao/Makefile
@@ -16,7 +16,8 @@ DIRS = \
   IORManipulation \
   IORTable \
   Strategies \
-  SmartProxies
+  SmartProxies \
+  TypeCodeFactory
 
 # These are headers for things which are exported and must be
 # installed.  (Currently not used).
@@ -186,6 +187,7 @@ ORB_CORE_FILES = \
   TAO_Internal \
   TAO_Server_Request \
   Typecode_Constants \
+  TypeCodeFactory_Adapter \
   Single_Reactor \
   Wait_Strategy \
   Wait_On_Read \
@@ -276,10 +278,9 @@ ORB_CORE_FILES += \
   Services \
   NVList \
   IFR_Client_Adapter \
-  Dynamic_Adapter
-
-INTERFACE_REPO_FILES += \
-  IFR_TypeCodes
+  IFR_TypeCodes \
+  Dynamic_Adapter \
+  DynamicInterface_Adapter
 
 endif # minimum_corba
 
@@ -386,7 +387,7 @@ all.nested: all.local
 include $(ACE_ROOT)/include/makeinclude/macros.GNU
 
 ifneq ($(ACE_HAS_GNUG_PRE_2_8),1)
-  DIRS += IFR_Client Domain
+  DIRS += IFR_Client Domain TypeCodeFactory
 endif # ACE_HAS_GNUG_PRE_2_8
 
 include $(ACE_ROOT)/include/makeinclude/rules.common.GNU
diff --git a/TAO/tao/Makefile.am b/TAO/tao/Makefile.am
index aa90885e1bc..52ff87d885a 100644
--- a/TAO/tao/Makefile.am
+++ b/TAO/tao/Makefile.am
@@ -114,8 +114,10 @@ ORB_CORE_FILES = \
   CDR.cpp \
   Client_Strategy_Factory.cpp \
   debug.cpp \
+  DynamicInterface_Adapter.cpp \
   Object_KeyC.cpp \
-  IFR_TypeCodes \
+  IFR_Client_Adapter.cpp \
+  IFR_TypeCodes.cpp \
   Invocation.cpp \
   Interceptor.cpp \
   InterceptorC.cpp \
@@ -139,6 +141,7 @@ ORB_CORE_FILES = \
   Sync_Strategies.cpp \
   TAO_Internal.cpp \
   Typecode_Constants.cpp \
+  TypeCodeFactory_Adapter.cpp \
   IOR_LookupTable.cpp \
   TAO.cpp \
   Wait_Strategy.cpp \
@@ -273,20 +276,14 @@ HEADER_FILES = \
   Direct_Priority_Mapping.h \
   DomainC.h \
   DomainS_T.h \
-  DynAnyC.h \
-  DynAny_i.h \
-  DynArray_i.h \
-  DynEnum_i.h \
-  DynSequence_i.h \
-  DynStruct_i.h \
-  DynUnion_i.h \
-  DynUnion_i_T.h \
+  DynamicInterface_Adapter.h \
   Environment.h \
   Exception.h \
   Forwarding_Servant.h \
   GIOP.h \
   GIOPC.h \
   GIOP_Server_Request.h \
+  IFR_Client_Adapter.h \
   IIOP_Acceptor.h \
   IIOP_Connect.h \
   IIOP_Connector.h \
@@ -371,6 +368,7 @@ HEADER_FILES = \
   TimeBaseS_T.h \
   Timeprobe.h \
   Typecode.h \
+  TypeCodeFactory_Adapter.h \
   UIOP_Acceptor.h \
   UIOP_Connect.h \
   UIOP_Connector.h \
@@ -428,7 +426,6 @@ INLINE_FILES = \
   Direct_Priority_Mapping.i \
   DomainC.i \
   DomainS_T.i \
-  DynAnyC.i \
   Environment.i \
   Exception.i \
   GIOP.i \
diff --git a/TAO/tao/Makefile.bor b/TAO/tao/Makefile.bor
index 1bdfbc8ce5a..98ec17ffdca 100644
--- a/TAO/tao/Makefile.bor
+++ b/TAO/tao/Makefile.bor
@@ -13,6 +13,7 @@ DIRS = \
 	Strategies \
         IFR_Client \
         Domain \
+        TypeCodeFactory \
         SmartProxies
 
 OBJFILES = \
diff --git a/TAO/tao/ORB.cpp b/TAO/tao/ORB.cpp
index 83580f21b20..367949de410 100644
--- a/TAO/tao/ORB.cpp
+++ b/TAO/tao/ORB.cpp
@@ -27,6 +27,8 @@
 
 #include "CodecFactory_ORBInitializer.h"
 
+#include "TypeCodeFactory_Adapter.h"
+
 #if TAO_HAS_RT_CORBA == 1
 # include "RT_ORBInitializer.h"         /* @@ This should go away! */
 #endif  /* TAO_HAS_RT_CORBA == 1 */
@@ -1551,6 +1553,328 @@ CORBA_ORB::create_policy (CORBA::PolicyType type,
 
 // ****************************************************************
 
+CORBA::TypeCode_ptr 
+CORBA_ORB::create_struct_tc (
+    const char *id,
+    const char *name,
+    const CORBA_StructMemberSeq & members,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  TAO_TypeCodeFactory_Adapter *adapter =
+    ACE_Dynamic_Service<TAO_TypeCodeFactory_Adapter>::instance (
+        TAO_ORB_Core::typecodefactory_adapter_name ()
+      );
+
+  return adapter->create_struct_tc (id,
+                                    name,
+                                    members,
+                                    ACE_TRY_ENV);              
+}
+
+CORBA::TypeCode_ptr 
+CORBA_ORB::create_union_tc (
+    const char *id,
+    const char *name,
+    CORBA::TypeCode_ptr discriminator_type,
+    const CORBA_UnionMemberSeq & members,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  TAO_TypeCodeFactory_Adapter *adapter =
+    ACE_Dynamic_Service<TAO_TypeCodeFactory_Adapter>::instance (
+        TAO_ORB_Core::typecodefactory_adapter_name ()
+      );
+
+  return adapter->create_union_tc (id,
+                                   name,
+                                   discriminator_type,
+                                   members,
+                                   ACE_TRY_ENV);              
+}
+
+CORBA::TypeCode_ptr 
+CORBA_ORB::create_enum_tc (
+    const char *id,
+    const char *name,
+    const CORBA_EnumMemberSeq & members,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  TAO_TypeCodeFactory_Adapter *adapter =
+    ACE_Dynamic_Service<TAO_TypeCodeFactory_Adapter>::instance (
+        TAO_ORB_Core::typecodefactory_adapter_name ()
+      );
+
+  return adapter->create_enum_tc (id,
+                                  name,
+                                  members,
+                                  ACE_TRY_ENV);              
+}
+
+CORBA::TypeCode_ptr 
+CORBA_ORB::create_alias_tc (
+    const char *id,
+    const char *name,
+    CORBA::TypeCode_ptr original_type,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  TAO_TypeCodeFactory_Adapter *adapter =
+    ACE_Dynamic_Service<TAO_TypeCodeFactory_Adapter>::instance (
+        TAO_ORB_Core::typecodefactory_adapter_name ()
+      );
+
+  return adapter->create_alias_tc (id,
+                                   name,
+                                   original_type,
+                                   ACE_TRY_ENV);              
+}
+
+CORBA::TypeCode_ptr 
+CORBA_ORB::create_exception_tc (
+    const char *id,
+    const char *name,
+    const CORBA_StructMemberSeq & members,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  TAO_TypeCodeFactory_Adapter *adapter =
+    ACE_Dynamic_Service<TAO_TypeCodeFactory_Adapter>::instance (
+        TAO_ORB_Core::typecodefactory_adapter_name ()
+      );
+
+  return adapter->create_exception_tc (id,
+                                       name,
+                                       members,
+                                       ACE_TRY_ENV);              
+}
+
+CORBA::TypeCode_ptr 
+CORBA_ORB::create_interface_tc (
+    const char *id,
+    const char *name,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  TAO_TypeCodeFactory_Adapter *adapter =
+    ACE_Dynamic_Service<TAO_TypeCodeFactory_Adapter>::instance (
+        TAO_ORB_Core::typecodefactory_adapter_name ()
+      );
+
+  return adapter->create_interface_tc (id,
+                                       name,
+                                       ACE_TRY_ENV);              
+}
+
+CORBA::TypeCode_ptr 
+CORBA_ORB::create_string_tc (
+    CORBA::ULong bound,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  TAO_TypeCodeFactory_Adapter *adapter =
+    ACE_Dynamic_Service<TAO_TypeCodeFactory_Adapter>::instance (
+        TAO_ORB_Core::typecodefactory_adapter_name ()
+      );
+
+  return adapter->create_string_tc (bound,
+                                    ACE_TRY_ENV);              
+}
+
+CORBA::TypeCode_ptr 
+CORBA_ORB::create_wstring_tc (
+    CORBA::ULong bound,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  TAO_TypeCodeFactory_Adapter *adapter =
+    ACE_Dynamic_Service<TAO_TypeCodeFactory_Adapter>::instance (
+        TAO_ORB_Core::typecodefactory_adapter_name ()
+      );
+
+  return adapter->create_wstring_tc (bound,
+                                     ACE_TRY_ENV);              
+}
+
+CORBA::TypeCode_ptr 
+CORBA_ORB::create_fixed_tc (
+    CORBA::UShort digits,
+    CORBA::UShort scale,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  TAO_TypeCodeFactory_Adapter *adapter =
+    ACE_Dynamic_Service<TAO_TypeCodeFactory_Adapter>::instance (
+        TAO_ORB_Core::typecodefactory_adapter_name ()
+      );
+
+  return adapter->create_fixed_tc (digits,
+                                   scale,
+                                   ACE_TRY_ENV);              
+}
+
+CORBA::TypeCode_ptr 
+CORBA_ORB::create_sequence_tc (
+    CORBA::ULong bound,
+    CORBA::TypeCode_ptr element_type,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  TAO_TypeCodeFactory_Adapter *adapter =
+    ACE_Dynamic_Service<TAO_TypeCodeFactory_Adapter>::instance (
+        TAO_ORB_Core::typecodefactory_adapter_name ()
+      );
+
+  return adapter->create_sequence_tc (bound,
+                                      element_type,
+                                      ACE_TRY_ENV);              
+}
+
+CORBA::TypeCode_ptr 
+CORBA_ORB::create_array_tc (
+    CORBA::ULong length,
+    CORBA::TypeCode_ptr element_type,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  TAO_TypeCodeFactory_Adapter *adapter =
+    ACE_Dynamic_Service<TAO_TypeCodeFactory_Adapter>::instance (
+        TAO_ORB_Core::typecodefactory_adapter_name ()
+      );
+
+  return adapter->create_array_tc (length,
+                                   element_type,
+                                   ACE_TRY_ENV);              
+}
+
+CORBA::TypeCode_ptr 
+CORBA_ORB::create_value_tc (
+    const char *id,
+    const char *name,
+    CORBA::ValueModifier type_modifier,
+    CORBA::TypeCode_ptr concrete_base,
+    const CORBA_ValueMemberSeq & members,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  TAO_TypeCodeFactory_Adapter *adapter =
+    ACE_Dynamic_Service<TAO_TypeCodeFactory_Adapter>::instance (
+        TAO_ORB_Core::typecodefactory_adapter_name ()
+      );
+
+  return adapter->create_value_tc (id,
+                                   name,
+                                   type_modifier,
+                                   concrete_base,
+                                   members,
+                                   ACE_TRY_ENV);              
+}
+
+CORBA::TypeCode_ptr 
+CORBA_ORB::create_value_box_tc (
+    const char *id,
+    const char *name,
+    CORBA::TypeCode_ptr boxed_type,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  TAO_TypeCodeFactory_Adapter *adapter =
+    ACE_Dynamic_Service<TAO_TypeCodeFactory_Adapter>::instance (
+        TAO_ORB_Core::typecodefactory_adapter_name ()
+      );
+
+  return adapter->create_value_box_tc (id,
+                                       name,
+                                       boxed_type,
+                                       ACE_TRY_ENV);              
+}
+
+CORBA::TypeCode_ptr 
+CORBA_ORB::create_native_tc (
+    const char *id,
+    const char *name,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  TAO_TypeCodeFactory_Adapter *adapter =
+    ACE_Dynamic_Service<TAO_TypeCodeFactory_Adapter>::instance (
+        TAO_ORB_Core::typecodefactory_adapter_name ()
+      );
+
+  return adapter->create_native_tc (id,
+                                    name,
+                                    ACE_TRY_ENV);              
+}
+
+CORBA::TypeCode_ptr 
+CORBA_ORB::create_recursive_tc (
+    const char *id,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  TAO_TypeCodeFactory_Adapter *adapter =
+    ACE_Dynamic_Service<TAO_TypeCodeFactory_Adapter>::instance (
+        TAO_ORB_Core::typecodefactory_adapter_name ()
+      );
+
+  return adapter->create_recursive_tc (id,
+                                       ACE_TRY_ENV);              
+}
+
+CORBA::TypeCode_ptr 
+CORBA_ORB::create_abstract_interface_tc (
+    const char *id,
+    const char *name,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  TAO_TypeCodeFactory_Adapter *adapter =
+    ACE_Dynamic_Service<TAO_TypeCodeFactory_Adapter>::instance (
+        TAO_ORB_Core::typecodefactory_adapter_name ()
+      );
+
+  return adapter->create_abstract_interface_tc (id,
+                                                name,
+                                                ACE_TRY_ENV);
+}
+
+CORBA::TypeCode_ptr 
+CORBA_ORB::create_local_interface_tc (
+    const char *id,
+    const char *name,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  TAO_TypeCodeFactory_Adapter *adapter =
+    ACE_Dynamic_Service<TAO_TypeCodeFactory_Adapter>::instance (
+        TAO_ORB_Core::typecodefactory_adapter_name ()
+      );
+
+  return adapter->create_local_interface_tc (id,
+                                             name,
+                                             ACE_TRY_ENV);
+}
+
+// ****************************************************************
+
 // Destringify OMG-specified "IOR" string.
 //
 // XXX there should be a simple way to reuse this code in other ORB
diff --git a/TAO/tao/ORB.h b/TAO/tao/ORB.h
index b79362babc0..83f21a5e732 100644
--- a/TAO/tao/ORB.h
+++ b/TAO/tao/ORB.h
@@ -313,6 +313,152 @@ public:
                                    CORBA_Environment &ACE_TRY_ENV =
                                        TAO_default_environment ());
 
+  /// The ORB TypeCode creation functions.
+
+  CORBA::TypeCode_ptr create_struct_tc (
+      const char *id,
+      const char *name,
+      const CORBA::StructMemberSeq &members,
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+  CORBA::TypeCode_ptr create_union_tc (
+      const char *id,
+      const char *name,
+      CORBA::TypeCode_ptr discriminator_type,
+      const CORBA::UnionMemberSeq &members,
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+  CORBA::TypeCode_ptr create_enum_tc (
+      const char *id,
+      const char *name,
+      const CORBA::EnumMemberSeq &members,
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+  CORBA::TypeCode_ptr create_alias_tc (
+      const char *id,
+      const char *name,
+      CORBA::TypeCode_ptr original_type,
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+  CORBA::TypeCode_ptr create_exception_tc (
+      const char *id,
+      const char *name,
+      const CORBA::StructMemberSeq &members,
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+  CORBA::TypeCode_ptr create_interface_tc (
+      const char *id,
+      const char *name,
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+  CORBA::TypeCode_ptr create_string_tc (
+      CORBA::ULong bound,
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+  CORBA::TypeCode_ptr create_wstring_tc (
+      CORBA::ULong bound,
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+  CORBA::TypeCode_ptr create_fixed_tc (
+      CORBA::UShort digits,
+      CORBA::UShort scale,
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+  CORBA::TypeCode_ptr create_sequence_tc (
+      CORBA::ULong bound,
+      CORBA::TypeCode_ptr element_type,
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+  CORBA::TypeCode_ptr create_array_tc (
+      CORBA::ULong length,
+      CORBA::TypeCode_ptr element_type,
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+  CORBA::TypeCode_ptr create_value_tc (
+      const char *id,
+      const char *name,
+      CORBA::ValueModifier type_modifier,
+      CORBA::TypeCode_ptr concrete_base,
+      const CORBA::ValueMemberSeq &members,
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+  CORBA::TypeCode_ptr create_value_box_tc (
+      const char *id,
+      const char *name,
+      CORBA::TypeCode_ptr boxed_type,
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+  CORBA::TypeCode_ptr create_native_tc (
+      const char *id,
+      const char *name,
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+  CORBA::TypeCode_ptr create_recursive_tc (
+      const char *id,
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+  CORBA::TypeCode_ptr create_abstract_interface_tc (
+      const char *id,
+      const char *name,
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+    
+  CORBA::TypeCode_ptr create_local_interface_tc (
+      const char *id,
+      const char *ame,
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
   // ----------------------------------------------------------------
   // = TAO-specific extensions to the CORBA specification.
   // ----------------------------------------------------------------
diff --git a/TAO/tao/ORB_Core.cpp b/TAO/tao/ORB_Core.cpp
index ce7b45eeafe..3cbb92472f4 100644
--- a/TAO/tao/ORB_Core.cpp
+++ b/TAO/tao/ORB_Core.cpp
@@ -60,11 +60,17 @@ TAO_default_environment ()
 
 TAO_ORB_Core::Timeout_Hook TAO_ORB_Core::timeout_hook_ = 0;
 TAO_ORB_Core::Sync_Scope_Hook TAO_ORB_Core::sync_scope_hook_ = 0;
-const char * TAO_ORB_Core::resource_factory_name_ = "Resource_Factory";
-const char * TAO_ORB_Core::protocols_hooks_name_ = "Protocols_Hooks";
-const char * TAO_ORB_Core::dynamic_adapter_name_ = "Dynamic_Adapter";
-const char * TAO_ORB_Core::ifr_client_adapter_name_ = "IFR_Client_Adapter";
 
+const char * TAO_ORB_Core::resource_factory_name_ = 
+  "Resource_Factory";
+const char * TAO_ORB_Core::protocols_hooks_name_ = 
+  "Protocols_Hooks";
+const char * TAO_ORB_Core::dynamic_adapter_name_ = 
+  "Dynamic_Adapter";
+const char * TAO_ORB_Core::ifr_client_adapter_name_ = 
+  "IFR_Client_Adapter";
+const char * TAO_ORB_Core::typecodefactory_adapter_name_ = 
+  "TypeCodeFactory_Adapter";
 
 TAO_ORB_Core::TAO_ORB_Core (const char *orbid)
   : protocols_hooks_ (0),
@@ -1275,6 +1281,18 @@ TAO_ORB_Core::ifr_client_adapter_name (void)
   return TAO_ORB_Core::ifr_client_adapter_name_;
 }
 
+void
+TAO_ORB_Core::typecodefactory_adapter_name (const char *name)
+{
+  TAO_ORB_Core::typecodefactory_adapter_name_ = name;
+}
+
+const char *
+TAO_ORB_Core::typecodefactory_adapter_name (void)
+{
+  return TAO_ORB_Core::typecodefactory_adapter_name_;
+}
+
 TAO_Resource_Factory *
 TAO_ORB_Core::resource_factory (void)
 {
@@ -2151,9 +2169,9 @@ TAO_ORB_Core::resolve_typecodefactory_i (CORBA::Environment &ACE_TRY_ENV)
   if (loader == 0)
     {
       ACE_Service_Config::process_directive (
-                                             "dynamic TypeCodeFactory Service_Object *"
-                                             "TypeCodeFactory_DLL:_make_TCF_Loader()"
-                                             );
+          "dynamic TypeCodeFactory Service_Object *"
+          "TAO_TypeCodeFactory:_make_TAO_TypeCodeFactory_Loader()"
+        );
       loader =
         ACE_Dynamic_Service<TAO_Object_Loader>::instance ("TypeCodeFactory");
       if (loader == 0)
diff --git a/TAO/tao/ORB_Core.h b/TAO/tao/ORB_Core.h
index c27a6c4b305..3b657f9ea02 100644
--- a/TAO/tao/ORB_Core.h
+++ b/TAO/tao/ORB_Core.h
@@ -390,6 +390,12 @@ public:
   /// Gets the value of TAO_ORB_Core::ifr_client_adapter_name_.
   static const char *ifr_client_adapter_name (void);
 
+  /// Sets the value of TAO_ORB_Core::typecodefactory_adapter_name_.
+  static void typecodefactory_adapter_name (const char *name);
+
+  /// Gets the value of TAO_ORB_Core::typecodefactory_adapter_name_.
+  static const char *typecodefactory_adapter_name (void);
+
   /// See if we have a collocated address, if yes, return the POA
   /// associated with the address.
   int is_collocated (const TAO_MProfile& mprofile);
@@ -997,6 +1003,13 @@ protected:
   // called to set the value to "Concrete_IFR_Client_Adapter".
   static const char *ifr_client_adapter_name_;
 
+  // Name of the service object used by the ORB create_*_tc functions.
+  // The default value is "TypeCodeFactory_Adapter". If the
+  // TypeCodeFactory library is linked, the corresponding accessor
+  // function typecodefactory_adapter_name() will be called to set
+  // the value to "Concrete_TypeCodeFactory_Adapter".
+  static const char *typecodefactory_adapter_name_;
+
   // @@ This is not needed since the default resource factory
   //    is staticaly added to the service configurator.
   /// TRUE if <resource_factory_> was obtained from the Service
diff --git a/TAO/tao/ORB_Core.i b/TAO/tao/ORB_Core.i
index b84892c001d..3fefd0b6264 100644
--- a/TAO/tao/ORB_Core.i
+++ b/TAO/tao/ORB_Core.i
@@ -476,13 +476,6 @@ TAO_ORB_Core::resolve_typecodefactory (CORBA::Environment &ACE_TRY_ENV)
   return CORBA::Object::_duplicate (this->typecode_factory_);
 }
 
-/*ACE_INLINE void
-TAO_ORB_Core::typecode_factory (const CORBA::Object_ptr tf)
-{
-  this->typecode_factory_ = tf;
-}
-*/
-
 ACE_INLINE CORBA::Object_ptr
 TAO_ORB_Core::resolve_dynanyfactory (CORBA::Environment &ACE_TRY_ENV)
 {
diff --git a/TAO/tao/Object.cpp b/TAO/tao/Object.cpp
index 1e9dee79503..61eb9ca0b44 100644
--- a/TAO/tao/Object.cpp
+++ b/TAO/tao/Object.cpp
@@ -367,34 +367,17 @@ CORBA_Object::_non_existent (CORBA::Environment &ACE_TRY_ENV)
   return _tao_retval;
 }
 
-CORBA_IRObject_ptr
-CORBA_Object::_get_interface_def (CORBA::Environment &ACE_TRY_ENV)
-{
-  TAO_IFR_Client_Adapter *adapter =
-    ACE_Dynamic_Service<TAO_IFR_Client_Adapter>::instance (
-        TAO_ORB_Core::ifr_client_adapter_name ()
-      );
-
-  CORBA::ORB_var orb = this->_stubobj ()->servant_orb_var ();
 
-  return adapter->get_interface_def (orb.in (),
-                                     this->_interface_repository_id (),
-                                     ACE_TRY_ENV);
-}
-
-IR_InterfaceDef *
+CORBA_InterfaceDef_ptr
 CORBA_Object::_get_interface (CORBA::Environment &ACE_TRY_ENV)
 {
-  TAO_IFR_Client_Adapter *adapter =
-    ACE_Dynamic_Service<TAO_IFR_Client_Adapter>::instance (
-        TAO_ORB_Core::ifr_client_adapter_name ()
-      );
-
-  CORBA::ORB_var orb = this->_stubobj ()->servant_orb_var ();
+  // Get the right Proxy.
+  TAO_Object_Proxy_Impl &the_proxy =
+    this->proxy_broker_->select_proxy (this, ACE_TRY_ENV);
+  ACE_CHECK_RETURN (0);
 
-  return adapter->get_interface (orb.in (),
-                                 this->_interface_repository_id (),
-                                 ACE_TRY_ENV);
+  // Perform the Call.
+  return the_proxy._get_interface (this, ACE_TRY_ENV);
 }
 
 CORBA::ImplementationDef_ptr
diff --git a/TAO/tao/Object.h b/TAO/tao/Object.h
index 45bc9195ce3..4cb7107a512 100644
--- a/TAO/tao/Object.h
+++ b/TAO/tao/Object.h
@@ -30,7 +30,6 @@
 # pragma once
 #endif /* ACE_LACKS_PRAGMA_ONCE */
 
-class IR_InterfaceDef;
 class TAO_Stub;
 
 class TAO_Abstract_ServantBase;
@@ -94,18 +93,12 @@ public:
         TAO_default_environment ()
     );
 
-  virtual CORBA_IRObject_ptr _get_interface_def (
+  /// Get info about the object from the Interface Repository.
+  virtual CORBA_InterfaceDef_ptr _get_interface (
       CORBA_Environment &ACE_TRY_ENV =
         TAO_default_environment ()
     );
 
-  virtual IR_InterfaceDef *_get_interface (
-      CORBA_Environment &ACE_TRY_ENV =
-        TAO_default_environment ()
-    );
-
-  // Interface repository related operations.
-
   // DII operations to create a request.
   //
   // The mapping for create_request is split into two forms,
diff --git a/TAO/tao/Object_Proxy_Impl.h b/TAO/tao/Object_Proxy_Impl.h
index 1f6f3f3703b..97a28bee81d 100644
--- a/TAO/tao/Object_Proxy_Impl.h
+++ b/TAO/tao/Object_Proxy_Impl.h
@@ -44,6 +44,11 @@ public:
   virtual CORBA::Boolean _non_existent (const CORBA::Object_ptr target,
                                         CORBA_Environment &ACE_TRY_ENV) = 0;
 
+  virtual CORBA_InterfaceDef_ptr _get_interface (
+      const CORBA::Object_ptr target,
+      CORBA_Environment &ACE_TRY_ENV
+    ) = 0;
+
 #endif /* TAO_HAS_MINIMUM_CORBA == 0 */
 
 protected:
diff --git a/TAO/tao/Remote_Object_Proxy_Broker.cpp b/TAO/tao/Remote_Object_Proxy_Broker.cpp
index eaca853dd7a..af9997ad750 100644
--- a/TAO/tao/Remote_Object_Proxy_Broker.cpp
+++ b/TAO/tao/Remote_Object_Proxy_Broker.cpp
@@ -21,9 +21,9 @@ TAO_Remote_Object_Proxy_Broker::~TAO_Remote_Object_Proxy_Broker (void)
   // No-Op.
 }
 
-TAO_Object_Proxy_Impl 
-&TAO_Remote_Object_Proxy_Broker::select_proxy (CORBA::Object_ptr,
-               CORBA::Environment &)
+TAO_Object_Proxy_Impl &
+TAO_Remote_Object_Proxy_Broker::select_proxy (CORBA::Object_ptr,
+                                              CORBA::Environment &)
 {
   return this->remote_proxy_impl_;
 }
diff --git a/TAO/tao/Remote_Object_Proxy_Impl.cpp b/TAO/tao/Remote_Object_Proxy_Impl.cpp
index 0de86840fdb..9953a9b6210 100644
--- a/TAO/tao/Remote_Object_Proxy_Impl.cpp
+++ b/TAO/tao/Remote_Object_Proxy_Impl.cpp
@@ -5,6 +5,9 @@
 #include "tao/Any.h"
 #include "tao/Stub.h"
 #include "tao/Invocation.h"
+#include "tao/IFR_Client_Adapter.h"
+
+#include "ace/Dynamic_Service.h"
 
 ACE_RCSID(tao, TAO_Remote_Object_Proxy_Impl, "$Id$")
 
@@ -90,8 +93,9 @@ TAO_Remote_Object_Proxy_Impl::_is_a (const CORBA::Object_ptr target,
 
 #if (TAO_HAS_MINIMUM_CORBA == 0)
 
-CORBA::Boolean TAO_Remote_Object_Proxy_Impl::_non_existent (const CORBA::Object_ptr target,
-                                                            CORBA_Environment &ACE_TRY_ENV)
+CORBA::Boolean 
+TAO_Remote_Object_Proxy_Impl::_non_existent (const CORBA::Object_ptr target,
+                                             CORBA_Environment &ACE_TRY_ENV)
 {
   CORBA::Boolean _tao_retval = 0;
 
@@ -160,4 +164,23 @@ CORBA::Boolean TAO_Remote_Object_Proxy_Impl::_non_existent (const CORBA::Object_
   return _tao_retval;
 }
 
+CORBA_InterfaceDef_ptr
+TAO_Remote_Object_Proxy_Impl::_get_interface (const CORBA::Object_ptr target,
+                                              CORBA_Environment &ACE_TRY_ENV)
+{
+  TAO_IFR_Client_Adapter *adapter =
+    ACE_Dynamic_Service<TAO_IFR_Client_Adapter>::instance (
+        TAO_ORB_Core::ifr_client_adapter_name ()
+      );
+
+  if (adapter == 0)
+    {
+      ACE_THROW_RETURN (CORBA::INTF_REPOS (),
+                        0);
+    }
+
+  return adapter->get_interface_remote (target,
+                                        ACE_TRY_ENV);
+}
+
 #endif /* TAO_HAS_MINIMUM_CORBA == 0 */
diff --git a/TAO/tao/Remote_Object_Proxy_Impl.h b/TAO/tao/Remote_Object_Proxy_Impl.h
index 586f2c93cf5..94dddb2c76c 100644
--- a/TAO/tao/Remote_Object_Proxy_Impl.h
+++ b/TAO/tao/Remote_Object_Proxy_Impl.h
@@ -46,6 +46,11 @@ public:
   virtual CORBA::Boolean _non_existent (const CORBA::Object_ptr target,
                                         CORBA_Environment &ACE_TRY_ENV);
 
+  virtual CORBA_InterfaceDef_ptr _get_interface (
+      const CORBA::Object_ptr target,
+      CORBA_Environment &ACE_TRY_ENV
+    );
+
 #endif /* TAO_HAS_MINIMUM_CORBA == 0 */
 
 };
diff --git a/TAO/tao/TAO.dsp b/TAO/tao/TAO.dsp
index b8e62d48e3f..95b557ef39c 100644
--- a/TAO/tao/TAO.dsp
+++ b/TAO/tao/TAO.dsp
@@ -263,14 +263,6 @@ SOURCE=.\CodecFactory_ORBInitializer.cpp
 # End Source File

 # Begin Source File

 

-SOURCE=.\Transport_Cache_Manager.cpp

-# End Source File

-# Begin Source File

-

-SOURCE=.\Transport_Descriptor_Interface.cpp

-# End Source File

-# Begin Source File

-

 SOURCE=.\Connection_Handler.cpp

 # End Source File

 # Begin Source File

@@ -827,6 +819,14 @@ SOURCE=.\Transport.cpp
 # End Source File

 # Begin Source File

 

+SOURCE=.\Transport_Cache_Manager.cpp

+# End Source File

+# Begin Source File

+

+SOURCE=.\Transport_Descriptor_Interface.cpp

+# End Source File

+# Begin Source File

+

 SOURCE=.\Transport_Mux_Strategy.cpp

 # End Source File

 # Begin Source File

@@ -839,6 +839,10 @@ SOURCE=.\Typecode_Constants.cpp
 # End Source File

 # Begin Source File

 

+SOURCE=.\TypeCodeFactory_Adapter.cpp

+# End Source File

+# Begin Source File

+

 SOURCE=.\ValueBase.cpp

 # End Source File

 # Begin Source File

@@ -983,14 +987,6 @@ SOURCE=.\CodecFactory_ORBInitializer.h
 # End Source File

 # Begin Source File

 

-SOURCE=.\Transport_Cache_Manager.h

-# End Source File

-# Begin Source File

-

-SOURCE=.\Transport_Descriptor_Interface.h

-# End Source File

-# Begin Source File

-

 SOURCE=.\Connection_Handler.h

 # End Source File

 # Begin Source File

@@ -1635,6 +1631,14 @@ SOURCE=.\Transport.inl
 # End Source File

 # Begin Source File

 

+SOURCE=.\Transport_Cache_Manager.h

+# End Source File

+# Begin Source File

+

+SOURCE=.\Transport_Descriptor_Interface.h

+# End Source File

+# Begin Source File

+

 SOURCE=.\Transport_Mux_Strategy.h

 # End Source File

 # Begin Source File

@@ -1647,6 +1651,10 @@ SOURCE=.\typecode.h
 # End Source File

 # Begin Source File

 

+SOURCE=.\TypeCodeFactory_Adapter.h

+# End Source File

+# Begin Source File

+

 SOURCE=.\ValueBase.h

 # End Source File

 # Begin Source File

@@ -1747,14 +1755,6 @@ SOURCE=.\Client_Priority_Policy.i
 # End Source File

 # Begin Source File

 

-SOURCE=.\Transport_Cache_Manager.inl

-# End Source File

-# Begin Source File

-

-SOURCE=.\Transport_Descriptor_Interface.inl

-# End Source File

-# Begin Source File

-

 SOURCE=.\Connection_Handler.i

 # End Source File

 # Begin Source File

@@ -2243,6 +2243,14 @@ SOURCE=.\TimeBaseS_T.i
 # End Source File

 # Begin Source File

 

+SOURCE=.\Transport_Cache_Manager.inl

+# End Source File

+# Begin Source File

+

+SOURCE=.\Transport_Descriptor_Interface.inl

+# End Source File

+# Begin Source File

+

 SOURCE=.\typecode.i

 # End Source File

 # Begin Source File

diff --git a/TAO/tao/TypeCodeFactory/Makefile b/TAO/tao/TypeCodeFactory/Makefile
new file mode 100644
index 00000000000..3b0bffb94f8
--- /dev/null
+++ b/TAO/tao/TypeCodeFactory/Makefile
@@ -0,0 +1,1037 @@
+#----------------------------------------------------------------------------
+#
+# $Id$
+#
+#----------------------------------------------------------------------------
+
+#----------------------------------------------------------------------------
+#       Local macros
+#----------------------------------------------------------------------------
+
+ifndef TAO_ROOT
+  TAO_ROOT = $(ACE_ROOT)/TAO
+endif # ! TAO_ROOT
+
+LDLIBS = -lTAO_IFR_Client -lTAO -lACE
+ACE_SHLIBS += -lTAO_IFR_Client -lTAO -lACE
+
+LIBNAME = libTypeCodeFactory_DLL
+LIB = $(LIBNAME).a
+SHLIB = $(LIBNAME).$(SOEXT)
+
+LSRC = \
+	TypeCodeFactoryC.cpp \
+	TypeCodeFactory_i.cpp \
+        TypeCodeFactory_Adapter_Impl.cpp \
+	TypeCodeFactory_Loader.cpp
+
+#----------------------------------------------------------------------------
+#       Include macros and targets
+#----------------------------------------------------------------------------
+
+include $(ACE_ROOT)/include/makeinclude/wrapper_macros.GNU
+include $(ACE_ROOT)/include/makeinclude/macros.GNU
+include $(TAO_ROOT)/rules.tao.GNU
+include $(TAO_ROOT)/taoconfig.mk
+include $(ACE_ROOT)/include/makeinclude/rules.common.GNU
+include $(ACE_ROOT)/include/makeinclude/rules.nonested.GNU
+include $(ACE_ROOT)/include/makeinclude/rules.lib.GNU
+include $(ACE_ROOT)/include/makeinclude/rules.local.GNU
+
+
+#----------------------------------------------------------------------------
+#       Local targets
+#----------------------------------------------------------------------------
+
+LDFLAGS += -I$(TAO_ROOT)/tao
+
+realclean: clean
+
+# DO NOT DELETE THIS LINE -- g++dep uses it.
+# DO NOT PUT ANYTHING AFTER THIS LINE, IT WILL GO AWAY.
+
+
+.obj/TypeCodeFactoryC.o .obj/TypeCodeFactoryC.so .shobj/TypeCodeFactoryC.o .shobj/TypeCodeFactoryC.so: TypeCodeFactoryC.cpp TCF_Loader.h \
+ $(ACE_ROOT)/ace/pre.h \
+ TCF_Export.h \
+ $(ACE_ROOT)/ace/post.h \
+ $(ACE_ROOT)/ace/ACE_export.h \
+ $(ACE_ROOT)/ace/svc_export.h \
+ $(ACE_ROOT)/ace/ace_wchar.h \
+ $(ACE_ROOT)/ace/ace_wchar.inl \
+ $(ACE_ROOT)/ace/OS_Errno.h \
+ $(ACE_ROOT)/ace/OS_Export.h \
+ $(ACE_ROOT)/ace/OS_Errno.inl \
+ $(TAO_ROOT)/tao/Object_Loader.h \
+ $(TAO_ROOT)/tao/corbafwd.h \
+ $(ACE_ROOT)/ace/CDR_Base.h \
+ $(ACE_ROOT)/ace/Basic_Types.h \
+ $(ACE_ROOT)/ace/Basic_Types.i \
+ $(ACE_ROOT)/ace/Message_Block.h \
+ $(ACE_ROOT)/ace/ACE.h \
+ $(ACE_ROOT)/ace/OS.h \
+ $(ACE_ROOT)/ace/OS_Dirent.h \
+ $(ACE_ROOT)/ace/OS_Dirent.inl \
+ $(ACE_ROOT)/ace/OS_String.h \
+ $(ACE_ROOT)/ace/OS_String.inl \
+ $(ACE_ROOT)/ace/OS_Memory.h \
+ $(ACE_ROOT)/ace/OS_Memory.inl \
+ $(ACE_ROOT)/ace/OS_TLI.h \
+ $(ACE_ROOT)/ace/OS_TLI.inl \
+ $(ACE_ROOT)/ace/Min_Max.h \
+ $(ACE_ROOT)/ace/streams.h \
+ $(ACE_ROOT)/ace/Trace.h \
+ $(ACE_ROOT)/ace/OS.i \
+ $(ACE_ROOT)/ace/Flag_Manip.h \
+ $(ACE_ROOT)/ace/Flag_Manip.i \
+ $(ACE_ROOT)/ace/Handle_Ops.h \
+ $(ACE_ROOT)/ace/Handle_Ops.i \
+ $(ACE_ROOT)/ace/Lib_Find.h \
+ $(ACE_ROOT)/ace/Lib_Find.i \
+ $(ACE_ROOT)/ace/Init_ACE.h \
+ $(ACE_ROOT)/ace/Init_ACE.i \
+ $(ACE_ROOT)/ace/Sock_Connect.h \
+ $(ACE_ROOT)/ace/Sock_Connect.i \
+ $(ACE_ROOT)/ace/ACE.i \
+ $(ACE_ROOT)/ace/Malloc.h \
+ $(ACE_ROOT)/ace/Log_Msg.h \
+ $(ACE_ROOT)/ace/Log_Record.h \
+ $(ACE_ROOT)/ace/Log_Priority.h \
+ $(ACE_ROOT)/ace/Log_Record.i \
+ $(ACE_ROOT)/ace/OS_Log_Msg_Attributes.h \
+ $(ACE_ROOT)/ace/OS_Log_Msg_Attributes.inl \
+ $(ACE_ROOT)/ace/Malloc.i \
+ $(ACE_ROOT)/ace/Malloc_T.h \
+ $(ACE_ROOT)/ace/Synch.h \
+ $(ACE_ROOT)/ace/Synch.i \
+ $(ACE_ROOT)/ace/Synch_T.h \
+ $(ACE_ROOT)/ace/Synch_T.i \
+ $(ACE_ROOT)/ace/Thread.h \
+ $(ACE_ROOT)/ace/Thread_Adapter.h \
+ $(ACE_ROOT)/ace/Base_Thread_Adapter.h \
+ $(ACE_ROOT)/ace/Base_Thread_Adapter.inl \
+ $(ACE_ROOT)/ace/Thread_Adapter.inl \
+ $(ACE_ROOT)/ace/Thread.i \
+ $(ACE_ROOT)/ace/Atomic_Op.i \
+ $(ACE_ROOT)/ace/Synch_T.cpp \
+ $(ACE_ROOT)/ace/Malloc_Allocator.h \
+ $(ACE_ROOT)/ace/Malloc_Base.h \
+ $(ACE_ROOT)/ace/Malloc_Allocator.i \
+ $(ACE_ROOT)/ace/Free_List.h \
+ $(ACE_ROOT)/ace/Free_List.i \
+ $(ACE_ROOT)/ace/Free_List.cpp \
+ $(ACE_ROOT)/ace/Malloc_T.i \
+ $(ACE_ROOT)/ace/Malloc_T.cpp \
+ $(ACE_ROOT)/ace/Memory_Pool.h \
+ $(ACE_ROOT)/ace/Event_Handler.h \
+ $(ACE_ROOT)/ace/Event_Handler.i \
+ $(ACE_ROOT)/ace/Signal.h \
+ $(ACE_ROOT)/ace/Containers.h \
+ $(ACE_ROOT)/ace/Containers.i \
+ $(ACE_ROOT)/ace/Containers_T.h \
+ $(ACE_ROOT)/ace/Containers_T.i \
+ $(ACE_ROOT)/ace/Containers_T.cpp \
+ $(ACE_ROOT)/ace/Signal.i \
+ $(ACE_ROOT)/ace/Mem_Map.h \
+ $(ACE_ROOT)/ace/Mem_Map.i \
+ $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \
+ $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \
+ $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \
+ $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \
+ $(ACE_ROOT)/ace/Memory_Pool.i \
+ $(ACE_ROOT)/ace/Message_Block.i \
+ $(ACE_ROOT)/ace/Message_Block_T.h \
+ $(ACE_ROOT)/ace/Message_Block_T.i \
+ $(ACE_ROOT)/ace/Message_Block_T.cpp \
+ $(ACE_ROOT)/ace/CDR_Base.inl \
+ $(TAO_ROOT)/tao/try_macros.h \
+ $(TAO_ROOT)/tao/orbconf.h \
+ $(ACE_ROOT)/ace/CORBA_macros.h \
+ $(TAO_ROOT)/tao/varbase.h \
+ $(TAO_ROOT)/tao/TAO_Export.h \
+ $(TAO_ROOT)/tao/corbafwd.i \
+ $(ACE_ROOT)/ace/Service_Object.h \
+ $(ACE_ROOT)/ace/Shared_Object.h \
+ $(ACE_ROOT)/ace/Shared_Object.i \
+ $(ACE_ROOT)/ace/Service_Object.i \
+ $(TAO_ROOT)/tao/Object_Loader.i \
+ $(ACE_ROOT)/ace/Service_Config.h \
+ $(ACE_ROOT)/ace/SString.h \
+ $(ACE_ROOT)/ace/SString.i \
+ $(ACE_ROOT)/ace/Service_Config.i \
+ $(ACE_ROOT)/ace/Reactor.h \
+ $(ACE_ROOT)/ace/Handle_Set.h \
+ $(ACE_ROOT)/ace/Handle_Set.i \
+ $(ACE_ROOT)/ace/Timer_Queue.h \
+ $(ACE_ROOT)/ace/Timer_Queue_T.h \
+ $(ACE_ROOT)/ace/Test_and_Set.h \
+ $(ACE_ROOT)/ace/Test_and_Set.i \
+ $(ACE_ROOT)/ace/Test_and_Set.cpp \
+ $(ACE_ROOT)/ace/Timer_Queue_T.i \
+ $(ACE_ROOT)/ace/Timer_Queue_T.cpp \
+ $(ACE_ROOT)/ace/Reactor.i \
+ $(ACE_ROOT)/ace/Reactor_Impl.h \
+ $(ACE_ROOT)/ace/Svc_Conf_Tokens.h \
+ TypeCodeFactoryC.h \
+ $(TAO_ROOT)/tao/corba.h \
+ $(TAO_ROOT)/tao/Environment.h \
+ $(TAO_ROOT)/tao/Environment.i \
+ $(TAO_ROOT)/tao/ORB.h \
+ $(TAO_ROOT)/tao/Exception.h \
+ $(TAO_ROOT)/tao/Exception.i \
+ $(TAO_ROOT)/tao/Services.h \
+ $(TAO_ROOT)/tao/Sequence.h \
+ $(TAO_ROOT)/tao/Managed_Types.h \
+ $(TAO_ROOT)/tao/Managed_Types.i \
+ $(TAO_ROOT)/tao/Sequence.i \
+ $(TAO_ROOT)/tao/Sequence_T.h \
+ $(TAO_ROOT)/tao/Sequence_T.i \
+ $(TAO_ROOT)/tao/Sequence_T.cpp \
+ $(TAO_ROOT)/tao/Services.i \
+ $(TAO_ROOT)/tao/CORBA_String.h \
+ $(TAO_ROOT)/tao/CORBA_String.inl \
+ $(TAO_ROOT)/tao/PolicyC.h \
+ $(TAO_ROOT)/tao/CurrentC.h \
+ $(TAO_ROOT)/tao/Object.h \
+ $(TAO_ROOT)/tao/Abstract_Servant_Base.h \
+ $(TAO_ROOT)/tao/Object_Proxy_Broker.h \
+ $(TAO_ROOT)/tao/Object_Proxy_Impl.h \
+ $(TAO_ROOT)/tao/Object.i \
+ $(TAO_ROOT)/tao/CurrentC.i \
+ $(TAO_ROOT)/tao/Encodable.h \
+ $(TAO_ROOT)/tao/CDR.h \
+ $(ACE_ROOT)/ace/CDR_Stream.h \
+ $(ACE_ROOT)/ace/CDR_Stream.i \
+ $(TAO_ROOT)/tao/CDR.i \
+ $(TAO_ROOT)/tao/Typecode.h \
+ $(TAO_ROOT)/tao/Typecode.i \
+ $(TAO_ROOT)/tao/PolicyC.i \
+ $(TAO_ROOT)/tao/ORB.i \
+ $(TAO_ROOT)/tao/Any.h \
+ $(TAO_ROOT)/tao/Any.i \
+ $(TAO_ROOT)/tao/NVList.h \
+ $(TAO_ROOT)/tao/NVList.i \
+ $(TAO_ROOT)/tao/Principal.h \
+ $(TAO_ROOT)/tao/OctetSeqC.h \
+ $(TAO_ROOT)/tao/OctetSeqC.i \
+ $(TAO_ROOT)/tao/Principal.i \
+ $(TAO_ROOT)/tao/TAO_Server_Request.h \
+ $(TAO_ROOT)/tao/Tagged_Profile.h \
+ $(TAO_ROOT)/tao/IOPC.h \
+ $(TAO_ROOT)/tao/IOPC.i \
+ $(TAO_ROOT)/tao/GIOPC.h \
+ $(TAO_ROOT)/tao/Object_KeyC.h \
+ $(TAO_ROOT)/tao/Object_KeyC.i \
+ $(TAO_ROOT)/tao/GIOPC.i \
+ $(TAO_ROOT)/tao/Tagged_Profile.i \
+ $(TAO_ROOT)/tao/Service_Context.h \
+ $(TAO_ROOT)/tao/Service_Context.inl \
+ $(TAO_ROOT)/tao/TAO_Server_Request.i \
+ $(TAO_ROOT)/tao/Remote_Object_Proxy_Impl.h \
+ $(TAO_ROOT)/tao/LocalObject.h \
+ $(TAO_ROOT)/tao/LocalObject.i \
+ $(TAO_ROOT)/tao/Stub.h \
+ $(TAO_ROOT)/tao/Pluggable.h \
+ $(TAO_ROOT)/tao/Pluggable.i \
+ $(TAO_ROOT)/tao/MProfile.h \
+ $(TAO_ROOT)/tao/Profile.h \
+ $(TAO_ROOT)/tao/Tagged_Components.h \
+ $(TAO_ROOT)/tao/CONV_FRAMEC.h \
+ $(TAO_ROOT)/tao/CONV_FRAMEC.i \
+ $(TAO_ROOT)/tao/Tagged_Components.i \
+ $(TAO_ROOT)/tao/GIOP_Message_State.h \
+ $(TAO_ROOT)/tao/GIOP_Message_State.i \
+ $(TAO_ROOT)/tao/Profile.i \
+ $(TAO_ROOT)/tao/MProfile.i \
+ $(TAO_ROOT)/tao/ORB_Core.h \
+ $(TAO_ROOT)/tao/Policy_Manager.h \
+ $(TAO_ROOT)/tao/Policy_Manager.i \
+ $(TAO_ROOT)/tao/Resource_Factory.h \
+ $(TAO_ROOT)/tao/Protocol_Factory.h \
+ $(TAO_ROOT)/tao/params.h \
+ $(TAO_ROOT)/tao/params.i \
+ $(TAO_ROOT)/tao/TAO_Singleton_Manager.h \
+ $(TAO_ROOT)/tao/TAO_Singleton_Manager.inl \
+ $(TAO_ROOT)/tao/TAO_Singleton.h \
+ $(TAO_ROOT)/tao/TAO_Singleton.inl \
+ $(TAO_ROOT)/tao/TAO_Singleton.cpp \
+ $(ACE_ROOT)/ace/Object_Manager.h \
+ $(ACE_ROOT)/ace/Object_Manager.i \
+ $(ACE_ROOT)/ace/Managed_Object.h \
+ $(ACE_ROOT)/ace/Managed_Object.i \
+ $(ACE_ROOT)/ace/Managed_Object.cpp \
+ $(TAO_ROOT)/tao/Adapter.h \
+ $(TAO_ROOT)/tao/Adapter.i \
+ $(TAO_ROOT)/tao/PolicyFactory_Registry.h \
+ $(TAO_ROOT)/tao/PortableInterceptorC.h \
+ $(TAO_ROOT)/tao/DynamicC.h \
+ $(TAO_ROOT)/tao/DynamicC.i \
+ $(TAO_ROOT)/tao/MessagingC.h \
+ $(TAO_ROOT)/tao/ValueBase.h \
+ $(TAO_ROOT)/tao/ValueBase.i \
+ $(TAO_ROOT)/tao/ValueFactory.h \
+ $(TAO_ROOT)/tao/ValueFactory.i \
+ $(TAO_ROOT)/tao/TimeBaseC.h \
+ $(TAO_ROOT)/tao/TimeBaseC.i \
+ $(TAO_ROOT)/tao/PollableC.h \
+ $(TAO_ROOT)/tao/PollableC.i \
+ $(TAO_ROOT)/tao/MessagingC.i \
+ $(TAO_ROOT)/tao/PortableInterceptorC.i \
+ $(ACE_ROOT)/ace/Map_Manager.h \
+ $(ACE_ROOT)/ace/Map_Manager.i \
+ $(ACE_ROOT)/ace/Map_Manager.cpp \
+ $(TAO_ROOT)/tao/Parser_Registry.h \
+ $(TAO_ROOT)/tao/Parser_Registry.i \
+ $(TAO_ROOT)/tao/Service_Callbacks.h \
+ $(TAO_ROOT)/tao/Service_Callbacks.i \
+ $(TAO_ROOT)/tao/Fault_Tolerance_Service.h \
+ $(TAO_ROOT)/tao/Fault_Tolerance_Service.i \
+ $(TAO_ROOT)/tao/Connection_Cache_Manager.h \
+ $(ACE_ROOT)/ace/Hash_Map_Manager_T.h \
+ $(ACE_ROOT)/ace/Functor.h \
+ $(ACE_ROOT)/ace/Functor.i \
+ $(ACE_ROOT)/ace/Functor_T.h \
+ $(ACE_ROOT)/ace/Functor_T.i \
+ $(ACE_ROOT)/ace/Functor_T.cpp \
+ $(ACE_ROOT)/ace/Hash_Map_Manager_T.i \
+ $(ACE_ROOT)/ace/Hash_Map_Manager_T.cpp \
+ $(TAO_ROOT)/tao/Cache_Entries.h \
+ $(TAO_ROOT)/tao/Connection_Descriptor_Interface.h \
+ $(TAO_ROOT)/tao/Endpoint.h \
+ $(TAO_ROOT)/tao/Endpoint.i \
+ $(TAO_ROOT)/tao/Connection_Descriptor_Interface.inl \
+ $(TAO_ROOT)/tao/Cache_Entries.inl \
+ $(TAO_ROOT)/tao/Connection_Cache_Manager.inl \
+ $(TAO_ROOT)/tao/Cleanup_Func_Registry.h \
+ $(TAO_ROOT)/tao/Cleanup_Func_Registry.inl \
+ $(TAO_ROOT)/tao/Object_Ref_Table.h \
+ $(TAO_ROOT)/tao/Interceptor_List.h \
+ $(TAO_ROOT)/tao/Interceptor_List.inl \
+ $(TAO_ROOT)/tao/RT_Policy_i.h \
+ $(TAO_ROOT)/tao/RTCORBAS.h \
+ $(TAO_ROOT)/tao/IOPS.h \
+ $(TAO_ROOT)/tao/IOPS_T.h \
+ $(TAO_ROOT)/tao/IOPS_T.i \
+ $(TAO_ROOT)/tao/IOPS_T.cpp \
+ $(TAO_ROOT)/tao/IOPS.i \
+ $(TAO_ROOT)/tao/TimeBaseS.h \
+ $(TAO_ROOT)/tao/TimeBaseS_T.h \
+ $(TAO_ROOT)/tao/TimeBaseS_T.i \
+ $(TAO_ROOT)/tao/TimeBaseS_T.cpp \
+ $(TAO_ROOT)/tao/TimeBaseS.i \
+ $(TAO_ROOT)/tao/RTCORBAC.h \
+ $(TAO_ROOT)/tao/RTCORBAC.i \
+ $(TAO_ROOT)/tao/RTCORBAS_T.h \
+ $(TAO_ROOT)/tao/RTCORBAS_T.i \
+ $(TAO_ROOT)/tao/RTCORBAS_T.cpp \
+ $(TAO_ROOT)/tao/RTCORBAS.i \
+ $(TAO_ROOT)/tao/RT_Policy_i.i \
+ $(TAO_ROOT)/tao/Protocols_Hooks.h \
+ $(ACE_ROOT)/ace/Hash_Map_Manager.h \
+ $(ACE_ROOT)/ace/Thread_Manager.h \
+ $(ACE_ROOT)/ace/Singleton.h \
+ $(ACE_ROOT)/ace/Singleton.i \
+ $(ACE_ROOT)/ace/Singleton.cpp \
+ $(ACE_ROOT)/ace/Thread_Manager.i \
+ $(TAO_ROOT)/tao/ORB_Core.i \
+ $(TAO_ROOT)/tao/Stub.i \
+ $(TAO_ROOT)/tao/debug.h \
+ $(TAO_ROOT)/tao/Client_Strategy_Factory.h \
+ $(TAO_ROOT)/tao/Server_Strategy_Factory.h \
+ $(TAO_ROOT)/tao/Invocation.h \
+ $(TAO_ROOT)/tao/Synch_Reply_Dispatcher.h \
+ $(TAO_ROOT)/tao/Reply_Dispatcher.h \
+ $(TAO_ROOT)/tao/Reply_Dispatcher.i \
+ $(TAO_ROOT)/tao/TAOC.h \
+ $(TAO_ROOT)/tao/Priority_Mapping_Manager.h \
+ $(TAO_ROOT)/tao/Priority_Mapping.h \
+ $(TAO_ROOT)/tao/Priority_Mapping.i \
+ $(TAO_ROOT)/tao/Priority_Mapping_Manager.i \
+ $(TAO_ROOT)/tao/TAOC.i \
+ $(TAO_ROOT)/tao/operation_details.h \
+ $(TAO_ROOT)/tao/target_specification.h \
+ $(TAO_ROOT)/tao/target_specification.i \
+ $(TAO_ROOT)/tao/operation_details.i \
+ $(TAO_ROOT)/tao/Invocation_Endpoint_Selectors.h \
+ $(TAO_ROOT)/tao/Invocation_Endpoint_Selectors.i \
+ $(TAO_ROOT)/tao/Invocation.i \
+ $(TAO_ROOT)/tao/ObjectIDList.h \
+ $(TAO_ROOT)/tao/ObjectIDList.i \
+ $(TAO_ROOT)/tao/DomainC.h \
+ $(TAO_ROOT)/tao/ClientRequestInfo.h \
+ $(TAO_ROOT)/tao/StringSeqC.h \
+ $(TAO_ROOT)/tao/StringSeqC.i \
+ $(TAO_ROOT)/tao/ClientRequestInfo.inl \
+ $(TAO_ROOT)/tao/DomainC.i \
+ $(TAO_ROOT)/tao/WrongTransactionC.h \
+ $(TAO_ROOT)/tao/BoundsC.h \
+ $(TAO_ROOT)/tao/BoundsC.i \
+ $(TAO_ROOT)/tao/PortableInterceptor.h \
+ $(TAO_ROOT)/tao/PortableInterceptor.i \
+ $(TAO_ROOT)/tao/BiDirPolicyC.h \
+ $(TAO_ROOT)/tao/BiDirPolicyC.i \
+ $(TAO_ROOT)/tao/IFR_Client/InterfaceC.h \
+ $(TAO_ROOT)/tao/IFR_Client/ifrfwd.h \
+ $(TAO_ROOT)/tao/IFR_Client/ifr_client_export.h \
+ $(TAO_ROOT)/tao/IFR_Client/IFR_Client_Adapter_Impl.h \
+ $(TAO_ROOT)/tao/IFR_Client_Adapter.h \
+ $(TAO_ROOT)/tao/IFR_Client/InterfaceC.i \
+ TypeCodeFactoryC.inl
+
+.obj/TypeCodeFactory_i.o .obj/TypeCodeFactory_i.so .shobj/TypeCodeFactory_i.o .shobj/TypeCodeFactory_i.so: TypeCodeFactory_i.cpp TypeCodeFactory_i.h \
+ $(ACE_ROOT)/ace/pre.h \
+ TCF_Loader.h TCF_Export.h \
+ $(ACE_ROOT)/ace/post.h \
+ $(ACE_ROOT)/ace/ACE_export.h \
+ $(ACE_ROOT)/ace/svc_export.h \
+ $(ACE_ROOT)/ace/ace_wchar.h \
+ $(ACE_ROOT)/ace/ace_wchar.inl \
+ $(ACE_ROOT)/ace/OS_Errno.h \
+ $(ACE_ROOT)/ace/OS_Export.h \
+ $(ACE_ROOT)/ace/OS_Errno.inl \
+ $(TAO_ROOT)/tao/Object_Loader.h \
+ $(TAO_ROOT)/tao/corbafwd.h \
+ $(ACE_ROOT)/ace/CDR_Base.h \
+ $(ACE_ROOT)/ace/Basic_Types.h \
+ $(ACE_ROOT)/ace/Basic_Types.i \
+ $(ACE_ROOT)/ace/Message_Block.h \
+ $(ACE_ROOT)/ace/ACE.h \
+ $(ACE_ROOT)/ace/OS.h \
+ $(ACE_ROOT)/ace/OS_Dirent.h \
+ $(ACE_ROOT)/ace/OS_Dirent.inl \
+ $(ACE_ROOT)/ace/OS_String.h \
+ $(ACE_ROOT)/ace/OS_String.inl \
+ $(ACE_ROOT)/ace/OS_Memory.h \
+ $(ACE_ROOT)/ace/OS_Memory.inl \
+ $(ACE_ROOT)/ace/OS_TLI.h \
+ $(ACE_ROOT)/ace/OS_TLI.inl \
+ $(ACE_ROOT)/ace/Min_Max.h \
+ $(ACE_ROOT)/ace/streams.h \
+ $(ACE_ROOT)/ace/Trace.h \
+ $(ACE_ROOT)/ace/OS.i \
+ $(ACE_ROOT)/ace/Flag_Manip.h \
+ $(ACE_ROOT)/ace/Flag_Manip.i \
+ $(ACE_ROOT)/ace/Handle_Ops.h \
+ $(ACE_ROOT)/ace/Handle_Ops.i \
+ $(ACE_ROOT)/ace/Lib_Find.h \
+ $(ACE_ROOT)/ace/Lib_Find.i \
+ $(ACE_ROOT)/ace/Init_ACE.h \
+ $(ACE_ROOT)/ace/Init_ACE.i \
+ $(ACE_ROOT)/ace/Sock_Connect.h \
+ $(ACE_ROOT)/ace/Sock_Connect.i \
+ $(ACE_ROOT)/ace/ACE.i \
+ $(ACE_ROOT)/ace/Malloc.h \
+ $(ACE_ROOT)/ace/Log_Msg.h \
+ $(ACE_ROOT)/ace/Log_Record.h \
+ $(ACE_ROOT)/ace/Log_Priority.h \
+ $(ACE_ROOT)/ace/Log_Record.i \
+ $(ACE_ROOT)/ace/OS_Log_Msg_Attributes.h \
+ $(ACE_ROOT)/ace/OS_Log_Msg_Attributes.inl \
+ $(ACE_ROOT)/ace/Malloc.i \
+ $(ACE_ROOT)/ace/Malloc_T.h \
+ $(ACE_ROOT)/ace/Synch.h \
+ $(ACE_ROOT)/ace/Synch.i \
+ $(ACE_ROOT)/ace/Synch_T.h \
+ $(ACE_ROOT)/ace/Synch_T.i \
+ $(ACE_ROOT)/ace/Thread.h \
+ $(ACE_ROOT)/ace/Thread_Adapter.h \
+ $(ACE_ROOT)/ace/Base_Thread_Adapter.h \
+ $(ACE_ROOT)/ace/Base_Thread_Adapter.inl \
+ $(ACE_ROOT)/ace/Thread_Adapter.inl \
+ $(ACE_ROOT)/ace/Thread.i \
+ $(ACE_ROOT)/ace/Atomic_Op.i \
+ $(ACE_ROOT)/ace/Synch_T.cpp \
+ $(ACE_ROOT)/ace/Malloc_Allocator.h \
+ $(ACE_ROOT)/ace/Malloc_Base.h \
+ $(ACE_ROOT)/ace/Malloc_Allocator.i \
+ $(ACE_ROOT)/ace/Free_List.h \
+ $(ACE_ROOT)/ace/Free_List.i \
+ $(ACE_ROOT)/ace/Free_List.cpp \
+ $(ACE_ROOT)/ace/Malloc_T.i \
+ $(ACE_ROOT)/ace/Malloc_T.cpp \
+ $(ACE_ROOT)/ace/Memory_Pool.h \
+ $(ACE_ROOT)/ace/Event_Handler.h \
+ $(ACE_ROOT)/ace/Event_Handler.i \
+ $(ACE_ROOT)/ace/Signal.h \
+ $(ACE_ROOT)/ace/Containers.h \
+ $(ACE_ROOT)/ace/Containers.i \
+ $(ACE_ROOT)/ace/Containers_T.h \
+ $(ACE_ROOT)/ace/Containers_T.i \
+ $(ACE_ROOT)/ace/Containers_T.cpp \
+ $(ACE_ROOT)/ace/Signal.i \
+ $(ACE_ROOT)/ace/Mem_Map.h \
+ $(ACE_ROOT)/ace/Mem_Map.i \
+ $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \
+ $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \
+ $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \
+ $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \
+ $(ACE_ROOT)/ace/Memory_Pool.i \
+ $(ACE_ROOT)/ace/Message_Block.i \
+ $(ACE_ROOT)/ace/Message_Block_T.h \
+ $(ACE_ROOT)/ace/Message_Block_T.i \
+ $(ACE_ROOT)/ace/Message_Block_T.cpp \
+ $(ACE_ROOT)/ace/CDR_Base.inl \
+ $(TAO_ROOT)/tao/try_macros.h \
+ $(TAO_ROOT)/tao/orbconf.h \
+ $(ACE_ROOT)/ace/CORBA_macros.h \
+ $(TAO_ROOT)/tao/varbase.h \
+ $(TAO_ROOT)/tao/TAO_Export.h \
+ $(TAO_ROOT)/tao/corbafwd.i \
+ $(ACE_ROOT)/ace/Service_Object.h \
+ $(ACE_ROOT)/ace/Shared_Object.h \
+ $(ACE_ROOT)/ace/Shared_Object.i \
+ $(ACE_ROOT)/ace/Service_Object.i \
+ $(TAO_ROOT)/tao/Object_Loader.i \
+ $(ACE_ROOT)/ace/Service_Config.h \
+ $(ACE_ROOT)/ace/SString.h \
+ $(ACE_ROOT)/ace/SString.i \
+ $(ACE_ROOT)/ace/Service_Config.i \
+ $(ACE_ROOT)/ace/Reactor.h \
+ $(ACE_ROOT)/ace/Handle_Set.h \
+ $(ACE_ROOT)/ace/Handle_Set.i \
+ $(ACE_ROOT)/ace/Timer_Queue.h \
+ $(ACE_ROOT)/ace/Timer_Queue_T.h \
+ $(ACE_ROOT)/ace/Test_and_Set.h \
+ $(ACE_ROOT)/ace/Test_and_Set.i \
+ $(ACE_ROOT)/ace/Test_and_Set.cpp \
+ $(ACE_ROOT)/ace/Timer_Queue_T.i \
+ $(ACE_ROOT)/ace/Timer_Queue_T.cpp \
+ $(ACE_ROOT)/ace/Reactor.i \
+ $(ACE_ROOT)/ace/Reactor_Impl.h \
+ $(ACE_ROOT)/ace/Svc_Conf_Tokens.h \
+ TypeCodeFactoryC.h \
+ $(TAO_ROOT)/tao/corba.h \
+ $(TAO_ROOT)/tao/Environment.h \
+ $(TAO_ROOT)/tao/Environment.i \
+ $(TAO_ROOT)/tao/ORB.h \
+ $(TAO_ROOT)/tao/Exception.h \
+ $(TAO_ROOT)/tao/Exception.i \
+ $(TAO_ROOT)/tao/Services.h \
+ $(TAO_ROOT)/tao/Sequence.h \
+ $(TAO_ROOT)/tao/Managed_Types.h \
+ $(TAO_ROOT)/tao/Managed_Types.i \
+ $(TAO_ROOT)/tao/Sequence.i \
+ $(TAO_ROOT)/tao/Sequence_T.h \
+ $(TAO_ROOT)/tao/Sequence_T.i \
+ $(TAO_ROOT)/tao/Sequence_T.cpp \
+ $(TAO_ROOT)/tao/Services.i \
+ $(TAO_ROOT)/tao/CORBA_String.h \
+ $(TAO_ROOT)/tao/CORBA_String.inl \
+ $(TAO_ROOT)/tao/PolicyC.h \
+ $(TAO_ROOT)/tao/CurrentC.h \
+ $(TAO_ROOT)/tao/Object.h \
+ $(TAO_ROOT)/tao/Abstract_Servant_Base.h \
+ $(TAO_ROOT)/tao/Object_Proxy_Broker.h \
+ $(TAO_ROOT)/tao/Object_Proxy_Impl.h \
+ $(TAO_ROOT)/tao/Object.i \
+ $(TAO_ROOT)/tao/CurrentC.i \
+ $(TAO_ROOT)/tao/Encodable.h \
+ $(TAO_ROOT)/tao/CDR.h \
+ $(ACE_ROOT)/ace/CDR_Stream.h \
+ $(ACE_ROOT)/ace/CDR_Stream.i \
+ $(TAO_ROOT)/tao/CDR.i \
+ $(TAO_ROOT)/tao/Typecode.h \
+ $(TAO_ROOT)/tao/Typecode.i \
+ $(TAO_ROOT)/tao/PolicyC.i \
+ $(TAO_ROOT)/tao/ORB.i \
+ $(TAO_ROOT)/tao/Any.h \
+ $(TAO_ROOT)/tao/Any.i \
+ $(TAO_ROOT)/tao/NVList.h \
+ $(TAO_ROOT)/tao/NVList.i \
+ $(TAO_ROOT)/tao/Principal.h \
+ $(TAO_ROOT)/tao/OctetSeqC.h \
+ $(TAO_ROOT)/tao/OctetSeqC.i \
+ $(TAO_ROOT)/tao/Principal.i \
+ $(TAO_ROOT)/tao/TAO_Server_Request.h \
+ $(TAO_ROOT)/tao/Tagged_Profile.h \
+ $(TAO_ROOT)/tao/IOPC.h \
+ $(TAO_ROOT)/tao/IOPC.i \
+ $(TAO_ROOT)/tao/GIOPC.h \
+ $(TAO_ROOT)/tao/Object_KeyC.h \
+ $(TAO_ROOT)/tao/Object_KeyC.i \
+ $(TAO_ROOT)/tao/GIOPC.i \
+ $(TAO_ROOT)/tao/Tagged_Profile.i \
+ $(TAO_ROOT)/tao/Service_Context.h \
+ $(TAO_ROOT)/tao/Service_Context.inl \
+ $(TAO_ROOT)/tao/TAO_Server_Request.i \
+ $(TAO_ROOT)/tao/Remote_Object_Proxy_Impl.h \
+ $(TAO_ROOT)/tao/LocalObject.h \
+ $(TAO_ROOT)/tao/LocalObject.i \
+ $(TAO_ROOT)/tao/Stub.h \
+ $(TAO_ROOT)/tao/Pluggable.h \
+ $(TAO_ROOT)/tao/Pluggable.i \
+ $(TAO_ROOT)/tao/MProfile.h \
+ $(TAO_ROOT)/tao/Profile.h \
+ $(TAO_ROOT)/tao/Tagged_Components.h \
+ $(TAO_ROOT)/tao/CONV_FRAMEC.h \
+ $(TAO_ROOT)/tao/CONV_FRAMEC.i \
+ $(TAO_ROOT)/tao/Tagged_Components.i \
+ $(TAO_ROOT)/tao/GIOP_Message_State.h \
+ $(TAO_ROOT)/tao/GIOP_Message_State.i \
+ $(TAO_ROOT)/tao/Profile.i \
+ $(TAO_ROOT)/tao/MProfile.i \
+ $(TAO_ROOT)/tao/ORB_Core.h \
+ $(TAO_ROOT)/tao/Policy_Manager.h \
+ $(TAO_ROOT)/tao/Policy_Manager.i \
+ $(TAO_ROOT)/tao/Resource_Factory.h \
+ $(TAO_ROOT)/tao/Protocol_Factory.h \
+ $(TAO_ROOT)/tao/params.h \
+ $(TAO_ROOT)/tao/params.i \
+ $(TAO_ROOT)/tao/TAO_Singleton_Manager.h \
+ $(TAO_ROOT)/tao/TAO_Singleton_Manager.inl \
+ $(TAO_ROOT)/tao/TAO_Singleton.h \
+ $(TAO_ROOT)/tao/TAO_Singleton.inl \
+ $(TAO_ROOT)/tao/TAO_Singleton.cpp \
+ $(ACE_ROOT)/ace/Object_Manager.h \
+ $(ACE_ROOT)/ace/Object_Manager.i \
+ $(ACE_ROOT)/ace/Managed_Object.h \
+ $(ACE_ROOT)/ace/Managed_Object.i \
+ $(ACE_ROOT)/ace/Managed_Object.cpp \
+ $(TAO_ROOT)/tao/Adapter.h \
+ $(TAO_ROOT)/tao/Adapter.i \
+ $(TAO_ROOT)/tao/PolicyFactory_Registry.h \
+ $(TAO_ROOT)/tao/PortableInterceptorC.h \
+ $(TAO_ROOT)/tao/DynamicC.h \
+ $(TAO_ROOT)/tao/DynamicC.i \
+ $(TAO_ROOT)/tao/MessagingC.h \
+ $(TAO_ROOT)/tao/ValueBase.h \
+ $(TAO_ROOT)/tao/ValueBase.i \
+ $(TAO_ROOT)/tao/ValueFactory.h \
+ $(TAO_ROOT)/tao/ValueFactory.i \
+ $(TAO_ROOT)/tao/TimeBaseC.h \
+ $(TAO_ROOT)/tao/TimeBaseC.i \
+ $(TAO_ROOT)/tao/PollableC.h \
+ $(TAO_ROOT)/tao/PollableC.i \
+ $(TAO_ROOT)/tao/MessagingC.i \
+ $(TAO_ROOT)/tao/PortableInterceptorC.i \
+ $(ACE_ROOT)/ace/Map_Manager.h \
+ $(ACE_ROOT)/ace/Map_Manager.i \
+ $(ACE_ROOT)/ace/Map_Manager.cpp \
+ $(TAO_ROOT)/tao/Parser_Registry.h \
+ $(TAO_ROOT)/tao/Parser_Registry.i \
+ $(TAO_ROOT)/tao/Service_Callbacks.h \
+ $(TAO_ROOT)/tao/Service_Callbacks.i \
+ $(TAO_ROOT)/tao/Fault_Tolerance_Service.h \
+ $(TAO_ROOT)/tao/Fault_Tolerance_Service.i \
+ $(TAO_ROOT)/tao/Connection_Cache_Manager.h \
+ $(ACE_ROOT)/ace/Hash_Map_Manager_T.h \
+ $(ACE_ROOT)/ace/Functor.h \
+ $(ACE_ROOT)/ace/Functor.i \
+ $(ACE_ROOT)/ace/Functor_T.h \
+ $(ACE_ROOT)/ace/Functor_T.i \
+ $(ACE_ROOT)/ace/Functor_T.cpp \
+ $(ACE_ROOT)/ace/Hash_Map_Manager_T.i \
+ $(ACE_ROOT)/ace/Hash_Map_Manager_T.cpp \
+ $(TAO_ROOT)/tao/Cache_Entries.h \
+ $(TAO_ROOT)/tao/Connection_Descriptor_Interface.h \
+ $(TAO_ROOT)/tao/Endpoint.h \
+ $(TAO_ROOT)/tao/Endpoint.i \
+ $(TAO_ROOT)/tao/Connection_Descriptor_Interface.inl \
+ $(TAO_ROOT)/tao/Cache_Entries.inl \
+ $(TAO_ROOT)/tao/Connection_Cache_Manager.inl \
+ $(TAO_ROOT)/tao/Cleanup_Func_Registry.h \
+ $(TAO_ROOT)/tao/Cleanup_Func_Registry.inl \
+ $(TAO_ROOT)/tao/Object_Ref_Table.h \
+ $(TAO_ROOT)/tao/Interceptor_List.h \
+ $(TAO_ROOT)/tao/Interceptor_List.inl \
+ $(TAO_ROOT)/tao/RT_Policy_i.h \
+ $(TAO_ROOT)/tao/RTCORBAS.h \
+ $(TAO_ROOT)/tao/IOPS.h \
+ $(TAO_ROOT)/tao/IOPS_T.h \
+ $(TAO_ROOT)/tao/IOPS_T.i \
+ $(TAO_ROOT)/tao/IOPS_T.cpp \
+ $(TAO_ROOT)/tao/IOPS.i \
+ $(TAO_ROOT)/tao/TimeBaseS.h \
+ $(TAO_ROOT)/tao/TimeBaseS_T.h \
+ $(TAO_ROOT)/tao/TimeBaseS_T.i \
+ $(TAO_ROOT)/tao/TimeBaseS_T.cpp \
+ $(TAO_ROOT)/tao/TimeBaseS.i \
+ $(TAO_ROOT)/tao/RTCORBAC.h \
+ $(TAO_ROOT)/tao/RTCORBAC.i \
+ $(TAO_ROOT)/tao/RTCORBAS_T.h \
+ $(TAO_ROOT)/tao/RTCORBAS_T.i \
+ $(TAO_ROOT)/tao/RTCORBAS_T.cpp \
+ $(TAO_ROOT)/tao/RTCORBAS.i \
+ $(TAO_ROOT)/tao/RT_Policy_i.i \
+ $(TAO_ROOT)/tao/Protocols_Hooks.h \
+ $(ACE_ROOT)/ace/Hash_Map_Manager.h \
+ $(ACE_ROOT)/ace/Thread_Manager.h \
+ $(ACE_ROOT)/ace/Singleton.h \
+ $(ACE_ROOT)/ace/Singleton.i \
+ $(ACE_ROOT)/ace/Singleton.cpp \
+ $(ACE_ROOT)/ace/Thread_Manager.i \
+ $(TAO_ROOT)/tao/ORB_Core.i \
+ $(TAO_ROOT)/tao/Stub.i \
+ $(TAO_ROOT)/tao/debug.h \
+ $(TAO_ROOT)/tao/Client_Strategy_Factory.h \
+ $(TAO_ROOT)/tao/Server_Strategy_Factory.h \
+ $(TAO_ROOT)/tao/Invocation.h \
+ $(TAO_ROOT)/tao/Synch_Reply_Dispatcher.h \
+ $(TAO_ROOT)/tao/Reply_Dispatcher.h \
+ $(TAO_ROOT)/tao/Reply_Dispatcher.i \
+ $(TAO_ROOT)/tao/TAOC.h \
+ $(TAO_ROOT)/tao/Priority_Mapping_Manager.h \
+ $(TAO_ROOT)/tao/Priority_Mapping.h \
+ $(TAO_ROOT)/tao/Priority_Mapping.i \
+ $(TAO_ROOT)/tao/Priority_Mapping_Manager.i \
+ $(TAO_ROOT)/tao/TAOC.i \
+ $(TAO_ROOT)/tao/operation_details.h \
+ $(TAO_ROOT)/tao/target_specification.h \
+ $(TAO_ROOT)/tao/target_specification.i \
+ $(TAO_ROOT)/tao/operation_details.i \
+ $(TAO_ROOT)/tao/Invocation_Endpoint_Selectors.h \
+ $(TAO_ROOT)/tao/Invocation_Endpoint_Selectors.i \
+ $(TAO_ROOT)/tao/Invocation.i \
+ $(TAO_ROOT)/tao/ObjectIDList.h \
+ $(TAO_ROOT)/tao/ObjectIDList.i \
+ $(TAO_ROOT)/tao/DomainC.h \
+ $(TAO_ROOT)/tao/ClientRequestInfo.h \
+ $(TAO_ROOT)/tao/StringSeqC.h \
+ $(TAO_ROOT)/tao/StringSeqC.i \
+ $(TAO_ROOT)/tao/ClientRequestInfo.inl \
+ $(TAO_ROOT)/tao/DomainC.i \
+ $(TAO_ROOT)/tao/WrongTransactionC.h \
+ $(TAO_ROOT)/tao/BoundsC.h \
+ $(TAO_ROOT)/tao/BoundsC.i \
+ $(TAO_ROOT)/tao/PortableInterceptor.h \
+ $(TAO_ROOT)/tao/PortableInterceptor.i \
+ $(TAO_ROOT)/tao/BiDirPolicyC.h \
+ $(TAO_ROOT)/tao/BiDirPolicyC.i \
+ $(TAO_ROOT)/tao/IFR_Client/InterfaceC.h \
+ $(TAO_ROOT)/tao/IFR_Client/ifrfwd.h \
+ $(TAO_ROOT)/tao/IFR_Client/ifr_client_export.h \
+ $(TAO_ROOT)/tao/IFR_Client/IFR_Client_Adapter_Impl.h \
+ $(TAO_ROOT)/tao/IFR_Client_Adapter.h \
+ $(TAO_ROOT)/tao/IFR_Client/InterfaceC.i \
+ TypeCodeFactoryC.inl \
+ $(TAO_ROOT)/tao/Marshal.h \
+ $(TAO_ROOT)/tao/Marshal.i
+
+.obj/TCF_Loader.o .obj/TCF_Loader.so .shobj/TCF_Loader.o .shobj/TCF_Loader.so: TCF_Loader.cpp TCF_Loader.h \
+ $(ACE_ROOT)/ace/pre.h \
+ TCF_Export.h \
+ $(ACE_ROOT)/ace/post.h \
+ $(ACE_ROOT)/ace/ACE_export.h \
+ $(ACE_ROOT)/ace/svc_export.h \
+ $(ACE_ROOT)/ace/ace_wchar.h \
+ $(ACE_ROOT)/ace/ace_wchar.inl \
+ $(ACE_ROOT)/ace/OS_Errno.h \
+ $(ACE_ROOT)/ace/OS_Export.h \
+ $(ACE_ROOT)/ace/OS_Errno.inl \
+ $(TAO_ROOT)/tao/Object_Loader.h \
+ $(TAO_ROOT)/tao/corbafwd.h \
+ $(ACE_ROOT)/ace/CDR_Base.h \
+ $(ACE_ROOT)/ace/Basic_Types.h \
+ $(ACE_ROOT)/ace/Basic_Types.i \
+ $(ACE_ROOT)/ace/Message_Block.h \
+ $(ACE_ROOT)/ace/ACE.h \
+ $(ACE_ROOT)/ace/OS.h \
+ $(ACE_ROOT)/ace/OS_Dirent.h \
+ $(ACE_ROOT)/ace/OS_Dirent.inl \
+ $(ACE_ROOT)/ace/OS_String.h \
+ $(ACE_ROOT)/ace/OS_String.inl \
+ $(ACE_ROOT)/ace/OS_Memory.h \
+ $(ACE_ROOT)/ace/OS_Memory.inl \
+ $(ACE_ROOT)/ace/OS_TLI.h \
+ $(ACE_ROOT)/ace/OS_TLI.inl \
+ $(ACE_ROOT)/ace/Min_Max.h \
+ $(ACE_ROOT)/ace/streams.h \
+ $(ACE_ROOT)/ace/Trace.h \
+ $(ACE_ROOT)/ace/OS.i \
+ $(ACE_ROOT)/ace/Flag_Manip.h \
+ $(ACE_ROOT)/ace/Flag_Manip.i \
+ $(ACE_ROOT)/ace/Handle_Ops.h \
+ $(ACE_ROOT)/ace/Handle_Ops.i \
+ $(ACE_ROOT)/ace/Lib_Find.h \
+ $(ACE_ROOT)/ace/Lib_Find.i \
+ $(ACE_ROOT)/ace/Init_ACE.h \
+ $(ACE_ROOT)/ace/Init_ACE.i \
+ $(ACE_ROOT)/ace/Sock_Connect.h \
+ $(ACE_ROOT)/ace/Sock_Connect.i \
+ $(ACE_ROOT)/ace/ACE.i \
+ $(ACE_ROOT)/ace/Malloc.h \
+ $(ACE_ROOT)/ace/Log_Msg.h \
+ $(ACE_ROOT)/ace/Log_Record.h \
+ $(ACE_ROOT)/ace/Log_Priority.h \
+ $(ACE_ROOT)/ace/Log_Record.i \
+ $(ACE_ROOT)/ace/OS_Log_Msg_Attributes.h \
+ $(ACE_ROOT)/ace/OS_Log_Msg_Attributes.inl \
+ $(ACE_ROOT)/ace/Malloc.i \
+ $(ACE_ROOT)/ace/Malloc_T.h \
+ $(ACE_ROOT)/ace/Synch.h \
+ $(ACE_ROOT)/ace/Synch.i \
+ $(ACE_ROOT)/ace/Synch_T.h \
+ $(ACE_ROOT)/ace/Synch_T.i \
+ $(ACE_ROOT)/ace/Thread.h \
+ $(ACE_ROOT)/ace/Thread_Adapter.h \
+ $(ACE_ROOT)/ace/Base_Thread_Adapter.h \
+ $(ACE_ROOT)/ace/Base_Thread_Adapter.inl \
+ $(ACE_ROOT)/ace/Thread_Adapter.inl \
+ $(ACE_ROOT)/ace/Thread.i \
+ $(ACE_ROOT)/ace/Atomic_Op.i \
+ $(ACE_ROOT)/ace/Synch_T.cpp \
+ $(ACE_ROOT)/ace/Malloc_Allocator.h \
+ $(ACE_ROOT)/ace/Malloc_Base.h \
+ $(ACE_ROOT)/ace/Malloc_Allocator.i \
+ $(ACE_ROOT)/ace/Free_List.h \
+ $(ACE_ROOT)/ace/Free_List.i \
+ $(ACE_ROOT)/ace/Free_List.cpp \
+ $(ACE_ROOT)/ace/Malloc_T.i \
+ $(ACE_ROOT)/ace/Malloc_T.cpp \
+ $(ACE_ROOT)/ace/Memory_Pool.h \
+ $(ACE_ROOT)/ace/Event_Handler.h \
+ $(ACE_ROOT)/ace/Event_Handler.i \
+ $(ACE_ROOT)/ace/Signal.h \
+ $(ACE_ROOT)/ace/Containers.h \
+ $(ACE_ROOT)/ace/Containers.i \
+ $(ACE_ROOT)/ace/Containers_T.h \
+ $(ACE_ROOT)/ace/Containers_T.i \
+ $(ACE_ROOT)/ace/Containers_T.cpp \
+ $(ACE_ROOT)/ace/Signal.i \
+ $(ACE_ROOT)/ace/Mem_Map.h \
+ $(ACE_ROOT)/ace/Mem_Map.i \
+ $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \
+ $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \
+ $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \
+ $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \
+ $(ACE_ROOT)/ace/Memory_Pool.i \
+ $(ACE_ROOT)/ace/Message_Block.i \
+ $(ACE_ROOT)/ace/Message_Block_T.h \
+ $(ACE_ROOT)/ace/Message_Block_T.i \
+ $(ACE_ROOT)/ace/Message_Block_T.cpp \
+ $(ACE_ROOT)/ace/CDR_Base.inl \
+ $(TAO_ROOT)/tao/try_macros.h \
+ $(TAO_ROOT)/tao/orbconf.h \
+ $(ACE_ROOT)/ace/CORBA_macros.h \
+ $(TAO_ROOT)/tao/varbase.h \
+ $(TAO_ROOT)/tao/TAO_Export.h \
+ $(TAO_ROOT)/tao/corbafwd.i \
+ $(ACE_ROOT)/ace/Service_Object.h \
+ $(ACE_ROOT)/ace/Shared_Object.h \
+ $(ACE_ROOT)/ace/Shared_Object.i \
+ $(ACE_ROOT)/ace/Service_Object.i \
+ $(TAO_ROOT)/tao/Object_Loader.i \
+ $(ACE_ROOT)/ace/Service_Config.h \
+ $(ACE_ROOT)/ace/SString.h \
+ $(ACE_ROOT)/ace/SString.i \
+ $(ACE_ROOT)/ace/Service_Config.i \
+ $(ACE_ROOT)/ace/Reactor.h \
+ $(ACE_ROOT)/ace/Handle_Set.h \
+ $(ACE_ROOT)/ace/Handle_Set.i \
+ $(ACE_ROOT)/ace/Timer_Queue.h \
+ $(ACE_ROOT)/ace/Timer_Queue_T.h \
+ $(ACE_ROOT)/ace/Test_and_Set.h \
+ $(ACE_ROOT)/ace/Test_and_Set.i \
+ $(ACE_ROOT)/ace/Test_and_Set.cpp \
+ $(ACE_ROOT)/ace/Timer_Queue_T.i \
+ $(ACE_ROOT)/ace/Timer_Queue_T.cpp \
+ $(ACE_ROOT)/ace/Reactor.i \
+ $(ACE_ROOT)/ace/Reactor_Impl.h \
+ $(ACE_ROOT)/ace/Svc_Conf_Tokens.h \
+ TypeCodeFactoryC.h \
+ $(TAO_ROOT)/tao/corba.h \
+ $(TAO_ROOT)/tao/Environment.h \
+ $(TAO_ROOT)/tao/Environment.i \
+ $(TAO_ROOT)/tao/ORB.h \
+ $(TAO_ROOT)/tao/Exception.h \
+ $(TAO_ROOT)/tao/Exception.i \
+ $(TAO_ROOT)/tao/Services.h \
+ $(TAO_ROOT)/tao/Sequence.h \
+ $(TAO_ROOT)/tao/Managed_Types.h \
+ $(TAO_ROOT)/tao/Managed_Types.i \
+ $(TAO_ROOT)/tao/Sequence.i \
+ $(TAO_ROOT)/tao/Sequence_T.h \
+ $(TAO_ROOT)/tao/Sequence_T.i \
+ $(TAO_ROOT)/tao/Sequence_T.cpp \
+ $(TAO_ROOT)/tao/Services.i \
+ $(TAO_ROOT)/tao/CORBA_String.h \
+ $(TAO_ROOT)/tao/CORBA_String.inl \
+ $(TAO_ROOT)/tao/PolicyC.h \
+ $(TAO_ROOT)/tao/CurrentC.h \
+ $(TAO_ROOT)/tao/Object.h \
+ $(TAO_ROOT)/tao/Abstract_Servant_Base.h \
+ $(TAO_ROOT)/tao/Object_Proxy_Broker.h \
+ $(TAO_ROOT)/tao/Object_Proxy_Impl.h \
+ $(TAO_ROOT)/tao/Object.i \
+ $(TAO_ROOT)/tao/CurrentC.i \
+ $(TAO_ROOT)/tao/Encodable.h \
+ $(TAO_ROOT)/tao/CDR.h \
+ $(ACE_ROOT)/ace/CDR_Stream.h \
+ $(ACE_ROOT)/ace/CDR_Stream.i \
+ $(TAO_ROOT)/tao/CDR.i \
+ $(TAO_ROOT)/tao/Typecode.h \
+ $(TAO_ROOT)/tao/Typecode.i \
+ $(TAO_ROOT)/tao/PolicyC.i \
+ $(TAO_ROOT)/tao/ORB.i \
+ $(TAO_ROOT)/tao/Any.h \
+ $(TAO_ROOT)/tao/Any.i \
+ $(TAO_ROOT)/tao/NVList.h \
+ $(TAO_ROOT)/tao/NVList.i \
+ $(TAO_ROOT)/tao/Principal.h \
+ $(TAO_ROOT)/tao/OctetSeqC.h \
+ $(TAO_ROOT)/tao/OctetSeqC.i \
+ $(TAO_ROOT)/tao/Principal.i \
+ $(TAO_ROOT)/tao/TAO_Server_Request.h \
+ $(TAO_ROOT)/tao/Tagged_Profile.h \
+ $(TAO_ROOT)/tao/IOPC.h \
+ $(TAO_ROOT)/tao/IOPC.i \
+ $(TAO_ROOT)/tao/GIOPC.h \
+ $(TAO_ROOT)/tao/Object_KeyC.h \
+ $(TAO_ROOT)/tao/Object_KeyC.i \
+ $(TAO_ROOT)/tao/GIOPC.i \
+ $(TAO_ROOT)/tao/Tagged_Profile.i \
+ $(TAO_ROOT)/tao/Service_Context.h \
+ $(TAO_ROOT)/tao/Service_Context.inl \
+ $(TAO_ROOT)/tao/TAO_Server_Request.i \
+ $(TAO_ROOT)/tao/Remote_Object_Proxy_Impl.h \
+ $(TAO_ROOT)/tao/LocalObject.h \
+ $(TAO_ROOT)/tao/LocalObject.i \
+ $(TAO_ROOT)/tao/Stub.h \
+ $(TAO_ROOT)/tao/Pluggable.h \
+ $(TAO_ROOT)/tao/Pluggable.i \
+ $(TAO_ROOT)/tao/MProfile.h \
+ $(TAO_ROOT)/tao/Profile.h \
+ $(TAO_ROOT)/tao/Tagged_Components.h \
+ $(TAO_ROOT)/tao/CONV_FRAMEC.h \
+ $(TAO_ROOT)/tao/CONV_FRAMEC.i \
+ $(TAO_ROOT)/tao/Tagged_Components.i \
+ $(TAO_ROOT)/tao/GIOP_Message_State.h \
+ $(TAO_ROOT)/tao/GIOP_Message_State.i \
+ $(TAO_ROOT)/tao/Profile.i \
+ $(TAO_ROOT)/tao/MProfile.i \
+ $(TAO_ROOT)/tao/ORB_Core.h \
+ $(TAO_ROOT)/tao/Policy_Manager.h \
+ $(TAO_ROOT)/tao/Policy_Manager.i \
+ $(TAO_ROOT)/tao/Resource_Factory.h \
+ $(TAO_ROOT)/tao/Protocol_Factory.h \
+ $(TAO_ROOT)/tao/params.h \
+ $(TAO_ROOT)/tao/params.i \
+ $(TAO_ROOT)/tao/TAO_Singleton_Manager.h \
+ $(TAO_ROOT)/tao/TAO_Singleton_Manager.inl \
+ $(TAO_ROOT)/tao/TAO_Singleton.h \
+ $(TAO_ROOT)/tao/TAO_Singleton.inl \
+ $(TAO_ROOT)/tao/TAO_Singleton.cpp \
+ $(ACE_ROOT)/ace/Object_Manager.h \
+ $(ACE_ROOT)/ace/Object_Manager.i \
+ $(ACE_ROOT)/ace/Managed_Object.h \
+ $(ACE_ROOT)/ace/Managed_Object.i \
+ $(ACE_ROOT)/ace/Managed_Object.cpp \
+ $(TAO_ROOT)/tao/Adapter.h \
+ $(TAO_ROOT)/tao/Adapter.i \
+ $(TAO_ROOT)/tao/PolicyFactory_Registry.h \
+ $(TAO_ROOT)/tao/PortableInterceptorC.h \
+ $(TAO_ROOT)/tao/DynamicC.h \
+ $(TAO_ROOT)/tao/DynamicC.i \
+ $(TAO_ROOT)/tao/MessagingC.h \
+ $(TAO_ROOT)/tao/ValueBase.h \
+ $(TAO_ROOT)/tao/ValueBase.i \
+ $(TAO_ROOT)/tao/ValueFactory.h \
+ $(TAO_ROOT)/tao/ValueFactory.i \
+ $(TAO_ROOT)/tao/TimeBaseC.h \
+ $(TAO_ROOT)/tao/TimeBaseC.i \
+ $(TAO_ROOT)/tao/PollableC.h \
+ $(TAO_ROOT)/tao/PollableC.i \
+ $(TAO_ROOT)/tao/MessagingC.i \
+ $(TAO_ROOT)/tao/PortableInterceptorC.i \
+ $(ACE_ROOT)/ace/Map_Manager.h \
+ $(ACE_ROOT)/ace/Map_Manager.i \
+ $(ACE_ROOT)/ace/Map_Manager.cpp \
+ $(TAO_ROOT)/tao/Parser_Registry.h \
+ $(TAO_ROOT)/tao/Parser_Registry.i \
+ $(TAO_ROOT)/tao/Service_Callbacks.h \
+ $(TAO_ROOT)/tao/Service_Callbacks.i \
+ $(TAO_ROOT)/tao/Fault_Tolerance_Service.h \
+ $(TAO_ROOT)/tao/Fault_Tolerance_Service.i \
+ $(TAO_ROOT)/tao/Connection_Cache_Manager.h \
+ $(ACE_ROOT)/ace/Hash_Map_Manager_T.h \
+ $(ACE_ROOT)/ace/Functor.h \
+ $(ACE_ROOT)/ace/Functor.i \
+ $(ACE_ROOT)/ace/Functor_T.h \
+ $(ACE_ROOT)/ace/Functor_T.i \
+ $(ACE_ROOT)/ace/Functor_T.cpp \
+ $(ACE_ROOT)/ace/Hash_Map_Manager_T.i \
+ $(ACE_ROOT)/ace/Hash_Map_Manager_T.cpp \
+ $(TAO_ROOT)/tao/Cache_Entries.h \
+ $(TAO_ROOT)/tao/Connection_Descriptor_Interface.h \
+ $(TAO_ROOT)/tao/Endpoint.h \
+ $(TAO_ROOT)/tao/Endpoint.i \
+ $(TAO_ROOT)/tao/Connection_Descriptor_Interface.inl \
+ $(TAO_ROOT)/tao/Cache_Entries.inl \
+ $(TAO_ROOT)/tao/Connection_Cache_Manager.inl \
+ $(TAO_ROOT)/tao/Cleanup_Func_Registry.h \
+ $(TAO_ROOT)/tao/Cleanup_Func_Registry.inl \
+ $(TAO_ROOT)/tao/Object_Ref_Table.h \
+ $(TAO_ROOT)/tao/Interceptor_List.h \
+ $(TAO_ROOT)/tao/Interceptor_List.inl \
+ $(TAO_ROOT)/tao/RT_Policy_i.h \
+ $(TAO_ROOT)/tao/RTCORBAS.h \
+ $(TAO_ROOT)/tao/IOPS.h \
+ $(TAO_ROOT)/tao/IOPS_T.h \
+ $(TAO_ROOT)/tao/IOPS_T.i \
+ $(TAO_ROOT)/tao/IOPS_T.cpp \
+ $(TAO_ROOT)/tao/IOPS.i \
+ $(TAO_ROOT)/tao/TimeBaseS.h \
+ $(TAO_ROOT)/tao/TimeBaseS_T.h \
+ $(TAO_ROOT)/tao/TimeBaseS_T.i \
+ $(TAO_ROOT)/tao/TimeBaseS_T.cpp \
+ $(TAO_ROOT)/tao/TimeBaseS.i \
+ $(TAO_ROOT)/tao/RTCORBAC.h \
+ $(TAO_ROOT)/tao/RTCORBAC.i \
+ $(TAO_ROOT)/tao/RTCORBAS_T.h \
+ $(TAO_ROOT)/tao/RTCORBAS_T.i \
+ $(TAO_ROOT)/tao/RTCORBAS_T.cpp \
+ $(TAO_ROOT)/tao/RTCORBAS.i \
+ $(TAO_ROOT)/tao/RT_Policy_i.i \
+ $(TAO_ROOT)/tao/Protocols_Hooks.h \
+ $(ACE_ROOT)/ace/Hash_Map_Manager.h \
+ $(ACE_ROOT)/ace/Thread_Manager.h \
+ $(ACE_ROOT)/ace/Singleton.h \
+ $(ACE_ROOT)/ace/Singleton.i \
+ $(ACE_ROOT)/ace/Singleton.cpp \
+ $(ACE_ROOT)/ace/Thread_Manager.i \
+ $(TAO_ROOT)/tao/ORB_Core.i \
+ $(TAO_ROOT)/tao/Stub.i \
+ $(TAO_ROOT)/tao/debug.h \
+ $(TAO_ROOT)/tao/Client_Strategy_Factory.h \
+ $(TAO_ROOT)/tao/Server_Strategy_Factory.h \
+ $(TAO_ROOT)/tao/Invocation.h \
+ $(TAO_ROOT)/tao/Synch_Reply_Dispatcher.h \
+ $(TAO_ROOT)/tao/Reply_Dispatcher.h \
+ $(TAO_ROOT)/tao/Reply_Dispatcher.i \
+ $(TAO_ROOT)/tao/TAOC.h \
+ $(TAO_ROOT)/tao/Priority_Mapping_Manager.h \
+ $(TAO_ROOT)/tao/Priority_Mapping.h \
+ $(TAO_ROOT)/tao/Priority_Mapping.i \
+ $(TAO_ROOT)/tao/Priority_Mapping_Manager.i \
+ $(TAO_ROOT)/tao/TAOC.i \
+ $(TAO_ROOT)/tao/operation_details.h \
+ $(TAO_ROOT)/tao/target_specification.h \
+ $(TAO_ROOT)/tao/target_specification.i \
+ $(TAO_ROOT)/tao/operation_details.i \
+ $(TAO_ROOT)/tao/Invocation_Endpoint_Selectors.h \
+ $(TAO_ROOT)/tao/Invocation_Endpoint_Selectors.i \
+ $(TAO_ROOT)/tao/Invocation.i \
+ $(TAO_ROOT)/tao/ObjectIDList.h \
+ $(TAO_ROOT)/tao/ObjectIDList.i \
+ $(TAO_ROOT)/tao/DomainC.h \
+ $(TAO_ROOT)/tao/ClientRequestInfo.h \
+ $(TAO_ROOT)/tao/StringSeqC.h \
+ $(TAO_ROOT)/tao/StringSeqC.i \
+ $(TAO_ROOT)/tao/ClientRequestInfo.inl \
+ $(TAO_ROOT)/tao/DomainC.i \
+ $(TAO_ROOT)/tao/WrongTransactionC.h \
+ $(TAO_ROOT)/tao/BoundsC.h \
+ $(TAO_ROOT)/tao/BoundsC.i \
+ $(TAO_ROOT)/tao/PortableInterceptor.h \
+ $(TAO_ROOT)/tao/PortableInterceptor.i \
+ $(TAO_ROOT)/tao/BiDirPolicyC.h \
+ $(TAO_ROOT)/tao/BiDirPolicyC.i \
+ $(TAO_ROOT)/tao/IFR_Client/InterfaceC.h \
+ $(TAO_ROOT)/tao/IFR_Client/ifrfwd.h \
+ $(TAO_ROOT)/tao/IFR_Client/ifr_client_export.h \
+ $(TAO_ROOT)/tao/IFR_Client/IFR_Client_Adapter_Impl.h \
+ $(TAO_ROOT)/tao/IFR_Client_Adapter.h \
+ $(TAO_ROOT)/tao/IFR_Client/InterfaceC.i \
+ TypeCodeFactoryC.inl TypeCodeFactory_i.h
+
+# IF YOU PUT ANYTHING HERE IT WILL GO AWAY
diff --git a/TAO/tao/TypeCodeFactory/Makefile.bor b/TAO/tao/TypeCodeFactory/Makefile.bor
new file mode 100644
index 00000000000..c0e02b9e520
--- /dev/null
+++ b/TAO/tao/TypeCodeFactory/Makefile.bor
@@ -0,0 +1,35 @@
+#
+# Makefile for building the TypeCodeFactory library
+#
+
+NAME = TAO_TypeCodeFactory
+
+OBJFILES = \
+	$(OBJDIR)\TypeCodeFactoryC.obj \
+	$(OBJDIR)\TypeCodeFactory_i.obj \
+	$(OBJDIR)\TypeCodeFactory_Loader.obj \
+        $(OBJDIR)\TypeCodeFactory_Adapter_Impl.obj
+
+!ifdef STATIC
+TCF_DLLFLAG=0
+!else
+TCF_DLLFLAG=1
+!endif
+
+CFLAGS = \
+	$(ACE_CFLAGS) \
+	$(TAO_CFLAGS) \
+	$(TAO_PORTABLESERVER_CFLAGS) \
+	$(TAO_IFR_CLIENT_CFLAGS) \
+	-DTCF_HAS_DLL=$(TCF_DLLFLAG) \
+	-DTCF_BUILD_DLL
+
+CPPDIR = .
+
+LIBFILES = \
+	$(ACE_LIB) \
+	$(TAO_LIB) \
+	$(TAO_PORTABLESERVER_LIB) \
+	$(TAO_IFR_CLIENT_LIB)
+
+!include <$(ACE_ROOT)\include\makeinclude\build_core_library.bor>
diff --git a/TAO/tao/TypeCodeFactory/README b/TAO/tao/TypeCodeFactory/README
new file mode 100644
index 00000000000..ac1240283f0
--- /dev/null
+++ b/TAO/tao/TypeCodeFactory/README
@@ -0,0 +1,27 @@
+$Id$
+
+TypeCodeFactory -------
+
+This library is used by the Interface Repository and
+by CORBA::ORB to create typecodes. To minimize 
+dependencies and footprint, this library need not be
+built or linked by an application. However, if an
+application needs to call CORBA::ORB::create_*_tc(),
+then it should #include the library's header file
+TypeCodeFactory_Adapter_Impl.h and link the library.
+This will automatically load the library, assuming
+it has been compiled. If an application is using the
+Interface Repository, nothing special need be done -
+the IFR will link the TypeCodeFactory library in its
+own build.
+
+Since the TypeCodeFactory must deal with Interface
+Repository data types, it depends on the 
+TAO_IFR_Client library.
+
+Typecode creation methods for recursive structs and
+unions, valuetypes, and CORBA components have not
+yet been implemented.
+
+For more information about the TypeCodeFactory, see
+ACE_ROOT/TAO/docs/releasenotes/index.html.
\ No newline at end of file
diff --git a/TAO/tao/TypeCodeFactory/TypeCodeFactory.dsp b/TAO/tao/TypeCodeFactory/TypeCodeFactory.dsp
new file mode 100644
index 00000000000..a6cbc12cd86
--- /dev/null
+++ b/TAO/tao/TypeCodeFactory/TypeCodeFactory.dsp
@@ -0,0 +1,143 @@
+# Microsoft Developer Studio Project File - Name="TypeCodeFactory" - Package Owner=<4>

+# Microsoft Developer Studio Generated Build File, Format Version 6.00

+# ** DO NOT EDIT **

+

+# TARGTYPE "Win32 (x86) Dynamic-Link Library" 0x0102

+

+CFG=TypeCodeFactory - Win32 Debug

+!MESSAGE This is not a valid makefile. To build this project using NMAKE,

+!MESSAGE use the Export Makefile command and run

+!MESSAGE 

+!MESSAGE NMAKE /f "TypeCodeFactory.mak".

+!MESSAGE 

+!MESSAGE You can specify a configuration when running NMAKE

+!MESSAGE by defining the macro CFG on the command line. For example:

+!MESSAGE 

+!MESSAGE NMAKE /f "TypeCodeFactory.mak" CFG="TypeCodeFactory - Win32 Debug"

+!MESSAGE 

+!MESSAGE Possible choices for configuration are:

+!MESSAGE 

+!MESSAGE "TypeCodeFactory - Win32 Release" (based on "Win32 (x86) Dynamic-Link Library")

+!MESSAGE "TypeCodeFactory - Win32 Debug" (based on "Win32 (x86) Dynamic-Link Library")

+!MESSAGE 

+

+# Begin Project

+# PROP AllowPerConfigDependencies 0

+# PROP Scc_ProjName ""

+# PROP Scc_LocalPath ""

+CPP=cl.exe

+MTL=midl.exe

+RSC=rc.exe

+

+!IF  "$(CFG)" == "TypeCodeFactory - Win32 Release"

+

+# PROP BASE Use_MFC 0

+# PROP BASE Use_Debug_Libraries 0

+# PROP BASE Output_Dir "Release"

+# PROP BASE Intermediate_Dir "Release"

+# PROP BASE Target_Dir ""

+# PROP Use_MFC 0

+# PROP Use_Debug_Libraries 0

+# PROP Output_Dir ""

+# PROP Intermediate_Dir "DLL\Release\TypeCodeFactory"

+# PROP Ignore_Export_Lib 0

+# PROP Target_Dir ""

+# ADD BASE CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "TYPECODEFACTORY_EXPORTS" /YX /FD /c

+# ADD CPP /nologo /MDd /W3 /GX /O2 /I "..\.." /I "..\..\.." /D TAO_TYPECODEFACTORY_HAS_DLL=1 /D "TAO_TYPECODEFACTORY_BUILD_DLL" /D "_DEBUG" /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /FD /c

+# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32

+# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32

+# ADD BASE RSC /l 0x409 /d "NDEBUG"

+# ADD RSC /l 0x409 /d "NDEBUG"

+BSC32=bscmake.exe

+# ADD BASE BSC32 /nologo

+# ADD BSC32 /nologo

+LINK32=link.exe

+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /machine:I386

+# ADD LINK32 TAO_IFR_Client.lib TAO.lib ace.lib /nologo /dll /machine:I386 /out:"..\..\..\bin\TAO_TypeCodeFactory.dll" /libpath:"..\..\tao\IFR_Client" /libpath:"..\..\tao" /libpath:"..\..\..\ace"

+

+!ELSEIF  "$(CFG)" == "TypeCodeFactory - Win32 Debug"

+

+# PROP BASE Use_MFC 0

+# PROP BASE Use_Debug_Libraries 1

+# PROP BASE Output_Dir "Debug"

+# PROP BASE Intermediate_Dir "Debug"

+# PROP BASE Target_Dir ""

+# PROP Use_MFC 0

+# PROP Use_Debug_Libraries 1

+# PROP Output_Dir ""

+# PROP Intermediate_Dir "DLL\Debug\TypeCodeFactory"

+# PROP Ignore_Export_Lib 0

+# PROP Target_Dir ""

+# ADD BASE CPP /nologo /MTd /W3 /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "TYPECODEFACTORY_EXPORTS" /YX /FD   /c

+# ADD CPP /nologo /MDd /W3 /Gm /GX /Zi /Od /I "..\.." /I "..\..\.." /D TAO_TYPECODEFACTORY_HAS_DLL=1 /D "TAO_TYPECODEFACTORY_BUILD_DLL" /D "_DEBUG" /D "WIN32" /D "_WINDOWS" /YX /FD   /c

+# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32

+# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32

+# ADD BASE RSC /l 0x409 /d "_DEBUG"

+# ADD RSC /l 0x409 /d "_DEBUG"

+BSC32=bscmake.exe

+# ADD BASE BSC32 /nologo

+# ADD BSC32 /nologo

+LINK32=link.exe

+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /debug /machine:I386 /pdbtype:sept

+# ADD LINK32 TAO_IFR_Clientd.lib TAOd.lib aced.lib /nologo /dll /debug /machine:I386 /out:"..\..\..\bin\TAO_TypeCodeFactoryd.dll" /pdbtype:sept /libpath:"..\..\tao\IFR_Client" /libpath:"..\..\tao" /libpath:"..\..\..\ace"

+

+!ENDIF 

+

+# Begin Target

+

+# Name "TypeCodeFactory - Win32 Release"

+# Name "TypeCodeFactory - Win32 Debug"

+# Begin Group "Source Files"

+

+# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"

+# Begin Source File

+

+SOURCE=.\TypeCodeFactory_Adapter_Impl.cpp

+# End Source File

+# Begin Source File

+

+SOURCE=.\TypeCodeFactory_i.cpp

+# End Source File

+# Begin Source File

+

+SOURCE=.\TypeCodeFactory_Loader.cpp

+# End Source File

+# Begin Source File

+

+SOURCE=.\TypeCodeFactoryC.cpp

+# End Source File

+# End Group

+# Begin Group "Header Files"

+

+# PROP Default_Filter "h;hpp;hxx;hm;inl"

+# Begin Source File

+

+SOURCE=.\TypeCodeFactory_Adapter_Impl.h

+# End Source File

+# Begin Source File

+

+SOURCE=.\typecodefactory_export.h

+# End Source File

+# Begin Source File

+

+SOURCE=.\TypeCodeFactory_i.h

+# End Source File

+# Begin Source File

+

+SOURCE=.\TypeCodeFactory_Loader.h

+# End Source File

+# Begin Source File

+

+SOURCE=.\TypeCodeFactoryC.h

+# End Source File

+# End Group

+# Begin Group "Inline Files"

+

+# PROP Default_Filter ""

+# Begin Source File

+

+SOURCE=.\TypeCodeFactoryC.inl

+# End Source File

+# End Group

+# End Target

+# End Project

diff --git a/TAO/tao/TypeCodeFactory/TypeCodeFactory.pidl b/TAO/tao/TypeCodeFactory/TypeCodeFactory.pidl
new file mode 100644
index 00000000000..c6fca988bc3
--- /dev/null
+++ b/TAO/tao/TypeCodeFactory/TypeCodeFactory.pidl
@@ -0,0 +1,171 @@
+//
+// $Id$
+//
+// ================================================================
+//
+// = LIBRARY
+//   TAO/tao/TypeCodeFactory
+//
+// = FILENAME
+//   TypeCodeFactory.pidl
+//
+// = DESCRIPTION
+//   This file was used to generate the code in TypeCodeFactoryC.{h,i,cpp}.
+//   It was originally part of Interface.idl, but since the TypeCodeFactory
+//   has been made into a separate library, and the TypeCodeFactory interface
+//   has been made local, it is simpler to generate the necessary stub
+//   code in TypeCodeFactoryC.* by splitting Interface.idl into two
+//   parts.
+//
+//   The command used to generate code from this file is:
+//
+//     tao_idl -o orig -Ge 1 -ci "C.inl" \
+//          -Wb,export_macro=TAO_TypeCodeFactory_Export \
+//          -Wb,export_include=typecodefactory_export.h \
+//          -Wb,pre_include="ace/pre.h" \
+//          -Wb,post_include="ace/post.h" \
+//          TypeCodeFactory.pidl
+//
+//   after the file is generated a patch must be applied.  The patch
+//   removes generated code for the typedefs appearing at the top of
+//   the IDL file below, since they are already included in the TAO
+//   library. Also the scoped names of the Interface Repository datatypes
+//   used in this file have been changed to their flat name counterparts
+//   (see the explanation in TAO/tao/IFR_Client/Interface.pidl).
+//
+//   Apply patches using the following commands:
+//
+//   patch < diffs/TypeCodeFactoryC.h.diff
+//   patch < diffs/TypeCodeFactoryC.inl.diff
+//   patch < diffs/TypeCodeFactoryC.cpp.diff
+//
+//   These patches are used to automate the above changes when the
+//   code, which is part of the TAO library, must be regenerated because
+//   of modifications to the output of the TAO IDL compiler.
+//
+//   Note: The diffs were generated with these commands:
+//
+//   diff -wbu orig/TypeCodeFactoryC.h TypeCodeFactoryC.h > diffs/TypeCodeFactoryC.h.diff
+//   diff -wbu orig/TypeCodeFactoryC.inl TypeCodeFactoryC.inl > diffs/TypeCodeFactoryC.inl.diff
+//   diff -wbu orig/TypeCodeFactoryC.cpp TypeCodeFactoryC.cpp > diffs/TypeCodeFactoryC.cpp.diff
+//
+// ================================================================
+
+#ifndef _TYPECODEFACTORY_IDL_
+#define _TYPECODEFACTORY_IDL_
+
+#pragma prefix "omg.org"
+
+module CORBA
+{
+  typedef string Identifier;
+  typedef string RepositoryId;
+  typedef short ValueModifier;
+
+  local interface TypeCodeFactory  // PIDL
+  {
+    TypeCode create_struct_tc (
+        in RepositoryId id,
+        in Identifier name,
+        in IR::StructMemberSeq members
+      );
+
+    TypeCode create_union_tc (
+        in RepositoryId id,
+        in Identifier name,
+        in TypeCode discriminator_type,
+        in IR::UnionMemberSeq members
+      );
+
+    TypeCode create_enum_tc (
+        in RepositoryId id,
+        in Identifier name,
+        in IR::EnumMemberSeq members
+      );
+
+    TypeCode create_alias_tc (
+        in RepositoryId id,
+        in Identifier name,
+        in TypeCode original_type
+      );
+
+    TypeCode create_exception_tc (
+        in RepositoryId id,
+        in Identifier name,
+        in IR::StructMemberSeq members
+      );
+
+    TypeCode create_interface_tc (
+        in RepositoryId id,
+        in Identifier name
+      );
+
+    TypeCode create_string_tc (
+        in unsigned long bound
+      );
+
+    TypeCode create_wstring_tc (
+        in unsigned long bound
+      );
+
+    TypeCode create_fixed_tc (
+        in unsigned short digits,
+        in unsigned short scale
+      );
+
+    TypeCode create_sequence_tc (
+        in unsigned long bound,
+        in TypeCode element_type
+      );
+
+    TypeCode create_array_tc (
+        in unsigned long length,
+        in TypeCode element_type
+      );
+
+    TypeCode create_value_tc (
+        in RepositoryId id,
+        in Identifier name,
+        in ValueModifier type_modifier,
+        in TypeCode concrete_base,
+        in IR::ValueMemberSeq members
+      );
+
+    TypeCode create_value_box_tc (
+        in RepositoryId id,
+        in Identifier name,
+        in TypeCode boxed_type
+      );
+
+    TypeCode create_native_tc (
+        in RepositoryId id,
+        in Identifier name
+      );
+
+    TypeCode create_recursive_tc (
+        in RepositoryId id
+      );
+
+    TypeCode create_abstract_interface_tc (
+        in RepositoryId id,
+        in Identifier name
+      );
+
+    TypeCode create_local_interface_tc (
+        in RepositoryId id,
+        in Identifier name
+      );
+    TypeCode create_component_tc (
+        in RepositoryId id,
+        in Identifier name
+      );
+
+    TypeCode create_home_tc (
+        in RepositoryId id,
+        in Identifier name
+      );
+  };
+};
+
+#pragma prefix ""
+#endif // _TYPECODEFACTORY_IDL_
diff --git a/TAO/tao/TypeCodeFactory/TypeCodeFactoryC.cpp b/TAO/tao/TypeCodeFactory/TypeCodeFactoryC.cpp
new file mode 100644
index 00000000000..8d0f3a26462
--- /dev/null
+++ b/TAO/tao/TypeCodeFactory/TypeCodeFactoryC.cpp
@@ -0,0 +1,112 @@
+// -*- C++ -*- 
+//
+// $Id$
+
+// ****  Code generated by the The ACE ORB (TAO) IDL Compiler ****
+// TAO and the TAO IDL Compiler have been developed by:
+//       Center for Distributed Object Computing
+//       Washington University
+//       St. Louis, MO
+//       USA
+//       http://www.cs.wustl.edu/~schmidt/doc-center.html
+// and
+//       Distributed Object Computing Laboratory
+//       University of California at Irvine
+//       Irvine, CA
+//       USA
+//       http://doc.ece.uci.edu/
+//
+// Information about TAO is available at:
+//                 http://www.cs.wustl.edu/~schmidt/TAO.html
+
+#include "TypeCodeFactory_Loader.h"
+
+#if TAO_HAS_INTERCEPTORS == 1
+#include "tao/RequestInfo_Util.h"
+#endif  /* TAO_HAS_INTERCEPTORS == 1 */
+
+#if defined (__BORLANDC__)
+#pragma option -w-rvl -w-rch -w-ccc -w-aus
+#endif /* __BORLANDC__ */
+
+#if !defined (__ACE_INLINE__)
+#include "TypeCodeFactoryC.inl"
+#endif /* !defined INLINE */
+
+// Default constructor.
+CORBA_TypeCodeFactory::CORBA_TypeCodeFactory (void)
+{}
+
+// Destructor.
+CORBA_TypeCodeFactory::~CORBA_TypeCodeFactory (void)
+{}
+
+CORBA::TypeCodeFactory_ptr CORBA::TypeCodeFactory::_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+{
+  return CORBA::TypeCodeFactory::_unchecked_narrow (obj, ACE_TRY_ENV);
+}
+
+CORBA::TypeCodeFactory_ptr CORBA::TypeCodeFactory::_unchecked_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &
+  )
+{
+  if (CORBA::is_nil (obj))
+    return CORBA::TypeCodeFactory::_nil ();
+
+  return
+      ACE_reinterpret_cast
+        (
+          CORBA_TypeCodeFactory_ptr,
+            obj->_tao_QueryInterface
+              (
+                ACE_reinterpret_cast
+                  (
+                    ptr_arith_t,
+                    &CORBA_TypeCodeFactory::_narrow
+                  )
+              )
+        );
+}
+
+CORBA::TypeCodeFactory_ptr
+CORBA::TypeCodeFactory::_duplicate (CORBA::TypeCodeFactory_ptr obj)
+{
+  if (!CORBA::is_nil (obj))
+    obj->_add_ref ();
+  return obj;
+}
+
+void *
+CORBA::TypeCodeFactory::_tao_QueryInterface (ptr_arith_t type)
+{
+  void *retv = 0;
+  if (type == ACE_reinterpret_cast
+    (ptr_arith_t,
+      &CORBA_TypeCodeFactory::_narrow))
+    retv = ACE_reinterpret_cast (void*, this);
+  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
+    retv = ACE_reinterpret_cast (void *,
+      ACE_static_cast (CORBA::Object_ptr, this));
+    
+  if (retv)
+    this->_add_ref ();
+  return retv;
+}
+
+const char *
+CORBA::TypeCodeFactory::_interface_repository_id (void) const
+{
+  return "IDL:omg.org/CORBA/TypeCodeFactory:1.0";
+}
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
+    defined (ACE_HAS_GNU_REPO)
+    template class TAO_Object_Manager<CORBA::TypeCodeFactory,CORBA::TypeCodeFactory_var>;
+  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+  #  pragma instantiate TAO_Object_Manager<CORBA::TypeCodeFactory,CORBA::TypeCodeFactory_var>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
diff --git a/TAO/tao/TypeCodeFactory/TypeCodeFactoryC.h b/TAO/tao/TypeCodeFactory/TypeCodeFactoryC.h
new file mode 100644
index 00000000000..387a0439c92
--- /dev/null
+++ b/TAO/tao/TypeCodeFactory/TypeCodeFactoryC.h
@@ -0,0 +1,355 @@
+// -*- C++ -*- 
+//
+// $Id$
+
+// ****  Code generated by the The ACE ORB (TAO) IDL Compiler ****
+// TAO and the TAO IDL Compiler have been developed by:
+//       Center for Distributed Object Computing
+//       Washington University
+//       St. Louis, MO
+//       USA
+//       http://www.cs.wustl.edu/~schmidt/doc-center.html
+// and
+//       Distributed Object Computing Laboratory
+//       University of California at Irvine
+//       Irvine, CA
+//       USA
+//       http://doc.ece.uci.edu/
+//
+// Information about TAO is available at:
+//                 http://www.cs.wustl.edu/~schmidt/TAO.html
+
+#ifndef TAO_TYPECODEFACTORYC_H
+#define TAO_TYPECODEFACTORYC_H
+
+#ifndef TAO_TYPECODEFACTORY_SAFE_INCLUDE
+#error "You should not include TypeCodeFactoryC.h directly, use TCF_Loader.h"
+#endif /* !TAO_TYPECODEFACTORY_SAFE_INCLUDE */
+
+#include "ace/pre.h"
+#include "typecodefactory_export.h"
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+# pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+#include "tao/Object.h"
+
+#if defined (TAO_EXPORT_MACRO)
+#undef TAO_EXPORT_MACRO
+#endif
+#define TAO_EXPORT_MACRO TAO_TypeCodeFactory_Export
+
+#if defined (TAO_EXPORT_NESTED_CLASSES)
+#  if defined (TAO_EXPORT_NESTED_MACRO)
+#    undef TAO_EXPORT_NESTED_MACRO
+#  endif /* defined (TAO_EXPORT_NESTED_MACRO) */
+#  define TAO_EXPORT_NESTED_MACRO TAO_TypeCodeFactory_Export
+#endif /* TAO_EXPORT_NESTED_CLASSES */
+
+#if defined(_MSC_VER)
+#if (_MSC_VER >= 1200)
+#pragma warning(push)
+#endif /* _MSC_VER >= 1200 */
+#pragma warning(disable:4250)
+#endif /* _MSC_VER */
+
+#if defined (__BORLANDC__)
+#pragma option push -w-rvl -w-rch -w-ccc -w-inl
+#endif /* __BORLANDC__ */
+
+class TAO_TypeCodeFactory_Export CORBA_TypeCodeFactory_var 
+  : public TAO_Base_var
+{
+public:
+  CORBA_TypeCodeFactory_var (void); // default constructor
+  CORBA_TypeCodeFactory_var (CORBA_TypeCodeFactory_ptr p) : ptr_ (p) {} 
+  CORBA_TypeCodeFactory_var (const CORBA_TypeCodeFactory_var &); // copy constructor
+  ~CORBA_TypeCodeFactory_var (void); // destructor
+
+  CORBA_TypeCodeFactory_var &operator= (CORBA_TypeCodeFactory_ptr);
+  CORBA_TypeCodeFactory_var &operator= (const CORBA_TypeCodeFactory_var &);
+  CORBA_TypeCodeFactory_ptr operator-> (void) const;
+
+  operator const CORBA_TypeCodeFactory_ptr &() const;
+  operator CORBA_TypeCodeFactory_ptr &();
+  // in, inout, out, _retn
+  CORBA_TypeCodeFactory_ptr in (void) const;
+  CORBA_TypeCodeFactory_ptr &inout (void);
+  CORBA_TypeCodeFactory_ptr &out (void);
+  CORBA_TypeCodeFactory_ptr _retn (void);
+  CORBA_TypeCodeFactory_ptr ptr (void) const;
+
+private:
+  CORBA_TypeCodeFactory_ptr ptr_;
+  // Unimplemented - prevents widening assignment.
+  CORBA_TypeCodeFactory_var (const TAO_Base_var &rhs);
+  CORBA_TypeCodeFactory_var &operator= (const TAO_Base_var &rhs);
+};
+
+class TAO_TypeCodeFactory_Export CORBA_TypeCodeFactory_out
+{
+public:
+  CORBA_TypeCodeFactory_out (CORBA_TypeCodeFactory_ptr &);
+  CORBA_TypeCodeFactory_out (CORBA_TypeCodeFactory_var &);
+  CORBA_TypeCodeFactory_out (const CORBA_TypeCodeFactory_out &);
+  CORBA_TypeCodeFactory_out &operator= (const CORBA_TypeCodeFactory_out &);
+  CORBA_TypeCodeFactory_out &operator= (const CORBA_TypeCodeFactory_var &);
+  CORBA_TypeCodeFactory_out &operator= (CORBA_TypeCodeFactory_ptr);
+  operator CORBA_TypeCodeFactory_ptr &();
+  CORBA_TypeCodeFactory_ptr &ptr (void);
+  CORBA_TypeCodeFactory_ptr operator-> (void);
+
+private:
+  CORBA_TypeCodeFactory_ptr &ptr_;
+};
+
+class TAO_TypeCodeFactory_Export CORBA_TypeCodeFactory 
+  : public virtual CORBA_Object
+  {
+  public:
+  #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+    typedef CORBA_TypeCodeFactory_ptr _ptr_type;
+    typedef CORBA_TypeCodeFactory_var _var_type;
+  #endif /* ! __GNUC__ || g++ >= 2.8 */
+
+    // the static operations
+    static CORBA_TypeCodeFactory_ptr _duplicate (CORBA_TypeCodeFactory_ptr obj);
+    static CORBA_TypeCodeFactory_ptr _narrow (
+        CORBA::Object_ptr obj,
+        CORBA::Environment &env =
+          TAO_default_environment ()
+      );
+    static CORBA_TypeCodeFactory_ptr _unchecked_narrow (
+        CORBA::Object_ptr obj,
+        CORBA::Environment &env =
+          TAO_default_environment ()
+      );
+    static CORBA_TypeCodeFactory_ptr _nil (void)
+      {
+        return (CORBA_TypeCodeFactory_ptr)0;
+      }
+
+    virtual CORBA::TypeCode_ptr create_struct_tc (
+        const char * id,
+        const char * name,
+        const CORBA_StructMemberSeq & members,
+        CORBA::Environment &ACE_TRY_ENV =
+          TAO_default_environment ()
+      )
+      ACE_THROW_SPEC ((
+        CORBA::SystemException
+      )) = 0;
+
+    virtual CORBA::TypeCode_ptr create_union_tc (
+        const char * id,
+        const char * name,
+        CORBA::TypeCode_ptr discriminator_type,
+        const CORBA_UnionMemberSeq & members,
+        CORBA::Environment &ACE_TRY_ENV =
+          TAO_default_environment ()
+      )
+      ACE_THROW_SPEC ((
+        CORBA::SystemException
+      )) = 0;
+
+    virtual CORBA::TypeCode_ptr create_enum_tc (
+        const char * id,
+        const char * name,
+        const CORBA_EnumMemberSeq & members,
+        CORBA::Environment &ACE_TRY_ENV =
+          TAO_default_environment ()
+      )
+      ACE_THROW_SPEC ((
+        CORBA::SystemException
+      )) = 0;
+
+    virtual CORBA::TypeCode_ptr create_alias_tc (
+        const char * id,
+        const char * name,
+        CORBA::TypeCode_ptr original_type,
+        CORBA::Environment &ACE_TRY_ENV =
+          TAO_default_environment ()
+      )
+      ACE_THROW_SPEC ((
+        CORBA::SystemException
+      )) = 0;
+
+    virtual CORBA::TypeCode_ptr create_exception_tc (
+        const char * id,
+        const char * name,
+        const CORBA_StructMemberSeq & members,
+        CORBA::Environment &ACE_TRY_ENV =
+          TAO_default_environment ()
+      )
+      ACE_THROW_SPEC ((
+        CORBA::SystemException
+      )) = 0;
+
+    virtual CORBA::TypeCode_ptr create_interface_tc (
+        const char * id,
+        const char * name,
+        CORBA::Environment &ACE_TRY_ENV =
+          TAO_default_environment ()
+      )
+      ACE_THROW_SPEC ((
+        CORBA::SystemException
+      )) = 0;
+
+    virtual CORBA::TypeCode_ptr create_string_tc (
+        CORBA::ULong bound,
+        CORBA::Environment &ACE_TRY_ENV =
+          TAO_default_environment ()
+      )
+      ACE_THROW_SPEC ((
+        CORBA::SystemException
+      )) = 0;
+
+    virtual CORBA::TypeCode_ptr create_wstring_tc (
+        CORBA::ULong bound,
+        CORBA::Environment &ACE_TRY_ENV =
+          TAO_default_environment ()
+      )
+      ACE_THROW_SPEC ((
+        CORBA::SystemException
+      )) = 0;
+
+    virtual CORBA::TypeCode_ptr create_fixed_tc (
+        CORBA::UShort digits,
+        CORBA::UShort scale,
+        CORBA::Environment &ACE_TRY_ENV =
+          TAO_default_environment ()
+      )
+      ACE_THROW_SPEC ((
+        CORBA::SystemException
+      )) = 0;
+
+    virtual CORBA::TypeCode_ptr create_sequence_tc (
+        CORBA::ULong bound,
+        CORBA::TypeCode_ptr element_type,
+        CORBA::Environment &ACE_TRY_ENV =
+          TAO_default_environment ()
+      )
+      ACE_THROW_SPEC ((
+        CORBA::SystemException
+      )) = 0;
+
+    virtual CORBA::TypeCode_ptr create_array_tc (
+        CORBA::ULong length,
+        CORBA::TypeCode_ptr element_type,
+        CORBA::Environment &ACE_TRY_ENV =
+          TAO_default_environment ()
+      )
+      ACE_THROW_SPEC ((
+        CORBA::SystemException
+      )) = 0;
+
+    virtual CORBA::TypeCode_ptr create_value_tc (
+        const char * id,
+        const char * name,
+        CORBA::ValueModifier type_modifier,
+        CORBA::TypeCode_ptr concrete_base,
+        const CORBA_ValueMemberSeq & members,
+        CORBA::Environment &ACE_TRY_ENV =
+          TAO_default_environment ()
+      )
+      ACE_THROW_SPEC ((
+        CORBA::SystemException
+      )) = 0;
+
+    virtual CORBA::TypeCode_ptr create_value_box_tc (
+        const char * id,
+        const char * name,
+        CORBA::TypeCode_ptr boxed_type,
+        CORBA::Environment &ACE_TRY_ENV =
+          TAO_default_environment ()
+      )
+      ACE_THROW_SPEC ((
+        CORBA::SystemException
+      )) = 0;
+
+    virtual CORBA::TypeCode_ptr create_native_tc (
+        const char * id,
+        const char * name,
+        CORBA::Environment &ACE_TRY_ENV =
+          TAO_default_environment ()
+      )
+      ACE_THROW_SPEC ((
+        CORBA::SystemException
+      )) = 0;
+
+    virtual CORBA::TypeCode_ptr create_recursive_tc (
+        const char * id,
+        CORBA::Environment &ACE_TRY_ENV =
+          TAO_default_environment ()
+      )
+      ACE_THROW_SPEC ((
+        CORBA::SystemException
+      )) = 0;
+
+    virtual CORBA::TypeCode_ptr create_abstract_interface_tc (
+        const char * id,
+        const char * name,
+        CORBA::Environment &ACE_TRY_ENV =
+          TAO_default_environment ()
+      )
+      ACE_THROW_SPEC ((
+        CORBA::SystemException
+      )) = 0;
+
+    virtual CORBA::TypeCode_ptr create_local_interface_tc (
+        const char *id,
+        const char *name,
+        CORBA::Environment &ACE_TRY_ENV =
+          TAO_default_environment ()
+      )
+      ACE_THROW_SPEC ((
+        CORBA::SystemException
+      )) = 0;
+
+    virtual CORBA::TypeCode_ptr create_component_tc (
+        const char * id,
+        const char * name,
+        CORBA::Environment &ACE_TRY_ENV =
+          TAO_default_environment ()
+      )
+      ACE_THROW_SPEC ((
+        CORBA::SystemException
+      )) = 0;
+
+    virtual CORBA::TypeCode_ptr create_home_tc (
+        const char * id,
+        const char * name,
+        CORBA::Environment &ACE_TRY_ENV =
+          TAO_default_environment ()
+      )
+      ACE_THROW_SPEC ((
+        CORBA::SystemException
+      )) = 0;
+
+    virtual void *_tao_QueryInterface (ptr_arith_t type);
+    
+    virtual const char* _interface_repository_id (void) const;
+
+  protected:
+    CORBA_TypeCodeFactory (void);
+    virtual ~CORBA_TypeCodeFactory (void);
+  private:
+    CORBA_TypeCodeFactory (const CORBA_TypeCodeFactory &);
+    void operator= (const CORBA_TypeCodeFactory &);
+};
+
+#if defined (__ACE_INLINE__)
+#include "TypeCodeFactoryC.inl"
+#endif /* defined INLINE */
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+#pragma warning(pop)
+#endif /* _MSC_VER */
+
+#if defined (__BORLANDC__)
+#pragma option pop
+#endif /* __BORLANDC__ */
+
+#include "ace/post.h"
+#endif /* TAO_TYPECODEFACTORYC_H */
diff --git a/TAO/tao/TypeCodeFactory/TypeCodeFactoryC.inl b/TAO/tao/TypeCodeFactory/TypeCodeFactoryC.inl
new file mode 100644
index 00000000000..a82f282ba04
--- /dev/null
+++ b/TAO/tao/TypeCodeFactory/TypeCodeFactoryC.inl
@@ -0,0 +1,172 @@
+/* -*- C++ -*- */
+//$Id$
+
+#if !defined (_CORBA_TYPECODEFACTORY___VAR_CI_)
+#define _CORBA_TYPECODEFACTORY___VAR_CI_
+
+// *************************************************************
+// Inline operations for class CORBA_TypeCodeFactory_var
+// *************************************************************
+
+ACE_INLINE
+CORBA_TypeCodeFactory_var::CORBA_TypeCodeFactory_var (void) // default constructor
+  : ptr_ (CORBA_TypeCodeFactory::_nil ())
+{}
+
+ACE_INLINE ::CORBA_TypeCodeFactory_ptr
+CORBA_TypeCodeFactory_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+CORBA_TypeCodeFactory_var::CORBA_TypeCodeFactory_var (const ::CORBA_TypeCodeFactory_var &p) // copy constructor
+  : TAO_Base_var (),
+    ptr_ (CORBA_TypeCodeFactory::_duplicate (p.ptr ()))
+{}
+
+ACE_INLINE
+CORBA_TypeCodeFactory_var::~CORBA_TypeCodeFactory_var (void) // destructor
+{
+  CORBA::release (this->ptr_);
+}
+
+ACE_INLINE CORBA_TypeCodeFactory_var &
+CORBA_TypeCodeFactory_var::operator= (CORBA_TypeCodeFactory_ptr p)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE CORBA_TypeCodeFactory_var &
+CORBA_TypeCodeFactory_var::operator= (const ::CORBA_TypeCodeFactory_var &p)
+{
+  if (this != &p)
+  {
+    CORBA::release (this->ptr_);
+    this->ptr_ = ::CORBA_TypeCodeFactory::_duplicate (p.ptr ());
+  }
+  return *this;
+}
+
+ACE_INLINE
+CORBA_TypeCodeFactory_var::operator const ::CORBA_TypeCodeFactory_ptr &() const // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+CORBA_TypeCodeFactory_var::operator ::CORBA_TypeCodeFactory_ptr &() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_TypeCodeFactory_ptr
+CORBA_TypeCodeFactory_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_TypeCodeFactory_ptr
+CORBA_TypeCodeFactory_var::in (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_TypeCodeFactory_ptr &
+CORBA_TypeCodeFactory_var::inout (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_TypeCodeFactory_ptr &
+CORBA_TypeCodeFactory_var::out (void)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = ::CORBA_TypeCodeFactory::_nil ();
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_TypeCodeFactory_ptr
+CORBA_TypeCodeFactory_var::_retn (void)
+{
+  // yield ownership of managed obj reference
+  ::CORBA_TypeCodeFactory_ptr val = this->ptr_;
+  this->ptr_ = ::CORBA_TypeCodeFactory::_nil ();
+  return val;
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_CORBA_TYPECODEFACTORY___OUT_CI_)
+#define _CORBA_TYPECODEFACTORY___OUT_CI_
+
+// *************************************************************
+// Inline operations for class CORBA_TypeCodeFactory_out
+// *************************************************************
+
+ACE_INLINE
+CORBA_TypeCodeFactory_out::CORBA_TypeCodeFactory_out (CORBA_TypeCodeFactory_ptr &p)
+  : ptr_ (p)
+{
+  this->ptr_ = ::CORBA_TypeCodeFactory::_nil ();
+}
+
+ACE_INLINE
+CORBA_TypeCodeFactory_out::CORBA_TypeCodeFactory_out (CORBA_TypeCodeFactory_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = ::CORBA_TypeCodeFactory::_nil ();
+}
+
+ACE_INLINE
+CORBA_TypeCodeFactory_out::CORBA_TypeCodeFactory_out (const ::CORBA_TypeCodeFactory_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (CORBA_TypeCodeFactory_out &, p).ptr_)
+{}
+
+ACE_INLINE ::CORBA_TypeCodeFactory_out &
+CORBA_TypeCodeFactory_out::operator= (const ::CORBA_TypeCodeFactory_out &p)
+{
+  this->ptr_ = ACE_const_cast (CORBA_TypeCodeFactory_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE CORBA_TypeCodeFactory_out &
+CORBA_TypeCodeFactory_out::operator= (const ::CORBA_TypeCodeFactory_var &p)
+{
+  this->ptr_ = ::CORBA_TypeCodeFactory::_duplicate (p.ptr ());
+  return *this;
+}
+
+ACE_INLINE CORBA_TypeCodeFactory_out &
+CORBA_TypeCodeFactory_out::operator= (CORBA_TypeCodeFactory_ptr p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE
+CORBA_TypeCodeFactory_out::operator ::CORBA_TypeCodeFactory_ptr &() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_TypeCodeFactory_ptr &
+CORBA_TypeCodeFactory_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::CORBA_TypeCodeFactory_ptr
+CORBA_TypeCodeFactory_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+
+#endif /* end #if !defined */
+
diff --git a/TAO/tao/TypeCodeFactory/TypeCodeFactory_Adapter_Impl.cpp b/TAO/tao/TypeCodeFactory/TypeCodeFactory_Adapter_Impl.cpp
new file mode 100644
index 00000000000..4f64ad31a96
--- /dev/null
+++ b/TAO/tao/TypeCodeFactory/TypeCodeFactory_Adapter_Impl.cpp
@@ -0,0 +1,310 @@
+// $Id$
+
+#include "TypeCodeFactory_Adapter_Impl.h"
+#include "TypeCodeFactory_i.h"
+#include "tao/ORB_Core.h"
+
+ACE_RCSID(IFR_Service, TypeCodeFactory_Adapter_Impl, "$Id$")
+
+TAO_TypeCodeFactory_Adapter_Impl::~TAO_TypeCodeFactory_Adapter_Impl (void)
+{
+}
+
+CORBA::TypeCode_ptr 
+TAO_TypeCodeFactory_Adapter_Impl::create_struct_tc (
+    const char * id,
+    const char * name,
+    const CORBA_StructMemberSeq & members,
+    CORBA::Environment &ACE_TRY_ENV
+  )  
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  TAO_TypeCodeFactory_i tcf;
+
+  return tcf.create_struct_tc (id,
+                               name,
+                               members,
+                               ACE_TRY_ENV);              
+}
+
+CORBA::TypeCode_ptr 
+TAO_TypeCodeFactory_Adapter_Impl::create_union_tc (
+    const char * id,
+    const char * name,
+    CORBA::TypeCode_ptr discriminator_type,
+    const CORBA_UnionMemberSeq & members,
+    CORBA::Environment &ACE_TRY_ENV
+  )  
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  TAO_TypeCodeFactory_i tcf;
+
+  return tcf.create_union_tc (id,
+                              name,
+                              discriminator_type,
+                              members,
+                              ACE_TRY_ENV);              
+}
+
+CORBA::TypeCode_ptr 
+TAO_TypeCodeFactory_Adapter_Impl::create_enum_tc (
+    const char * id,
+    const char * name,
+    const CORBA_EnumMemberSeq & members,
+    CORBA::Environment &ACE_TRY_ENV
+  )  
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  TAO_TypeCodeFactory_i tcf;
+
+  return tcf.create_enum_tc (id,
+                             name,
+                             members,
+                             ACE_TRY_ENV);              
+}
+
+CORBA::TypeCode_ptr 
+TAO_TypeCodeFactory_Adapter_Impl::create_alias_tc (
+    const char * id,
+    const char * name,
+    CORBA::TypeCode_ptr original_type,
+    CORBA::Environment &ACE_TRY_ENV
+  )  
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  TAO_TypeCodeFactory_i tcf;
+
+  return tcf.create_alias_tc (id,
+                              name,
+                              original_type,
+                              ACE_TRY_ENV);              
+}
+
+CORBA::TypeCode_ptr 
+TAO_TypeCodeFactory_Adapter_Impl::create_exception_tc (
+    const char * id,
+    const char * name,
+    const CORBA_StructMemberSeq & members,
+    CORBA::Environment &ACE_TRY_ENV
+  )  
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  TAO_TypeCodeFactory_i tcf;
+
+  return tcf.create_exception_tc (id,
+                                  name,
+                                  members,
+                                  ACE_TRY_ENV);              
+}
+
+CORBA::TypeCode_ptr 
+TAO_TypeCodeFactory_Adapter_Impl::create_interface_tc (
+    const char * id,
+    const char * name,
+    CORBA::Environment &ACE_TRY_ENV
+  )  
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  TAO_TypeCodeFactory_i tcf;
+
+  return tcf.create_interface_tc (id,
+                                  name,
+                                  ACE_TRY_ENV);              
+}
+
+CORBA::TypeCode_ptr 
+TAO_TypeCodeFactory_Adapter_Impl::create_string_tc (
+    CORBA::ULong bound,
+    CORBA::Environment &ACE_TRY_ENV
+  )  
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  TAO_TypeCodeFactory_i tcf;
+
+  return tcf.create_string_tc (bound,
+                               ACE_TRY_ENV);              
+}
+
+CORBA::TypeCode_ptr 
+TAO_TypeCodeFactory_Adapter_Impl::create_wstring_tc (
+    CORBA::ULong bound,
+    CORBA::Environment &ACE_TRY_ENV
+  )  
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  TAO_TypeCodeFactory_i tcf;
+
+  return tcf.create_wstring_tc (bound,
+                                ACE_TRY_ENV);              
+}
+
+CORBA::TypeCode_ptr 
+TAO_TypeCodeFactory_Adapter_Impl::create_fixed_tc (
+    CORBA::UShort digits,
+    CORBA::UShort scale,
+    CORBA::Environment &ACE_TRY_ENV
+  )  
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  TAO_TypeCodeFactory_i tcf;
+
+  return tcf.create_fixed_tc (digits,
+                              scale,
+                              ACE_TRY_ENV);              
+}
+
+CORBA::TypeCode_ptr 
+TAO_TypeCodeFactory_Adapter_Impl::create_sequence_tc (
+    CORBA::ULong bound,
+    CORBA::TypeCode_ptr element_type,
+    CORBA::Environment &ACE_TRY_ENV
+  )  
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  TAO_TypeCodeFactory_i tcf;
+
+  return tcf.create_sequence_tc (bound,
+                                 element_type,
+                                 ACE_TRY_ENV);              
+}
+
+CORBA::TypeCode_ptr 
+TAO_TypeCodeFactory_Adapter_Impl::create_array_tc (
+    CORBA::ULong length,
+    CORBA::TypeCode_ptr element_type,
+    CORBA::Environment &ACE_TRY_ENV
+  )  
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  TAO_TypeCodeFactory_i tcf;
+
+  return tcf.create_array_tc (length,
+                              element_type,
+                              ACE_TRY_ENV);              
+}
+
+CORBA::TypeCode_ptr 
+TAO_TypeCodeFactory_Adapter_Impl::create_value_tc (
+    const char * id,
+    const char * name,
+    CORBA::ValueModifier type_modifier,
+    CORBA::TypeCode_ptr concrete_base,
+    const CORBA_ValueMemberSeq & members,
+    CORBA::Environment &ACE_TRY_ENV
+  )  
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  TAO_TypeCodeFactory_i tcf;
+
+  return tcf.create_value_tc (id,
+                              name,
+                              type_modifier,
+                              concrete_base,
+                              members,
+                              ACE_TRY_ENV);              
+}
+
+CORBA::TypeCode_ptr 
+TAO_TypeCodeFactory_Adapter_Impl::create_value_box_tc (
+    const char * id,
+    const char * name,
+    CORBA::TypeCode_ptr boxed_type,
+    CORBA::Environment &ACE_TRY_ENV
+  )  
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  TAO_TypeCodeFactory_i tcf;
+
+  return tcf.create_value_box_tc (id,
+                                  name,
+                                  boxed_type,
+                                  ACE_TRY_ENV);              
+}
+
+CORBA::TypeCode_ptr 
+TAO_TypeCodeFactory_Adapter_Impl::create_native_tc (
+    const char * id,
+    const char * name,
+    CORBA::Environment &ACE_TRY_ENV
+  )  
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  TAO_TypeCodeFactory_i tcf;
+
+  return tcf.create_native_tc (id,
+                               name,
+                               ACE_TRY_ENV);              
+}
+
+CORBA::TypeCode_ptr 
+TAO_TypeCodeFactory_Adapter_Impl::create_recursive_tc (
+    const char * id,
+    CORBA::Environment &ACE_TRY_ENV
+  )  
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  TAO_TypeCodeFactory_i tcf;
+
+  return tcf.create_recursive_tc (id,
+                                  ACE_TRY_ENV);              
+}
+
+CORBA::TypeCode_ptr 
+TAO_TypeCodeFactory_Adapter_Impl::create_abstract_interface_tc (
+    const char * id,
+    const char * name,
+    CORBA::Environment &ACE_TRY_ENV
+  )  
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  TAO_TypeCodeFactory_i tcf;
+
+  return tcf.create_abstract_interface_tc (id,
+                                           name,
+                                           ACE_TRY_ENV);
+}
+
+CORBA::TypeCode_ptr 
+TAO_TypeCodeFactory_Adapter_Impl::create_local_interface_tc (
+    const char * id,
+    const char * name,
+    CORBA::Environment &ACE_TRY_ENV
+  )  
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  TAO_TypeCodeFactory_i tcf;
+
+  return tcf.create_local_interface_tc (id,
+                                        name,
+                                        ACE_TRY_ENV);
+}
+
+// *********************************************************************
+
+// Initialization and registration of dynamic service object.
+
+int
+TAO_TypeCodeFactory_Adapter_Impl::Initializer (void)
+{
+  TAO_ORB_Core::typecodefactory_adapter_name (
+      "Concrete_TypeCodeFactory_Adapter"
+    );
+
+  ACE_Service_Config::static_svcs ()->insert (
+      &ace_svc_desc_TAO_TypeCodeFactory_Adapter_Impl
+    );
+  
+  return 0;
+}
+
+ACE_STATIC_SVC_DEFINE (
+    TAO_TypeCodeFactory_Adapter_Impl,
+    ACE_TEXT ("Concrete_TypeCodeFactory_Adapter"),
+    ACE_SVC_OBJ_T,
+    &ACE_SVC_NAME (TAO_TypeCodeFactory_Adapter_Impl),
+    ACE_Service_Type::DELETE_THIS | ACE_Service_Type::DELETE_OBJ,
+    0
+  )
+
+ACE_FACTORY_DEFINE (TAO_TypeCodeFactory, TAO_TypeCodeFactory_Adapter_Impl)
+
diff --git a/TAO/tao/TypeCodeFactory/TypeCodeFactory_Adapter_Impl.h b/TAO/tao/TypeCodeFactory/TypeCodeFactory_Adapter_Impl.h
new file mode 100644
index 00000000000..c83bb32af7c
--- /dev/null
+++ b/TAO/tao/TypeCodeFactory/TypeCodeFactory_Adapter_Impl.h
@@ -0,0 +1,209 @@
+// This may look like C, but it's really -*- C++ -*-
+
+//=============================================================================
+/**
+ *  @file    TypeCodeFactory_Adapter_Impl.h
+ *
+ *  $Id$
+ *
+ *  @author  Jeff Parsons <parsons@cs.wustl.edu>
+ */
+//=============================================================================
+
+
+#ifndef TAO_TYPECODEFACTORY_ADAPTER_IMPL_H
+#define TAO_TYPECODEFACTORY_ADAPTER_IMPL_H
+#include "ace/pre.h"
+
+#include "tao/TypeCodeFactory_Adapter.h"
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+# pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+#include "typecodefactory_export.h"
+#include "ace/Service_Config.h"
+
+/**
+ * @class TAO_TypeCodeFactory_Adapter_Impl
+ *
+ * @brief TAO_TypeCodeFactory_Adapter_Impl.
+ *
+ * Class that adapts the CORBA::ORB create_*_tc functions
+ * to use the TypeCodeFactory. This is the derived class
+ * that contains the actual implementations.
+ */
+class TAO_TypeCodeFactory_Export TAO_TypeCodeFactory_Adapter_Impl 
+  : public TAO_TypeCodeFactory_Adapter
+{
+public:
+  virtual ~TAO_TypeCodeFactory_Adapter_Impl (void);
+
+  virtual CORBA::TypeCode_ptr create_struct_tc (
+      const char *id,
+      const char *name,
+      const CORBA_StructMemberSeq &members,
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )  
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+  virtual CORBA::TypeCode_ptr create_union_tc (
+      const char *id,
+      const char *name,
+      CORBA::TypeCode_ptr discriminator_type,
+      const CORBA_UnionMemberSeq &members,
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )  
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+  virtual CORBA::TypeCode_ptr create_enum_tc (
+      const char *id,
+      const char *name,
+      const CORBA_EnumMemberSeq &members,
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )  
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+  virtual CORBA::TypeCode_ptr create_alias_tc (
+      const char *id,
+      const char *name,
+      CORBA::TypeCode_ptr original_type,
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )  
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+  virtual CORBA::TypeCode_ptr create_exception_tc (
+      const char *id,
+      const char *name,
+      const CORBA_StructMemberSeq &members,
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )  
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+  virtual CORBA::TypeCode_ptr create_interface_tc (
+      const char *id,
+      const char *name,
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )  
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+  virtual CORBA::TypeCode_ptr create_string_tc (
+      CORBA::ULong bound,
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )  
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+  virtual CORBA::TypeCode_ptr create_wstring_tc (
+      CORBA::ULong bound,
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )  
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+  virtual CORBA::TypeCode_ptr create_fixed_tc (
+      CORBA::UShort digits,
+      CORBA::UShort scale,
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )  
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+  virtual CORBA::TypeCode_ptr create_sequence_tc (
+      CORBA::ULong bound,
+      CORBA::TypeCode_ptr element_type,
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )  
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+  virtual CORBA::TypeCode_ptr create_array_tc (
+      CORBA::ULong length,
+      CORBA::TypeCode_ptr element_type,
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )  
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+  virtual CORBA::TypeCode_ptr create_value_tc (
+      const char *id,
+      const char *name,
+      CORBA::ValueModifier type_modifier,
+      CORBA::TypeCode_ptr concrete_base,
+      const CORBA_ValueMemberSeq &members,
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )  
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+  virtual CORBA::TypeCode_ptr create_value_box_tc (
+      const char *id,
+      const char *name,
+      CORBA::TypeCode_ptr boxed_type,
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )  
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+  virtual CORBA::TypeCode_ptr create_native_tc (
+      const char *id,
+      const char *name,
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )  
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+  virtual CORBA::TypeCode_ptr create_recursive_tc (
+      const char *id,
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )  
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+  virtual CORBA::TypeCode_ptr create_abstract_interface_tc (
+      const char *id,
+      const char *name,
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )  
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+  virtual CORBA::TypeCode_ptr create_local_interface_tc (
+      const char *id,
+      const char *name,
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )  
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+  /// Used to force the initialization of the ORB code.
+  static int Initializer (void);
+};
+
+ACE_STATIC_SVC_DECLARE (TAO_TypeCodeFactory_Adapter_Impl)
+ACE_FACTORY_DECLARE (TAO_TypeCodeFactory, TAO_TypeCodeFactory_Adapter_Impl)
+
+#if defined(ACE_HAS_BROKEN_STATIC_CONSTRUCTORS)
+
+typedef int (*TAO_Module_Initializer) (void);
+
+static TAO_Module_Initializer
+TAO_Requires_TypeCodeFactory_Initializer = 
+  &TAO_TypeCodeFactory_Adapter_Impl::Initializer;
+
+#else
+
+static int
+TAO_Requires_TypeCodeFactory_Initializer = 
+  TAO_TypeCodeFactory_Adapter_Impl::Initializer ();
+
+#endif /* ACE_HAS_BROKEN_STATIC_CONSTRUCTORS */
+
+#include "ace/post.h"
+#endif /* TAO_TYPECODEFACTORY_ADAPTER_IMPL_H */
diff --git a/TAO/tao/TypeCodeFactory/TypeCodeFactory_Loader.cpp b/TAO/tao/TypeCodeFactory/TypeCodeFactory_Loader.cpp
new file mode 100644
index 00000000000..d4b9a94da70
--- /dev/null
+++ b/TAO/tao/TypeCodeFactory/TypeCodeFactory_Loader.cpp
@@ -0,0 +1,59 @@
+/* -*- C++ -*- */
+// $Id$
+
+// =================================================================
+//
+// = LIBRARY
+//    TAO/tao/TypeCodeFactory
+//
+// = FILENAME
+//    TypeCodeFactory_Loader.cpp
+//
+// = AUTHOR
+//    Jeff Parsons <parsons@cs.wustl.edu>
+//
+// =================================================================
+
+#include "TypeCodeFactory_Loader.h"
+#include "TypeCodeFactory_i.h"
+
+ACE_RCSID(TypeCodeFactory, TypeCodeFactory_Loader, "$Id$")
+
+TAO_TypeCodeFactory_Loader::TAO_TypeCodeFactory_Loader (void)
+{
+}
+
+CORBA::Object_ptr
+TAO_TypeCodeFactory_Loader::create_object (CORBA::ORB_ptr,
+                                           int,
+                                           char * [],
+                                           CORBA::Environment &)
+  ACE_THROW_SPEC (())
+{
+  CORBA::Object_ptr obj;
+  ACE_NEW_RETURN (obj,
+                  TAO_TypeCodeFactory_i,
+                  CORBA::Object::_nil ());
+  return obj;
+}
+
+int
+TAO_TypeCodeFactory_Loader::Initializer (void)
+{
+  ACE_Service_Config::static_svcs ()-> insert (
+      &ace_svc_desc_TAO_TypeCodeFactory_Loader
+    );
+
+  return 0;
+}
+
+ACE_STATIC_SVC_DEFINE (
+    TAO_TypeCodeFactory_Loader,
+    ACE_TEXT ("TypeCodeFactory_Loader"),
+    ACE_SVC_OBJ_T,
+    &ACE_SVC_NAME (TAO_TypeCodeFactory_Loader),
+    ACE_Service_Type::DELETE_THIS | ACE_Service_Type::DELETE_OBJ,
+    0
+  )
+
+ACE_FACTORY_DEFINE (TAO_TypeCodeFactory, TAO_TypeCodeFactory_Loader)
diff --git a/TAO/tao/TypeCodeFactory/TypeCodeFactory_Loader.h b/TAO/tao/TypeCodeFactory/TypeCodeFactory_Loader.h
new file mode 100644
index 00000000000..13b6d9ce41c
--- /dev/null
+++ b/TAO/tao/TypeCodeFactory/TypeCodeFactory_Loader.h
@@ -0,0 +1,73 @@
+// This may look like C, but it's really -*- C++ -*-
+
+//=============================================================================
+/**
+ *  @file    TypeCodeFactory_Loader.h
+ *
+ *  $Id$
+ *
+ *  @author Jeff Parsons <parsons@cs.wustl.edu>
+ */
+//=============================================================================
+
+#ifndef TAO_TYPECODEFACTORY_LOADER_H
+#define TAO_TYPECODEFACTORY_LOADER_H
+#include "ace/pre.h"
+
+#include "typecodefactory_export.h"
+#include "tao/Object_Loader.h"
+#include "ace/Service_Config.h"
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+# pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+class TAO_TypeCodeFactory_Export TAO_TypeCodeFactory_Loader 
+  : public TAO_Object_Loader
+{
+  // = TITLE
+  //     TAO_TypeCodeFactory_Loader
+  //
+  // = DESCRIPTION
+  //     Create an instance of TypeCodeFactory and return
+  //     it to the caller.
+  //
+public:
+  TAO_TypeCodeFactory_Loader (void);
+  // Constructor.
+
+  virtual CORBA::Object_ptr create_object (CORBA::ORB_ptr orb,
+                                           int argc,
+                                           char *argv [],
+                                           CORBA::Environment &)
+    ACE_THROW_SPEC (());
+  // Overload the base class method to create a new instance
+  // of a TypeCodeFactory object.
+
+  static int Initializer (void);
+  // Used to force the initialization of the ORB code.
+};
+
+ACE_STATIC_SVC_DECLARE (TAO_TypeCodeFactory_Loader)
+ACE_FACTORY_DECLARE (TAO_TypeCodeFactory, TAO_TypeCodeFactory_Loader)
+
+#if defined(ACE_HAS_BROKEN_STATIC_CONSTRUCTORS)
+
+typedef int (*TAO_Module_Initializer) (void);
+
+static TAO_Module_Initializer
+TAO_Requires_TCF_Initializer = &TAO_TypeCodeFactory_Loader::Initializer;
+
+#else
+
+static int
+TAO_Requires_TCF_Initializer = TAO_TypeCodeFactory_Loader::Initializer ();
+
+#endif /* ACE_HAS_BROKEN_STATIC_CONSTRUCTORS */
+
+#define TAO_TYPECODEFACTORY_SAFE_INCLUDE
+#include "TypeCodeFactoryC.h"
+#undef TAO_TYPECODEFACTORY_SAFE_INCLUDE
+
+#include "ace/post.h"
+#endif /* TAO_TYPECODEFACTORY_LOADER_H */
diff --git a/TAO/tao/TypeCodeFactory/TypeCodeFactory_i.cpp b/TAO/tao/TypeCodeFactory/TypeCodeFactory_i.cpp
new file mode 100644
index 00000000000..8ec0b9937c5
--- /dev/null
+++ b/TAO/tao/TypeCodeFactory/TypeCodeFactory_i.cpp
@@ -0,0 +1,832 @@
+/* -*- C++ -*- */
+// $Id$
+
+#include "TypeCodeFactory_i.h"
+#include "tao/IFR_Client/IFR_BasicC.h"
+#include "tao/Marshal.h"
+
+ACE_RCSID(IFR_Service, TypeCodeFactory_i, "$Id$")
+
+TAO_TypeCodeFactory_i::TAO_TypeCodeFactory_i (void)
+{
+}
+
+TAO_TypeCodeFactory_i::~TAO_TypeCodeFactory_i (void)
+{
+}
+
+TAO_TypeCodeFactory_i *
+TAO_TypeCodeFactory_i::_narrow (CORBA::Object_ptr obj,
+                                CORBA::Environment &)
+{
+  if (CORBA::is_nil (obj))
+    {
+      return 0;
+    }
+
+  return ACE_reinterpret_cast (
+             TAO_TypeCodeFactory_i *,
+             obj->_tao_QueryInterface (
+                      ACE_reinterpret_cast (
+                          ptr_arith_t,
+                          &TAO_TypeCodeFactory_i::_narrow
+                        )
+                    )
+           );
+}
+
+void *
+TAO_TypeCodeFactory_i::_tao_QueryInterface (ptr_arith_t type)
+{
+  ptr_arith_t mytype =
+    ACE_reinterpret_cast (ptr_arith_t,
+                          &TAO_TypeCodeFactory_i::_narrow);
+  if (type == mytype)
+    {
+      this->_add_ref ();
+      return this;
+    }
+
+  return this->CORBA_TypeCodeFactory::_tao_QueryInterface (type);
+}
+
+CORBA::TypeCode_ptr
+TAO_TypeCodeFactory_i::create_struct_tc (
+    const char *id,
+    const char *name,
+    const CORBA_StructMemberSeq &members,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+    ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  TAO_OutputCDR cdr;
+
+  cdr << TAO_ENCAP_BYTE_ORDER;
+
+  cdr << id;
+
+  cdr << name;
+
+  // Number of members..
+  CORBA::ULong len = members.length ();
+  cdr << len;
+
+  for (CORBA::ULong index = 0; index < len; ++index)
+    {
+      cdr << members[index].name;
+
+      cdr << members[index].type.in ();
+    }
+
+  CORBA::TypeCode_ptr struct_typecode = 
+    CORBA::TypeCode::_nil ();
+  ACE_NEW_THROW_EX (struct_typecode,
+                    CORBA_TypeCode (CORBA::tk_struct,
+                                    cdr.total_length (),
+                                    cdr.buffer (),
+                                    0,
+                                    0),
+                    CORBA::NO_MEMORY ());
+  ACE_CHECK_RETURN (CORBA::TypeCode::_nil ());
+
+  return struct_typecode;
+}
+
+CORBA::TypeCode_ptr 
+TAO_TypeCodeFactory_i::create_union_tc (
+    const char *id,
+    const char *name,
+    CORBA::TypeCode_ptr discriminator_type,
+    const CORBA_UnionMemberSeq &members,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+    ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  TAO_OutputCDR cdr;
+
+  cdr << TAO_ENCAP_BYTE_ORDER;
+
+  cdr << id;
+
+  cdr << name;
+
+  cdr << discriminator_type;
+
+  CORBA::ULong len = members.length ();
+  CORBA::ULong dups = 0;
+  CORBA::Long default_index = -1;
+  CORBA::Long raw_default_index = -1;
+  CORBA::Octet value = ACE_OCTET_MAX;
+
+  for (CORBA::ULong i = 0; i < len; ++i)
+    {
+      if (i > 0)
+        {
+          // Is this a duplicate case label? If so, we have to adjust
+          // the 'length' we encode - a member gets encoded only once.
+          if (ACE_OS::strcmp (members[i].name, 
+                              members[i - 1].name) 
+               == 0)
+            {
+              ++dups;
+            }
+        }
+
+      // Reset the default index, if we have a default case label.
+      if ((members[i].label >>= CORBA::Any::to_octet (value)) == 1)
+        {
+          if (value == 0)
+            {
+              raw_default_index = ACE_static_cast (CORBA::Long, i);
+              // Only the multiple labels that come before the
+              // default label affect its adjusted value.
+              default_index = ACE_static_cast (CORBA::Long, i - dups);
+            }
+        }
+    }
+
+  cdr << default_index;
+
+  cdr << len - dups;
+
+  for (CORBA::ULong index = 0; index < len; index++)
+    {
+      if (index > 0)
+        {
+          // Is this a duplicate case label? If so, skip it - a member
+          // goes into the typecode only once.
+          if (ACE_OS::strcmp (members[index].name, 
+                              members[index - 1].name) 
+               == 0)
+            {
+              continue;
+            }
+        }
+
+      if (raw_default_index >= 0
+          && index == ACE_static_cast (CORBA::ULong, raw_default_index))
+        {
+          // This is the default label - we have to find a legal value.
+          CORBA::TCKind kind = discriminator_type->kind (ACE_TRY_ENV);
+          ACE_CHECK_RETURN (CORBA::TypeCode::_nil ());
+
+          this->compute_default_label (kind,
+                                       index,
+                                       members,
+                                       cdr);
+        }
+      else
+        {
+          // Interpretive marshaling refuses to die ;-).
+          TAO_InputCDR in (members[index].label._tao_get_cdr (),
+                           members[index].label._tao_byte_order ());
+
+          CORBA::TypeCode_var tc = members[index].label.type ();
+
+          (void) TAO_Marshal_Object::perform_append (tc.in (),
+                                                     &in,
+                                                     &cdr,
+                                                     ACE_TRY_ENV);
+          ACE_CHECK_RETURN (CORBA::TypeCode::_nil ());
+        }
+
+      cdr << members[index].name;
+
+      cdr << members[index].type.in ();
+    }
+
+  CORBA::TypeCode_ptr union_typecode = 
+    CORBA::TypeCode::_nil ();
+  ACE_NEW_THROW_EX (union_typecode,
+                    CORBA_TypeCode (CORBA::tk_union,
+                                    cdr.total_length (),
+                                    cdr.buffer (),
+                                    0,
+                                    0),
+                    CORBA::NO_MEMORY ());
+  ACE_CHECK_RETURN (CORBA::TypeCode::_nil ());
+
+  return union_typecode;
+}
+
+CORBA::TypeCode_ptr
+TAO_TypeCodeFactory_i::create_enum_tc (
+    const char *id,
+    const char *name,
+    const CORBA_EnumMemberSeq &members,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+    ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  TAO_OutputCDR cdr;
+
+  cdr << TAO_ENCAP_BYTE_ORDER;
+
+  cdr << id;
+
+  cdr << name;
+
+  CORBA::ULong len = members.length ();
+
+  cdr << len;
+
+  for (CORBA::ULong index = 0; index < len; ++index)
+    {
+      cdr << members[index];
+    }
+
+  CORBA::TypeCode_ptr enum_typecode = 
+    CORBA::TypeCode::_nil ();
+  ACE_NEW_THROW_EX (enum_typecode,
+                    CORBA_TypeCode (CORBA::tk_enum,
+                                    cdr.total_length (),
+                                    cdr.buffer (),
+                                    0,
+                                    0),
+                    CORBA::NO_MEMORY ());
+  ACE_CHECK_RETURN (CORBA::TypeCode::_nil ());
+
+  return enum_typecode;
+}
+
+CORBA::TypeCode_ptr
+TAO_TypeCodeFactory_i::create_alias_tc (
+    const char *id,
+    const char *name,
+    CORBA::TypeCode_ptr original_type,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+    ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  TAO_OutputCDR cdr;
+
+  cdr << TAO_ENCAP_BYTE_ORDER;
+
+  cdr << id;
+
+  cdr << name;
+
+  cdr << original_type;
+
+  CORBA::TypeCode_ptr alias_typecode = 
+    CORBA::TypeCode::_nil ();
+
+  ACE_NEW_THROW_EX (alias_typecode,
+                    CORBA_TypeCode (CORBA::tk_alias,
+                                    cdr.total_length (),
+                                    cdr.buffer (),
+                                    0,
+                                    0),
+                    CORBA::NO_MEMORY ());
+  ACE_CHECK_RETURN (CORBA::TypeCode::_nil ());
+
+  return alias_typecode;
+}
+
+CORBA::TypeCode_ptr
+TAO_TypeCodeFactory_i::create_exception_tc (
+    const char *id,
+    const char *name,
+    const CORBA_StructMemberSeq &members,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+    ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  TAO_OutputCDR cdr;
+
+  cdr << TAO_ENCAP_BYTE_ORDER;
+
+  cdr << id;
+
+  cdr << name;
+
+  // Number of members..
+  CORBA::ULong len = members.length ();
+  cdr << len;
+
+  for (CORBA::ULong index = 0; index < len; ++index)
+    {
+      // Get the first member which is a string..
+      CORBA_StructMember struct_member = members[index];
+
+      cdr << struct_member.name;
+
+      cdr << struct_member.type.in ();
+    }
+
+  CORBA::TypeCode_ptr exception_typecode = 
+    CORBA::TypeCode::_nil ();
+  ACE_NEW_THROW_EX (exception_typecode,
+                    CORBA_TypeCode (CORBA::tk_except,
+                                    cdr.total_length (),
+                                    cdr.buffer (),
+                                    0,
+                                    0),
+                    CORBA::NO_MEMORY ());
+  ACE_CHECK_RETURN (CORBA::TypeCode::_nil ());
+
+  return exception_typecode;
+}
+
+CORBA::TypeCode_ptr
+TAO_TypeCodeFactory_i::create_interface_tc (
+    const char *id,
+    const char *name,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+    ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  return this->create_tc_common (id,
+                                 name,
+                                 CORBA::tk_objref,
+                                 ACE_TRY_ENV); 
+}
+
+CORBA::TypeCode_ptr 
+TAO_TypeCodeFactory_i::create_string_tc (
+    CORBA::ULong bound,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+    ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  TAO_OutputCDR cdr;
+
+  cdr << TAO_ENCAP_BYTE_ORDER;
+
+  cdr << bound;
+
+  CORBA::TypeCode_ptr string_typecode = 
+    CORBA::TypeCode::_nil ();
+  ACE_NEW_THROW_EX (string_typecode,
+                    CORBA_TypeCode (CORBA::tk_string,
+                                    cdr.total_length (),
+                                    cdr.buffer (),
+                                    0,
+                                    0),
+                    CORBA::NO_MEMORY ());
+  ACE_CHECK_RETURN (CORBA::TypeCode::_nil ());
+
+  return string_typecode;
+}
+
+CORBA::TypeCode_ptr 
+TAO_TypeCodeFactory_i::create_wstring_tc (
+    CORBA::ULong bound,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+    ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  TAO_OutputCDR cdr;
+
+  cdr << TAO_ENCAP_BYTE_ORDER;
+
+  cdr << bound;
+
+  CORBA::TypeCode_ptr wstring_typecode = 
+    CORBA::TypeCode::_nil ();
+  ACE_NEW_THROW_EX (wstring_typecode,
+                    CORBA_TypeCode (CORBA::tk_wstring,
+                                    cdr.total_length (),
+                                    cdr.buffer (),
+                                    0,
+                                    0),
+                    CORBA::NO_MEMORY ());
+  ACE_CHECK_RETURN (CORBA::TypeCode::_nil ());
+
+  return wstring_typecode;
+}
+
+CORBA::TypeCode_ptr 
+TAO_TypeCodeFactory_i::create_fixed_tc (
+    CORBA::UShort /* digits */,
+    CORBA::UShort /* scale */,
+    CORBA::Environment & /* ACE_TRY_ENV */
+  )
+    ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // TODO
+  return 0; 
+}
+
+CORBA::TypeCode_ptr 
+TAO_TypeCodeFactory_i::create_sequence_tc (
+    CORBA::ULong bound,
+    CORBA::TypeCode_ptr element_type,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+    ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  TAO_OutputCDR cdr;
+
+  cdr << TAO_ENCAP_BYTE_ORDER;
+
+  cdr << element_type;
+
+  cdr << bound;
+
+  CORBA::TypeCode_ptr sequence_typecode = 
+    CORBA::TypeCode::_nil ();
+  ACE_NEW_THROW_EX (sequence_typecode,
+                    CORBA_TypeCode (CORBA::tk_sequence,
+                                    cdr.total_length (),
+                                    cdr.buffer (),
+                                    0,
+                                    0),
+                    CORBA::NO_MEMORY ());
+  ACE_CHECK_RETURN (CORBA::TypeCode::_nil ());
+
+  return sequence_typecode;
+}
+
+CORBA::TypeCode_ptr 
+TAO_TypeCodeFactory_i::create_array_tc (
+    CORBA::ULong length,
+    CORBA::TypeCode_ptr element_type,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+    ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  TAO_OutputCDR cdr;
+
+  cdr << TAO_ENCAP_BYTE_ORDER;
+
+  cdr << element_type;
+
+  cdr << length;
+
+  CORBA::TypeCode_ptr array_typecode = 
+    CORBA::TypeCode::_nil ();
+  ACE_NEW_THROW_EX (array_typecode,
+                    CORBA_TypeCode (CORBA::tk_array,
+                                    cdr.total_length (),
+                                    cdr.buffer (),
+                                    0,
+                                    0),
+                    CORBA::NO_MEMORY ());
+  ACE_CHECK_RETURN (CORBA::TypeCode::_nil ());
+
+  return array_typecode;
+}
+
+CORBA::TypeCode_ptr 
+TAO_TypeCodeFactory_i::create_value_tc (
+    const char * /* id */,
+    const char * /* name */,
+    CORBA::ValueModifier /* type_modifier */,
+    CORBA::TypeCode_ptr /* concrete_base */,
+    const CORBA_ValueMemberSeq & /* members */,
+    CORBA::Environment & /* ACE_TRY_ENV */
+  )
+    ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // TODO
+  return 0; 
+}
+
+CORBA::TypeCode_ptr 
+TAO_TypeCodeFactory_i::create_value_box_tc (
+    const char *id,
+    const char *name,
+    CORBA::TypeCode_ptr boxed_type,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+    ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  TAO_OutputCDR cdr;
+
+  cdr << TAO_ENCAP_BYTE_ORDER;
+
+  cdr << id;
+
+  cdr << name;
+
+  cdr << boxed_type;
+
+  CORBA::TypeCode_ptr value_box_typecode = 
+    CORBA::TypeCode::_nil ();
+
+  ACE_NEW_THROW_EX (value_box_typecode,
+                    CORBA_TypeCode (CORBA::tk_value_box,
+                                    cdr.total_length (),
+                                    cdr.buffer (),
+                                    0,
+                                    0),
+                    CORBA::NO_MEMORY ());
+  ACE_CHECK_RETURN (CORBA::TypeCode::_nil ());
+
+  return value_box_typecode;
+}
+
+CORBA::TypeCode_ptr 
+TAO_TypeCodeFactory_i::create_native_tc (
+    const char *id,
+    const char *name,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+    ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  return this->create_tc_common (id,
+                                 name,
+                                 CORBA::tk_native,
+                                 ACE_TRY_ENV); 
+}
+
+CORBA::TypeCode_ptr 
+TAO_TypeCodeFactory_i::create_recursive_tc (
+    const char * /* id */,
+    CORBA::Environment & /* ACE_TRY_ENV */
+  )
+    ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  // TODO
+  return 0; 
+}
+
+CORBA::TypeCode_ptr 
+TAO_TypeCodeFactory_i::create_abstract_interface_tc (
+    const char *id,
+    const char *name,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+    ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  return this->create_tc_common (id,
+                                 name,
+                                 CORBA::tk_abstract_interface,
+                                 ACE_TRY_ENV); 
+}
+
+CORBA::TypeCode_ptr 
+TAO_TypeCodeFactory_i::create_local_interface_tc (
+    const char *id,
+    const char *name,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+    ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  return this->create_tc_common (id,
+                                 name,
+                                 CORBA::tk_local_interface,
+                                 ACE_TRY_ENV); 
+}
+
+CORBA::TypeCode_ptr 
+TAO_TypeCodeFactory_i::create_component_tc (
+    const char *id,
+    const char *name,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+    ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  return this->create_tc_common (id,
+                                 name,
+                                 CORBA::tk_component,
+                                 ACE_TRY_ENV); 
+}
+
+CORBA::TypeCode_ptr 
+TAO_TypeCodeFactory_i::create_home_tc (
+    const char *id,
+    const char *name,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+    ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  return this->create_tc_common (id,
+                                 name,
+                                 CORBA::tk_home,
+                                 ACE_TRY_ENV); 
+}
+
+void
+TAO_TypeCodeFactory_i::compute_default_label (
+    CORBA::TCKind kind,
+    CORBA::ULong skip_slot,
+    const CORBA_UnionMemberSeq &members,
+    TAO_OutputCDR &cdr
+  )
+{
+  // One to hold the current default value, one to
+  // hold the curent label's extracted value.
+  union disc_types
+  {
+    CORBA::Char char_val;
+    CORBA::WChar wchar_val;
+    CORBA::Boolean bool_val;
+    CORBA::Short short_val;
+    CORBA::UShort ushort_val;
+    CORBA::Long long_val;
+    CORBA::ULong ulong_val;
+    CORBA::ULongLong ulonglong_val;
+    CORBA::ULong enum_val;
+    // TODO - handle (u)longlong types
+  } dv, u;
+
+  // To prevent 'may be uninitialized' warnings.
+  dv.ulonglong_val = 0;
+
+  // Set these to the minimum value they can have.
+  switch (kind)
+  {
+    case CORBA::tk_char:
+      dv.char_val = 0;
+      break;
+    case CORBA::tk_wchar:
+      dv.wchar_val = 0;
+      break;
+    case CORBA::tk_boolean:
+      dv.bool_val = 0;
+      break;
+    case CORBA::tk_short:
+      dv.short_val = ACE_INT16_MIN;
+      break;
+    case CORBA::tk_ushort:
+      dv.ushort_val = 0;
+      break;
+    case CORBA::tk_long:
+      dv.long_val = ACE_INT32_MIN;
+      break;
+    case CORBA::tk_ulong:
+      dv.ulong_val = 0;
+      break;
+    case CORBA::tk_ulonglong:
+      dv.ulonglong_val = 0;
+      break;
+    case CORBA::tk_enum:
+      dv.enum_val = 0;
+      break;
+    default:
+      break;
+  }
+
+  CORBA::ULong len = members.length ();
+  int success = 0;
+
+  // A collision forces us to start over, because the label
+  // values need not be in sorted order.
+  while (success == 0)
+    {
+      success = 1;
+
+      for (CORBA::ULong i = 0; i < len; i++)
+        {
+          // This is the one we're trying to find a legal value for.
+          if (i == skip_slot)
+            continue;
+
+          // If there's a collision, we increment the default value.
+          switch (kind)
+          {
+            case CORBA::tk_char:
+              members[i].label >>= CORBA::Any::to_char (u.char_val);
+              if (u.char_val == dv.char_val)
+                {
+                  dv.char_val++;
+                  success = 0;
+                }
+              break;
+            case CORBA::tk_wchar:
+              members[i].label >>= CORBA::Any::to_wchar (u.wchar_val);
+              if (u.wchar_val == dv.wchar_val)
+                {
+                  dv.wchar_val++;
+                  success = 0;
+                }
+              break;
+            case CORBA::tk_boolean:
+              members[i].label >>= CORBA::Any::to_boolean (u.bool_val);
+              if (u.bool_val == dv.bool_val)
+                {
+                  dv.bool_val++;
+                  success = 0;
+                }
+              break;
+            case CORBA::tk_short:
+              members[i].label >>= u.short_val;
+              if (u.short_val == dv.short_val)
+                {
+                  dv.short_val++;
+                  success = 0;
+                }
+              break;
+            case CORBA::tk_ushort:
+              members[i].label >>= u.ushort_val;
+              if (u.ushort_val == dv.ushort_val)
+                {
+                  dv.ushort_val++;
+                  success = 0;
+                }
+              break;
+            case CORBA::tk_long:
+              members[i].label >>= u.long_val;
+              if (u.long_val == dv.long_val)
+                {
+                  dv.long_val++;
+                  success = 0;
+                }
+              break;
+            case CORBA::tk_ulong:
+              members[i].label >>= u.ulong_val;
+              if (u.ulong_val == dv.ulong_val)
+                {
+                  dv.ulong_val++;
+                  success = 0;
+                }
+              break;
+            case CORBA::tk_ulonglong:
+              members[i].label >>= u.ulonglong_val;
+              if (u.ulonglong_val == dv.ulonglong_val)
+                {
+                  dv.ulonglong_val++;
+                  success = 0;
+                }
+              break;
+            case CORBA::tk_enum:
+            {
+              TAO_InputCDR cdr (members[i].label._tao_get_cdr (),
+                                members[i].label._tao_byte_order ());
+              cdr.read_ulong (u.enum_val);
+              if (u.enum_val == dv.enum_val)
+                {
+                  dv.enum_val++;
+                  success = 0;
+                }
+              break;
+            }
+            default:
+              break;
+          }
+
+          // If there's been a collision, we should start over right away.
+          if (success == 0)
+            break;
+        }
+    }
+
+  // Add the default value to the encapsulation.
+  switch (kind)
+  {
+    case CORBA::tk_char:
+      cdr << CORBA::Any::from_char (dv.char_val);
+      break;
+    case CORBA::tk_wchar:
+      cdr << CORBA::Any::from_wchar (dv.wchar_val);
+      break;
+    case CORBA::tk_boolean:
+      cdr << CORBA::Any::from_boolean (dv.bool_val);
+      break;
+    case CORBA::tk_short:
+      cdr << dv.short_val;
+      break;
+    case CORBA::tk_ushort:
+      cdr << dv.ushort_val;
+      break;
+    case CORBA::tk_long:
+      cdr << dv.long_val;
+      break;
+    case CORBA::tk_ulong:
+      cdr << dv.ulong_val;
+      break;
+    case CORBA::tk_ulonglong:
+      cdr << dv.ulonglong_val;
+      break;
+    case CORBA::tk_enum:
+      cdr << dv.enum_val;
+      break;
+    default:
+      break;
+  }
+}
+
+CORBA::TypeCode_ptr 
+TAO_TypeCodeFactory_i::create_tc_common (
+    const char *id,
+    const char *name,
+    CORBA::TCKind kind,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+    ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  TAO_OutputCDR cdr;
+
+  cdr << TAO_ENCAP_BYTE_ORDER;
+
+  cdr << id;
+
+  cdr << name;
+
+  CORBA::TypeCode_ptr result = 
+    CORBA::TypeCode::_nil ();
+
+  ACE_NEW_THROW_EX (result,
+                    CORBA_TypeCode (kind,
+                                    cdr.total_length (),
+                                    cdr.buffer (),
+                                    0,
+                                    0),
+                    CORBA::NO_MEMORY ());
+  ACE_CHECK_RETURN (CORBA::TypeCode::_nil ());
+
+  return result;
+}
+
diff --git a/TAO/tao/TypeCodeFactory/TypeCodeFactory_i.h b/TAO/tao/TypeCodeFactory/TypeCodeFactory_i.h
new file mode 100644
index 00000000000..f11fe316ac5
--- /dev/null
+++ b/TAO/tao/TypeCodeFactory/TypeCodeFactory_i.h
@@ -0,0 +1,244 @@
+// This may look like C, but it's really -*- C++ -*-
+
+//=============================================================================
+/**
+ *  @file    TypeCodeFactory_i.h
+ *
+ *  $Id$
+ *
+ *  @author Jeff Parsons <parsons@cs.wustl.edu>
+ */
+//=============================================================================
+
+#ifndef TAO_TYPECODEFACTORY_I_H
+#define TAO_TYPECODEFACTORY_I_H
+
+#include "ace/pre.h"
+#include "TypeCodeFactory_Loader.h"
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+# pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+#include "tao/LocalObject.h"
+
+#if defined(_MSC_VER)
+#if (_MSC_VER >= 1200)
+#pragma warning(push)
+#endif /* _MSC_VER >= 1200 */
+#pragma warning(disable:4250)
+#endif /* _MSC_VER */
+
+class TAO_TypeCodeFactory_Export TAO_TypeCodeFactory_i
+    : public virtual CORBA_TypeCodeFactory,
+      public virtual TAO_Local_RefCounted_Object
+{
+/**
+ * @class TAO_TypeCodeFactory_i
+ *
+ * @brief TAO_TypeCodeFactory_i.
+ *
+ * Implementation of the CORBA::TypeCodeFactory interface
+ */
+public:
+  TAO_TypeCodeFactory_i (void);
+  /// ctor
+
+  ~TAO_TypeCodeFactory_i (void);
+  /// dtor
+
+  /// = LocalObject methods
+  static TAO_TypeCodeFactory_i *_narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    );
+  virtual void *_tao_QueryInterface (ptr_arith_t type);
+
+  virtual CORBA::TypeCode_ptr create_struct_tc (
+      const char *id,
+      const char *name,
+      const CORBA_StructMemberSeq &members,
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+  virtual CORBA::TypeCode_ptr create_union_tc (
+      const char *id,
+      const char *name,
+      CORBA::TypeCode_ptr discriminator_type,
+      const CORBA_UnionMemberSeq &members,
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+  virtual CORBA::TypeCode_ptr create_enum_tc (
+      const char *id,
+      const char *name,
+      const CORBA_EnumMemberSeq &members,
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+  virtual CORBA::TypeCode_ptr create_alias_tc (
+      const char *id,
+      const char *name,
+      CORBA::TypeCode_ptr original_type,
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+  virtual CORBA::TypeCode_ptr create_exception_tc (
+      const char *id,
+      const char *name,
+      const CORBA_StructMemberSeq &members,
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+  virtual CORBA::TypeCode_ptr create_interface_tc (
+      const char *id,
+      const char *name,
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+  virtual CORBA::TypeCode_ptr create_string_tc (
+      CORBA::ULong bound,
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+  virtual CORBA::TypeCode_ptr create_wstring_tc (
+      CORBA::ULong bound,
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+  virtual CORBA::TypeCode_ptr create_fixed_tc (
+      CORBA::UShort digits,
+      CORBA::UShort scale,
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+  virtual CORBA::TypeCode_ptr create_sequence_tc (
+      CORBA::ULong bound,
+      CORBA::TypeCode_ptr element_type,
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+  virtual CORBA::TypeCode_ptr create_array_tc (
+      CORBA::ULong length,
+      CORBA::TypeCode_ptr element_type,
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+  virtual CORBA::TypeCode_ptr create_value_tc (
+      const char *id,
+      const char *name,
+      CORBA::ValueModifier type_modifier,
+      CORBA::TypeCode_ptr concrete_base,
+      const CORBA_ValueMemberSeq &members,
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+  virtual CORBA::TypeCode_ptr create_value_box_tc (
+      const char *id,
+      const char *name,
+      CORBA::TypeCode_ptr boxed_type,
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+  virtual CORBA::TypeCode_ptr create_native_tc (
+      const char *id,
+      const char *name,
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+  virtual CORBA::TypeCode_ptr create_recursive_tc (
+      const char *id,
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+  virtual CORBA::TypeCode_ptr create_abstract_interface_tc (
+      const char *id,
+      const char *name,
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+  virtual CORBA::TypeCode_ptr create_local_interface_tc (
+      const char *id,
+      const char *name,
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+  virtual CORBA::TypeCode_ptr create_component_tc (
+      const char *id,
+      const char *name,
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+  virtual CORBA::TypeCode_ptr create_home_tc (
+      const char *id,
+      const char *name,
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+private:
+  /// Finds a legal default label value.
+  void compute_default_label (CORBA::TCKind kind,
+                              CORBA::ULong skip_slot,
+                              const CORBA_UnionMemberSeq &members,
+                              TAO_OutputCDR &cdr);
+
+  /// Called for all types that take just an id and a name.
+  CORBA::TypeCode_ptr create_tc_common (
+      const char *id,
+      const char *name,
+      CORBA::TCKind kind,
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+  /// Prohibited
+  TAO_TypeCodeFactory_i (const TAO_TypeCodeFactory_i &src);
+  TAO_TypeCodeFactory_i &operator= (const TAO_TypeCodeFactory_i &src);
+};
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+#pragma warning(pop)
+#endif /* _MSC_VER */
+
+#include "ace/post.h"
+#endif /* TAO_TYPECODEFACTORY_I_H */
diff --git a/TAO/tao/TypeCodeFactory/diffs/TypeCodeFactoryC.cpp.diff b/TAO/tao/TypeCodeFactory/diffs/TypeCodeFactoryC.cpp.diff
new file mode 100644
index 00000000000..b00cba99963
--- /dev/null
+++ b/TAO/tao/TypeCodeFactory/diffs/TypeCodeFactoryC.cpp.diff
@@ -0,0 +1,142 @@
+--- orig/TypeCodeFactoryC.cpp	Mon Mar 12 22:17:35 2001
++++ TypeCodeFactoryC.cpp	Mon Mar 12 22:41:37 2001
+@@ -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,7 +19,7 @@
+ // Information about TAO is available at:
+ //     http://www.cs.wustl.edu/~schmidt/TAO.html
+ 
+-#include "TypeCodeFactoryC.h"
++#include "TypeCodeFactory_Loader.h"
+ 
+ #if TAO_HAS_INTERCEPTORS == 1
+ #include "tao/RequestInfo_Util.h"
+@@ -33,53 +33,12 @@
+ #include "TypeCodeFactoryC.inl"
+ #endif /* !defined INLINE */
+ 
+-static const CORBA::Long _oc_CORBA_Identifier[] =
+-{
+-  TAO_ENCAP_BYTE_ORDER, // byte order
+-  33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+-  11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+-  CORBA::tk_string, 
+-  0U, // string length
+-};
+-static CORBA::TypeCode _tc_TAO_tc_CORBA_Identifier (CORBA::tk_alias, sizeof (_oc_CORBA_Identifier), (char *) &_oc_CORBA_Identifier, 0, sizeof (CORBA::Identifier));
+-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+-TAO_NAMESPACE_BEGIN (CORBA)
+-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_Identifier, &_tc_TAO_tc_CORBA_Identifier)
+-TAO_NAMESPACE_END
+-static const CORBA::Long _oc_CORBA_RepositoryId[] =
+-{
+-  TAO_ENCAP_BYTE_ORDER, // byte order
+-  35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+-  13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+-  CORBA::tk_string, 
+-  0U, // string length
+-};
+-static CORBA::TypeCode _tc_TAO_tc_CORBA_RepositoryId (CORBA::tk_alias, sizeof (_oc_CORBA_RepositoryId), (char *) &_oc_CORBA_RepositoryId, 0, sizeof (CORBA::RepositoryId));
+-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+-TAO_NAMESPACE_BEGIN (CORBA)
+-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_RepositoryId, &_tc_TAO_tc_CORBA_RepositoryId)
+-TAO_NAMESPACE_END
+-static const CORBA::Long _oc_CORBA_ValueModifier[] =
+-{
+-  TAO_ENCAP_BYTE_ORDER, // byte order
+-  36, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5661), ACE_NTOHL (0x6c75654d), ACE_NTOHL (0x6f646966), ACE_NTOHL (0x6965723a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/ValueModifier:1.0
+-  14, ACE_NTOHL (0x56616c75), ACE_NTOHL (0x654d6f64), ACE_NTOHL (0x69666965), ACE_NTOHL (0x72000000),  // name = ValueModifier
+-  CORBA::tk_short,
+-
+-};
+-static CORBA::TypeCode _tc_TAO_tc_CORBA_ValueModifier (CORBA::tk_alias, sizeof (_oc_CORBA_ValueModifier), (char *) &_oc_CORBA_ValueModifier, 0, sizeof (CORBA::ValueModifier));
+-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+-TAO_NAMESPACE_BEGIN (CORBA)
+-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ValueModifier, &_tc_TAO_tc_CORBA_ValueModifier)
+-TAO_NAMESPACE_END
+-
+-// default constructor
+-CORBA::TypeCodeFactory::TypeCodeFactory ()
+-{
+-  }
++// Default constructor.
++CORBA_TypeCodeFactory::CORBA_TypeCodeFactory (void)
++{}
+ 
+-// destructor
+-CORBA::TypeCodeFactory::~TypeCodeFactory (void)
++// Destructor.
++CORBA_TypeCodeFactory::~CORBA_TypeCodeFactory (void)
+ {}
+ 
+ CORBA::TypeCodeFactory_ptr CORBA::TypeCodeFactory::_narrow (
+@@ -87,7 +46,7 @@
+     CORBA::Environment &ACE_TRY_ENV
+   )
+ {
+-  return TypeCodeFactory::_unchecked_narrow (obj, ACE_TRY_ENV);
++  return CORBA::TypeCodeFactory::_unchecked_narrow (obj, ACE_TRY_ENV);
+ }
+ 
+ CORBA::TypeCodeFactory_ptr CORBA::TypeCodeFactory::_unchecked_narrow (
+@@ -96,36 +55,38 @@
+   )
+ {
+   if (CORBA::is_nil (obj))
+-    return TypeCodeFactory::_nil ();
++    return CORBA::TypeCodeFactory::_nil ();
++
+   return
+       ACE_reinterpret_cast
+         (
+-          TypeCodeFactory_ptr,
++          CORBA::TypeCodeFactory_ptr,
+             obj->_tao_QueryInterface
+               (
+                 ACE_reinterpret_cast
+                   (
+                     ptr_arith_t,
+-                    &TypeCodeFactory::_narrow
++                    &CORBA::TypeCodeFactory::_narrow
+                   )
+               )
+         );
+ }
+ 
+ CORBA::TypeCodeFactory_ptr
+-CORBA::TypeCodeFactory::_duplicate (TypeCodeFactory_ptr obj)
++CORBA::TypeCodeFactory::_duplicate (CORBA::TypeCodeFactory_ptr obj)
+ {
+   if (!CORBA::is_nil (obj))
+     obj->_add_ref ();
+   return obj;
+ }
+ 
+-void *CORBA::TypeCodeFactory::_tao_QueryInterface (ptr_arith_t type)
++void *
++CORBA::TypeCodeFactory::_tao_QueryInterface (ptr_arith_t type)
+ {
+   void *retv = 0;
+   if (type == ACE_reinterpret_cast
+     (ptr_arith_t,
+-      &ACE_NESTED_CLASS (::CORBA, TypeCodeFactory)::_narrow))
++      &CORBA_TypeCodeFactory::_narrow))
+     retv = ACE_reinterpret_cast (void*, this);
+   else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
+     retv = ACE_reinterpret_cast (void *,
+@@ -136,7 +97,8 @@
+   return retv;
+ }
+ 
+-const char* CORBA::TypeCodeFactory::_interface_repository_id (void) const
++const char *
++CORBA::TypeCodeFactory::_interface_repository_id (void) const
+ {
+   return "IDL:omg.org/CORBA/TypeCodeFactory:1.0";
+ }
diff --git a/TAO/tao/TypeCodeFactory/diffs/TypeCodeFactoryC.h.diff b/TAO/tao/TypeCodeFactory/diffs/TypeCodeFactoryC.h.diff
new file mode 100644
index 00000000000..e88593e0b2c
--- /dev/null
+++ b/TAO/tao/TypeCodeFactory/diffs/TypeCodeFactoryC.h.diff
@@ -0,0 +1,278 @@
+--- orig/TypeCodeFactoryC.h	Mon Mar 12 22:17:35 2001
++++ TypeCodeFactoryC.h	Mon Mar 12 22:49:58 2001
+@@ -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,8 +19,12 @@
+ // Information about TAO is available at:
+ //     http://www.cs.wustl.edu/~schmidt/TAO.html
+ 
+-#ifndef _TAO_IDL_ORIG_TYPECODEFACTORYC_H_
+-#define _TAO_IDL_ORIG_TYPECODEFACTORYC_H_
++#ifndef TAO_TYPECODEFACTORYC_H
++#define TAO_TYPECODEFACTORYC_H
++
++#ifndef TAO_TYPECODEFACTORY_SAFE_INCLUDE
++#error "You should not include TypeCodeFactoryC.h directly, use TCF_Loader.h"
++#endif /* !TAO_TYPECODEFACTORY_SAFE_INCLUDE */
+ 
+ #include "ace/pre.h"
+ #include "tao/corba.h"
+@@ -30,7 +34,7 @@
+ #endif /* ACE_LACKS_PRAGMA_ONCE */
+ 
+ #include "typecodefactory_export.h"
+-#include "../IFR_Client/InterfaceC.h"
++#include "tao/IFR_Client/InterfaceC.h"
+ 
+ #if defined (TAO_EXPORT_MACRO)
+ #undef TAO_EXPORT_MACRO
+@@ -55,123 +59,82 @@
+ #pragma option push -w-rvl -w-rch -w-ccc -w-inl
+ #endif /* __BORLANDC__ */
+ 
+-TAO_NAMESPACE  CORBA
+-{
+-  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 * RepositoryId;
+-  typedef CORBA::String_var RepositoryId_var;
+-  typedef CORBA::String_out RepositoryId_out;
+-    TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_RepositoryId;
+-
+-  typedef CORBA::Short ValueModifier;
+-  typedef CORBA::Short_out ValueModifier_out;
+-    TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ValueModifier;
+-
+-
+-#if !defined (_CORBA_TYPECODEFACTORY___PTR_CH_)
+-#define _CORBA_TYPECODEFACTORY___PTR_CH_
+-
+-  class TypeCodeFactory;
+-  typedef TypeCodeFactory *TypeCodeFactory_ptr;
+-  
+-#endif /* end #if !defined */
+-
+-
+-#if !defined (_CORBA_TYPECODEFACTORY___VAR_CH_)
+-#define _CORBA_TYPECODEFACTORY___VAR_CH_
+-
+-  class TAO_TypeCodeFactory_Export TypeCodeFactory_var : public TAO_Base_var
++class TAO_TypeCodeFactory_Export CORBA_TypeCodeFactory_var 
++  : public TAO_Base_var
+   {
+   public:
+-    TypeCodeFactory_var (void); // default constructor
+-    TypeCodeFactory_var (TypeCodeFactory_ptr p) : ptr_ (p) {} 
+-    TypeCodeFactory_var (const TypeCodeFactory_var &); // copy constructor
+-    ~TypeCodeFactory_var (void); // destructor
+-    
+-    TypeCodeFactory_var &operator= (TypeCodeFactory_ptr);
+-    TypeCodeFactory_var &operator= (const TypeCodeFactory_var &);
+-    TypeCodeFactory_ptr operator-> (void) const;
++  CORBA_TypeCodeFactory_var (void); // default constructor
++  CORBA_TypeCodeFactory_var (CORBA_TypeCodeFactory_ptr p) : ptr_ (p) {} 
++  CORBA_TypeCodeFactory_var (const CORBA_TypeCodeFactory_var &); // copy constructor
++  ~CORBA_TypeCodeFactory_var (void); // destructor
++
++  CORBA_TypeCodeFactory_var &operator= (CORBA_TypeCodeFactory_ptr);
++  CORBA_TypeCodeFactory_var &operator= (const CORBA_TypeCodeFactory_var &);
++  CORBA_TypeCodeFactory_ptr operator-> (void) const;
+     
+-    operator const TypeCodeFactory_ptr &() const;
+-    operator TypeCodeFactory_ptr &();
++  operator const CORBA_TypeCodeFactory_ptr &() const;
++  operator CORBA_TypeCodeFactory_ptr &();
+     // in, inout, out, _retn 
+-    TypeCodeFactory_ptr in (void) const;
+-    TypeCodeFactory_ptr &inout (void);
+-    TypeCodeFactory_ptr &out (void);
+-    TypeCodeFactory_ptr _retn (void);
+-    TypeCodeFactory_ptr ptr (void) const;
++  CORBA_TypeCodeFactory_ptr in (void) const;
++  CORBA_TypeCodeFactory_ptr &inout (void);
++  CORBA_TypeCodeFactory_ptr &out (void);
++  CORBA_TypeCodeFactory_ptr _retn (void);
++  CORBA_TypeCodeFactory_ptr ptr (void) const;
+ 
+   private:
+-    TypeCodeFactory_ptr ptr_;
++  CORBA_TypeCodeFactory_ptr ptr_;
+     // Unimplemented - prevents widening assignment.
+-    TypeCodeFactory_var (const TAO_Base_var &rhs);
+-    TypeCodeFactory_var &operator= (const TAO_Base_var &rhs);
++  CORBA_TypeCodeFactory_var (const TAO_Base_var &rhs);
++  CORBA_TypeCodeFactory_var &operator= (const TAO_Base_var &rhs);
+   };
+ 
+-
+-#endif /* end #if !defined */
+-
+-
+-#if !defined (_CORBA_TYPECODEFACTORY___OUT_CH_)
+-#define _CORBA_TYPECODEFACTORY___OUT_CH_
+-
+-  class TAO_TypeCodeFactory_Export TypeCodeFactory_out
++class TAO_TypeCodeFactory_Export CORBA_TypeCodeFactory_out
+   {
+   public:
+-    TypeCodeFactory_out (TypeCodeFactory_ptr &);
+-    TypeCodeFactory_out (TypeCodeFactory_var &);
+-    TypeCodeFactory_out (const TypeCodeFactory_out &);
+-    TypeCodeFactory_out &operator= (const TypeCodeFactory_out &);
+-    TypeCodeFactory_out &operator= (const TypeCodeFactory_var &);
+-    TypeCodeFactory_out &operator= (TypeCodeFactory_ptr);
+-    operator TypeCodeFactory_ptr &();
+-    TypeCodeFactory_ptr &ptr (void);
+-    TypeCodeFactory_ptr operator-> (void);
++  CORBA_TypeCodeFactory_out (CORBA_TypeCodeFactory_ptr &);
++  CORBA_TypeCodeFactory_out (CORBA_TypeCodeFactory_var &);
++  CORBA_TypeCodeFactory_out (const CORBA_TypeCodeFactory_out &);
++  CORBA_TypeCodeFactory_out &operator= (const CORBA_TypeCodeFactory_out &);
++  CORBA_TypeCodeFactory_out &operator= (const CORBA_TypeCodeFactory_var &);
++  CORBA_TypeCodeFactory_out &operator= (CORBA_TypeCodeFactory_ptr);
++  operator CORBA_TypeCodeFactory_ptr &();
++  CORBA_TypeCodeFactory_ptr &ptr (void);
++  CORBA_TypeCodeFactory_ptr operator-> (void);
+     
+   private:
+-    TypeCodeFactory_ptr &ptr_;
++  CORBA_TypeCodeFactory_ptr &ptr_;
+   };
+ 
+-
+-#endif /* end #if !defined */
+-
+-
+-#if !defined (_CORBA_TYPECODEFACTORY_CH_)
+-#define _CORBA_TYPECODEFACTORY_CH_
+-
+-class TAO_TypeCodeFactory_Export TypeCodeFactory : public virtual CORBA_Object
++class TAO_TypeCodeFactory_Export CORBA_TypeCodeFactory 
++  : public virtual CORBA_Object
+   {
+   public:
+   #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+-    typedef TypeCodeFactory_ptr _ptr_type;
+-    typedef TypeCodeFactory_var _var_type;
++    typedef CORBA_TypeCodeFactory_ptr _ptr_type;
++    typedef CORBA_TypeCodeFactory_var _var_type;
+   #endif /* ! __GNUC__ || g++ >= 2.8 */
+ 
+     // the static operations
+-    static TypeCodeFactory_ptr _duplicate (TypeCodeFactory_ptr obj);
+-    static TypeCodeFactory_ptr _narrow (
++    static CORBA_TypeCodeFactory_ptr _duplicate (CORBA_TypeCodeFactory_ptr obj);
++    static CORBA_TypeCodeFactory_ptr _narrow (
+         CORBA::Object_ptr obj,
+-        CORBA::Environment &ACE_TRY_ENV = 
++        CORBA::Environment &env =
+           TAO_default_environment ()
+       );
+-    static TypeCodeFactory_ptr _unchecked_narrow (
++    static CORBA_TypeCodeFactory_ptr _unchecked_narrow (
+         CORBA::Object_ptr obj,
+-        CORBA::Environment &ACE_TRY_ENV = 
++        CORBA::Environment &env =
+           TAO_default_environment ()
+       );
+-    static TypeCodeFactory_ptr _nil (void)
++    static CORBA_TypeCodeFactory_ptr _nil (void)
+       {
+-        return (TypeCodeFactory_ptr)0;
++        return (CORBA_TypeCodeFactory_ptr)0;
+       }
+ 
+     virtual CORBA::TypeCode_ptr create_struct_tc (
+         const char * id,
+         const char * name,
+-        const IR::StructMemberSeq & members,
++        const IR_StructMemberSeq & members,
+         CORBA::Environment &ACE_TRY_ENV = 
+           TAO_default_environment ()
+       )
+@@ -183,7 +146,7 @@
+         const char * id,
+         const char * name,
+         CORBA::TypeCode_ptr discriminator_type,
+-        const IR::UnionMemberSeq & members,
++        const IR_UnionMemberSeq & members,
+         CORBA::Environment &ACE_TRY_ENV = 
+           TAO_default_environment ()
+       )
+@@ -194,7 +157,7 @@
+     virtual CORBA::TypeCode_ptr create_enum_tc (
+         const char * id,
+         const char * name,
+-        const IR::EnumMemberSeq & members,
++        const IR_EnumMemberSeq & members,
+         CORBA::Environment &ACE_TRY_ENV = 
+           TAO_default_environment ()
+       )
+@@ -216,7 +179,7 @@
+     virtual CORBA::TypeCode_ptr create_exception_tc (
+         const char * id,
+         const char * name,
+-        const IR::StructMemberSeq & members,
++        const IR_StructMemberSeq & members,
+         CORBA::Environment &ACE_TRY_ENV = 
+           TAO_default_environment ()
+       )
+@@ -287,7 +250,7 @@
+         const char * name,
+         CORBA::ValueModifier type_modifier,
+         CORBA::TypeCode_ptr concrete_base,
+-        const IR::ValueMemberSeq & members,
++        const IR_ValueMemberSeq & members,
+         CORBA::Environment &ACE_TRY_ENV = 
+           TAO_default_environment ()
+       )
+@@ -370,30 +333,13 @@
+     virtual const char* _interface_repository_id (void) const;
+ 
+   protected:
+-    TypeCodeFactory ();
+-    
+-    virtual ~TypeCodeFactory (void);
++    CORBA_TypeCodeFactory (void);
++    virtual ~CORBA_TypeCodeFactory (void);
+   private:
+-    TypeCodeFactory (const TypeCodeFactory &);
+-    void operator= (const TypeCodeFactory &);
++    CORBA_TypeCodeFactory (const CORBA_TypeCodeFactory &);
++    void operator= (const CORBA_TypeCodeFactory &);
+   };
+ 
+-
+-#endif /* end #if !defined */
+-
+-
+-}
+-TAO_NAMESPACE_CLOSE // module CORBA
+-
+-// Proxy Broker Factory function pointer declarations.
+-
+-
+-#ifndef __ACE_INLINE__
+-
+-
+-#endif /* __ACE_INLINE__ */
+-
+-
+ #if defined (__ACE_INLINE__)
+ #include "TypeCodeFactoryC.inl"
+ #endif /* defined INLINE */
+@@ -407,4 +353,4 @@
+ #endif /* __BORLANDC__ */
+ 
+ #include "ace/post.h"
+-#endif /* ifndef */
++#endif /* TAO_TYPECODEFACTORYC_H */
diff --git a/TAO/tao/TypeCodeFactory/diffs/TypeCodeFactoryC.inl.diff b/TAO/tao/TypeCodeFactory/diffs/TypeCodeFactoryC.inl.diff
new file mode 100644
index 00000000000..7cc48ce5c9f
--- /dev/null
+++ b/TAO/tao/TypeCodeFactory/diffs/TypeCodeFactoryC.inl.diff
@@ -0,0 +1,236 @@
+--- orig/TypeCodeFactoryC.inl	Mon Mar 12 22:17:35 2001
++++ TypeCodeFactoryC.inl	Mon Mar 12 22:32:17 2001
+@@ -1,118 +1,99 @@
+-// -*- C++ -*-
+-//
+-// $Id$
+-
+-// ****  Code generated by the The ACE ORB (TAO) IDL Compiler ****
+-// TAO and the TAO IDL Compiler have been developed by:
+-//       Center for Distributed Object Computing
+-//       Washington University
+-//       St. Louis, MO
+-//       USA
+-//       http://www.cs.wustl.edu/~schmidt/doc-center.html
+-// and
+-//       Distributed Object Computing Laboratory
+-//       University of California at Irvine
+-//       Irvine, CA
+-//       USA
+-//       http://doc.ece.uci.edu/
+-//
+-// Information about TAO is available at:
+-//     http://www.cs.wustl.edu/~schmidt/TAO.html
+-
++/* -*- C++ -*- */
++//$Id$
+ 
+ #if !defined (_CORBA_TYPECODEFACTORY___VAR_CI_)
+ #define _CORBA_TYPECODEFACTORY___VAR_CI_
+ 
+ // *************************************************************
+-// Inline operations for class CORBA::TypeCodeFactory_var
++// Inline operations for class CORBA_TypeCodeFactory_var
+ // *************************************************************
+ 
+ ACE_INLINE
+-CORBA::TypeCodeFactory_var::TypeCodeFactory_var (void) // default constructor
+-  : ptr_ (TypeCodeFactory::_nil ())
++CORBA_TypeCodeFactory_var::CORBA_TypeCodeFactory_var (void) // default constructor
++  : ptr_ (CORBA_TypeCodeFactory::_nil ())
+ {}
+ 
+-ACE_INLINE ::CORBA::TypeCodeFactory_ptr
+-CORBA::TypeCodeFactory_var::ptr (void) const
++ACE_INLINE ::CORBA_TypeCodeFactory_ptr
++CORBA_TypeCodeFactory_var::ptr (void) const
+ {
+   return this->ptr_;
+ }
+ 
+ ACE_INLINE
+-CORBA::TypeCodeFactory_var::TypeCodeFactory_var (const ::CORBA::TypeCodeFactory_var &p) // copy constructor
++CORBA_TypeCodeFactory_var::CORBA_TypeCodeFactory_var (const ::CORBA_TypeCodeFactory_var &p) // copy constructor
+   : TAO_Base_var (),
+-    ptr_ (TypeCodeFactory::_duplicate (p.ptr ()))
++    ptr_ (CORBA_TypeCodeFactory::_duplicate (p.ptr ()))
+ {}
+ 
+ ACE_INLINE
+-CORBA::TypeCodeFactory_var::~TypeCodeFactory_var (void) // destructor
++CORBA_TypeCodeFactory_var::~CORBA_TypeCodeFactory_var (void) // destructor
+ {
+   CORBA::release (this->ptr_);
+ }
+ 
+-ACE_INLINE CORBA::TypeCodeFactory_var &
+-CORBA::TypeCodeFactory_var::operator= (TypeCodeFactory_ptr p)
++ACE_INLINE CORBA_TypeCodeFactory_var &
++CORBA_TypeCodeFactory_var::operator= (CORBA_TypeCodeFactory_ptr p)
+ {
+   CORBA::release (this->ptr_);
+   this->ptr_ = p;
+   return *this;
+ }
+ 
+-ACE_INLINE CORBA::TypeCodeFactory_var &
+-CORBA::TypeCodeFactory_var::operator= (const ::CORBA::TypeCodeFactory_var &p)
++ACE_INLINE CORBA_TypeCodeFactory_var &
++CORBA_TypeCodeFactory_var::operator= (const ::CORBA_TypeCodeFactory_var &p)
+ {
+   if (this != &p)
+   {
+     CORBA::release (this->ptr_);
+-    this->ptr_ = ::CORBA::TypeCodeFactory::_duplicate (p.ptr ());
++    this->ptr_ = ::CORBA_TypeCodeFactory::_duplicate (p.ptr ());
+   }
+   return *this;
+ }
+ 
+ ACE_INLINE 
+-CORBA::TypeCodeFactory_var::operator const ::CORBA::TypeCodeFactory_ptr &() const // cast
++CORBA_TypeCodeFactory_var::operator const ::CORBA_TypeCodeFactory_ptr &() const // cast
+ {
+   return this->ptr_;
+ }
+ 
+ ACE_INLINE 
+-CORBA::TypeCodeFactory_var::operator ::CORBA::TypeCodeFactory_ptr &() // cast 
++CORBA_TypeCodeFactory_var::operator ::CORBA_TypeCodeFactory_ptr &() // cast
+ {
+   return this->ptr_;
+ }
+ 
+-ACE_INLINE ::CORBA::TypeCodeFactory_ptr
+-CORBA::TypeCodeFactory_var::operator-> (void) const
++ACE_INLINE ::CORBA_TypeCodeFactory_ptr
++CORBA_TypeCodeFactory_var::operator-> (void) const
+ {
+   return this->ptr_;
+ }
+ 
+-ACE_INLINE ::CORBA::TypeCodeFactory_ptr
+-CORBA::TypeCodeFactory_var::in (void) const
++ACE_INLINE ::CORBA_TypeCodeFactory_ptr
++CORBA_TypeCodeFactory_var::in (void) const
+ {
+   return this->ptr_;
+ }
+ 
+-ACE_INLINE ::CORBA::TypeCodeFactory_ptr &
+-CORBA::TypeCodeFactory_var::inout (void)
++ACE_INLINE ::CORBA_TypeCodeFactory_ptr &
++CORBA_TypeCodeFactory_var::inout (void)
+ {
+   return this->ptr_;
+ }
+ 
+-ACE_INLINE ::CORBA::TypeCodeFactory_ptr &
+-CORBA::TypeCodeFactory_var::out (void)
++ACE_INLINE ::CORBA_TypeCodeFactory_ptr &
++CORBA_TypeCodeFactory_var::out (void)
+ {
+   CORBA::release (this->ptr_);
+-  this->ptr_ = ::CORBA::TypeCodeFactory::_nil ();
++  this->ptr_ = ::CORBA_TypeCodeFactory::_nil ();
+   return this->ptr_;
+ }
+ 
+-ACE_INLINE ::CORBA::TypeCodeFactory_ptr
+-CORBA::TypeCodeFactory_var::_retn (void)
++ACE_INLINE ::CORBA_TypeCodeFactory_ptr
++CORBA_TypeCodeFactory_var::_retn (void)
+ {
+   // yield ownership of managed obj reference
+-  ::CORBA::TypeCodeFactory_ptr val = this->ptr_;
+-  this->ptr_ = ::CORBA::TypeCodeFactory::_nil ();
++  ::CORBA_TypeCodeFactory_ptr val = this->ptr_;
++  this->ptr_ = ::CORBA_TypeCodeFactory::_nil ();
+   return val;
+ }
+ 
+@@ -124,64 +105,64 @@
+ #define _CORBA_TYPECODEFACTORY___OUT_CI_
+ 
+ // *************************************************************
+-// Inline operations for class CORBA::TypeCodeFactory_out
++// Inline operations for class CORBA_TypeCodeFactory_out
+ // *************************************************************
+ 
+ ACE_INLINE
+-CORBA::TypeCodeFactory_out::TypeCodeFactory_out (TypeCodeFactory_ptr &p)
++CORBA_TypeCodeFactory_out::CORBA_TypeCodeFactory_out (CORBA_TypeCodeFactory_ptr &p)
+   : ptr_ (p)
+ {
+-  this->ptr_ = ::CORBA::TypeCodeFactory::_nil ();
++  this->ptr_ = ::CORBA_TypeCodeFactory::_nil ();
+ }
+ 
+ ACE_INLINE
+-CORBA::TypeCodeFactory_out::TypeCodeFactory_out (TypeCodeFactory_var &p) // constructor from _var
++CORBA_TypeCodeFactory_out::CORBA_TypeCodeFactory_out (CORBA_TypeCodeFactory_var &p) // constructor from _var
+   : ptr_ (p.out ())
+ {
+   CORBA::release (this->ptr_);
+-  this->ptr_ = ::CORBA::TypeCodeFactory::_nil ();
++  this->ptr_ = ::CORBA_TypeCodeFactory::_nil ();
+ }
+ 
+ ACE_INLINE
+-CORBA::TypeCodeFactory_out::TypeCodeFactory_out (const ::CORBA::TypeCodeFactory_out &p) // copy constructor
+-  : ptr_ (ACE_const_cast (TypeCodeFactory_out &, p).ptr_)
++CORBA_TypeCodeFactory_out::CORBA_TypeCodeFactory_out (const ::CORBA_TypeCodeFactory_out &p) // copy constructor
++  : ptr_ (ACE_const_cast (CORBA_TypeCodeFactory_out &, p).ptr_)
+ {}
+ 
+-ACE_INLINE ::CORBA::TypeCodeFactory_out &
+-CORBA::TypeCodeFactory_out::operator= (const ::CORBA::TypeCodeFactory_out &p)
++ACE_INLINE ::CORBA_TypeCodeFactory_out &
++CORBA_TypeCodeFactory_out::operator= (const ::CORBA_TypeCodeFactory_out &p)
+ {
+-  this->ptr_ = ACE_const_cast (TypeCodeFactory_out&, p).ptr_;
++  this->ptr_ = ACE_const_cast (CORBA_TypeCodeFactory_out&, p).ptr_;
+   return *this;
+ }
+ 
+-ACE_INLINE CORBA::TypeCodeFactory_out &
+-CORBA::TypeCodeFactory_out::operator= (const ::CORBA::TypeCodeFactory_var &p)
++ACE_INLINE CORBA_TypeCodeFactory_out &
++CORBA_TypeCodeFactory_out::operator= (const ::CORBA_TypeCodeFactory_var &p)
+ {
+-  this->ptr_ = ::CORBA::TypeCodeFactory::_duplicate (p.ptr ());
++  this->ptr_ = ::CORBA_TypeCodeFactory::_duplicate (p.ptr ());
+   return *this;
+ }
+ 
+-ACE_INLINE CORBA::TypeCodeFactory_out &
+-CORBA::TypeCodeFactory_out::operator= (TypeCodeFactory_ptr p)
++ACE_INLINE CORBA_TypeCodeFactory_out &
++CORBA_TypeCodeFactory_out::operator= (CORBA_TypeCodeFactory_ptr p)
+ {
+   this->ptr_ = p;
+   return *this;
+ }
+ 
+ ACE_INLINE 
+-CORBA::TypeCodeFactory_out::operator ::CORBA::TypeCodeFactory_ptr &() // cast
++CORBA_TypeCodeFactory_out::operator ::CORBA_TypeCodeFactory_ptr &() // cast
+ {
+   return this->ptr_;
+ }
+ 
+-ACE_INLINE ::CORBA::TypeCodeFactory_ptr &
+-CORBA::TypeCodeFactory_out::ptr (void) // ptr
++ACE_INLINE ::CORBA_TypeCodeFactory_ptr &
++CORBA_TypeCodeFactory_out::ptr (void) // ptr
+ {
+   return this->ptr_;
+ }
+ 
+-ACE_INLINE ::CORBA::TypeCodeFactory_ptr
+-CORBA::TypeCodeFactory_out::operator-> (void)
++ACE_INLINE ::CORBA_TypeCodeFactory_ptr
++CORBA_TypeCodeFactory_out::operator-> (void)
+ {
+   return this->ptr_;
+ }
diff --git a/TAO/tao/TypeCodeFactory/typecodefactory_export.h b/TAO/tao/TypeCodeFactory/typecodefactory_export.h
new file mode 100644
index 00000000000..03bfa7334ab
--- /dev/null
+++ b/TAO/tao/TypeCodeFactory/typecodefactory_export.h
@@ -0,0 +1,40 @@
+
+// -*- C++ -*-
+// $Id$
+// Definition for Win32 Export directives.
+// This file is generated automatically by generate_export_file.pl
+// ------------------------------
+#ifndef TAO_TYPECODEFACTORY_EXPORT_H
+#define TAO_TYPECODEFACTORY_EXPORT_H
+
+#include "ace/config-all.h"
+
+#if defined (TAO_AS_STATIC_LIBS)
+#  if !defined (TAO_TYPECODEFACTORY_HAS_DLL)
+#    define TAO_TYPECODEFACTORY_HAS_DLL 0
+#  endif /* ! TAO_TYPECODEFACTORY_HAS_DLL */
+#else
+#  if !defined (TAO_TYPECODEFACTORY_HAS_DLL)
+#    define TAO_TYPECODEFACTORY_HAS_DLL 1
+#  endif /* ! TAO_TYPECODEFACTORY_HAS_DLL */
+#endif
+
+#if defined (TAO_TYPECODEFACTORY_HAS_DLL) && (TAO_TYPECODEFACTORY_HAS_DLL == 1)
+#  if defined (TAO_TYPECODEFACTORY_BUILD_DLL)
+#    define TAO_TypeCodeFactory_Export ACE_Proper_Export_Flag
+#    define TAO_TYPECODEFACTORY_SINGLETON_DECLARATION(T) ACE_EXPORT_SINGLETON_DECLARATION (T)
+#    define TAO_TYPECODEFACTORY_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) ACE_EXPORT_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK)
+#  else /* TAO_TYPECODEFACTORY_BUILD_DLL */
+#    define TAO_TypeCodeFactory_Export ACE_Proper_Import_Flag
+#    define TAO_TYPECODEFACTORY_SINGLETON_DECLARATION(T) ACE_IMPORT_SINGLETON_DECLARATION (T)
+#    define TAO_TYPECODEFACTORY_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) ACE_IMPORT_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK)
+#  endif /* TAO_TYPECODEFACTORY_BUILD_DLL */
+#else /* TAO_TYPECODEFACTORY_HAS_DLL == 1 */
+#  define TAO_TypeCodeFactory_Export
+#  define TAO_TYPECODEFACTORY_SINGLETON_DECLARATION(T)
+#  define TAO_TYPECODEFACTORY_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK)
+#endif /* TAO_TYPECODEFACTORY_HAS_DLL == 1 */
+
+#endif /* TAO_TYPECODEFACTORY_EXPORT_H */
+
+// End of auto generated file.
diff --git a/TAO/tao/TypeCodeFactory_Adapter.cpp b/TAO/tao/TypeCodeFactory_Adapter.cpp
new file mode 100644
index 00000000000..b6620145094
--- /dev/null
+++ b/TAO/tao/TypeCodeFactory_Adapter.cpp
@@ -0,0 +1,219 @@
+// @(#) $Id$
+
+#include "tao/TypeCodeFactory_Adapter.h"
+#include "tao/Typecode.h"
+#include "ace/Dynamic_Service.h"
+
+ACE_RCSID(tao, TypeCodeFactory_Adapter, "$Id$")
+
+TAO_TypeCodeFactory_Adapter::~TAO_TypeCodeFactory_Adapter (void)
+{
+}
+
+// Methods to be overridden.
+
+CORBA::TypeCode_ptr 
+TAO_TypeCodeFactory_Adapter::create_struct_tc (
+    const char * /* id */,
+    const char * /* name */,
+    const CORBA_StructMemberSeq & /* members */,
+    CORBA::Environment &
+  )  
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  return CORBA::TypeCode::_nil ();
+}
+
+CORBA::TypeCode_ptr 
+TAO_TypeCodeFactory_Adapter::create_union_tc (
+    const char * /* id */,
+    const char * /* name */,
+    CORBA::TypeCode_ptr /* discriminator_type */,
+    const CORBA_UnionMemberSeq & /* members */,
+    CORBA::Environment &
+  )  
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  return CORBA::TypeCode::_nil ();
+}
+
+CORBA::TypeCode_ptr 
+TAO_TypeCodeFactory_Adapter::create_enum_tc (
+    const char * /* id */,
+    const char * /* name */,
+    const CORBA_EnumMemberSeq & /* members */,
+    CORBA::Environment &
+  )  
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  return CORBA::TypeCode::_nil ();
+}
+
+CORBA::TypeCode_ptr 
+TAO_TypeCodeFactory_Adapter::create_alias_tc (
+    const char * /* id */,
+    const char * /* name */,
+    CORBA::TypeCode_ptr /* original_type */,
+    CORBA::Environment &
+  )  
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  return CORBA::TypeCode::_nil ();
+}
+
+CORBA::TypeCode_ptr 
+TAO_TypeCodeFactory_Adapter::create_exception_tc (
+    const char * /* id */,
+    const char * /* name */,
+    const CORBA_StructMemberSeq & /* members */,
+    CORBA::Environment &
+  )  
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  return CORBA::TypeCode::_nil ();
+}
+
+CORBA::TypeCode_ptr 
+TAO_TypeCodeFactory_Adapter::create_interface_tc (
+    const char * /* id */,
+    const char * /* name */,
+    CORBA::Environment &
+  )  
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  return CORBA::TypeCode::_nil ();
+}
+
+CORBA::TypeCode_ptr 
+TAO_TypeCodeFactory_Adapter::create_string_tc (
+    CORBA::ULong /* bound */,
+    CORBA::Environment &
+  )  
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  return CORBA::TypeCode::_nil ();
+}
+
+CORBA::TypeCode_ptr 
+TAO_TypeCodeFactory_Adapter::create_wstring_tc (
+    CORBA::ULong /* bound */,
+    CORBA::Environment &
+  )  
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  return CORBA::TypeCode::_nil ();
+}
+
+CORBA::TypeCode_ptr 
+TAO_TypeCodeFactory_Adapter::create_fixed_tc (
+    CORBA::UShort /* digits */,
+    CORBA::UShort /* scale */,
+    CORBA::Environment &
+  )  
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  return CORBA::TypeCode::_nil ();
+}
+
+CORBA::TypeCode_ptr 
+TAO_TypeCodeFactory_Adapter::create_sequence_tc (
+    CORBA::ULong /* bound */,
+    CORBA::TypeCode_ptr /* element_type */,
+    CORBA::Environment &
+  )  
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  return CORBA::TypeCode::_nil ();
+}
+
+CORBA::TypeCode_ptr 
+TAO_TypeCodeFactory_Adapter::create_array_tc (
+    CORBA::ULong /* length */,
+    CORBA::TypeCode_ptr /* element_type */,
+    CORBA::Environment &
+  )
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{  
+  return CORBA::TypeCode::_nil ();
+}
+
+CORBA::TypeCode_ptr 
+TAO_TypeCodeFactory_Adapter::create_value_tc (
+    const char * /* id */,
+    const char * /* name */,
+    CORBA::ValueModifier /* type_modifier */,
+    CORBA::TypeCode_ptr /* concrete_base */,
+    const CORBA_ValueMemberSeq & /* members */,
+    CORBA::Environment &
+  )  
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  return CORBA::TypeCode::_nil ();
+}
+
+CORBA::TypeCode_ptr 
+TAO_TypeCodeFactory_Adapter::create_value_box_tc (
+    const char * /* id */,
+    const char * /* name */,
+    CORBA::TypeCode_ptr  /* boxed_type */,
+    CORBA::Environment &
+  )  
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  return CORBA::TypeCode::_nil ();
+}
+
+CORBA::TypeCode_ptr 
+TAO_TypeCodeFactory_Adapter::create_native_tc (
+    const char * /* id */,
+    const char * /* name */,
+    CORBA::Environment &
+  )  
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  return CORBA::TypeCode::_nil ();
+}
+
+CORBA::TypeCode_ptr 
+TAO_TypeCodeFactory_Adapter::create_recursive_tc (
+    const char * /* id */,
+    CORBA::Environment &
+  )  
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  return CORBA::TypeCode::_nil ();
+}
+
+CORBA::TypeCode_ptr 
+TAO_TypeCodeFactory_Adapter::create_abstract_interface_tc (
+    const char * /* id */,
+    const char * /* name */,
+    CORBA::Environment &
+  )  
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  return CORBA::TypeCode::_nil ();
+}
+
+CORBA::TypeCode_ptr 
+TAO_TypeCodeFactory_Adapter::create_local_interface_tc (
+    const char * /* id */,
+    const char * /* name */,
+    CORBA::Environment &
+  )  
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  return CORBA::TypeCode::_nil ();
+}
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)
+
+template class ACE_Dynamic_Service<TAO_TypeCodeFactory_Adapter>;
+
+#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+
+#pragma instantiate ACE_Dynamic_Service<TAO_TypeCodeFactory_Adapter>
+
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+
diff --git a/TAO/tao/TypeCodeFactory_Adapter.h b/TAO/tao/TypeCodeFactory_Adapter.h
new file mode 100644
index 00000000000..23d571c70b5
--- /dev/null
+++ b/TAO/tao/TypeCodeFactory_Adapter.h
@@ -0,0 +1,185 @@
+// This may look like C, but it's really -*- C++ -*-
+
+//=============================================================================
+/**
+ *  @file    TypeCodeFactory_Adapter.h
+ *
+ *  $Id$
+ *
+ *  @author  Jeff Parsons <parsons@cs.wustl.edu>
+ */
+//=============================================================================
+
+
+#ifndef TAO_TYPECODEFACTORY_ADAPTER_H
+#define TAO_TYPECODEFACTORY_ADAPTER_H
+#include "ace/pre.h"
+
+#include "tao/corbafwd.h"
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+# pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+#include "ace/Service_Object.h"
+
+/**
+ * @class TAO_TypeCodeFactory_Adapter
+ *
+ * @brief TAO_TypeCodeFactory_Adapter.
+ *
+ * Class that adapts the CORBA::ORB create_*_tc functions
+ * to use the TypeCodeFactory. This is a base class for 
+ * the actual implementation in the TypeCodeFactory_DLL library.
+ */
+class TAO_Export TAO_TypeCodeFactory_Adapter : public ACE_Service_Object
+{
+public:
+  virtual ~TAO_TypeCodeFactory_Adapter (void);
+
+  virtual CORBA::TypeCode_ptr create_struct_tc (
+      const char *id,
+      const char *name,
+      const CORBA_StructMemberSeq &members,
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )  
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+  virtual CORBA::TypeCode_ptr create_union_tc (
+      const char *id,
+      const char *name,
+      CORBA::TypeCode_ptr discriminator_type,
+      const CORBA_UnionMemberSeq &members,
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )  
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+  virtual CORBA::TypeCode_ptr create_enum_tc (
+      const char *id,
+      const char *name,
+      const CORBA_EnumMemberSeq &members,
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )  
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+  virtual CORBA::TypeCode_ptr create_alias_tc (
+      const char *id,
+      const char *name,
+      CORBA::TypeCode_ptr original_type,
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )  
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+  virtual CORBA::TypeCode_ptr create_exception_tc (
+      const char *id,
+      const char *name,
+      const CORBA_StructMemberSeq &members,
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )  
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+  virtual CORBA::TypeCode_ptr create_interface_tc (
+      const char *id,
+      const char *name,
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )  
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+  virtual CORBA::TypeCode_ptr create_string_tc (
+      CORBA::ULong bound,
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )  
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+  virtual CORBA::TypeCode_ptr create_wstring_tc (
+      CORBA::ULong bound,
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )  
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+  virtual CORBA::TypeCode_ptr create_fixed_tc (
+      CORBA::UShort digits,
+      CORBA::UShort scale,
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )  
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+  virtual CORBA::TypeCode_ptr create_sequence_tc (
+      CORBA::ULong bound,
+      CORBA::TypeCode_ptr element_type,
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )  
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+  virtual CORBA::TypeCode_ptr create_array_tc (
+      CORBA::ULong length,
+      CORBA::TypeCode_ptr element_type,
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )  
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+  virtual CORBA::TypeCode_ptr create_value_tc (
+      const char *id,
+      const char *name,
+      CORBA::ValueModifier type_modifier,
+      CORBA::TypeCode_ptr concrete_base,
+      const CORBA_ValueMemberSeq &members,
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )  
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+  virtual CORBA::TypeCode_ptr create_value_box_tc (
+      const char *id,
+      const char *name,
+      CORBA::TypeCode_ptr boxed_type,
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )  
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+  virtual CORBA::TypeCode_ptr create_native_tc (
+      const char *id,
+      const char *name,
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )  
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+  virtual CORBA::TypeCode_ptr create_recursive_tc (
+      const char *id,
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )  
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+  virtual CORBA::TypeCode_ptr create_abstract_interface_tc (
+      const char *id,
+      const char *name,
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )  
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+  virtual CORBA::TypeCode_ptr create_local_interface_tc (
+      const char *id,
+      const char *name,
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )  
+    ACE_THROW_SPEC ((CORBA::SystemException));
+};
+
+#include "ace/post.h"
+#endif /* TAO_TYPECODEFACTORY_ADAPTER_H */
diff --git a/TAO/tao/corbafwd.h b/TAO/tao/corbafwd.h
index 514f053800e..39ebc75c4e4 100644
--- a/TAO/tao/corbafwd.h
+++ b/TAO/tao/corbafwd.h
@@ -323,109 +323,266 @@ class CORBA_IRObject_var;
 class CORBA_IRObject_out;
 typedef CORBA_IRObject *CORBA_IRObject_ptr;
 
-class IR_StructMemberSeq;
-class IR_StructMemberSeq_var;
-class IR_StructMemberSeq_out;
-
-class IR_UnionMemberSeq;
-class IR_UnionMemberSeq_var;
-class IR_UnionMemberSeq_out;
-
-class IR_EnumMemberSeq;
-class IR_EnumMemberSeq_var;
-class IR_EnumMemberSeq_out;
-
-class IR_ValueMemberSeq;
-class IR_ValueMemberSeq_var;
-class IR_ValueMemberSeq_out;
-
-class IR_InterfaceDef;
-class IR_InterfaceDef_var;
-class IR_InterfaceDef_out;
-typedef class IR_InterfaceDef *IR_InterfaceDef_ptr;
-
-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
-  };
-
-enum IR_PrimitiveKind
-  {
-    pk_null,
-    pk_void,
-    pk_short,
-    pk_long,
-    pk_ushort,
-    pk_ulong,
-    pk_float,
-    pk_double,
-    pk_boolean,
-    pk_char,
-    pk_octet,
-    pk_any,
-    pk_TypeCode,
-    pk_Principal,
-    pk_string,
-    pk_objref,
-    pk_longlong,
-    pk_ulonglong,
-    pk_longdouble,
-    pk_wchar,
-    pk_wstring,
-    pk_value_base
-  };
-
-enum IR_AttributeMode
-{
-  ATTR_NORMAL,
-  ATTR_READONLY
-};
-
-enum IR_OperationMode
-  {
-    OP_NORMAL,
-    OP_ONEWAY
-  };
-
-enum IR_ParameterMode
-  {
-    PARAM_IN,
-    PARAM_OUT,
-    PARAM_INOUT
-  };
+class CORBA_Contained;
+class CORBA_Contained_var;
+class CORBA_Contained_out;
+typedef CORBA_Contained *CORBA_Contained_ptr;
+
+class CORBA_ContainedSeq;
+class CORBA_ContainedSeq_var;
+class CORBA_ContainedSeq_out;
+
+class CORBA_Repository;
+class CORBA_Repository_var;
+class CORBA_Repository_out;
+typedef CORBA_Repository *CORBA_Repository_ptr;
+
+class CORBA_Container;
+class CORBA_Container_var;
+class CORBA_Container_out;
+typedef CORBA_Container *CORBA_Container_ptr;
+
+class CORBA_ModuleDef;
+class CORBA_ModuleDef_var;
+class CORBA_ModuleDef_out;
+typedef CORBA_ModuleDef *CORBA_ModuleDef_ptr;
+
+class CORBA_ConstantDef;
+class CORBA_ConstantDef_var;
+class CORBA_ConstantDef_out;
+typedef CORBA_ConstantDef *CORBA_ConstantDef_ptr;
+
+class CORBA_IDLType;
+class CORBA_IDLType_var;
+class CORBA_IDLType_out;
+typedef CORBA_IDLType *CORBA_IDLType_ptr;
+
+class CORBA_StructDef;
+class CORBA_StructDef_var;
+class CORBA_StructDef_out;
+typedef CORBA_StructDef *CORBA_StructDef_ptr;
+
+class CORBA_UnionDef;
+class CORBA_UnionDef_var;
+class CORBA_UnionDef_out;
+typedef CORBA_UnionDef *CORBA_UnionDef_ptr;
+
+class CORBA_EnumDef;
+class CORBA_EnumDef_var;
+class CORBA_EnumDef_out;
+typedef CORBA_EnumDef *CORBA_EnumDef_ptr;
+
+class CORBA_AliasDef;
+class CORBA_AliasDef_var;
+class CORBA_AliasDef_out;
+typedef CORBA_AliasDef *CORBA_AliasDef_ptr;
+
+class CORBA_InterfaceDef;
+class CORBA_InterfaceDef_var;
+class CORBA_InterfaceDef_out;
+typedef CORBA_InterfaceDef *CORBA_InterfaceDef_ptr;
+
+typedef CORBA_InterfaceDef IR_InterfaceDef;
+
+class CORBA_AbstractInterfaceDef;
+class CORBA_AbstractInterfaceDef_var;
+class CORBA_AbstractInterfaceDef_out;
+typedef CORBA_AbstractInterfaceDef *CORBA_AbstractInterfaceDef_ptr;
+
+class CORBA_LocalInterfaceDef;
+class CORBA_LocalInterfaceDef_var;
+class CORBA_LocalInterfaceDef_out;
+typedef CORBA_LocalInterfaceDef *CORBA_LocalInterfaceDef_ptr;
+
+class CORBA_ExceptionDef;
+class CORBA_ExceptionDef_var;
+class CORBA_ExceptionDef_out;
+typedef CORBA_ExceptionDef *CORBA_ExceptionDef_ptr;
+
+class CORBA_NativeDef;
+class CORBA_NativeDef_var;
+class CORBA_NativeDef_out;
+typedef CORBA_NativeDef *CORBA_NativeDef_ptr;
+
+class CORBA_InterfaceDefSeq;
+class CORBA_InterfaceDefSeq_var;
+class CORBA_InterfaceDefSeq_out;
+
+class CORBA_AbstractInterfaceDefSeq;
+class CORBA_AbstractInterfaceDefSeq_var;
+class CORBA_AbstractInterfaceDefSeq_out;
+
+class CORBA_LocalInterfaceDefSeq;
+class CORBA_LocalInterfaceDefSeq_var;
+class CORBA_LocalInterfaceDefSeq_out;
+
+class CORBA_ValueDef;
+class CORBA_ValueDef_var;
+class CORBA_ValueDef_out;
+typedef CORBA_ValueDef *CORBA_ValueDef_ptr;
+
+class CORBA_ValueDefSeq;
+class CORBA_ValueDefSeq_var;
+class CORBA_ValueDefSeq_out;
+
+class CORBA_ValueBoxDef;
+class CORBA_ValueBoxDef_var;
+class CORBA_ValueBoxDef_out;
+typedef CORBA_ValueBoxDef *CORBA_ValueBoxDef_ptr;
+
+struct CORBA_StructMember;
+class CORBA_StructMember_var;
+class CORBA_StructMember_out;
+
+class CORBA_StructMemberSeq;
+class CORBA_StructMemberSeq_var;
+class CORBA_StructMemberSeq_out;
+
+struct CORBA_Initializer;
+class CORBA_Initializer_var;
+class CORBA_Initializer_out;
+
+class CORBA_InitializerSeq;
+class CORBA_InitializerSeq_var;
+class CORBA_InitializerSeq_out;
+
+struct CORBA_UnionMember;
+class CORBA_UnionMember_var;
+class CORBA_UnionMember_out;
+
+class CORBA_UnionMemberSeq;
+class CORBA_UnionMemberSeq_var;
+class CORBA_UnionMemberSeq_out;
+
+class CORBA_EnumMemberSeq;
+class CORBA_EnumMemberSeq_var;
+class CORBA_EnumMemberSeq_out;
+
+struct CORBA_ModuleDescription;
+class CORBA_ModuleDescription_var;
+class CORBA_ModuleDescription_out;
+
+struct CORBA_ConstantDescription;
+class CORBA_ConstantDescription_var;
+class CORBA_ConstantDescription_out;
+
+class CORBA_TypedefDef;
+class CORBA_TypedefDef_var;
+class CORBA_TypedefDef_out;
+typedef CORBA_TypedefDef *CORBA_TypedefDef_ptr;
+
+struct CORBA_TypeDescription;
+class CORBA_TypeDescription_var;
+class CORBA_TypeDescription_out;
+
+class CORBA_PrimitiveDef;
+class CORBA_PrimitiveDef_var;
+class CORBA_PrimitiveDef_out;
+typedef CORBA_PrimitiveDef *CORBA_PrimitiveDef_ptr;
+
+class CORBA_StringDef;
+class CORBA_StringDef_var;
+class CORBA_StringDef_out;
+typedef CORBA_StringDef *CORBA_StringDef_ptr;
+
+class CORBA_WstringDef;
+class CORBA_WstringDef_var;
+class CORBA_WstringDef_out;
+typedef CORBA_WstringDef *CORBA_WstringDef_ptr;
+
+class CORBA_FixedDef;
+class CORBA_FixedDef_var;
+class CORBA_FixedDef_out;
+typedef CORBA_FixedDef *CORBA_FixedDef_ptr;
+
+class CORBA_SequenceDef;
+class CORBA_SequenceDef_var;
+class CORBA_SequenceDef_out;
+typedef CORBA_SequenceDef *CORBA_SequenceDef_ptr;
+
+class CORBA_ArrayDef;
+class CORBA_ArrayDef_var;
+class CORBA_ArrayDef_out;
+typedef CORBA_ArrayDef *CORBA_ArrayDef_ptr;
+
+struct CORBA_ExceptionDescription;
+class CORBA_ExceptionDescription_var;
+class CORBA_ExceptionDescription_out;
+
+class CORBA_ExceptionDefSeq;
+class CORBA_ExceptionDefSeq_var;
+class CORBA_ExceptionDefSeq_out;
+
+class CORBA_ExcDescriptionSeq;
+class CORBA_ExcDescriptionSeq_var;
+class CORBA_ExcDescriptionSeq_out;
+
+class CORBA_AttributeDef;
+class CORBA_AttributeDef_var;
+class CORBA_AttributeDef_out;
+typedef CORBA_AttributeDef *CORBA_AttributeDef_ptr;
+
+struct CORBA_AttributeDescription;
+class CORBA_AttributeDescription_var;
+class CORBA_AttributeDescription_out;
+
+struct CORBA_ParameterDescription;
+class CORBA_ParameterDescription_var;
+class CORBA_ParameterDescription_out;
+
+class CORBA_ParDescriptionSeq;
+class CORBA_ParDescriptionSeq_var;
+class CORBA_ParDescriptionSeq_out;
+
+class CORBA_ContextIdSeq;
+class CORBA_ContextIdSeq_var;
+class CORBA_ContextIdSeq_out;
+
+class CORBA_OperationDef;
+class CORBA_OperationDef_var;
+class CORBA_OperationDef_out;
+typedef CORBA_OperationDef *CORBA_OperationDef_ptr;
+
+struct CORBA_OperationDescription;
+class CORBA_OperationDescription_var;
+class CORBA_OperationDescription_out;
+
+struct CORBA_ParameterDescription;
+class CORBA_ParameterDescription_var;
+class CORBA_ParameterDescription_out;
+
+class CORBA_RepositoryIdSeq;
+class CORBA_RepositoryIdSeq_var;
+class CORBA_RepositoryIdSeq_out;
+
+class CORBA_OpDescriptionSeq;
+class CORBA_OpDescriptionSeq_var;
+class CORBA_OpDescriptionSeq_out;
+
+class CORBA_AttrDescriptionSeq;
+class CORBA_AttrDescriptionSeq_var;
+class CORBA_AttrDescriptionSeq_out;
+
+struct CORBA_InterfaceDescription;
+class CORBA_InterfaceDescription_var;
+class CORBA_InterfaceDescription_out;
+
+struct CORBA_ValueMember;
+class CORBA_ValueMember_var;
+class CORBA_ValueMember_out;
+
+class CORBA_ValueMemberSeq;
+class CORBA_ValueMemberSeq_var;
+class CORBA_ValueMemberSeq_out;
+
+class CORBA_ValueMemberDef;
+class CORBA_ValueMemberDef_var;
+class CORBA_ValueMemberDef_out;
+typedef CORBA_ValueMemberDef *CORBA_ValueMemberDef_ptr;
+
+struct CORBA_ValueDescription;
+class CORBA_ValueDescription_var;
+class CORBA_ValueDescription_out;
 
 class CORBA_TypeCodeFactory;
 class CORBA_TypeCodeFactory_var;
@@ -651,6 +808,7 @@ TAO_NAMESPACE CORBA
   typedef CORBA_TypeCodeFactory *TypeCodeFactory_ptr;
   typedef CORBA_TypeCodeFactory_out TypeCodeFactory_out;
   typedef CORBA_TypeCodeFactory_var TypeCodeFactory_var;
+  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_TypeCodeFactory;
 
   typedef CORBA_Bounds Bounds;
   typedef CORBA_Bounds *Bounds_ptr;
@@ -995,8 +1153,10 @@ TAO_NAMESPACE CORBA
   typedef CORBA_String_out ScopedName_out;
   TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ScopedName;
 
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_IRObject;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_TypeCodeFactory;
+  typedef char *VersionSpec;
+  typedef CORBA_String_var VersionSpec_var;
+  typedef CORBA_String_out VersionSpec_out;
+  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_VersionSpec;
 
   typedef CORBA::Short Visibility;
   typedef CORBA::Short_out Visibility_out;
@@ -1014,31 +1174,438 @@ TAO_NAMESPACE CORBA
   TAO_NAMESPACE_STORAGE_CLASS const CORBA::Short VM_ABSTRACT;
   TAO_NAMESPACE_STORAGE_CLASS const CORBA::Short VM_TRUNCATABLE;
 
-  typedef IR_StructMemberSeq StructMemberSeq;
-  typedef IR_StructMemberSeq_var StructMemberSeq_var;
-  typedef IR_StructMemberSeq_out StructMemberSeq_out;
-
-  typedef IR_UnionMemberSeq UnionMemberSeq;
-  typedef IR_UnionMemberSeq_var UnionMemberSeq_var;
-  typedef IR_UnionMemberSeq_out UnionMemberSeq_out;
-
-  typedef IR_EnumMemberSeq EnumMemberSeq;
-  typedef IR_EnumMemberSeq_var EnumMemberSeq_var;
-  typedef IR_EnumMemberSeq_out EnumMemberSeq_out;
-
-  typedef IR_ValueMemberSeq ValueMemberSeq;
-  typedef IR_ValueMemberSeq_var ValueMemberSeq_var;
-  typedef IR_ValueMemberSeq_out ValueMemberSeq_out;
+  typedef char * ContextIdentifier;
+  typedef CORBA::String_var ContextIdentifier_var;
+  typedef CORBA::String_out ContextIdentifier_out;
+  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ContextIdentifier;
 
   typedef CORBA_IRObject IRObject;
   typedef CORBA_IRObject *IRObject_ptr;
-  typedef CORBA_IRObject_out IRObject_out;
   typedef CORBA_IRObject_var IRObject_var;
+  typedef CORBA_IRObject_out IRObject_out;
+  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_IRObject;
+
+  enum 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,
+
+        // CORBA 2.x version.
+        dk_AbstractInterface,
+        dk_LocalInterface,
+
+        // CCM version. These do not have the
+        // correct values (position in the enum)
+        // but are included so we can compile
+        // as much of the IFR CCM implementation
+        // as possible. When the two OMG versions
+        // of Interface.idl come into line, this
+        // enum will change to reflect that.
+        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;
+
+  typedef CORBA_Contained Contained;
+  typedef CORBA_Contained *Contained_ptr;
+  typedef CORBA_Contained_var Contained_var;
+  typedef CORBA_Contained_out Contained_out;
+  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_Contained;
+
+  typedef CORBA_ContainedSeq ContainedSeq;
+  typedef CORBA_ContainedSeq_var ContainedSeq_var;
+  typedef CORBA_ContainedSeq_out ContainedSeq_out;
+  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ContainedSeq;
+
+  typedef CORBA_Repository Repository;
+  typedef CORBA_Repository *Repository_ptr;
+  typedef CORBA_Repository_var Repository_var;
+  typedef CORBA_Repository_out Repository_out;
+  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_Repository;
+
+  typedef CORBA_Container Container;
+  typedef CORBA_Container *Container_ptr;
+  typedef CORBA_Container_var Container_var;
+  typedef CORBA_Container_out Container_out;
+  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_Container;
+
+  typedef CORBA_ModuleDef ModuleDef;
+  typedef CORBA_ModuleDef *ModuleDef_ptr;
+  typedef CORBA_ModuleDef_var ModuleDef_var;
+  typedef CORBA_ModuleDef_out ModuleDef_out;
+  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ModuleDef;
+
+  typedef CORBA_ConstantDef ConstantDef;
+  typedef CORBA_ConstantDef *ConstantDef_ptr;
+  typedef CORBA_ConstantDef_var ConstantDef_var;
+  typedef CORBA_ConstantDef_out ConstantDef_out;
+  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ConstantDef;
+
+  typedef CORBA_IDLType IDLType;
+  typedef CORBA_IDLType *IDLType_ptr;
+  typedef CORBA_IDLType_var IDLType_var;
+  typedef CORBA_IDLType_out IDLType_out;
+  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_IDLType;
+
+  typedef CORBA_StructDef StructDef;
+  typedef CORBA_StructDef *StructDef_ptr;
+  typedef CORBA_StructDef_var StructDef_var;
+  typedef CORBA_StructDef_out StructDef_out;
+  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_StructDef;
+
+  typedef CORBA_UnionDef UnionDef;
+  typedef CORBA_UnionDef *UnionDef_ptr;
+  typedef CORBA_UnionDef_var UnionDef_var;
+  typedef CORBA_UnionDef_out UnionDef_out;
+  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_UnionDef;
+
+  typedef CORBA_EnumDef EnumDef;
+  typedef CORBA_EnumDef *EnumDef_ptr;
+  typedef CORBA_EnumDef_var EnumDef_var;
+  typedef CORBA_EnumDef_out EnumDef_out;
+  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_EnumDef;
+
+  typedef CORBA_AliasDef AliasDef;
+  typedef CORBA_AliasDef *AliasDef_ptr;
+  typedef CORBA_AliasDef_var AliasDef_var;
+  typedef CORBA_AliasDef_out AliasDef_out;
+  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_AliasDef;
+
+  typedef CORBA_InterfaceDef InterfaceDef;
+  typedef CORBA_InterfaceDef *InterfaceDef_ptr;
+  typedef CORBA_InterfaceDef_var InterfaceDef_var;
+  typedef CORBA_InterfaceDef_out InterfaceDef_out;
+  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_InterfaceDef;
+
+  typedef CORBA_AbstractInterfaceDef AbstractInterfaceDef;
+  typedef CORBA_AbstractInterfaceDef *AbstractInterfaceDef_ptr;
+  typedef CORBA_AbstractInterfaceDef_var AbstractInterfaceDef_var;
+  typedef CORBA_AbstractInterfaceDef_out AbstractInterfaceDef_out;
+  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_AbstractInterfaceDef;
+
+  typedef CORBA_LocalInterfaceDef LocalInterfaceDef;
+  typedef CORBA_LocalInterfaceDef *LocalInterfaceDef_ptr;
+  typedef CORBA_LocalInterfaceDef_var LocalInterfaceDef_var;
+  typedef CORBA_LocalInterfaceDef_out LocalInterfaceDef_out;
+  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_LocalInterfaceDef;
+
+  typedef CORBA_ExceptionDef ExceptionDef;
+  typedef CORBA_ExceptionDef *ExceptionDef_ptr;
+  typedef CORBA_ExceptionDef_var ExceptionDef_var;
+  typedef CORBA_ExceptionDef_out ExceptionDef_out;
+  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ExceptionDef;
+
+  typedef CORBA_NativeDef NativeDef;
+  typedef CORBA_NativeDef *NativeDef_ptr;
+  typedef CORBA_NativeDef_var NativeDef_var;
+  typedef CORBA_NativeDef_out NativeDef_out;
+  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_NativeDef;
+
+  typedef CORBA_InterfaceDefSeq InterfaceDefSeq;
+  typedef CORBA_InterfaceDefSeq_var InterfaceDefSeq_var;
+  typedef CORBA_InterfaceDefSeq_out InterfaceDefSeq_out;
+  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_InterfaceDefSeq;
+
+  typedef CORBA_AbstractInterfaceDefSeq AbstractInterfaceDefSeq;
+  typedef CORBA_AbstractInterfaceDefSeq_var AbstractInterfaceDefSeq_var;
+  typedef CORBA_AbstractInterfaceDefSeq_out AbstractInterfaceDefSeq_out;
+  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_AbstractInterfaceDefSeq;
+
+  typedef CORBA_LocalInterfaceDefSeq LocalInterfaceDefSeq;
+  typedef CORBA_LocalInterfaceDefSeq_var LocalInterfaceDefSeq_var;
+  typedef CORBA_LocalInterfaceDefSeq_out LocalInterfaceDefSeq_out;
+  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_LocalInterfaceDefSeq;
+
+  typedef CORBA_ValueDef ValueDef;
+  typedef CORBA_ValueDef *ValueDef_ptr;
+  typedef CORBA_ValueDef_var ValueDef_var;
+  typedef CORBA_ValueDef_out ValueDef_out;
+  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ValueDef;
+
+  typedef CORBA_ValueDefSeq ValueDefSeq;
+  typedef CORBA_ValueDefSeq_var ValueDefSeq_var;
+  typedef CORBA_ValueDefSeq_out ValueDefSeq_out;
+  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ValueDefSeq;
+
+  typedef CORBA_ValueBoxDef ValueBoxDef;
+  typedef CORBA_ValueBoxDef *ValueBoxDef_ptr;
+  typedef CORBA_ValueBoxDef_var ValueBoxDef_var;
+  typedef CORBA_ValueBoxDef_out ValueBoxDef_out;
+  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ValueBoxDef;
+
+  typedef CORBA_StructMember StructMember;
+  typedef CORBA_StructMember_var StructMember_var;
+  typedef CORBA_StructMember_out StructMember_out;
+  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_StructMember;
+
+  typedef CORBA_StructMemberSeq StructMemberSeq;
+  typedef CORBA_StructMemberSeq_var StructMemberSeq_var;
+  typedef CORBA_StructMemberSeq_out StructMemberSeq_out;
+  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_StructMemberSeq;
+
+  typedef CORBA_Initializer Initializer;
+  typedef CORBA_Initializer_var Initializer_var;
+  typedef CORBA_Initializer_out Initializer_out;
+  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_Initializer;
+
+  typedef CORBA_InitializerSeq InitializerSeq;
+  typedef CORBA_InitializerSeq_var InitializerSeq_var;
+  typedef CORBA_InitializerSeq_out InitializerSeq_out;
+  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_InitializerSeq;
+
+  typedef CORBA_UnionMember UnionMember;
+  typedef CORBA_UnionMember_var UnionMember_var;
+  typedef CORBA_UnionMember_out UnionMember_out;
+  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_UnionMember;
+
+  typedef CORBA_UnionMemberSeq UnionMemberSeq;
+  typedef CORBA_UnionMemberSeq_var UnionMemberSeq_var;
+  typedef CORBA_UnionMemberSeq_out UnionMemberSeq_out;
+  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_UnionMemberSeq;
+
+  typedef CORBA_EnumMemberSeq EnumMemberSeq;
+  typedef CORBA_EnumMemberSeq_var EnumMemberSeq_var;
+  typedef CORBA_EnumMemberSeq_out EnumMemberSeq_out;
+  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_EnumMemberSeq;
+
+  typedef CORBA_ModuleDescription ModuleDescription;
+  typedef CORBA_ModuleDescription_var ModuleDescription_var;
+  typedef CORBA_ModuleDescription_out ModuleDescription_out;
+  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ModuleDescription;
+
+  typedef CORBA_ConstantDescription ConstantDescription;
+  typedef CORBA_ConstantDescription_var ConstantDescription_var;
+  typedef CORBA_ConstantDescription_out ConstantDescription_out;
+  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ConstantDescription;
+
+  typedef CORBA_TypedefDef TypedefDef;
+  typedef CORBA_TypedefDef *TypedefDef_ptr;
+  typedef CORBA_TypedefDef_var TypedefDef_var;
+  typedef CORBA_TypedefDef_out TypedefDef_out;
+  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_TypedefDef;
+
+  typedef CORBA_TypeDescription TypeDescription;
+  typedef CORBA_TypeDescription_var TypeDescription_var;
+  typedef CORBA_TypeDescription_out TypeDescription_out;
+  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_TypeDescription;
+
+  typedef CORBA_PrimitiveDef PrimitiveDef;
+  typedef CORBA_PrimitiveDef *PrimitiveDef_ptr;
+  typedef CORBA_PrimitiveDef_var PrimitiveDef_var;
+  typedef CORBA_PrimitiveDef_out PrimitiveDef_out;
+  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_PrimitiveDef;
+
+  typedef CORBA_StringDef StringDef;
+  typedef CORBA_StringDef *StringDef_ptr;
+  typedef CORBA_StringDef_var StringDef_var;
+  typedef CORBA_StringDef_out StringDef_out;
+  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_StringDef;
+
+  typedef CORBA_WstringDef WstringDef;
+  typedef CORBA_WstringDef *WstringDef_ptr;
+  typedef CORBA_WstringDef_var WstringDef_var;
+  typedef CORBA_WstringDef_out WstringDef_out;
+  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_WstringDef;
+
+  typedef CORBA_FixedDef FixedDef;
+  typedef CORBA_FixedDef *FixedDef_ptr;
+  typedef CORBA_FixedDef_var FixedDef_var;
+  typedef CORBA_FixedDef_out FixedDef_out;
+  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_FixedDef;
+
+  typedef CORBA_SequenceDef SequenceDef;
+  typedef CORBA_SequenceDef *SequenceDef_ptr;
+  typedef CORBA_SequenceDef_var SequenceDef_var;
+  typedef CORBA_SequenceDef_out SequenceDef_out;
+  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_SequenceDef;
+
+  typedef CORBA_ArrayDef ArrayDef;
+  typedef CORBA_ArrayDef *ArrayDef_ptr;
+  typedef CORBA_ArrayDef_var ArrayDef_var;
+  typedef CORBA_ArrayDef_out ArrayDef_out;
+  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ArrayDef;
+
+  typedef CORBA_ExceptionDescription ExceptionDescription;
+  typedef CORBA_ExceptionDescription_var ExceptionDescription_var;
+  typedef CORBA_ExceptionDescription_out ExceptionDescription_out;
+  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ExceptionDescription;
+
+  typedef CORBA_ExceptionDefSeq ExceptionDefSeq;
+  typedef CORBA_ExceptionDefSeq_var ExceptionDefSeq_var;
+  typedef CORBA_ExceptionDefSeq_out ExceptionDefSeq_out;
+  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ExceptionDefSeq;
+
+  typedef CORBA_ExcDescriptionSeq ExcDescriptionSeq;
+  typedef CORBA_ExcDescriptionSeq_var ExcDescriptionSeq_var;
+  typedef CORBA_ExcDescriptionSeq_out ExcDescriptionSeq_out;
+  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ExcDescriptionSeq;
+
+  enum AttributeMode
+  {
+    ATTR_NORMAL,
+    ATTR_READONLY
+  };
 
-  typedef IR_InterfaceDef InterfaceDef;
-  typedef IR_InterfaceDef_var InterfaceDef_var;
-  typedef IR_InterfaceDef_out InterfaceDef_out;
-  typedef IR_InterfaceDef *InterfaceDef_ptr;
+  typedef AttributeMode &AttributeMode_out;
+  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_AttributeMode;
+
+  typedef CORBA_AttributeDef AttributeDef;
+  typedef CORBA_AttributeDef *AttributeDef_ptr;
+  typedef CORBA_AttributeDef_var AttributeDef_var;
+  typedef CORBA_AttributeDef_out AttributeDef_out;
+  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_AttributeDef;
+
+  typedef CORBA_AttributeDescription AttributeDescription;
+  typedef CORBA_AttributeDescription_var AttributeDescription_var;
+  typedef CORBA_AttributeDescription_out AttributeDescription_out;
+  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_AttributeDescription;
+
+  enum PrimitiveKind
+    {
+      pk_null,
+      pk_void,
+      pk_short,
+      pk_long,
+      pk_ushort,
+      pk_ulong,
+      pk_float,
+      pk_double,
+      pk_boolean,
+      pk_char,
+      pk_octet,
+      pk_any,
+      pk_TypeCode,
+      pk_Principal,
+      pk_string,
+      pk_objref,
+      pk_longlong,
+      pk_ulonglong,
+      pk_longdouble,
+      pk_wchar,
+      pk_wstring,
+      pk_value_base
+    };
+
+  typedef PrimitiveKind &PrimitiveKind_out;
+  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_PrimitiveKind;
+
+  enum ParameterMode
+    {
+      PARAM_IN,
+      PARAM_OUT,
+      PARAM_INOUT
+    };
+
+  typedef ParameterMode &ParameterMode_out;
+  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ParameterMode;
+
+  typedef CORBA_ParameterDescription ParameterDescription;
+  typedef CORBA_ParameterDescription_var ParameterDescription_var;
+  typedef CORBA_ParameterDescription_out ParameterDescription_out;
+  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ParameterDescription;
+
+  typedef CORBA_ParDescriptionSeq ParDescriptionSeq;
+  typedef CORBA_ParDescriptionSeq_var ParDescriptionSeq_var;
+  typedef CORBA_ParDescriptionSeq_out ParDescriptionSeq_out;
+  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ParDescriptionSeq;
+
+  typedef CORBA_ContextIdSeq ContextIdSeq;
+  typedef CORBA_ContextIdSeq_var ContextIdSeq_var;
+  typedef CORBA_ContextIdSeq_out ContextIdSeq_out;
+  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ContextIdSeq;
+
+  typedef CORBA_OperationDef OperationDef;
+  typedef CORBA_OperationDef *OperationDef_ptr;
+  typedef CORBA_OperationDef_var OperationDef_var;
+  typedef CORBA_OperationDef_out OperationDef_out;
+  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_OperationDef;
+
+  enum OperationMode
+    {
+      OP_NORMAL,
+      OP_ONEWAY
+    };
+
+  typedef OperationMode &OperationMode_out;
+  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_OperationMode;
+
+  typedef CORBA_OperationDescription OperationDescription;
+  typedef CORBA_OperationDescription_var OperationDescription_var;
+  typedef CORBA_OperationDescription_out OperationDescription_out;
+  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_OperationDescription;
+
+  typedef CORBA_RepositoryIdSeq RepositoryIdSeq;
+  typedef CORBA_RepositoryIdSeq_var RepositoryIdSeq_var;
+  typedef CORBA_RepositoryIdSeq_out RepositoryIdSeq_out;
+  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_RepositoryIdSeq;
+
+  typedef CORBA_OpDescriptionSeq OpDescriptionSeq;
+  typedef CORBA_OpDescriptionSeq_var OpDescriptionSeq_var;
+  typedef CORBA_OpDescriptionSeq_out OpDescriptionSeq_out;
+  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_OpDescriptionSeq;
+
+  typedef CORBA_AttrDescriptionSeq AttrDescriptionSeq;
+  typedef CORBA_AttrDescriptionSeq_var AttrDescriptionSeq_var;
+  typedef CORBA_AttrDescriptionSeq_out AttrDescriptionSeq_out;
+  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_AttrDescriptionSeq;
+
+  typedef CORBA_InterfaceDescription InterfaceDescription;
+  typedef CORBA_InterfaceDescription_var InterfaceDescription_var;
+  typedef CORBA_InterfaceDescription_out InterfaceDescription_out;
+  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_InterfaceDescription;
+
+  typedef CORBA_ValueMember ValueMember;
+  typedef CORBA_ValueMember_var ValueMember_var;
+  typedef CORBA_ValueMember_out ValueMember_out;
+  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ValueMember;
+
+  typedef CORBA_ValueMemberSeq ValueMemberSeq;
+  typedef CORBA_ValueMemberSeq_var ValueMemberSeq_var;
+  typedef CORBA_ValueMemberSeq_out ValueMemberSeq_out;
+  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ValueMemberSeq;
+
+  typedef CORBA_ValueMemberDef ValueMemberDef;
+  typedef CORBA_ValueMemberDef *ValueMemberDef_ptr;
+  typedef CORBA_ValueMemberDef_var ValueMemberDef_var;
+  typedef CORBA_ValueMemberDef_out ValueMemberDef_out;
+  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ValueMemberDef;
+
+  typedef CORBA_ValueDescription ValueDescription;
+  typedef CORBA_ValueDescription_var ValueDescription_var;
+  typedef CORBA_ValueDescription_out ValueDescription_out;
+  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ValueDescription;
   // ================== Interface Repository =====================
 
   // There could be a single version of these methods, but g++ 2.7.2