// -*- 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"

#include "tao/PortableInterceptor.h"

#if TAO_HAS_INTERCEPTORS == 1
#include "tao/RequestInfo_Util.h"
#include "tao/ClientRequestInfo_i.h"
#include "tao/ClientInterceptorAdapter.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 */

CORBA_IRObject_ptr
tao_CORBA_IRObject_duplicate (
    CORBA_IRObject_ptr p
  )
{
  return CORBA_IRObject::_duplicate (p);
}

void
tao_CORBA_IRObject_release (
    CORBA_IRObject_ptr p
  )
{
  CORBA::release (p);
}

CORBA_IRObject_ptr
tao_CORBA_IRObject_nil (
    void
  )
{
  return CORBA_IRObject::_nil ();
}

CORBA_IRObject_ptr
tao_CORBA_IRObject_narrow (
    CORBA::Object *p
    TAO_ENV_ARG_DECL
  )
{
  return CORBA_IRObject::_narrow (p TAO_ENV_ARG_PARAMETER);
}

CORBA::Object *
tao_CORBA_IRObject_upcast (
    void *src
  )
{
  CORBA_IRObject **tmp =
    ACE_static_cast (CORBA_IRObject **, src);
  return *tmp;
}

int CORBA_IRObject::_tao_class_id = 0;

// *************************************************************
// Operations for class CORBA_IRObject_var
// *************************************************************

CORBA_IRObject_var::CORBA_IRObject_var (void) // default constructor
  : ptr_ (CORBA_IRObject::_nil ())
{}

::CORBA_IRObject_ptr
CORBA_IRObject_var::ptr (void) const
{
  return this->ptr_;
}

CORBA_IRObject_var::CORBA_IRObject_var (const ::CORBA_IRObject_var &p) // copy constructor
  : TAO_Base_var (),
    ptr_ (CORBA_IRObject::_duplicate (p.ptr ()))
{}

CORBA_IRObject_var::~CORBA_IRObject_var (void) // destructor
{
  CORBA::release (this->ptr_);
}

CORBA_IRObject_var &
CORBA_IRObject_var::operator= (CORBA_IRObject_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

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;
}

CORBA_IRObject_var::operator const ::CORBA_IRObject_ptr &() const // cast
{
  return this->ptr_;
}

CORBA_IRObject_var::operator ::CORBA_IRObject_ptr &() // cast
{
  return this->ptr_;
}

::CORBA_IRObject_ptr
CORBA_IRObject_var::operator-> (void) const
{
  return this->ptr_;
}

::CORBA_IRObject_ptr
CORBA_IRObject_var::in (void) const
{
  return this->ptr_;
}

::CORBA_IRObject_ptr &
CORBA_IRObject_var::inout (void)
{
  return this->ptr_;
}

::CORBA_IRObject_ptr &
CORBA_IRObject_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::CORBA_IRObject::_nil ();
  return this->ptr_;
}

::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;
}

::CORBA_IRObject_ptr
CORBA_IRObject_var::tao_duplicate (CORBA_IRObject_ptr p)
{
  return ::CORBA_IRObject::_duplicate (p);
}

void
CORBA_IRObject_var::tao_release (CORBA_IRObject_ptr p)
{
  CORBA::release (p);
}

::CORBA_IRObject_ptr
CORBA_IRObject_var::tao_nil (void)
{
  return ::CORBA_IRObject::_nil ();
}

::CORBA_IRObject_ptr
CORBA_IRObject_var::tao_narrow (
    CORBA::Object *p
    TAO_ENV_ARG_DECL
  )
{
  return ::CORBA_IRObject::_narrow (p TAO_ENV_ARG_PARAMETER);
}

CORBA::Object *
CORBA_IRObject_var::tao_upcast (void *src)
{
  CORBA_IRObject **tmp =
    ACE_static_cast (CORBA_IRObject **, src);
  return *tmp;
}

// *************************************************************
// Operations for class CORBA_IRObject_out
// *************************************************************

CORBA_IRObject_out::CORBA_IRObject_out (CORBA_IRObject_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = ::CORBA_IRObject::_nil ();
}

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 ();
}

CORBA_IRObject_out::CORBA_IRObject_out (const ::CORBA_IRObject_out &p) // copy constructor
  : ptr_ (ACE_const_cast (CORBA_IRObject_out &, p).ptr_)
{}

::CORBA_IRObject_out &
CORBA_IRObject_out::operator= (const ::CORBA_IRObject_out &p)
{
  this->ptr_ = ACE_const_cast (CORBA_IRObject_out&, p).ptr_;
  return *this;
}

CORBA_IRObject_out &
CORBA_IRObject_out::operator= (const ::CORBA_IRObject_var &p)
{
  this->ptr_ = ::CORBA_IRObject::_duplicate (p.ptr ());
  return *this;
}

CORBA_IRObject_out &
CORBA_IRObject_out::operator= (CORBA_IRObject_ptr p)
{
  this->ptr_ = p;
  return *this;
}

CORBA_IRObject_out::operator ::CORBA_IRObject_ptr &() // cast
{
  return this->ptr_;
}

::CORBA_IRObject_ptr &
CORBA_IRObject_out::ptr (void) // ptr
{
  return this->ptr_;
}

::CORBA_IRObject_ptr
CORBA_IRObject_out::operator-> (void)
{
  return this->ptr_;
}


#if (TAO_HAS_INTERCEPTORS == 1)
class TAO_ClientRequestInfo_CORBA_IRObject_def_kind_get : public TAO_ClientRequestInfo_i
{
public:
  TAO_ClientRequestInfo_CORBA_IRObject_def_kind_get (
      TAO_GIOP_Invocation *_tao_invocation,
      CORBA::Object_ptr _tao_target
      TAO_ENV_ARG_DECL_WITH_DEFAULTS);


  virtual Dynamic::ParameterList * arguments (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  virtual Dynamic::ExceptionList * exceptions (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  virtual CORBA::Any * result (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  void result (CORBA::DefinitionKind result);

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 &);

  CORBA::DefinitionKind _result;
};

TAO_ClientRequestInfo_CORBA_IRObject_def_kind_get::TAO_ClientRequestInfo_CORBA_IRObject_def_kind_get (
    TAO_GIOP_Invocation *_tao_invocation,
    CORBA::Object_ptr _tao_target
    TAO_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ClientRequestInfo_i (_tao_invocation, _tao_target)
{}

Dynamic::ParameterList *
TAO_ClientRequestInfo_CORBA_IRObject_def_kind_get::arguments (TAO_ENV_SINGLE_ARG_DECL)
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the argument list on demand.
  Dynamic::ParameterList *parameter_list =
    TAO_RequestInfo_Util::make_parameter_list (TAO_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  return parameter_list;
}

Dynamic::ExceptionList *
TAO_ClientRequestInfo_CORBA_IRObject_def_kind_get::exceptions (TAO_ENV_SINGLE_ARG_DECL)
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the exception list on demand.
  Dynamic::ExceptionList *exception_list =
    TAO_RequestInfo_Util::make_exception_list (TAO_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  return exception_list;
}


CORBA::Any *
TAO_ClientRequestInfo_CORBA_IRObject_def_kind_get::result (TAO_ENV_SINGLE_ARG_DECL)
  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 TAO_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  CORBA::Any_var safe_result_any = result_any;

  (*result_any) <<= this->_result;
  return safe_result_any._retn ();
}

void
TAO_ClientRequestInfo_CORBA_IRObject_def_kind_get::result (CORBA::DefinitionKind result)
{
  // update the result
  this->_result = result;
}

class TAO_ClientRequestInfo_CORBA_IRObject_destroy : public TAO_ClientRequestInfo_i
{
public:
  TAO_ClientRequestInfo_CORBA_IRObject_destroy (
      TAO_GIOP_Invocation *_tao_invocation,
      CORBA::Object_ptr _tao_target
      TAO_ENV_ARG_DECL_WITH_DEFAULTS);


  virtual Dynamic::ParameterList * arguments (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  virtual Dynamic::ExceptionList * exceptions (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  virtual CORBA::Any * result (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    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 &);


};

TAO_ClientRequestInfo_CORBA_IRObject_destroy::TAO_ClientRequestInfo_CORBA_IRObject_destroy (
    TAO_GIOP_Invocation *_tao_invocation,
    CORBA::Object_ptr _tao_target
    TAO_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ClientRequestInfo_i (_tao_invocation, _tao_target)
{}

Dynamic::ParameterList *
TAO_ClientRequestInfo_CORBA_IRObject_destroy::arguments (TAO_ENV_SINGLE_ARG_DECL)
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the argument list on demand.
  Dynamic::ParameterList *parameter_list =
    TAO_RequestInfo_Util::make_parameter_list (TAO_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  return parameter_list;
}

Dynamic::ExceptionList *
TAO_ClientRequestInfo_CORBA_IRObject_destroy::exceptions (TAO_ENV_SINGLE_ARG_DECL)
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the exception list on demand.
  Dynamic::ExceptionList *exception_list =
    TAO_RequestInfo_Util::make_exception_list (TAO_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  return exception_list;
}


CORBA::Any *
TAO_ClientRequestInfo_CORBA_IRObject_destroy::result (TAO_ENV_SINGLE_ARG_DECL)
  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 TAO_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  return result_any;
}

#endif /* TAO_HAS_INTERCEPTORS */

///////////////////////////////////////////////////////////////////////
//                Base & Remote Proxy  Implementation.
//

_TAO_CORBA_IRObject_Proxy_Impl::_TAO_CORBA_IRObject_Proxy_Impl (void)
{}

_TAO_CORBA_IRObject_Remote_Proxy_Impl::_TAO_CORBA_IRObject_Remote_Proxy_Impl (void)
{}

// Remote Implementation of the IDL interface methods

CORBA::DefinitionKind _TAO_CORBA_IRObject_Remote_Proxy_Impl::def_kind (
    CORBA_Object *_collocated_tao_target_
    TAO_ENV_ARG_DECL
  )
  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 ()
    );

  int _invoke_status;

#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
      istub->orb_core ()->client_request_interceptors (),
      &_tao_call,
      _invoke_status
    );

#endif  /* TAO_HAS_INTERCEPTORS */

  for (;;)
    {
      _invoke_status = TAO_INVOKE_EXCEPTION;

#if TAO_HAS_INTERCEPTORS == 1
      TAO_ClientRequestInfo_CORBA_IRObject_def_kind_get ri (
        &_tao_call,
        _collocated_tao_target_
        TAO_ENV_ARG_PARAMETER
      );
      ACE_CHECK_RETURN  (_tao_retval);

#endif /* TAO_HAS_INTERCEPTORS */


      CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
      TAO_INTERCEPTOR (ri.response_expected (1));

#if TAO_HAS_INTERCEPTORS == 1

      ACE_TRY
        {
          _tao_vfr.send_request (
            &ri
            TAO_ENV_ARG_PARAMETER
          );
          ACE_TRY_CHECK;

          if (_invoke_status == TAO_INVOKE_RESTART)
            {
              _tao_call.restart_flag (1);
              continue;
            }

#endif /* TAO_HAS_INTERCEPTORS */

          _tao_call.start (TAO_ENV_SINGLE_ARG_PARAMETER);
          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);

          _tao_call.prepare_header (
              ACE_static_cast (CORBA::Octet, _tao_response_flag)
              TAO_ENV_ARG_PARAMETER
            );
          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);

          _invoke_status =
            _tao_call.invoke (0, 0 TAO_ENV_ARG_PARAMETER);
          TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);

          if (_invoke_status == TAO_INVOKE_EXCEPTION)
            {
              TAO_INTERCEPTOR_THROW_RETURN (
                CORBA::UNKNOWN (TAO_OMG_VMCID | 1, CORBA::COMPLETED_YES),
                _tao_retval
              );

            }
          else if (_invoke_status == TAO_INVOKE_RESTART)
            {
              TAO_INTERCEPTOR (
                ri.reply_status (_invoke_status);
                _tao_vfr.receive_other (
                  &ri
                  TAO_ENV_ARG_PARAMETER
                );
                ACE_TRY_CHECK;
              )

              continue;
            }

          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
              );

            }

#if TAO_HAS_INTERCEPTORS == 1
          CORBA::DefinitionKind _tao_retval_info = _tao_retval;
          ri.result (_tao_retval_info);

          ri.reply_status (_invoke_status);
          _tao_vfr.receive_reply (
            &ri
            TAO_ENV_ARG_PARAMETER
          );
          ACE_TRY_CHECK;

      }
    ACE_CATCHANY
      {
        ri.exception (&ACE_ANY_EXCEPTION);
        _tao_vfr.receive_exception (
          &ri
          TAO_ENV_ARG_PARAMETER
        );
        ACE_TRY_CHECK;

        PortableInterceptor::ReplyStatus _tao_status =
          ri.reply_status (TAO_ENV_SINGLE_ARG_PARAMETER);
        ACE_TRY_CHECK;

        if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION
            || _tao_status == PortableInterceptor::USER_EXCEPTION)
          ACE_RE_THROW;
      }
    ACE_ENDTRY;
    ACE_CHECK_RETURN  (_tao_retval);

    PortableInterceptor::ReplyStatus _tao_status =
      ri.reply_status (TAO_ENV_SINGLE_ARG_PARAMETER);
    ACE_CHECK_RETURN  (_tao_retval);

    if (_tao_status == PortableInterceptor::LOCATION_FORWARD
        || _tao_status == PortableInterceptor::TRANSPORT_RETRY)
      continue;

#endif  /* TAO_HAS_INTERCEPTORS */

    break;
  }
return _tao_retval;
}

void _TAO_CORBA_IRObject_Remote_Proxy_Impl::destroy (
    CORBA_Object *_collocated_tao_target_
    TAO_ENV_ARG_DECL
  )
  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 ()
    );

  int _invoke_status;

#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
      istub->orb_core ()->client_request_interceptors (),
      &_tao_call,
      _invoke_status
    );

#endif  /* TAO_HAS_INTERCEPTORS */

  for (;;)
    {
      _invoke_status = TAO_INVOKE_EXCEPTION;

#if TAO_HAS_INTERCEPTORS == 1
      TAO_ClientRequestInfo_CORBA_IRObject_destroy ri (
        &_tao_call,
        _collocated_tao_target_
        TAO_ENV_ARG_PARAMETER
      );
      ACE_CHECK;

#endif /* TAO_HAS_INTERCEPTORS */


      CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
      TAO_INTERCEPTOR (ri.response_expected (1));

#if TAO_HAS_INTERCEPTORS == 1

      ACE_TRY
        {
          _tao_vfr.send_request (
            &ri
            TAO_ENV_ARG_PARAMETER
          );
          ACE_TRY_CHECK;

          if (_invoke_status == TAO_INVOKE_RESTART)
            {
              _tao_call.restart_flag (1);
              continue;
            }

#endif /* TAO_HAS_INTERCEPTORS */

          _tao_call.start (TAO_ENV_SINGLE_ARG_PARAMETER);
          TAO_INTERCEPTOR_CHECK;

          _tao_call.prepare_header (
              ACE_static_cast (CORBA::Octet, _tao_response_flag)
              TAO_ENV_ARG_PARAMETER
            );
          TAO_INTERCEPTOR_CHECK;

          _invoke_status =
            _tao_call.invoke (0, 0 TAO_ENV_ARG_PARAMETER);
          TAO_INTERCEPTOR_CHECK;

          if (_invoke_status == TAO_INVOKE_EXCEPTION)
            {
              TAO_INTERCEPTOR_THROW (
                CORBA::UNKNOWN (TAO_OMG_VMCID | 1, CORBA::COMPLETED_YES)
              );

            }
          else if (_invoke_status == TAO_INVOKE_RESTART)
            {
              TAO_INTERCEPTOR (
                ri.reply_status (_invoke_status);
                _tao_vfr.receive_other (
                  &ri
                  TAO_ENV_ARG_PARAMETER
                );
                ACE_TRY_CHECK;
              )

              continue;
            }


#if TAO_HAS_INTERCEPTORS == 1

          ri.reply_status (_invoke_status);
          _tao_vfr.receive_reply (
            &ri
            TAO_ENV_ARG_PARAMETER
          );
          ACE_TRY_CHECK;

      }
    ACE_CATCHANY
      {
        ri.exception (&ACE_ANY_EXCEPTION);
        _tao_vfr.receive_exception (
          &ri
          TAO_ENV_ARG_PARAMETER
        );
        ACE_TRY_CHECK;

        PortableInterceptor::ReplyStatus _tao_status =
          ri.reply_status (TAO_ENV_SINGLE_ARG_PARAMETER);
        ACE_TRY_CHECK;

        if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION
            || _tao_status == PortableInterceptor::USER_EXCEPTION)
          ACE_RE_THROW;
      }
    ACE_ENDTRY;
    ACE_CHECK;

    PortableInterceptor::ReplyStatus _tao_status =
      ri.reply_status (TAO_ENV_SINGLE_ARG_PARAMETER);
    ACE_CHECK;

    if (_tao_status == PortableInterceptor::LOCATION_FORWARD
        || _tao_status == PortableInterceptor::TRANSPORT_RETRY)
      continue;

#endif  /* TAO_HAS_INTERCEPTORS */

    break;
  }

}


//
//            End  Base & Remote  Proxy Implemeentation.
///////////////////////////////////////////////////////////////////////


///////////////////////////////////////////////////////////////////////
//           Remote & Base  Proxy Broker Implementation
//

_TAO_CORBA_IRObject_Proxy_Broker::_TAO_CORBA_IRObject_Proxy_Broker (void)
{
}

_TAO_CORBA_IRObject_Proxy_Broker::~_TAO_CORBA_IRObject_Proxy_Broker (void)
{
}

_TAO_CORBA_IRObject_Proxy_Broker * (*_TAO_CORBA_IRObject_Proxy_Broker_Factory_function_pointer) (
    CORBA::Object_ptr obj
  ) = 0;

// Factory Member function Implementation.
_TAO_CORBA_IRObject_Remote_Proxy_Broker *
_TAO_CORBA_IRObject_Remote_Proxy_Broker::the_TAO_CORBA_IRObject_Remote_Proxy_Broker (void)
{
  static ::_TAO_CORBA_IRObject_Remote_Proxy_Broker remote_proxy_broker;
  return &remote_proxy_broker;
}

_TAO_CORBA_IRObject_Remote_Proxy_Broker::_TAO_CORBA_IRObject_Remote_Proxy_Broker (void)
{
}

_TAO_CORBA_IRObject_Remote_Proxy_Broker::~_TAO_CORBA_IRObject_Remote_Proxy_Broker (void)
{
}

_TAO_CORBA_IRObject_Proxy_Impl&
_TAO_CORBA_IRObject_Remote_Proxy_Broker::select_proxy (
  ::CORBA_IRObject *
  TAO_ENV_ARG_DECL_NOT_USED
)
{
  return this->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_CORBA_IRObject_Proxy_Broker_ =
      ::_TAO_CORBA_IRObject_Proxy_Broker_Factory_function_pointer (this);
  else
    this->the_TAO_CORBA_IRObject_Proxy_Broker_ =
      ::_TAO_CORBA_IRObject_Remote_Proxy_Broker::the_TAO_CORBA_IRObject_Remote_Proxy_Broker ();
}

void CORBA_IRObject::_tao_any_destructor (void *_tao_void_pointer)
{
  CORBA_IRObject *tmp = ACE_static_cast (CORBA_IRObject*, _tao_void_pointer);
  CORBA::release (tmp);
}

CORBA_IRObject_ptr CORBA_IRObject::_narrow (
    CORBA::Object_ptr obj
    TAO_ENV_ARG_DECL
  )
{
  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" TAO_ENV_ARG_PARAMETER);
      ACE_CHECK_RETURN (CORBA_IRObject::_nil ());
      if (is_a == 0)
        return CORBA_IRObject::_nil ();
    }
  return CORBA_IRObject::_unchecked_narrow (obj TAO_ENV_ARG_PARAMETER);
}

CORBA_IRObject_ptr CORBA_IRObject::_unchecked_narrow (
    CORBA::Object_ptr obj
    TAO_ENV_ARG_DECL_NOT_USED
  )
{
  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_CORBA_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::_tao_class_id
                    )
                )
          );
}

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 TAO_ENV_ARG_DECL)
{
  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 TAO_ENV_ARG_PARAMETER);
}

void *CORBA_IRObject::_tao_QueryInterface (ptr_arith_t type)
{
  void *retv = 0;
  if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &CORBA_IRObject::_tao_class_id))
    retv = ACE_reinterpret_cast (void*, this);
  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_tao_class_id))
    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 (
    TAO_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  _TAO_CORBA_IRObject_Proxy_Impl &proxy =
    this->the_TAO_CORBA_IRObject_Proxy_Broker_->select_proxy (this TAO_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN ((CORBA::DefinitionKind)0);

  return proxy.def_kind (
      this
      TAO_ENV_ARG_PARAMETER
    );
}

void CORBA_IRObject::destroy (
    TAO_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  _TAO_CORBA_IRObject_Proxy_Impl &proxy =
    this->the_TAO_CORBA_IRObject_Proxy_Broker_->select_proxy (this TAO_ENV_ARG_PARAMETER);
  ACE_CHECK;

  proxy.destroy (
      this
      TAO_ENV_ARG_PARAMETER
    );
}

CORBA_Contained_ptr
tao_CORBA_Contained_duplicate (
    CORBA_Contained_ptr p
  )
{
  return CORBA_Contained::_duplicate (p);
}

void
tao_CORBA_Contained_release (
    CORBA_Contained_ptr p
  )
{
  CORBA::release (p);
}

CORBA_Contained_ptr
tao_CORBA_Contained_nil (
    void
  )
{
  return CORBA_Contained::_nil ();
}

CORBA_Contained_ptr
tao_CORBA_Contained_narrow (
    CORBA::Object *p
    TAO_ENV_ARG_DECL
  )
{
  return CORBA_Contained::_narrow (p TAO_ENV_ARG_PARAMETER);
}

CORBA::Object *
tao_CORBA_Contained_upcast (
    void *src
  )
{
  CORBA_Contained **tmp =
    ACE_static_cast (CORBA_Contained **, src);
  return *tmp;
}

int CORBA_Contained::_tao_class_id = 0;

// *************************************************************
// Operations for class CORBA_Contained_var
// *************************************************************

CORBA_Contained_var::CORBA_Contained_var (void) // default constructor
  : ptr_ (CORBA_Contained::_nil ())
{}

::CORBA_Contained_ptr
CORBA_Contained_var::ptr (void) const
{
  return this->ptr_;
}

CORBA_Contained_var::CORBA_Contained_var (const ::CORBA_Contained_var &p) // copy constructor
  : TAO_Base_var (),
    ptr_ (CORBA_Contained::_duplicate (p.ptr ()))
{}

CORBA_Contained_var::~CORBA_Contained_var (void) // destructor
{
  CORBA::release (this->ptr_);
}

CORBA_Contained_var &
CORBA_Contained_var::operator= (CORBA_Contained_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

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;
}

CORBA_Contained_var::operator const ::CORBA_Contained_ptr &() const // cast
{
  return this->ptr_;
}

CORBA_Contained_var::operator ::CORBA_Contained_ptr &() // cast
{
  return this->ptr_;
}

::CORBA_Contained_ptr
CORBA_Contained_var::operator-> (void) const
{
  return this->ptr_;
}

::CORBA_Contained_ptr
CORBA_Contained_var::in (void) const
{
  return this->ptr_;
}

::CORBA_Contained_ptr &
CORBA_Contained_var::inout (void)
{
  return this->ptr_;
}

::CORBA_Contained_ptr &
CORBA_Contained_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::CORBA_Contained::_nil ();
  return this->ptr_;
}

::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;
}

::CORBA_Contained_ptr
CORBA_Contained_var::tao_duplicate (CORBA_Contained_ptr p)
{
  return ::CORBA_Contained::_duplicate (p);
}

void
CORBA_Contained_var::tao_release (CORBA_Contained_ptr p)
{
  CORBA::release (p);
}

::CORBA_Contained_ptr
CORBA_Contained_var::tao_nil (void)
{
  return ::CORBA_Contained::_nil ();
}

::CORBA_Contained_ptr
CORBA_Contained_var::tao_narrow (
    CORBA::Object *p
    TAO_ENV_ARG_DECL
  )
{
  return ::CORBA_Contained::_narrow (p TAO_ENV_ARG_PARAMETER);
}

CORBA::Object *
CORBA_Contained_var::tao_upcast (void *src)
{
  CORBA_Contained **tmp =
    ACE_static_cast (CORBA_Contained **, src);
  return *tmp;
}

// *************************************************************
// Operations for class CORBA_Contained_out
// *************************************************************

CORBA_Contained_out::CORBA_Contained_out (CORBA_Contained_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = ::CORBA_Contained::_nil ();
}

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 ();
}

CORBA_Contained_out::CORBA_Contained_out (const ::CORBA_Contained_out &p) // copy constructor
  : ptr_ (ACE_const_cast (CORBA_Contained_out &, p).ptr_)
{}

::CORBA_Contained_out &
CORBA_Contained_out::operator= (const ::CORBA_Contained_out &p)
{
  this->ptr_ = ACE_const_cast (CORBA_Contained_out&, p).ptr_;
  return *this;
}

CORBA_Contained_out &
CORBA_Contained_out::operator= (const ::CORBA_Contained_var &p)
{
  this->ptr_ = ::CORBA_Contained::_duplicate (p.ptr ());
  return *this;
}

CORBA_Contained_out &
CORBA_Contained_out::operator= (CORBA_Contained_ptr p)
{
  this->ptr_ = p;
  return *this;
}

CORBA_Contained_out::operator ::CORBA_Contained_ptr &() // cast
{
  return this->ptr_;
}

::CORBA_Contained_ptr &
CORBA_Contained_out::ptr (void) // ptr
{
  return this->ptr_;
}

::CORBA_Contained_ptr
CORBA_Contained_out::operator-> (void)
{
  return this->ptr_;
}


#if (TAO_HAS_INTERCEPTORS == 1)
class TAO_ClientRequestInfo_CORBA_Contained_id_get : public TAO_ClientRequestInfo_i
{
public:
  TAO_ClientRequestInfo_CORBA_Contained_id_get (
      TAO_GIOP_Invocation *_tao_invocation,
      CORBA::Object_ptr _tao_target
      TAO_ENV_ARG_DECL_WITH_DEFAULTS);


  virtual Dynamic::ParameterList * arguments (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  virtual Dynamic::ExceptionList * exceptions (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  virtual CORBA::Any * result (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  void result (char * result);

private:
  TAO_ClientRequestInfo_CORBA_Contained_id_get (const TAO_ClientRequestInfo_CORBA_Contained_id_get &);
  void operator= (const TAO_ClientRequestInfo_CORBA_Contained_id_get &);

  char * _result;
};

TAO_ClientRequestInfo_CORBA_Contained_id_get::TAO_ClientRequestInfo_CORBA_Contained_id_get (
    TAO_GIOP_Invocation *_tao_invocation,
    CORBA::Object_ptr _tao_target
    TAO_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ClientRequestInfo_i (_tao_invocation, _tao_target)
{}

Dynamic::ParameterList *
TAO_ClientRequestInfo_CORBA_Contained_id_get::arguments (TAO_ENV_SINGLE_ARG_DECL)
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the argument list on demand.
  Dynamic::ParameterList *parameter_list =
    TAO_RequestInfo_Util::make_parameter_list (TAO_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  return parameter_list;
}

Dynamic::ExceptionList *
TAO_ClientRequestInfo_CORBA_Contained_id_get::exceptions (TAO_ENV_SINGLE_ARG_DECL)
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the exception list on demand.
  Dynamic::ExceptionList *exception_list =
    TAO_RequestInfo_Util::make_exception_list (TAO_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  return exception_list;
}


CORBA::Any *
TAO_ClientRequestInfo_CORBA_Contained_id_get::result (TAO_ENV_SINGLE_ARG_DECL)
  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 TAO_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  CORBA::Any_var safe_result_any = result_any;

  (*result_any) <<= this->_result;
  return safe_result_any._retn ();
}

void
TAO_ClientRequestInfo_CORBA_Contained_id_get::result (char * result)
{
  // update the result
  this->_result = result;
}

class TAO_ClientRequestInfo_CORBA_Contained_id_set : public TAO_ClientRequestInfo_i
{
public:
  TAO_ClientRequestInfo_CORBA_Contained_id_set (
      TAO_GIOP_Invocation *_tao_invocation,
      CORBA::Object_ptr _tao_target,
      const char * id
      TAO_ENV_ARG_DECL_WITH_DEFAULTS);


  virtual Dynamic::ParameterList * arguments (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  virtual Dynamic::ExceptionList * exceptions (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  virtual CORBA::Any * result (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    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_;

};

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
    TAO_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ClientRequestInfo_i (_tao_invocation, _tao_target),
    id_ (id)
{}

Dynamic::ParameterList *
TAO_ClientRequestInfo_CORBA_Contained_id_set::arguments (TAO_ENV_SINGLE_ARG_DECL)
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the argument list on demand.
  Dynamic::ParameterList *parameter_list =
    TAO_RequestInfo_Util::make_parameter_list (TAO_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  Dynamic::ParameterList_var safe_parameter_list = parameter_list;

  parameter_list->length (1);
  CORBA::ULong len = 0;

    (*parameter_list)[len].argument <<= id_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;

  return safe_parameter_list._retn ();
}

Dynamic::ExceptionList *
TAO_ClientRequestInfo_CORBA_Contained_id_set::exceptions (TAO_ENV_SINGLE_ARG_DECL)
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the exception list on demand.
  Dynamic::ExceptionList *exception_list =
    TAO_RequestInfo_Util::make_exception_list (TAO_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  return exception_list;
}


CORBA::Any *
TAO_ClientRequestInfo_CORBA_Contained_id_set::result (TAO_ENV_SINGLE_ARG_DECL)
  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 TAO_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  return result_any;
}

class TAO_ClientRequestInfo_CORBA_Contained_name_get : public TAO_ClientRequestInfo_i
{
public:
  TAO_ClientRequestInfo_CORBA_Contained_name_get (
      TAO_GIOP_Invocation *_tao_invocation,
      CORBA::Object_ptr _tao_target
      TAO_ENV_ARG_DECL_WITH_DEFAULTS);


  virtual Dynamic::ParameterList * arguments (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  virtual Dynamic::ExceptionList * exceptions (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  virtual CORBA::Any * result (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  void result (char * result);

private:
  TAO_ClientRequestInfo_CORBA_Contained_name_get (const TAO_ClientRequestInfo_CORBA_Contained_name_get &);
  void operator= (const TAO_ClientRequestInfo_CORBA_Contained_name_get &);

  char * _result;
};

TAO_ClientRequestInfo_CORBA_Contained_name_get::TAO_ClientRequestInfo_CORBA_Contained_name_get (
    TAO_GIOP_Invocation *_tao_invocation,
    CORBA::Object_ptr _tao_target
    TAO_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ClientRequestInfo_i (_tao_invocation, _tao_target)
{}

Dynamic::ParameterList *
TAO_ClientRequestInfo_CORBA_Contained_name_get::arguments (TAO_ENV_SINGLE_ARG_DECL)
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the argument list on demand.
  Dynamic::ParameterList *parameter_list =
    TAO_RequestInfo_Util::make_parameter_list (TAO_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  return parameter_list;
}

Dynamic::ExceptionList *
TAO_ClientRequestInfo_CORBA_Contained_name_get::exceptions (TAO_ENV_SINGLE_ARG_DECL)
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the exception list on demand.
  Dynamic::ExceptionList *exception_list =
    TAO_RequestInfo_Util::make_exception_list (TAO_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  return exception_list;
}


CORBA::Any *
TAO_ClientRequestInfo_CORBA_Contained_name_get::result (TAO_ENV_SINGLE_ARG_DECL)
  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 TAO_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  CORBA::Any_var safe_result_any = result_any;

  (*result_any) <<= this->_result;
  return safe_result_any._retn ();
}

void
TAO_ClientRequestInfo_CORBA_Contained_name_get::result (char * result)
{
  // update the result
  this->_result = result;
}

class TAO_ClientRequestInfo_CORBA_Contained_name_set : public TAO_ClientRequestInfo_i
{
public:
  TAO_ClientRequestInfo_CORBA_Contained_name_set (
      TAO_GIOP_Invocation *_tao_invocation,
      CORBA::Object_ptr _tao_target,
      const char * name
      TAO_ENV_ARG_DECL_WITH_DEFAULTS);


  virtual Dynamic::ParameterList * arguments (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  virtual Dynamic::ExceptionList * exceptions (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  virtual CORBA::Any * result (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    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_;

};

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
    TAO_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ClientRequestInfo_i (_tao_invocation, _tao_target),
    name_ (name)
{}

Dynamic::ParameterList *
TAO_ClientRequestInfo_CORBA_Contained_name_set::arguments (TAO_ENV_SINGLE_ARG_DECL)
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the argument list on demand.
  Dynamic::ParameterList *parameter_list =
    TAO_RequestInfo_Util::make_parameter_list (TAO_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  Dynamic::ParameterList_var safe_parameter_list = parameter_list;

  parameter_list->length (1);
  CORBA::ULong len = 0;

    (*parameter_list)[len].argument <<= name_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;

  return safe_parameter_list._retn ();
}

Dynamic::ExceptionList *
TAO_ClientRequestInfo_CORBA_Contained_name_set::exceptions (TAO_ENV_SINGLE_ARG_DECL)
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the exception list on demand.
  Dynamic::ExceptionList *exception_list =
    TAO_RequestInfo_Util::make_exception_list (TAO_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  return exception_list;
}


CORBA::Any *
TAO_ClientRequestInfo_CORBA_Contained_name_set::result (TAO_ENV_SINGLE_ARG_DECL)
  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 TAO_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  return result_any;
}

class TAO_ClientRequestInfo_CORBA_Contained_version_get : public TAO_ClientRequestInfo_i
{
public:
  TAO_ClientRequestInfo_CORBA_Contained_version_get (
      TAO_GIOP_Invocation *_tao_invocation,
      CORBA::Object_ptr _tao_target
      TAO_ENV_ARG_DECL_WITH_DEFAULTS);


  virtual Dynamic::ParameterList * arguments (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  virtual Dynamic::ExceptionList * exceptions (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  virtual CORBA::Any * result (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  void result (char * result);

private:
  TAO_ClientRequestInfo_CORBA_Contained_version_get (const TAO_ClientRequestInfo_CORBA_Contained_version_get &);
  void operator= (const TAO_ClientRequestInfo_CORBA_Contained_version_get &);

  char * _result;
};

TAO_ClientRequestInfo_CORBA_Contained_version_get::TAO_ClientRequestInfo_CORBA_Contained_version_get (
    TAO_GIOP_Invocation *_tao_invocation,
    CORBA::Object_ptr _tao_target
    TAO_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ClientRequestInfo_i (_tao_invocation, _tao_target)
{}

Dynamic::ParameterList *
TAO_ClientRequestInfo_CORBA_Contained_version_get::arguments (TAO_ENV_SINGLE_ARG_DECL)
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the argument list on demand.
  Dynamic::ParameterList *parameter_list =
    TAO_RequestInfo_Util::make_parameter_list (TAO_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  return parameter_list;
}

Dynamic::ExceptionList *
TAO_ClientRequestInfo_CORBA_Contained_version_get::exceptions (TAO_ENV_SINGLE_ARG_DECL)
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the exception list on demand.
  Dynamic::ExceptionList *exception_list =
    TAO_RequestInfo_Util::make_exception_list (TAO_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  return exception_list;
}


CORBA::Any *
TAO_ClientRequestInfo_CORBA_Contained_version_get::result (TAO_ENV_SINGLE_ARG_DECL)
  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 TAO_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  CORBA::Any_var safe_result_any = result_any;

  (*result_any) <<= this->_result;
  return safe_result_any._retn ();
}

void
TAO_ClientRequestInfo_CORBA_Contained_version_get::result (char * result)
{
  // update the result
  this->_result = result;
}

class TAO_ClientRequestInfo_CORBA_Contained_version_set : public TAO_ClientRequestInfo_i
{
public:
  TAO_ClientRequestInfo_CORBA_Contained_version_set (
      TAO_GIOP_Invocation *_tao_invocation,
      CORBA::Object_ptr _tao_target,
      const char * version
      TAO_ENV_ARG_DECL_WITH_DEFAULTS);


  virtual Dynamic::ParameterList * arguments (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  virtual Dynamic::ExceptionList * exceptions (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  virtual CORBA::Any * result (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    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_;

};

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
    TAO_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ClientRequestInfo_i (_tao_invocation, _tao_target),
    version_ (version)
{}

Dynamic::ParameterList *
TAO_ClientRequestInfo_CORBA_Contained_version_set::arguments (TAO_ENV_SINGLE_ARG_DECL)
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the argument list on demand.
  Dynamic::ParameterList *parameter_list =
    TAO_RequestInfo_Util::make_parameter_list (TAO_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  Dynamic::ParameterList_var safe_parameter_list = parameter_list;

  parameter_list->length (1);
  CORBA::ULong len = 0;

    (*parameter_list)[len].argument <<= version_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;

  return safe_parameter_list._retn ();
}

Dynamic::ExceptionList *
TAO_ClientRequestInfo_CORBA_Contained_version_set::exceptions (TAO_ENV_SINGLE_ARG_DECL)
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the exception list on demand.
  Dynamic::ExceptionList *exception_list =
    TAO_RequestInfo_Util::make_exception_list (TAO_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  return exception_list;
}


CORBA::Any *
TAO_ClientRequestInfo_CORBA_Contained_version_set::result (TAO_ENV_SINGLE_ARG_DECL)
  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 TAO_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  return result_any;
}

class TAO_ClientRequestInfo_CORBA_Contained_defined_in_get : public TAO_ClientRequestInfo_i
{
public:
  TAO_ClientRequestInfo_CORBA_Contained_defined_in_get (
      TAO_GIOP_Invocation *_tao_invocation,
      CORBA::Object_ptr _tao_target
      TAO_ENV_ARG_DECL_WITH_DEFAULTS);


  virtual Dynamic::ParameterList * arguments (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  virtual Dynamic::ExceptionList * exceptions (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  virtual CORBA::Any * result (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  void result (CORBA_Container_ptr result);

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 &);

  CORBA_Container_ptr _result;
};

TAO_ClientRequestInfo_CORBA_Contained_defined_in_get::TAO_ClientRequestInfo_CORBA_Contained_defined_in_get (
    TAO_GIOP_Invocation *_tao_invocation,
    CORBA::Object_ptr _tao_target
    TAO_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ClientRequestInfo_i (_tao_invocation, _tao_target)
{}

Dynamic::ParameterList *
TAO_ClientRequestInfo_CORBA_Contained_defined_in_get::arguments (TAO_ENV_SINGLE_ARG_DECL)
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the argument list on demand.
  Dynamic::ParameterList *parameter_list =
    TAO_RequestInfo_Util::make_parameter_list (TAO_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  return parameter_list;
}

Dynamic::ExceptionList *
TAO_ClientRequestInfo_CORBA_Contained_defined_in_get::exceptions (TAO_ENV_SINGLE_ARG_DECL)
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the exception list on demand.
  Dynamic::ExceptionList *exception_list =
    TAO_RequestInfo_Util::make_exception_list (TAO_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  return exception_list;
}


CORBA::Any *
TAO_ClientRequestInfo_CORBA_Contained_defined_in_get::result (TAO_ENV_SINGLE_ARG_DECL)
  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 TAO_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  CORBA::Any_var safe_result_any = result_any;

  (*result_any) <<= this->_result;
  return safe_result_any._retn ();
}

void
TAO_ClientRequestInfo_CORBA_Contained_defined_in_get::result (CORBA_Container_ptr result)
{
  // update the result
  this->_result = result;
}

class TAO_ClientRequestInfo_CORBA_Contained_absolute_name_get : public TAO_ClientRequestInfo_i
{
public:
  TAO_ClientRequestInfo_CORBA_Contained_absolute_name_get (
      TAO_GIOP_Invocation *_tao_invocation,
      CORBA::Object_ptr _tao_target
      TAO_ENV_ARG_DECL_WITH_DEFAULTS);


  virtual Dynamic::ParameterList * arguments (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  virtual Dynamic::ExceptionList * exceptions (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  virtual CORBA::Any * result (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  void result (char * result);

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 &);

  char * _result;
};

TAO_ClientRequestInfo_CORBA_Contained_absolute_name_get::TAO_ClientRequestInfo_CORBA_Contained_absolute_name_get (
    TAO_GIOP_Invocation *_tao_invocation,
    CORBA::Object_ptr _tao_target
    TAO_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ClientRequestInfo_i (_tao_invocation, _tao_target)
{}

Dynamic::ParameterList *
TAO_ClientRequestInfo_CORBA_Contained_absolute_name_get::arguments (TAO_ENV_SINGLE_ARG_DECL)
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the argument list on demand.
  Dynamic::ParameterList *parameter_list =
    TAO_RequestInfo_Util::make_parameter_list (TAO_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  return parameter_list;
}

Dynamic::ExceptionList *
TAO_ClientRequestInfo_CORBA_Contained_absolute_name_get::exceptions (TAO_ENV_SINGLE_ARG_DECL)
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the exception list on demand.
  Dynamic::ExceptionList *exception_list =
    TAO_RequestInfo_Util::make_exception_list (TAO_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  return exception_list;
}


CORBA::Any *
TAO_ClientRequestInfo_CORBA_Contained_absolute_name_get::result (TAO_ENV_SINGLE_ARG_DECL)
  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 TAO_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  CORBA::Any_var safe_result_any = result_any;

  (*result_any) <<= this->_result;
  return safe_result_any._retn ();
}

void
TAO_ClientRequestInfo_CORBA_Contained_absolute_name_get::result (char * result)
{
  // update the result
  this->_result = result;
}

class TAO_ClientRequestInfo_CORBA_Contained_containing_repository_get : public TAO_ClientRequestInfo_i
{
public:
  TAO_ClientRequestInfo_CORBA_Contained_containing_repository_get (
      TAO_GIOP_Invocation *_tao_invocation,
      CORBA::Object_ptr _tao_target
      TAO_ENV_ARG_DECL_WITH_DEFAULTS);


  virtual Dynamic::ParameterList * arguments (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  virtual Dynamic::ExceptionList * exceptions (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  virtual CORBA::Any * result (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  void result (CORBA_Repository_ptr result);

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 &);

  CORBA_Repository_ptr _result;
};

TAO_ClientRequestInfo_CORBA_Contained_containing_repository_get::TAO_ClientRequestInfo_CORBA_Contained_containing_repository_get (
    TAO_GIOP_Invocation *_tao_invocation,
    CORBA::Object_ptr _tao_target
    TAO_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ClientRequestInfo_i (_tao_invocation, _tao_target)
{}

Dynamic::ParameterList *
TAO_ClientRequestInfo_CORBA_Contained_containing_repository_get::arguments (TAO_ENV_SINGLE_ARG_DECL)
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the argument list on demand.
  Dynamic::ParameterList *parameter_list =
    TAO_RequestInfo_Util::make_parameter_list (TAO_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  return parameter_list;
}

Dynamic::ExceptionList *
TAO_ClientRequestInfo_CORBA_Contained_containing_repository_get::exceptions (TAO_ENV_SINGLE_ARG_DECL)
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the exception list on demand.
  Dynamic::ExceptionList *exception_list =
    TAO_RequestInfo_Util::make_exception_list (TAO_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  return exception_list;
}


CORBA::Any *
TAO_ClientRequestInfo_CORBA_Contained_containing_repository_get::result (TAO_ENV_SINGLE_ARG_DECL)
  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 TAO_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  CORBA::Any_var safe_result_any = result_any;

  (*result_any) <<= this->_result;
  return safe_result_any._retn ();
}

void
TAO_ClientRequestInfo_CORBA_Contained_containing_repository_get::result (CORBA_Repository_ptr result)
{
  // update the result
  this->_result = result;
}

class TAO_ClientRequestInfo_CORBA_Contained_describe : public TAO_ClientRequestInfo_i
{
public:
  TAO_ClientRequestInfo_CORBA_Contained_describe (
      TAO_GIOP_Invocation *_tao_invocation,
      CORBA::Object_ptr _tao_target
      TAO_ENV_ARG_DECL_WITH_DEFAULTS);


  virtual Dynamic::ParameterList * arguments (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  virtual Dynamic::ExceptionList * exceptions (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  virtual CORBA::Any * result (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  void result (CORBA_Contained::Description * result);

private:
  TAO_ClientRequestInfo_CORBA_Contained_describe (const TAO_ClientRequestInfo_CORBA_Contained_describe &);
  void operator= (const TAO_ClientRequestInfo_CORBA_Contained_describe &);

  CORBA_Contained::Description * _result;
};

TAO_ClientRequestInfo_CORBA_Contained_describe::TAO_ClientRequestInfo_CORBA_Contained_describe (
    TAO_GIOP_Invocation *_tao_invocation,
    CORBA::Object_ptr _tao_target
    TAO_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ClientRequestInfo_i (_tao_invocation, _tao_target)
{}

Dynamic::ParameterList *
TAO_ClientRequestInfo_CORBA_Contained_describe::arguments (TAO_ENV_SINGLE_ARG_DECL)
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the argument list on demand.
  Dynamic::ParameterList *parameter_list =
    TAO_RequestInfo_Util::make_parameter_list (TAO_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  return parameter_list;
}

Dynamic::ExceptionList *
TAO_ClientRequestInfo_CORBA_Contained_describe::exceptions (TAO_ENV_SINGLE_ARG_DECL)
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the exception list on demand.
  Dynamic::ExceptionList *exception_list =
    TAO_RequestInfo_Util::make_exception_list (TAO_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  return exception_list;
}


CORBA::Any *
TAO_ClientRequestInfo_CORBA_Contained_describe::result (TAO_ENV_SINGLE_ARG_DECL)
  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 TAO_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  CORBA::Any_var safe_result_any = result_any;

  (*result_any) <<= this->_result;
  return safe_result_any._retn ();
}

void
TAO_ClientRequestInfo_CORBA_Contained_describe::result (CORBA_Contained::Description * result)
{
  // update the result
  this->_result = result;
}

class TAO_ClientRequestInfo_CORBA_Contained_move : public TAO_ClientRequestInfo_i
{
public:
  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
      TAO_ENV_ARG_DECL_WITH_DEFAULTS);


  virtual Dynamic::ParameterList * arguments (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  virtual Dynamic::ExceptionList * exceptions (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  virtual CORBA::Any * result (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    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_;

};

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
    TAO_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ClientRequestInfo_i (_tao_invocation, _tao_target),
    new_container_ (new_container),
    new_name_ (new_name),
    new_version_ (new_version)
{}

Dynamic::ParameterList *
TAO_ClientRequestInfo_CORBA_Contained_move::arguments (TAO_ENV_SINGLE_ARG_DECL)
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the argument list on demand.
  Dynamic::ParameterList *parameter_list =
    TAO_RequestInfo_Util::make_parameter_list (TAO_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  Dynamic::ParameterList_var safe_parameter_list = parameter_list;

  parameter_list->length (3);
  CORBA::ULong len = 0;

    (*parameter_list)[len].argument <<=  this->new_container_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
    (*parameter_list)[len].argument <<= new_name_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
    (*parameter_list)[len].argument <<= new_version_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;

  return safe_parameter_list._retn ();
}

Dynamic::ExceptionList *
TAO_ClientRequestInfo_CORBA_Contained_move::exceptions (TAO_ENV_SINGLE_ARG_DECL)
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the exception list on demand.
  Dynamic::ExceptionList *exception_list =
    TAO_RequestInfo_Util::make_exception_list (TAO_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  return exception_list;
}


CORBA::Any *
TAO_ClientRequestInfo_CORBA_Contained_move::result (TAO_ENV_SINGLE_ARG_DECL)
  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 TAO_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  return result_any;
}

#endif /* TAO_HAS_INTERCEPTORS */

///////////////////////////////////////////////////////////////////////
//                Base & Remote Proxy  Implementation.
//

_TAO_CORBA_Contained_Proxy_Impl::_TAO_CORBA_Contained_Proxy_Impl (void)
{}

_TAO_CORBA_Contained_Remote_Proxy_Impl::_TAO_CORBA_Contained_Remote_Proxy_Impl (void)
{}

// Remote Implementation of the IDL interface methods

char * _TAO_CORBA_Contained_Remote_Proxy_Impl::id (
    CORBA_Object *_collocated_tao_target_
    TAO_ENV_ARG_DECL
  )
  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 ()
    );

  int _invoke_status;

#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
      istub->orb_core ()->client_request_interceptors (),
      &_tao_call,
      _invoke_status
    );

#endif  /* TAO_HAS_INTERCEPTORS */

  for (;;)
    {
      _invoke_status = TAO_INVOKE_EXCEPTION;

#if TAO_HAS_INTERCEPTORS == 1
      TAO_ClientRequestInfo_CORBA_Contained_id_get ri (
        &_tao_call,
        _collocated_tao_target_
        TAO_ENV_ARG_PARAMETER
      );
      ACE_CHECK_RETURN (0);

#endif /* TAO_HAS_INTERCEPTORS */


      CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
      TAO_INTERCEPTOR (ri.response_expected (1));

#if TAO_HAS_INTERCEPTORS == 1

      ACE_TRY
        {
          _tao_vfr.send_request (
            &ri
            TAO_ENV_ARG_PARAMETER
          );
          ACE_TRY_CHECK;

          if (_invoke_status == TAO_INVOKE_RESTART)
            {
              _tao_call.restart_flag (1);
              continue;
            }

#endif /* TAO_HAS_INTERCEPTORS */

          _tao_call.start (TAO_ENV_SINGLE_ARG_PARAMETER);
          TAO_INTERCEPTOR_CHECK_RETURN (0);

          _tao_call.prepare_header (
              ACE_static_cast (CORBA::Octet, _tao_response_flag)
              TAO_ENV_ARG_PARAMETER
            );
          TAO_INTERCEPTOR_CHECK_RETURN (0);

          _invoke_status =
            _tao_call.invoke (0, 0 TAO_ENV_ARG_PARAMETER);
          TAO_INTERCEPTOR_CHECK_RETURN (0);

          if (_invoke_status == TAO_INVOKE_EXCEPTION)
            {
              TAO_INTERCEPTOR_THROW_RETURN (
                CORBA::UNKNOWN (TAO_OMG_VMCID | 1, CORBA::COMPLETED_YES),
                0
              );

            }
          else if (_invoke_status == TAO_INVOKE_RESTART)
            {
              TAO_INTERCEPTOR (
                ri.reply_status (_invoke_status);
                _tao_vfr.receive_other (
                  &ri
                  TAO_ENV_ARG_PARAMETER
                );
                ACE_TRY_CHECK;
              )

              continue;
            }

          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
              );

            }

#if TAO_HAS_INTERCEPTORS == 1
          char * _tao_retval_info = _tao_safe_retval._retn ();
          ri.result (_tao_retval_info);
          _tao_safe_retval = _tao_retval_info;

          ri.reply_status (_invoke_status);
          _tao_vfr.receive_reply (
            &ri
            TAO_ENV_ARG_PARAMETER
          );
          ACE_TRY_CHECK;

      }
    ACE_CATCHANY
      {
        ri.exception (&ACE_ANY_EXCEPTION);
        _tao_vfr.receive_exception (
          &ri
          TAO_ENV_ARG_PARAMETER
        );
        ACE_TRY_CHECK;

        PortableInterceptor::ReplyStatus _tao_status =
          ri.reply_status (TAO_ENV_SINGLE_ARG_PARAMETER);
        ACE_TRY_CHECK;

        if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION
            || _tao_status == PortableInterceptor::USER_EXCEPTION)
          ACE_RE_THROW;
      }
    ACE_ENDTRY;
    ACE_CHECK_RETURN (0);

    PortableInterceptor::ReplyStatus _tao_status =
      ri.reply_status (TAO_ENV_SINGLE_ARG_PARAMETER);
    ACE_CHECK_RETURN (0);

    if (_tao_status == PortableInterceptor::LOCATION_FORWARD
        || _tao_status == PortableInterceptor::TRANSPORT_RETRY)
      continue;

#endif  /* TAO_HAS_INTERCEPTORS */

    break;
  }
return _tao_safe_retval._retn ();
}

void _TAO_CORBA_Contained_Remote_Proxy_Impl::id (
    CORBA_Object *_collocated_tao_target_,
    const char * id
    TAO_ENV_ARG_DECL
  )
  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 ()
    );

  int _invoke_status;

#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
      istub->orb_core ()->client_request_interceptors (),
      &_tao_call,
      _invoke_status
    );

#endif  /* TAO_HAS_INTERCEPTORS */

  for (;;)
    {
      _invoke_status = TAO_INVOKE_EXCEPTION;

#if TAO_HAS_INTERCEPTORS == 1
      TAO_ClientRequestInfo_CORBA_Contained_id_set ri (
        &_tao_call,
        _collocated_tao_target_,
        id
        TAO_ENV_ARG_PARAMETER
      );
      ACE_CHECK;

#endif /* TAO_HAS_INTERCEPTORS */


      CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
      TAO_INTERCEPTOR (ri.response_expected (1));

#if TAO_HAS_INTERCEPTORS == 1

      ACE_TRY
        {
          _tao_vfr.send_request (
            &ri
            TAO_ENV_ARG_PARAMETER
          );
          ACE_TRY_CHECK;

          if (_invoke_status == TAO_INVOKE_RESTART)
            {
              _tao_call.restart_flag (1);
              continue;
            }

#endif /* TAO_HAS_INTERCEPTORS */

          _tao_call.start (TAO_ENV_SINGLE_ARG_PARAMETER);
          TAO_INTERCEPTOR_CHECK;

          _tao_call.prepare_header (
              ACE_static_cast (CORBA::Octet, _tao_response_flag)
              TAO_ENV_ARG_PARAMETER
            );
          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 TAO_ENV_ARG_PARAMETER);
          TAO_INTERCEPTOR_CHECK;

          if (_invoke_status == TAO_INVOKE_EXCEPTION)
            {
              TAO_INTERCEPTOR_THROW (
                CORBA::UNKNOWN (TAO_OMG_VMCID | 1, CORBA::COMPLETED_YES)
              );

            }
          else if (_invoke_status == TAO_INVOKE_RESTART)
            {
              TAO_INTERCEPTOR (
                ri.reply_status (_invoke_status);
                _tao_vfr.receive_other (
                  &ri
                  TAO_ENV_ARG_PARAMETER
                );
                ACE_TRY_CHECK;
              )

              continue;
            }


#if TAO_HAS_INTERCEPTORS == 1

          ri.reply_status (_invoke_status);
          _tao_vfr.receive_reply (
            &ri
            TAO_ENV_ARG_PARAMETER
          );
          ACE_TRY_CHECK;

      }
    ACE_CATCHANY
      {
        ri.exception (&ACE_ANY_EXCEPTION);
        _tao_vfr.receive_exception (
          &ri
          TAO_ENV_ARG_PARAMETER
        );
        ACE_TRY_CHECK;

        PortableInterceptor::ReplyStatus _tao_status =
          ri.reply_status (TAO_ENV_SINGLE_ARG_PARAMETER);
        ACE_TRY_CHECK;

        if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION
            || _tao_status == PortableInterceptor::USER_EXCEPTION)
          ACE_RE_THROW;
      }
    ACE_ENDTRY;
    ACE_CHECK;

    PortableInterceptor::ReplyStatus _tao_status =
      ri.reply_status (TAO_ENV_SINGLE_ARG_PARAMETER);
    ACE_CHECK;

    if (_tao_status == PortableInterceptor::LOCATION_FORWARD
        || _tao_status == PortableInterceptor::TRANSPORT_RETRY)
      continue;

#endif  /* TAO_HAS_INTERCEPTORS */

    break;
  }

}

char * _TAO_CORBA_Contained_Remote_Proxy_Impl::name (
    CORBA_Object *_collocated_tao_target_
    TAO_ENV_ARG_DECL
  )
  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 ()
    );

  int _invoke_status;

#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
      istub->orb_core ()->client_request_interceptors (),
      &_tao_call,
      _invoke_status
    );

#endif  /* TAO_HAS_INTERCEPTORS */

  for (;;)
    {
      _invoke_status = TAO_INVOKE_EXCEPTION;

#if TAO_HAS_INTERCEPTORS == 1
      TAO_ClientRequestInfo_CORBA_Contained_name_get ri (
        &_tao_call,
        _collocated_tao_target_
        TAO_ENV_ARG_PARAMETER
      );
      ACE_CHECK_RETURN (0);

#endif /* TAO_HAS_INTERCEPTORS */


      CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
      TAO_INTERCEPTOR (ri.response_expected (1));

#if TAO_HAS_INTERCEPTORS == 1

      ACE_TRY
        {
          _tao_vfr.send_request (
            &ri
            TAO_ENV_ARG_PARAMETER
          );
          ACE_TRY_CHECK;

          if (_invoke_status == TAO_INVOKE_RESTART)
            {
              _tao_call.restart_flag (1);
              continue;
            }

#endif /* TAO_HAS_INTERCEPTORS */

          _tao_call.start (TAO_ENV_SINGLE_ARG_PARAMETER);
          TAO_INTERCEPTOR_CHECK_RETURN (0);

          _tao_call.prepare_header (
              ACE_static_cast (CORBA::Octet, _tao_response_flag)
              TAO_ENV_ARG_PARAMETER
            );
          TAO_INTERCEPTOR_CHECK_RETURN (0);

          _invoke_status =
            _tao_call.invoke (0, 0 TAO_ENV_ARG_PARAMETER);
          TAO_INTERCEPTOR_CHECK_RETURN (0);

          if (_invoke_status == TAO_INVOKE_EXCEPTION)
            {
              TAO_INTERCEPTOR_THROW_RETURN (
                CORBA::UNKNOWN (TAO_OMG_VMCID | 1, CORBA::COMPLETED_YES),
                0
              );

            }
          else if (_invoke_status == TAO_INVOKE_RESTART)
            {
              TAO_INTERCEPTOR (
                ri.reply_status (_invoke_status);
                _tao_vfr.receive_other (
                  &ri
                  TAO_ENV_ARG_PARAMETER
                );
                ACE_TRY_CHECK;
              )

              continue;
            }

          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
              );

            }

#if TAO_HAS_INTERCEPTORS == 1
          char * _tao_retval_info = _tao_safe_retval._retn ();
          ri.result (_tao_retval_info);
          _tao_safe_retval = _tao_retval_info;

          ri.reply_status (_invoke_status);
          _tao_vfr.receive_reply (
            &ri
            TAO_ENV_ARG_PARAMETER
          );
          ACE_TRY_CHECK;

      }
    ACE_CATCHANY
      {
        ri.exception (&ACE_ANY_EXCEPTION);
        _tao_vfr.receive_exception (
          &ri
          TAO_ENV_ARG_PARAMETER
        );
        ACE_TRY_CHECK;

        PortableInterceptor::ReplyStatus _tao_status =
          ri.reply_status (TAO_ENV_SINGLE_ARG_PARAMETER);
        ACE_TRY_CHECK;

        if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION
            || _tao_status == PortableInterceptor::USER_EXCEPTION)
          ACE_RE_THROW;
      }
    ACE_ENDTRY;
    ACE_CHECK_RETURN (0);

    PortableInterceptor::ReplyStatus _tao_status =
      ri.reply_status (TAO_ENV_SINGLE_ARG_PARAMETER);
    ACE_CHECK_RETURN (0);

    if (_tao_status == PortableInterceptor::LOCATION_FORWARD
        || _tao_status == PortableInterceptor::TRANSPORT_RETRY)
      continue;

#endif  /* TAO_HAS_INTERCEPTORS */

    break;
  }
return _tao_safe_retval._retn ();
}

void _TAO_CORBA_Contained_Remote_Proxy_Impl::name (
    CORBA_Object *_collocated_tao_target_,
    const char * name
    TAO_ENV_ARG_DECL
  )
  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 ()
    );

  int _invoke_status;

#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
      istub->orb_core ()->client_request_interceptors (),
      &_tao_call,
      _invoke_status
    );

#endif  /* TAO_HAS_INTERCEPTORS */

  for (;;)
    {
      _invoke_status = TAO_INVOKE_EXCEPTION;

#if TAO_HAS_INTERCEPTORS == 1
      TAO_ClientRequestInfo_CORBA_Contained_name_set ri (
        &_tao_call,
        _collocated_tao_target_,
        name
        TAO_ENV_ARG_PARAMETER
      );
      ACE_CHECK;

#endif /* TAO_HAS_INTERCEPTORS */


      CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
      TAO_INTERCEPTOR (ri.response_expected (1));

#if TAO_HAS_INTERCEPTORS == 1

      ACE_TRY
        {
          _tao_vfr.send_request (
            &ri
            TAO_ENV_ARG_PARAMETER
          );
          ACE_TRY_CHECK;

          if (_invoke_status == TAO_INVOKE_RESTART)
            {
              _tao_call.restart_flag (1);
              continue;
            }

#endif /* TAO_HAS_INTERCEPTORS */

          _tao_call.start (TAO_ENV_SINGLE_ARG_PARAMETER);
          TAO_INTERCEPTOR_CHECK;

          _tao_call.prepare_header (
              ACE_static_cast (CORBA::Octet, _tao_response_flag)
              TAO_ENV_ARG_PARAMETER
            );
          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 TAO_ENV_ARG_PARAMETER);
          TAO_INTERCEPTOR_CHECK;

          if (_invoke_status == TAO_INVOKE_EXCEPTION)
            {
              TAO_INTERCEPTOR_THROW (
                CORBA::UNKNOWN (TAO_OMG_VMCID | 1, CORBA::COMPLETED_YES)
              );

            }
          else if (_invoke_status == TAO_INVOKE_RESTART)
            {
              TAO_INTERCEPTOR (
                ri.reply_status (_invoke_status);
                _tao_vfr.receive_other (
                  &ri
                  TAO_ENV_ARG_PARAMETER
                );
                ACE_TRY_CHECK;
              )

              continue;
            }


#if TAO_HAS_INTERCEPTORS == 1

          ri.reply_status (_invoke_status);
          _tao_vfr.receive_reply (
            &ri
            TAO_ENV_ARG_PARAMETER
          );
          ACE_TRY_CHECK;

      }
    ACE_CATCHANY
      {
        ri.exception (&ACE_ANY_EXCEPTION);
        _tao_vfr.receive_exception (
          &ri
          TAO_ENV_ARG_PARAMETER
        );
        ACE_TRY_CHECK;

        PortableInterceptor::ReplyStatus _tao_status =
          ri.reply_status (TAO_ENV_SINGLE_ARG_PARAMETER);
        ACE_TRY_CHECK;

        if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION
            || _tao_status == PortableInterceptor::USER_EXCEPTION)
          ACE_RE_THROW;
      }
    ACE_ENDTRY;
    ACE_CHECK;

    PortableInterceptor::ReplyStatus _tao_status =
      ri.reply_status (TAO_ENV_SINGLE_ARG_PARAMETER);
    ACE_CHECK;

    if (_tao_status == PortableInterceptor::LOCATION_FORWARD
        || _tao_status == PortableInterceptor::TRANSPORT_RETRY)
      continue;

#endif  /* TAO_HAS_INTERCEPTORS */

    break;
  }

}

char * _TAO_CORBA_Contained_Remote_Proxy_Impl::version (
    CORBA_Object *_collocated_tao_target_
    TAO_ENV_ARG_DECL
  )
  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 ()
    );

  int _invoke_status;

#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
      istub->orb_core ()->client_request_interceptors (),
      &_tao_call,
      _invoke_status
    );

#endif  /* TAO_HAS_INTERCEPTORS */

  for (;;)
    {
      _invoke_status = TAO_INVOKE_EXCEPTION;

#if TAO_HAS_INTERCEPTORS == 1
      TAO_ClientRequestInfo_CORBA_Contained_version_get ri (
        &_tao_call,
        _collocated_tao_target_
        TAO_ENV_ARG_PARAMETER
      );
      ACE_CHECK_RETURN (0);

#endif /* TAO_HAS_INTERCEPTORS */


      CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
      TAO_INTERCEPTOR (ri.response_expected (1));

#if TAO_HAS_INTERCEPTORS == 1

      ACE_TRY
        {
          _tao_vfr.send_request (
            &ri
            TAO_ENV_ARG_PARAMETER
          );
          ACE_TRY_CHECK;

          if (_invoke_status == TAO_INVOKE_RESTART)
            {
              _tao_call.restart_flag (1);
              continue;
            }

#endif /* TAO_HAS_INTERCEPTORS */

          _tao_call.start (TAO_ENV_SINGLE_ARG_PARAMETER);
          TAO_INTERCEPTOR_CHECK_RETURN (0);

          _tao_call.prepare_header (
              ACE_static_cast (CORBA::Octet, _tao_response_flag)
              TAO_ENV_ARG_PARAMETER
            );
          TAO_INTERCEPTOR_CHECK_RETURN (0);

          _invoke_status =
            _tao_call.invoke (0, 0 TAO_ENV_ARG_PARAMETER);
          TAO_INTERCEPTOR_CHECK_RETURN (0);

          if (_invoke_status == TAO_INVOKE_EXCEPTION)
            {
              TAO_INTERCEPTOR_THROW_RETURN (
                CORBA::UNKNOWN (TAO_OMG_VMCID | 1, CORBA::COMPLETED_YES),
                0
              );

            }
          else if (_invoke_status == TAO_INVOKE_RESTART)
            {
              TAO_INTERCEPTOR (
                ri.reply_status (_invoke_status);
                _tao_vfr.receive_other (
                  &ri
                  TAO_ENV_ARG_PARAMETER
                );
                ACE_TRY_CHECK;
              )

              continue;
            }

          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
              );

            }

#if TAO_HAS_INTERCEPTORS == 1
          char * _tao_retval_info = _tao_safe_retval._retn ();
          ri.result (_tao_retval_info);
          _tao_safe_retval = _tao_retval_info;

          ri.reply_status (_invoke_status);
          _tao_vfr.receive_reply (
            &ri
            TAO_ENV_ARG_PARAMETER
          );
          ACE_TRY_CHECK;

      }
    ACE_CATCHANY
      {
        ri.exception (&ACE_ANY_EXCEPTION);
        _tao_vfr.receive_exception (
          &ri
          TAO_ENV_ARG_PARAMETER
        );
        ACE_TRY_CHECK;

        PortableInterceptor::ReplyStatus _tao_status =
          ri.reply_status (TAO_ENV_SINGLE_ARG_PARAMETER);
        ACE_TRY_CHECK;

        if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION
            || _tao_status == PortableInterceptor::USER_EXCEPTION)
          ACE_RE_THROW;
      }
    ACE_ENDTRY;
    ACE_CHECK_RETURN (0);

    PortableInterceptor::ReplyStatus _tao_status =
      ri.reply_status (TAO_ENV_SINGLE_ARG_PARAMETER);
    ACE_CHECK_RETURN (0);

    if (_tao_status == PortableInterceptor::LOCATION_FORWARD
        || _tao_status == PortableInterceptor::TRANSPORT_RETRY)
      continue;

#endif  /* TAO_HAS_INTERCEPTORS */

    break;
  }
return _tao_safe_retval._retn ();
}

void _TAO_CORBA_Contained_Remote_Proxy_Impl::version (
    CORBA_Object *_collocated_tao_target_,
    const char * version
    TAO_ENV_ARG_DECL
  )
  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 ()
    );

  int _invoke_status;

#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
      istub->orb_core ()->client_request_interceptors (),
      &_tao_call,
      _invoke_status
    );

#endif  /* TAO_HAS_INTERCEPTORS */

  for (;;)
    {
      _invoke_status = TAO_INVOKE_EXCEPTION;

#if TAO_HAS_INTERCEPTORS == 1
      TAO_ClientRequestInfo_CORBA_Contained_version_set ri (
        &_tao_call,
        _collocated_tao_target_,
        version
        TAO_ENV_ARG_PARAMETER
      );
      ACE_CHECK;

#endif /* TAO_HAS_INTERCEPTORS */


      CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
      TAO_INTERCEPTOR (ri.response_expected (1));

#if TAO_HAS_INTERCEPTORS == 1

      ACE_TRY
        {
          _tao_vfr.send_request (
            &ri
            TAO_ENV_ARG_PARAMETER
          );
          ACE_TRY_CHECK;

          if (_invoke_status == TAO_INVOKE_RESTART)
            {
              _tao_call.restart_flag (1);
              continue;
            }

#endif /* TAO_HAS_INTERCEPTORS */

          _tao_call.start (TAO_ENV_SINGLE_ARG_PARAMETER);
          TAO_INTERCEPTOR_CHECK;

          _tao_call.prepare_header (
              ACE_static_cast (CORBA::Octet, _tao_response_flag)
              TAO_ENV_ARG_PARAMETER
            );
          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 TAO_ENV_ARG_PARAMETER);
          TAO_INTERCEPTOR_CHECK;

          if (_invoke_status == TAO_INVOKE_EXCEPTION)
            {
              TAO_INTERCEPTOR_THROW (
                CORBA::UNKNOWN (TAO_OMG_VMCID | 1, CORBA::COMPLETED_YES)
              );

            }
          else if (_invoke_status == TAO_INVOKE_RESTART)
            {
              TAO_INTERCEPTOR (
                ri.reply_status (_invoke_status);
                _tao_vfr.receive_other (
                  &ri
                  TAO_ENV_ARG_PARAMETER
                );
                ACE_TRY_CHECK;
              )

              continue;
            }


#if TAO_HAS_INTERCEPTORS == 1

          ri.reply_status (_invoke_status);
          _tao_vfr.receive_reply (
            &ri
            TAO_ENV_ARG_PARAMETER
          );
          ACE_TRY_CHECK;

      }
    ACE_CATCHANY
      {
        ri.exception (&ACE_ANY_EXCEPTION);
        _tao_vfr.receive_exception (
          &ri
          TAO_ENV_ARG_PARAMETER
        );
        ACE_TRY_CHECK;

        PortableInterceptor::ReplyStatus _tao_status =
          ri.reply_status (TAO_ENV_SINGLE_ARG_PARAMETER);
        ACE_TRY_CHECK;

        if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION
            || _tao_status == PortableInterceptor::USER_EXCEPTION)
          ACE_RE_THROW;
      }
    ACE_ENDTRY;
    ACE_CHECK;

    PortableInterceptor::ReplyStatus _tao_status =
      ri.reply_status (TAO_ENV_SINGLE_ARG_PARAMETER);
    ACE_CHECK;

    if (_tao_status == PortableInterceptor::LOCATION_FORWARD
        || _tao_status == PortableInterceptor::TRANSPORT_RETRY)
      continue;

#endif  /* TAO_HAS_INTERCEPTORS */

    break;
  }

}

CORBA_Container_ptr _TAO_CORBA_Contained_Remote_Proxy_Impl::defined_in (
    CORBA_Object *_collocated_tao_target_
    TAO_ENV_ARG_DECL
  )
  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 ()
    );

  int _invoke_status;

#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
      istub->orb_core ()->client_request_interceptors (),
      &_tao_call,
      _invoke_status
    );

#endif  /* TAO_HAS_INTERCEPTORS */

  for (;;)
    {
      _invoke_status = TAO_INVOKE_EXCEPTION;

#if TAO_HAS_INTERCEPTORS == 1
      TAO_ClientRequestInfo_CORBA_Contained_defined_in_get ri (
        &_tao_call,
        _collocated_tao_target_
        TAO_ENV_ARG_PARAMETER
      );
      ACE_CHECK_RETURN (0);

#endif /* TAO_HAS_INTERCEPTORS */


      CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
      TAO_INTERCEPTOR (ri.response_expected (1));

#if TAO_HAS_INTERCEPTORS == 1

      ACE_TRY
        {
          _tao_vfr.send_request (
            &ri
            TAO_ENV_ARG_PARAMETER
          );
          ACE_TRY_CHECK;

          if (_invoke_status == TAO_INVOKE_RESTART)
            {
              _tao_call.restart_flag (1);
              continue;
            }

#endif /* TAO_HAS_INTERCEPTORS */

          _tao_call.start (TAO_ENV_SINGLE_ARG_PARAMETER);
          TAO_INTERCEPTOR_CHECK_RETURN (0);

          _tao_call.prepare_header (
              ACE_static_cast (CORBA::Octet, _tao_response_flag)
              TAO_ENV_ARG_PARAMETER
            );
          TAO_INTERCEPTOR_CHECK_RETURN (0);

          _invoke_status =
            _tao_call.invoke (0, 0 TAO_ENV_ARG_PARAMETER);
          TAO_INTERCEPTOR_CHECK_RETURN (0);

          if (_invoke_status == TAO_INVOKE_EXCEPTION)
            {
              TAO_INTERCEPTOR_THROW_RETURN (
                CORBA::UNKNOWN (TAO_OMG_VMCID | 1, CORBA::COMPLETED_YES),
                0
              );

            }
          else if (_invoke_status == TAO_INVOKE_RESTART)
            {
              TAO_INTERCEPTOR (
                ri.reply_status (_invoke_status);
                _tao_vfr.receive_other (
                  &ri
                  TAO_ENV_ARG_PARAMETER
                );
                ACE_TRY_CHECK;
              )

              continue;
            }

          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
              );

            }

#if TAO_HAS_INTERCEPTORS == 1
          CORBA_Container_ptr _tao_retval_info = _tao_safe_retval._retn ();
          ri.result (_tao_retval_info);
          _tao_safe_retval = _tao_retval_info;

          ri.reply_status (_invoke_status);
          _tao_vfr.receive_reply (
            &ri
            TAO_ENV_ARG_PARAMETER
          );
          ACE_TRY_CHECK;

      }
    ACE_CATCHANY
      {
        ri.exception (&ACE_ANY_EXCEPTION);
        _tao_vfr.receive_exception (
          &ri
          TAO_ENV_ARG_PARAMETER
        );
        ACE_TRY_CHECK;

        PortableInterceptor::ReplyStatus _tao_status =
          ri.reply_status (TAO_ENV_SINGLE_ARG_PARAMETER);
        ACE_TRY_CHECK;

        if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION
            || _tao_status == PortableInterceptor::USER_EXCEPTION)
          ACE_RE_THROW;
      }
    ACE_ENDTRY;
    ACE_CHECK_RETURN (0);

    PortableInterceptor::ReplyStatus _tao_status =
      ri.reply_status (TAO_ENV_SINGLE_ARG_PARAMETER);
    ACE_CHECK_RETURN (0);

    if (_tao_status == PortableInterceptor::LOCATION_FORWARD
        || _tao_status == PortableInterceptor::TRANSPORT_RETRY)
      continue;

#endif  /* TAO_HAS_INTERCEPTORS */

    break;
  }
return _tao_safe_retval._retn ();
}

char * _TAO_CORBA_Contained_Remote_Proxy_Impl::absolute_name (
    CORBA_Object *_collocated_tao_target_
    TAO_ENV_ARG_DECL
  )
  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 ()
    );

  int _invoke_status;

#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
      istub->orb_core ()->client_request_interceptors (),
      &_tao_call,
      _invoke_status
    );

#endif  /* TAO_HAS_INTERCEPTORS */

  for (;;)
    {
      _invoke_status = TAO_INVOKE_EXCEPTION;

#if TAO_HAS_INTERCEPTORS == 1
      TAO_ClientRequestInfo_CORBA_Contained_absolute_name_get ri (
        &_tao_call,
        _collocated_tao_target_
        TAO_ENV_ARG_PARAMETER
      );
      ACE_CHECK_RETURN (0);

#endif /* TAO_HAS_INTERCEPTORS */


      CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
      TAO_INTERCEPTOR (ri.response_expected (1));

#if TAO_HAS_INTERCEPTORS == 1

      ACE_TRY
        {
          _tao_vfr.send_request (
            &ri
            TAO_ENV_ARG_PARAMETER
          );
          ACE_TRY_CHECK;

          if (_invoke_status == TAO_INVOKE_RESTART)
            {
              _tao_call.restart_flag (1);
              continue;
            }

#endif /* TAO_HAS_INTERCEPTORS */

          _tao_call.start (TAO_ENV_SINGLE_ARG_PARAMETER);
          TAO_INTERCEPTOR_CHECK_RETURN (0);

          _tao_call.prepare_header (
              ACE_static_cast (CORBA::Octet, _tao_response_flag)
              TAO_ENV_ARG_PARAMETER
            );
          TAO_INTERCEPTOR_CHECK_RETURN (0);

          _invoke_status =
            _tao_call.invoke (0, 0 TAO_ENV_ARG_PARAMETER);
          TAO_INTERCEPTOR_CHECK_RETURN (0);

          if (_invoke_status == TAO_INVOKE_EXCEPTION)
            {
              TAO_INTERCEPTOR_THROW_RETURN (
                CORBA::UNKNOWN (TAO_OMG_VMCID | 1, CORBA::COMPLETED_YES),
                0
              );

            }
          else if (_invoke_status == TAO_INVOKE_RESTART)
            {
              TAO_INTERCEPTOR (
                ri.reply_status (_invoke_status);
                _tao_vfr.receive_other (
                  &ri
                  TAO_ENV_ARG_PARAMETER
                );
                ACE_TRY_CHECK;
              )

              continue;
            }

          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
              );

            }

#if TAO_HAS_INTERCEPTORS == 1
          char * _tao_retval_info = _tao_safe_retval._retn ();
          ri.result (_tao_retval_info);
          _tao_safe_retval = _tao_retval_info;

          ri.reply_status (_invoke_status);
          _tao_vfr.receive_reply (
            &ri
            TAO_ENV_ARG_PARAMETER
          );
          ACE_TRY_CHECK;

      }
    ACE_CATCHANY
      {
        ri.exception (&ACE_ANY_EXCEPTION);
        _tao_vfr.receive_exception (
          &ri
          TAO_ENV_ARG_PARAMETER
        );
        ACE_TRY_CHECK;

        PortableInterceptor::ReplyStatus _tao_status =
          ri.reply_status (TAO_ENV_SINGLE_ARG_PARAMETER);
        ACE_TRY_CHECK;

        if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION
            || _tao_status == PortableInterceptor::USER_EXCEPTION)
          ACE_RE_THROW;
      }
    ACE_ENDTRY;
    ACE_CHECK_RETURN (0);

    PortableInterceptor::ReplyStatus _tao_status =
      ri.reply_status (TAO_ENV_SINGLE_ARG_PARAMETER);
    ACE_CHECK_RETURN (0);

    if (_tao_status == PortableInterceptor::LOCATION_FORWARD
        || _tao_status == PortableInterceptor::TRANSPORT_RETRY)
      continue;

#endif  /* TAO_HAS_INTERCEPTORS */

    break;
  }
return _tao_safe_retval._retn ();
}

CORBA_Repository_ptr _TAO_CORBA_Contained_Remote_Proxy_Impl::containing_repository (
    CORBA_Object *_collocated_tao_target_
    TAO_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{

  CORBA_Repository_ptr _tao_retval = tao_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 ()
    );

  int _invoke_status;

#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
      istub->orb_core ()->client_request_interceptors (),
      &_tao_call,
      _invoke_status
    );

#endif  /* TAO_HAS_INTERCEPTORS */

  for (;;)
    {
      _invoke_status = TAO_INVOKE_EXCEPTION;

#if TAO_HAS_INTERCEPTORS == 1
      TAO_ClientRequestInfo_CORBA_Contained_containing_repository_get ri (
        &_tao_call,
        _collocated_tao_target_
        TAO_ENV_ARG_PARAMETER
      );
      ACE_CHECK_RETURN (0);

#endif /* TAO_HAS_INTERCEPTORS */


      CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
      TAO_INTERCEPTOR (ri.response_expected (1));

#if TAO_HAS_INTERCEPTORS == 1

      ACE_TRY
        {
          _tao_vfr.send_request (
            &ri
            TAO_ENV_ARG_PARAMETER
          );
          ACE_TRY_CHECK;

          if (_invoke_status == TAO_INVOKE_RESTART)
            {
              _tao_call.restart_flag (1);
              continue;
            }

#endif /* TAO_HAS_INTERCEPTORS */

          _tao_call.start (TAO_ENV_SINGLE_ARG_PARAMETER);
          TAO_INTERCEPTOR_CHECK_RETURN (0);

          _tao_call.prepare_header (
              ACE_static_cast (CORBA::Octet, _tao_response_flag)
              TAO_ENV_ARG_PARAMETER
            );
          TAO_INTERCEPTOR_CHECK_RETURN (0);

          _invoke_status =
            _tao_call.invoke (0, 0 TAO_ENV_ARG_PARAMETER);
          TAO_INTERCEPTOR_CHECK_RETURN (0);

          if (_invoke_status == TAO_INVOKE_EXCEPTION)
            {
              TAO_INTERCEPTOR_THROW_RETURN (
                CORBA::UNKNOWN (TAO_OMG_VMCID | 1, CORBA::COMPLETED_YES),
                0
              );

            }
          else if (_invoke_status == TAO_INVOKE_RESTART)
            {
              TAO_INTERCEPTOR (
                ri.reply_status (_invoke_status);
                _tao_vfr.receive_other (
                  &ri
                  TAO_ENV_ARG_PARAMETER
                );
                ACE_TRY_CHECK;
              )

              continue;
            }

          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
              );

            }

#if TAO_HAS_INTERCEPTORS == 1
          CORBA_Repository_ptr _tao_retval_info = _tao_safe_retval._retn ();
          ri.result (_tao_retval_info);
          _tao_safe_retval = _tao_retval_info;

          ri.reply_status (_invoke_status);
          _tao_vfr.receive_reply (
            &ri
            TAO_ENV_ARG_PARAMETER
          );
          ACE_TRY_CHECK;

      }
    ACE_CATCHANY
      {
        ri.exception (&ACE_ANY_EXCEPTION);
        _tao_vfr.receive_exception (
          &ri
          TAO_ENV_ARG_PARAMETER
        );
        ACE_TRY_CHECK;

        PortableInterceptor::ReplyStatus _tao_status =
          ri.reply_status (TAO_ENV_SINGLE_ARG_PARAMETER);
        ACE_TRY_CHECK;

        if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION
            || _tao_status == PortableInterceptor::USER_EXCEPTION)
          ACE_RE_THROW;
      }
    ACE_ENDTRY;
    ACE_CHECK_RETURN (0);

    PortableInterceptor::ReplyStatus _tao_status =
      ri.reply_status (TAO_ENV_SINGLE_ARG_PARAMETER);
    ACE_CHECK_RETURN (0);

    if (_tao_status == PortableInterceptor::LOCATION_FORWARD
        || _tao_status == PortableInterceptor::TRANSPORT_RETRY)
      continue;

#endif  /* TAO_HAS_INTERCEPTORS */

    break;
  }
return _tao_safe_retval._retn ();
}

CORBA_Contained::Description * _TAO_CORBA_Contained_Remote_Proxy_Impl::describe (
    CORBA_Object *_collocated_tao_target_
    TAO_ENV_ARG_DECL
  )
  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 ()
    );

  int _invoke_status;

#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
      istub->orb_core ()->client_request_interceptors (),
      &_tao_call,
      _invoke_status
    );

#endif  /* TAO_HAS_INTERCEPTORS */

  for (;;)
    {
      _invoke_status = TAO_INVOKE_EXCEPTION;

#if TAO_HAS_INTERCEPTORS == 1
      TAO_ClientRequestInfo_CORBA_Contained_describe ri (
        &_tao_call,
        _collocated_tao_target_
        TAO_ENV_ARG_PARAMETER
      );
      ACE_CHECK_RETURN (0);

#endif /* TAO_HAS_INTERCEPTORS */


      CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
      TAO_INTERCEPTOR (ri.response_expected (1));

#if TAO_HAS_INTERCEPTORS == 1

      ACE_TRY
        {
          _tao_vfr.send_request (
            &ri
            TAO_ENV_ARG_PARAMETER
          );
          ACE_TRY_CHECK;

          if (_invoke_status == TAO_INVOKE_RESTART)
            {
              _tao_call.restart_flag (1);
              continue;
            }

#endif /* TAO_HAS_INTERCEPTORS */

          _tao_call.start (TAO_ENV_SINGLE_ARG_PARAMETER);
          TAO_INTERCEPTOR_CHECK_RETURN (0);

          _tao_call.prepare_header (
              ACE_static_cast (CORBA::Octet, _tao_response_flag)
              TAO_ENV_ARG_PARAMETER
            );
          TAO_INTERCEPTOR_CHECK_RETURN (0);

          _invoke_status =
            _tao_call.invoke (0, 0 TAO_ENV_ARG_PARAMETER);
          TAO_INTERCEPTOR_CHECK_RETURN (0);

          if (_invoke_status == TAO_INVOKE_EXCEPTION)
            {
              TAO_INTERCEPTOR_THROW_RETURN (
                CORBA::UNKNOWN (TAO_OMG_VMCID | 1, CORBA::COMPLETED_YES),
                0
              );

            }
          else if (_invoke_status == TAO_INVOKE_RESTART)
            {
              TAO_INTERCEPTOR (
                ri.reply_status (_invoke_status);
                _tao_vfr.receive_other (
                  &ri
                  TAO_ENV_ARG_PARAMETER
                );
                ACE_TRY_CHECK;
              )

              continue;
            }

          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
              );

            }

#if TAO_HAS_INTERCEPTORS == 1
          CORBA_Contained::Description * _tao_retval_info = _tao_safe_retval._retn ();
          ri.result (_tao_retval_info);
          _tao_safe_retval = _tao_retval_info;

          ri.reply_status (_invoke_status);
          _tao_vfr.receive_reply (
            &ri
            TAO_ENV_ARG_PARAMETER
          );
          ACE_TRY_CHECK;

      }
    ACE_CATCHANY
      {
        ri.exception (&ACE_ANY_EXCEPTION);
        _tao_vfr.receive_exception (
          &ri
          TAO_ENV_ARG_PARAMETER
        );
        ACE_TRY_CHECK;

        PortableInterceptor::ReplyStatus _tao_status =
          ri.reply_status (TAO_ENV_SINGLE_ARG_PARAMETER);
        ACE_TRY_CHECK;

        if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION
            || _tao_status == PortableInterceptor::USER_EXCEPTION)
          ACE_RE_THROW;
      }
    ACE_ENDTRY;
    ACE_CHECK_RETURN (0);

    PortableInterceptor::ReplyStatus _tao_status =
      ri.reply_status (TAO_ENV_SINGLE_ARG_PARAMETER);
    ACE_CHECK_RETURN (0);

    if (_tao_status == PortableInterceptor::LOCATION_FORWARD
        || _tao_status == PortableInterceptor::TRANSPORT_RETRY)
      continue;

#endif  /* TAO_HAS_INTERCEPTORS */

    break;
  }
return _tao_safe_retval._retn ();
}

void _TAO_CORBA_Contained_Remote_Proxy_Impl::move (
    CORBA_Object *_collocated_tao_target_,
    CORBA_Container_ptr new_container,
    const char * new_name,
    const char * new_version
    TAO_ENV_ARG_DECL
  )
  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 ()
    );

  int _invoke_status;

#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
      istub->orb_core ()->client_request_interceptors (),
      &_tao_call,
      _invoke_status
    );

#endif  /* TAO_HAS_INTERCEPTORS */

  for (;;)
    {
      _invoke_status = TAO_INVOKE_EXCEPTION;

#if TAO_HAS_INTERCEPTORS == 1
      TAO_ClientRequestInfo_CORBA_Contained_move ri (
        &_tao_call,
        _collocated_tao_target_,
        new_container,
        new_name,
        new_version
        TAO_ENV_ARG_PARAMETER
      );
      ACE_CHECK;

#endif /* TAO_HAS_INTERCEPTORS */


      CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
      TAO_INTERCEPTOR (ri.response_expected (1));

#if TAO_HAS_INTERCEPTORS == 1

      ACE_TRY
        {
          _tao_vfr.send_request (
            &ri
            TAO_ENV_ARG_PARAMETER
          );
          ACE_TRY_CHECK;

          if (_invoke_status == TAO_INVOKE_RESTART)
            {
              _tao_call.restart_flag (1);
              continue;
            }

#endif /* TAO_HAS_INTERCEPTORS */

          _tao_call.start (TAO_ENV_SINGLE_ARG_PARAMETER);
          TAO_INTERCEPTOR_CHECK;

          _tao_call.prepare_header (
              ACE_static_cast (CORBA::Octet, _tao_response_flag)
              TAO_ENV_ARG_PARAMETER
            );
          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 TAO_ENV_ARG_PARAMETER);
          TAO_INTERCEPTOR_CHECK;

          if (_invoke_status == TAO_INVOKE_EXCEPTION)
            {
              TAO_INTERCEPTOR_THROW (
                CORBA::UNKNOWN (TAO_OMG_VMCID | 1, CORBA::COMPLETED_YES)
              );

            }
          else if (_invoke_status == TAO_INVOKE_RESTART)
            {
              TAO_INTERCEPTOR (
                ri.reply_status (_invoke_status);
                _tao_vfr.receive_other (
                  &ri
                  TAO_ENV_ARG_PARAMETER
                );
                ACE_TRY_CHECK;
              )

              continue;
            }


#if TAO_HAS_INTERCEPTORS == 1

          ri.reply_status (_invoke_status);
          _tao_vfr.receive_reply (
            &ri
            TAO_ENV_ARG_PARAMETER
          );
          ACE_TRY_CHECK;

      }
    ACE_CATCHANY
      {
        ri.exception (&ACE_ANY_EXCEPTION);
        _tao_vfr.receive_exception (
          &ri
          TAO_ENV_ARG_PARAMETER
        );
        ACE_TRY_CHECK;

        PortableInterceptor::ReplyStatus _tao_status =
          ri.reply_status (TAO_ENV_SINGLE_ARG_PARAMETER);
        ACE_TRY_CHECK;

        if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION
            || _tao_status == PortableInterceptor::USER_EXCEPTION)
          ACE_RE_THROW;
      }
    ACE_ENDTRY;
    ACE_CHECK;

    PortableInterceptor::ReplyStatus _tao_status =
      ri.reply_status (TAO_ENV_SINGLE_ARG_PARAMETER);
    ACE_CHECK;

    if (_tao_status == PortableInterceptor::LOCATION_FORWARD
        || _tao_status == PortableInterceptor::TRANSPORT_RETRY)
      continue;

#endif  /* TAO_HAS_INTERCEPTORS */

    break;
  }

}


//
//            End  Base & Remote  Proxy Implemeentation.
///////////////////////////////////////////////////////////////////////


///////////////////////////////////////////////////////////////////////
//           Remote & Base  Proxy Broker Implementation
//

_TAO_CORBA_Contained_Proxy_Broker::_TAO_CORBA_Contained_Proxy_Broker (void)
{
}

_TAO_CORBA_Contained_Proxy_Broker::~_TAO_CORBA_Contained_Proxy_Broker (void)
{
}

_TAO_CORBA_Contained_Proxy_Broker * (*_TAO_CORBA_Contained_Proxy_Broker_Factory_function_pointer) (
    CORBA::Object_ptr obj
  ) = 0;

// Factory Member function Implementation.
_TAO_CORBA_Contained_Remote_Proxy_Broker *
_TAO_CORBA_Contained_Remote_Proxy_Broker::the_TAO_CORBA_Contained_Remote_Proxy_Broker (void)
{
  static ::_TAO_CORBA_Contained_Remote_Proxy_Broker remote_proxy_broker;
  return &remote_proxy_broker;
}

_TAO_CORBA_Contained_Remote_Proxy_Broker::_TAO_CORBA_Contained_Remote_Proxy_Broker (void)
{
}

_TAO_CORBA_Contained_Remote_Proxy_Broker::~_TAO_CORBA_Contained_Remote_Proxy_Broker (void)
{
}

_TAO_CORBA_Contained_Proxy_Impl&
_TAO_CORBA_Contained_Remote_Proxy_Broker::select_proxy (
  ::CORBA_Contained *
  TAO_ENV_ARG_DECL_NOT_USED
)
{
  return this->remote_proxy_impl_;
}


//
//           End Remote & Base Proxy Broker Implementation
///////////////////////////////////////////////////////////////////////


// default constructor
CORBA_Contained::CORBA_Contained (int collocated)
{
  this->CORBA_Contained_setup_collocation (collocated);
}

// destructor
CORBA_Contained::~CORBA_Contained (void)
{}

void
CORBA_Contained::CORBA_Contained_setup_collocation (int collocated)
{
  if (collocated)
    this->the_TAO_CORBA_Contained_Proxy_Broker_ =
      ::_TAO_CORBA_Contained_Proxy_Broker_Factory_function_pointer (this);
  else
    this->the_TAO_CORBA_Contained_Proxy_Broker_ =
      ::_TAO_CORBA_Contained_Remote_Proxy_Broker::the_TAO_CORBA_Contained_Remote_Proxy_Broker ();

  this->CORBA_IRObject_setup_collocation (collocated);
}

void CORBA_Contained::_tao_any_destructor (void *_tao_void_pointer)
{
  CORBA_Contained *tmp = ACE_static_cast (CORBA_Contained*, _tao_void_pointer);
  CORBA::release (tmp);
}

CORBA_Contained_ptr CORBA_Contained::_narrow (
    CORBA::Object_ptr obj
    TAO_ENV_ARG_DECL
  )
{
  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" TAO_ENV_ARG_PARAMETER);
      ACE_CHECK_RETURN (CORBA_Contained::_nil ());
      if (is_a == 0)
        return CORBA_Contained::_nil ();
    }
  return CORBA_Contained::_unchecked_narrow (obj TAO_ENV_ARG_PARAMETER);
}

CORBA_Contained_ptr CORBA_Contained::_unchecked_narrow (
    CORBA::Object_ptr obj
    TAO_ENV_ARG_DECL_NOT_USED
  )
{
  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 () &&_TAO_CORBA_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::_tao_class_id
                    )
                )
          );
}

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 TAO_ENV_ARG_DECL)
{
  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 TAO_ENV_ARG_PARAMETER);
}

void *CORBA_Contained::_tao_QueryInterface (ptr_arith_t type)
{
  void *retv = 0;
  if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &CORBA_Contained::_tao_class_id))
    retv = ACE_reinterpret_cast (void*, this);
  else if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &CORBA_IRObject::_tao_class_id))
    retv = ACE_reinterpret_cast
      (
        void *,
        ACE_static_cast
          (
            CORBA_IRObject_ptr,
            this
          )
      );
  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_tao_class_id))
    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 (
    TAO_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  _TAO_CORBA_Contained_Proxy_Impl &proxy =
    this->the_TAO_CORBA_Contained_Proxy_Broker_->select_proxy (this TAO_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  return proxy.id (
      this
      TAO_ENV_ARG_PARAMETER
    );
}

void CORBA_Contained::id (
    const char * id
    TAO_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  _TAO_CORBA_Contained_Proxy_Impl &proxy =
    this->the_TAO_CORBA_Contained_Proxy_Broker_->select_proxy (this TAO_ENV_ARG_PARAMETER);
  ACE_CHECK;

  proxy.id (
      this,
      id
      TAO_ENV_ARG_PARAMETER
    );
}

char * CORBA_Contained::name (
    TAO_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  _TAO_CORBA_Contained_Proxy_Impl &proxy =
    this->the_TAO_CORBA_Contained_Proxy_Broker_->select_proxy (this TAO_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  return proxy.name (
      this
      TAO_ENV_ARG_PARAMETER
    );
}

void CORBA_Contained::name (
    const char * name
    TAO_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  _TAO_CORBA_Contained_Proxy_Impl &proxy =
    this->the_TAO_CORBA_Contained_Proxy_Broker_->select_proxy (this TAO_ENV_ARG_PARAMETER);
  ACE_CHECK;

  proxy.name (
      this,
      name
      TAO_ENV_ARG_PARAMETER
    );
}

char * CORBA_Contained::version (
    TAO_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  _TAO_CORBA_Contained_Proxy_Impl &proxy =
    this->the_TAO_CORBA_Contained_Proxy_Broker_->select_proxy (this TAO_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  return proxy.version (
      this
      TAO_ENV_ARG_PARAMETER
    );
}

void CORBA_Contained::version (
    const char * version
    TAO_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  _TAO_CORBA_Contained_Proxy_Impl &proxy =
    this->the_TAO_CORBA_Contained_Proxy_Broker_->select_proxy (this TAO_ENV_ARG_PARAMETER);
  ACE_CHECK;

  proxy.version (
      this,
      version
      TAO_ENV_ARG_PARAMETER
    );
}

CORBA_Container_ptr CORBA_Contained::defined_in (
    TAO_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  _TAO_CORBA_Contained_Proxy_Impl &proxy =
    this->the_TAO_CORBA_Contained_Proxy_Broker_->select_proxy (this TAO_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  return proxy.defined_in (
      this
      TAO_ENV_ARG_PARAMETER
    );
}

char * CORBA_Contained::absolute_name (
    TAO_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  _TAO_CORBA_Contained_Proxy_Impl &proxy =
    this->the_TAO_CORBA_Contained_Proxy_Broker_->select_proxy (this TAO_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  return proxy.absolute_name (
      this
      TAO_ENV_ARG_PARAMETER
    );
}

CORBA_Repository_ptr CORBA_Contained::containing_repository (
    TAO_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  _TAO_CORBA_Contained_Proxy_Impl &proxy =
    this->the_TAO_CORBA_Contained_Proxy_Broker_->select_proxy (this TAO_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  return proxy.containing_repository (
      this
      TAO_ENV_ARG_PARAMETER
    );
}

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 *_tao_void_pointer)
{
  Description *tmp = ACE_static_cast (Description*, _tao_void_pointer);
  delete tmp;
}

CORBA_Contained::Description * CORBA_Contained::describe (
    TAO_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  _TAO_CORBA_Contained_Proxy_Impl &proxy =
    this->the_TAO_CORBA_Contained_Proxy_Broker_->select_proxy (this TAO_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  return proxy.describe (
      this
      TAO_ENV_ARG_PARAMETER
    );
}

void CORBA_Contained::move (
    CORBA_Container_ptr new_container,
    const char * new_name,
    const char * new_version
    TAO_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  _TAO_CORBA_Contained_Proxy_Impl &proxy =
    this->the_TAO_CORBA_Contained_Proxy_Broker_->select_proxy (this TAO_ENV_ARG_PARAMETER);
  ACE_CHECK;

  proxy.move (
      this,
      new_container,
      new_name,
      new_version
      TAO_ENV_ARG_PARAMETER
    );
}

#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
_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::_allocate_buffer (CORBA::ULong length)
{
  CORBA_Contained **tmp = 0;
  tmp = _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::allocbuf (length);

  if (this->buffer_ != 0)
  {
    CORBA_Contained **old = ACE_reinterpret_cast (CORBA_Contained**, this->buffer_);
    for (CORBA::ULong i = 0; i < this->length_; ++i)
      {
        if (!this->release_)
          {
            tmp[i] = CORBA_Contained::_duplicate (old[i]);
          }
        else
          {
            tmp[i] = old[i];
          }
      }

    if (this->release_)
      {
        delete[] old;
      }
  }
  this->buffer_ = tmp;
}

void
_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::_deallocate_buffer (void)
{
  if (this->buffer_ == 0 || this->release_ == 0)
    return;
  CORBA_Contained **tmp = ACE_reinterpret_cast (CORBA_Contained**, this->buffer_);

  for (CORBA::ULong i = 0; i < this->length_; ++i)
    {
      CORBA::release (tmp[i]);
      tmp[i] = CORBA_Contained::_nil ();
    }

  _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::freebuf (tmp);
  this->buffer_ = 0;
}

_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::~_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq (void)
{
  this->_deallocate_buffer ();
}

void
_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::_shrink_buffer (CORBA::ULong nl, CORBA::ULong ol)
{
  CORBA_Contained **tmp = ACE_reinterpret_cast (CORBA_Contained**, this->buffer_);

  for (CORBA::ULong i = nl; i < ol; ++i)
    {
      CORBA::release (tmp[i]);
      tmp[i] = CORBA_Contained::_nil ();
    }
}

void
_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::_downcast (
    void* target,
    CORBA_Object *src
    TAO_ENV_ARG_DECL
  )
{
  CORBA_Contained **tmp = ACE_static_cast (CORBA_Contained**, target);
  *tmp = CORBA_Contained::_narrow (src TAO_ENV_ARG_PARAMETER);
  ACE_CHECK;
}

CORBA_Object*
_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::_upcast (void *src) const
{
  CORBA_Contained **tmp = ACE_static_cast (CORBA_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 *_tao_void_pointer)
{
  CORBA_ContainedSeq *tmp = ACE_static_cast (CORBA_ContainedSeq*, _tao_void_pointer);
  delete tmp;
}


#endif /* end #if !defined */

#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
_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] = tao_CORBA_InterfaceDef_duplicate (old[i]);
          }
        else
          {
            tmp[i] = old[i];
          }
      }

    if (this->release_)
      {
        delete[] old;
      }
  }
  this->buffer_ = tmp;
}

void
_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)
    {
      tao_CORBA_InterfaceDef_release (tmp[i]);
      tmp[i] = tao_CORBA_InterfaceDef_nil ();
    }

  _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::freebuf (tmp);
  this->buffer_ = 0;
}

_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::~_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq (void)
{
  this->_deallocate_buffer ();
}

void
_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)
    {
      tao_CORBA_InterfaceDef_release (tmp[i]);
      tmp[i] = tao_CORBA_InterfaceDef_nil ();
    }
}

void
_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::_downcast (
    void* target,
    CORBA_Object *src
    TAO_ENV_ARG_DECL
  )
{
  CORBA_InterfaceDef **tmp = ACE_static_cast (CORBA_InterfaceDef**, target);
  *tmp = tao_CORBA_InterfaceDef_narrow (src TAO_ENV_ARG_PARAMETER);
  ACE_CHECK;
}

CORBA_Object*
_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::_upcast (void *src) const
{
  return tao_CORBA_InterfaceDef_upcast (src);
}

#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 *_tao_void_pointer)
{
  CORBA_InterfaceDefSeq *tmp = ACE_static_cast (CORBA_InterfaceDefSeq*, _tao_void_pointer);
  delete tmp;
}


#endif /* end #if !defined */

#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
_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] = tao_CORBA_ValueDef_duplicate (old[i]);
          }
        else
          {
            tmp[i] = old[i];
          }
      }

    if (this->release_)
      {
        delete[] old;
      }
  }
  this->buffer_ = tmp;
}

void
_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)
    {
      tao_CORBA_ValueDef_release (tmp[i]);
      tmp[i] = tao_CORBA_ValueDef_nil ();
    }

  _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::freebuf (tmp);
  this->buffer_ = 0;
}

_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::~_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq (void)
{
  this->_deallocate_buffer ();
}

void
_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)
    {
      tao_CORBA_ValueDef_release (tmp[i]);
      tmp[i] = tao_CORBA_ValueDef_nil ();
    }
}

void
_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::_downcast (
    void* target,
    CORBA_Object *src
    TAO_ENV_ARG_DECL
  )
{
  CORBA_ValueDef **tmp = ACE_static_cast (CORBA_ValueDef**, target);
  *tmp = tao_CORBA_ValueDef_narrow (src TAO_ENV_ARG_PARAMETER);
  ACE_CHECK;
}

CORBA_Object*
_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::_upcast (void *src) const
{
  return tao_CORBA_ValueDef_upcast (src);
}

#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 *_tao_void_pointer)
{
  CORBA_ValueDefSeq *tmp = ACE_static_cast (CORBA_ValueDefSeq*, _tao_void_pointer);
  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
_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] = tao_CORBA_AbstractInterfaceDef_duplicate (old[i]);
          }
        else
          {
            tmp[i] = old[i];
          }
      }

    if (this->release_)
      {
        delete[] old;
      }
  }
  this->buffer_ = tmp;
}

void
_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)
    {
      tao_CORBA_AbstractInterfaceDef_release (tmp[i]);
      tmp[i] = tao_CORBA_AbstractInterfaceDef_nil ();
    }

  _TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::freebuf (tmp);
  this->buffer_ = 0;
}

_TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::~_TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq (void)
{
  this->_deallocate_buffer ();
}

void
_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)
    {
      tao_CORBA_AbstractInterfaceDef_release (tmp[i]);
      tmp[i] = tao_CORBA_AbstractInterfaceDef_nil ();
    }
}

void
_TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::_downcast (
    void* target,
    CORBA_Object *src
    TAO_ENV_ARG_DECL
  )
{
  CORBA_AbstractInterfaceDef **tmp = ACE_static_cast (CORBA_AbstractInterfaceDef**, target);
  *tmp = tao_CORBA_AbstractInterfaceDef_narrow (src TAO_ENV_ARG_PARAMETER);
  ACE_CHECK;
}

CORBA_Object*
_TAO_Unbounded_Object_Sequence_CORBA_AbstractInterfaceDefSeq::_upcast (void *src) const
{
  return tao_CORBA_AbstractInterfaceDef_upcast (src);
}

#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 *_tao_void_pointer)
{
  CORBA_AbstractInterfaceDefSeq *tmp = ACE_static_cast (CORBA_AbstractInterfaceDefSeq*, _tao_void_pointer);
  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
_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] = tao_CORBA_LocalInterfaceDef_duplicate (old[i]);
          }
        else
          {
            tmp[i] = old[i];
          }
      }

    if (this->release_)
      {
        delete[] old;
      }
  }
  this->buffer_ = tmp;
}

void
_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)
    {
      tao_CORBA_LocalInterfaceDef_release (tmp[i]);
      tmp[i] = tao_CORBA_LocalInterfaceDef_nil ();
    }

  _TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::freebuf (tmp);
  this->buffer_ = 0;
}

_TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::~_TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq (void)
{
  this->_deallocate_buffer ();
}

void
_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)
    {
      tao_CORBA_LocalInterfaceDef_release (tmp[i]);
      tmp[i] = tao_CORBA_LocalInterfaceDef_nil ();
    }
}

void
_TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::_downcast (
    void* target,
    CORBA_Object *src
    TAO_ENV_ARG_DECL
  )
{
  CORBA_LocalInterfaceDef **tmp = ACE_static_cast (CORBA_LocalInterfaceDef**, target);
  *tmp = tao_CORBA_LocalInterfaceDef_narrow (src TAO_ENV_ARG_PARAMETER);
  ACE_CHECK;
}

CORBA_Object*
_TAO_Unbounded_Object_Sequence_CORBA_LocalInterfaceDefSeq::_upcast (void *src) const
{
  return tao_CORBA_LocalInterfaceDef_upcast (src);
}

#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 *_tao_void_pointer)
{
  CORBA_LocalInterfaceDefSeq *tmp = ACE_static_cast (CORBA_LocalInterfaceDefSeq*, _tao_void_pointer);
  delete tmp;
}


#endif /* end #if !defined */

void CORBA_StructMember::_tao_any_destructor (void *_tao_void_pointer)
{
  CORBA_StructMember *tmp = ACE_static_cast (CORBA_StructMember*, _tao_void_pointer);
  delete tmp;
}


#if !defined (TAO_USE_SEQUENCE_TEMPLATES)

#if !defined (__TAO_UNBOUNDED_SEQUENCE_CORBA_STRUCTMEMBERSEQ_CS_)
#define __TAO_UNBOUNDED_SEQUENCE_CORBA_STRUCTMEMBERSEQ_CS_

void
_TAO_Unbounded_Sequence_CORBA_StructMemberSeq::_allocate_buffer (CORBA::ULong length)
{
  CORBA_StructMember* tmp = 0;
  tmp = _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::allocbuf (length);

  if (this->buffer_ != 0)
  {
    CORBA_StructMember *old = ACE_reinterpret_cast (CORBA_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
_TAO_Unbounded_Sequence_CORBA_StructMemberSeq::_deallocate_buffer (void)
{
  if (this->buffer_ == 0 || this->release_ == 0)
    return;

  CORBA_StructMember *tmp = ACE_reinterpret_cast (CORBA_StructMember *,this->buffer_);

  _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::freebuf (tmp);
  this->buffer_ = 0;
}

_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 *_tao_void_pointer)
{
  CORBA_StructMemberSeq *tmp = ACE_static_cast (CORBA_StructMemberSeq*, _tao_void_pointer);
  delete tmp;
}


#endif /* end #if !defined */

void CORBA_Initializer::_tao_any_destructor (void *_tao_void_pointer)
{
  CORBA_Initializer *tmp = ACE_static_cast (CORBA_Initializer*, _tao_void_pointer);
  delete tmp;
}


#if !defined (TAO_USE_SEQUENCE_TEMPLATES)

#if !defined (__TAO_UNBOUNDED_SEQUENCE_CORBA_INITIALIZERSEQ_CS_)
#define __TAO_UNBOUNDED_SEQUENCE_CORBA_INITIALIZERSEQ_CS_

void
_TAO_Unbounded_Sequence_CORBA_InitializerSeq::_allocate_buffer (CORBA::ULong length)
{
  CORBA_Initializer* tmp = 0;
  tmp = _TAO_Unbounded_Sequence_CORBA_InitializerSeq::allocbuf (length);

  if (this->buffer_ != 0)
  {
    CORBA_Initializer *old = ACE_reinterpret_cast (CORBA_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
_TAO_Unbounded_Sequence_CORBA_InitializerSeq::_deallocate_buffer (void)
{
  if (this->buffer_ == 0 || this->release_ == 0)
    return;

  CORBA_Initializer *tmp = ACE_reinterpret_cast (CORBA_Initializer *,this->buffer_);

  _TAO_Unbounded_Sequence_CORBA_InitializerSeq::freebuf (tmp);
  this->buffer_ = 0;
}

_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 *_tao_void_pointer)
{
  CORBA_InitializerSeq *tmp = ACE_static_cast (CORBA_InitializerSeq*, _tao_void_pointer);
  delete tmp;
}


#endif /* end #if !defined */


void CORBA_UnionMember::_tao_any_destructor (void *_tao_void_pointer)
{
  CORBA_UnionMember *tmp = ACE_static_cast (CORBA_UnionMember*, _tao_void_pointer);
  delete tmp;
}


#if !defined (TAO_USE_SEQUENCE_TEMPLATES)

#if !defined (__TAO_UNBOUNDED_SEQUENCE_CORBA_UNIONMEMBERSEQ_CS_)
#define __TAO_UNBOUNDED_SEQUENCE_CORBA_UNIONMEMBERSEQ_CS_

void
_TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::_allocate_buffer (CORBA::ULong length)
{
  CORBA_UnionMember* tmp = 0;
  tmp = _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::allocbuf (length);

  if (this->buffer_ != 0)
  {
    CORBA_UnionMember *old = ACE_reinterpret_cast (CORBA_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
_TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::_deallocate_buffer (void)
{
  if (this->buffer_ == 0 || this->release_ == 0)
    return;

  CORBA_UnionMember *tmp = ACE_reinterpret_cast (CORBA_UnionMember *,this->buffer_);

  _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::freebuf (tmp);
  this->buffer_ = 0;
}

_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 *_tao_void_pointer)
{
  CORBA_UnionMemberSeq *tmp = ACE_static_cast (CORBA_UnionMemberSeq*, _tao_void_pointer);
  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 *_tao_void_pointer)
{
  CORBA_EnumMemberSeq *tmp = ACE_static_cast (CORBA_EnumMemberSeq*, _tao_void_pointer);
  delete tmp;
}


#endif /* end #if !defined */

CORBA_Container_ptr
tao_CORBA_Container_duplicate (
    CORBA_Container_ptr p
  )
{
  return CORBA_Container::_duplicate (p);
}

void
tao_CORBA_Container_release (
    CORBA_Container_ptr p
  )
{
  CORBA::release (p);
}

CORBA_Container_ptr
tao_CORBA_Container_nil (
    void
  )
{
  return CORBA_Container::_nil ();
}

CORBA_Container_ptr
tao_CORBA_Container_narrow (
    CORBA::Object *p
    TAO_ENV_ARG_DECL
  )
{
  return CORBA_Container::_narrow (p TAO_ENV_ARG_PARAMETER);
}

CORBA::Object *
tao_CORBA_Container_upcast (
    void *src
  )
{
  CORBA_Container **tmp =
    ACE_static_cast (CORBA_Container **, src);
  return *tmp;
}

int CORBA_Container::_tao_class_id = 0;

// *************************************************************
// Operations for class CORBA_Container_var
// *************************************************************

CORBA_Container_var::CORBA_Container_var (void) // default constructor
  : ptr_ (CORBA_Container::_nil ())
{}

::CORBA_Container_ptr
CORBA_Container_var::ptr (void) const
{
  return this->ptr_;
}

CORBA_Container_var::CORBA_Container_var (const ::CORBA_Container_var &p) // copy constructor
  : TAO_Base_var (),
    ptr_ (CORBA_Container::_duplicate (p.ptr ()))
{}

CORBA_Container_var::~CORBA_Container_var (void) // destructor
{
  CORBA::release (this->ptr_);
}

CORBA_Container_var &
CORBA_Container_var::operator= (CORBA_Container_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

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;
}

CORBA_Container_var::operator const ::CORBA_Container_ptr &() const // cast
{
  return this->ptr_;
}

CORBA_Container_var::operator ::CORBA_Container_ptr &() // cast
{
  return this->ptr_;
}

::CORBA_Container_ptr
CORBA_Container_var::operator-> (void) const
{
  return this->ptr_;
}

::CORBA_Container_ptr
CORBA_Container_var::in (void) const
{
  return this->ptr_;
}

::CORBA_Container_ptr &
CORBA_Container_var::inout (void)
{
  return this->ptr_;
}

::CORBA_Container_ptr &
CORBA_Container_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::CORBA_Container::_nil ();
  return this->ptr_;
}

::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;
}

::CORBA_Container_ptr
CORBA_Container_var::tao_duplicate (CORBA_Container_ptr p)
{
  return ::CORBA_Container::_duplicate (p);
}

void
CORBA_Container_var::tao_release (CORBA_Container_ptr p)
{
  CORBA::release (p);
}

::CORBA_Container_ptr
CORBA_Container_var::tao_nil (void)
{
  return ::CORBA_Container::_nil ();
}

::CORBA_Container_ptr
CORBA_Container_var::tao_narrow (
    CORBA::Object *p
    TAO_ENV_ARG_DECL
  )
{
  return ::CORBA_Container::_narrow (p TAO_ENV_ARG_PARAMETER);
}

CORBA::Object *
CORBA_Container_var::tao_upcast (void *src)
{
  CORBA_Container **tmp =
    ACE_static_cast (CORBA_Container **, src);
  return *tmp;
}

// *************************************************************
// Operations for class CORBA_Container_out
// *************************************************************

CORBA_Container_out::CORBA_Container_out (CORBA_Container_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = ::CORBA_Container::_nil ();
}

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 ();
}

CORBA_Container_out::CORBA_Container_out (const ::CORBA_Container_out &p) // copy constructor
  : ptr_ (ACE_const_cast (CORBA_Container_out &, p).ptr_)
{}

::CORBA_Container_out &
CORBA_Container_out::operator= (const ::CORBA_Container_out &p)
{
  this->ptr_ = ACE_const_cast (CORBA_Container_out&, p).ptr_;
  return *this;
}

CORBA_Container_out &
CORBA_Container_out::operator= (const ::CORBA_Container_var &p)
{
  this->ptr_ = ::CORBA_Container::_duplicate (p.ptr ());
  return *this;
}

CORBA_Container_out &
CORBA_Container_out::operator= (CORBA_Container_ptr p)
{
  this->ptr_ = p;
  return *this;
}

CORBA_Container_out::operator ::CORBA_Container_ptr &() // cast
{
  return this->ptr_;
}

::CORBA_Container_ptr &
CORBA_Container_out::ptr (void) // ptr
{
  return this->ptr_;
}

::CORBA_Container_ptr
CORBA_Container_out::operator-> (void)
{
  return this->ptr_;
}


#if (TAO_HAS_INTERCEPTORS == 1)
class TAO_ClientRequestInfo_CORBA_Container_lookup : public TAO_ClientRequestInfo_i
{
public:
  TAO_ClientRequestInfo_CORBA_Container_lookup (
      TAO_GIOP_Invocation *_tao_invocation,
      CORBA::Object_ptr _tao_target,
      const char * search_name
      TAO_ENV_ARG_DECL_WITH_DEFAULTS);


  virtual Dynamic::ParameterList * arguments (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  virtual Dynamic::ExceptionList * exceptions (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  virtual CORBA::Any * result (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  void result (CORBA_Contained_ptr result);

private:
  TAO_ClientRequestInfo_CORBA_Container_lookup (const TAO_ClientRequestInfo_CORBA_Container_lookup &);
  void operator= (const TAO_ClientRequestInfo_CORBA_Container_lookup &);

  const char * search_name_;
  CORBA_Contained_ptr _result;
};

TAO_ClientRequestInfo_CORBA_Container_lookup::TAO_ClientRequestInfo_CORBA_Container_lookup (
    TAO_GIOP_Invocation *_tao_invocation,
    CORBA::Object_ptr _tao_target,
    const char * search_name
    TAO_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ClientRequestInfo_i (_tao_invocation, _tao_target),
    search_name_ (search_name)
{}

Dynamic::ParameterList *
TAO_ClientRequestInfo_CORBA_Container_lookup::arguments (TAO_ENV_SINGLE_ARG_DECL)
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the argument list on demand.
  Dynamic::ParameterList *parameter_list =
    TAO_RequestInfo_Util::make_parameter_list (TAO_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  Dynamic::ParameterList_var safe_parameter_list = parameter_list;

  parameter_list->length (1);
  CORBA::ULong len = 0;

    (*parameter_list)[len].argument <<= search_name_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;

  return safe_parameter_list._retn ();
}

Dynamic::ExceptionList *
TAO_ClientRequestInfo_CORBA_Container_lookup::exceptions (TAO_ENV_SINGLE_ARG_DECL)
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the exception list on demand.
  Dynamic::ExceptionList *exception_list =
    TAO_RequestInfo_Util::make_exception_list (TAO_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  return exception_list;
}


CORBA::Any *
TAO_ClientRequestInfo_CORBA_Container_lookup::result (TAO_ENV_SINGLE_ARG_DECL)
  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 TAO_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  CORBA::Any_var safe_result_any = result_any;

  (*result_any) <<= this->_result;
  return safe_result_any._retn ();
}

void
TAO_ClientRequestInfo_CORBA_Container_lookup::result (CORBA_Contained_ptr result)
{
  // update the result
  this->_result = result;
}

class TAO_ClientRequestInfo_CORBA_Container_contents : public TAO_ClientRequestInfo_i
{
public:
  TAO_ClientRequestInfo_CORBA_Container_contents (
      TAO_GIOP_Invocation *_tao_invocation,
      CORBA::Object_ptr _tao_target,
      CORBA::DefinitionKind & limit_type,
      const CORBA::Boolean & exclude_inherited
      TAO_ENV_ARG_DECL_WITH_DEFAULTS);


  virtual Dynamic::ParameterList * arguments (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  virtual Dynamic::ExceptionList * exceptions (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  virtual CORBA::Any * result (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  void result (CORBA_ContainedSeq * result);

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_;
  CORBA_ContainedSeq * _result;
};

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
    TAO_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ClientRequestInfo_i (_tao_invocation, _tao_target),
    limit_type_ (limit_type),
    exclude_inherited_ (exclude_inherited)
{}

Dynamic::ParameterList *
TAO_ClientRequestInfo_CORBA_Container_contents::arguments (TAO_ENV_SINGLE_ARG_DECL)
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the argument list on demand.
  Dynamic::ParameterList *parameter_list =
    TAO_RequestInfo_Util::make_parameter_list (TAO_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  Dynamic::ParameterList_var safe_parameter_list = parameter_list;

  parameter_list->length (2);
  CORBA::ULong len = 0;

    (*parameter_list)[len].argument <<=  this->limit_type_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
    (*parameter_list)[len].argument <<= CORBA::Any::from_boolean (this->exclude_inherited_);
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;

  return safe_parameter_list._retn ();
}

Dynamic::ExceptionList *
TAO_ClientRequestInfo_CORBA_Container_contents::exceptions (TAO_ENV_SINGLE_ARG_DECL)
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the exception list on demand.
  Dynamic::ExceptionList *exception_list =
    TAO_RequestInfo_Util::make_exception_list (TAO_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  return exception_list;
}


CORBA::Any *
TAO_ClientRequestInfo_CORBA_Container_contents::result (TAO_ENV_SINGLE_ARG_DECL)
  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 TAO_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  CORBA::Any_var safe_result_any = result_any;

  (*result_any) <<= this->_result;
  return safe_result_any._retn ();
}

void
TAO_ClientRequestInfo_CORBA_Container_contents::result (CORBA_ContainedSeq * result)
{
  // update the result
  this->_result = result;
}

class TAO_ClientRequestInfo_CORBA_Container_lookup_name : public TAO_ClientRequestInfo_i
{
public:
  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
      TAO_ENV_ARG_DECL_WITH_DEFAULTS);


  virtual Dynamic::ParameterList * arguments (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  virtual Dynamic::ExceptionList * exceptions (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  virtual CORBA::Any * result (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  void result (CORBA_ContainedSeq * result);

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_;
  CORBA_ContainedSeq * _result;
};

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
    TAO_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ClientRequestInfo_i (_tao_invocation, _tao_target),
    search_name_ (search_name),
    levels_to_search_ (levels_to_search),
    limit_type_ (limit_type),
    exclude_inherited_ (exclude_inherited)
{}

Dynamic::ParameterList *
TAO_ClientRequestInfo_CORBA_Container_lookup_name::arguments (TAO_ENV_SINGLE_ARG_DECL)
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the argument list on demand.
  Dynamic::ParameterList *parameter_list =
    TAO_RequestInfo_Util::make_parameter_list (TAO_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  Dynamic::ParameterList_var safe_parameter_list = parameter_list;

  parameter_list->length (4);
  CORBA::ULong len = 0;

    (*parameter_list)[len].argument <<= search_name_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
    (*parameter_list)[len].argument <<= levels_to_search_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
    (*parameter_list)[len].argument <<=  this->limit_type_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
    (*parameter_list)[len].argument <<= CORBA::Any::from_boolean (this->exclude_inherited_);
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;

  return safe_parameter_list._retn ();
}

Dynamic::ExceptionList *
TAO_ClientRequestInfo_CORBA_Container_lookup_name::exceptions (TAO_ENV_SINGLE_ARG_DECL)
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the exception list on demand.
  Dynamic::ExceptionList *exception_list =
    TAO_RequestInfo_Util::make_exception_list (TAO_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  return exception_list;
}


CORBA::Any *
TAO_ClientRequestInfo_CORBA_Container_lookup_name::result (TAO_ENV_SINGLE_ARG_DECL)
  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 TAO_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  CORBA::Any_var safe_result_any = result_any;

  (*result_any) <<= this->_result;
  return safe_result_any._retn ();
}

void
TAO_ClientRequestInfo_CORBA_Container_lookup_name::result (CORBA_ContainedSeq * result)
{
  // update the result
  this->_result = result;
}

class TAO_ClientRequestInfo_CORBA_Container_describe_contents : public TAO_ClientRequestInfo_i
{
public:
  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
      TAO_ENV_ARG_DECL_WITH_DEFAULTS);


  virtual Dynamic::ParameterList * arguments (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  virtual Dynamic::ExceptionList * exceptions (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  virtual CORBA::Any * result (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  void result (CORBA_Container::DescriptionSeq * result);

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_;
  CORBA_Container::DescriptionSeq * _result;
};

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
    TAO_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ClientRequestInfo_i (_tao_invocation, _tao_target),
    limit_type_ (limit_type),
    exclude_inherited_ (exclude_inherited),
    max_returned_objs_ (max_returned_objs)
{}

Dynamic::ParameterList *
TAO_ClientRequestInfo_CORBA_Container_describe_contents::arguments (TAO_ENV_SINGLE_ARG_DECL)
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the argument list on demand.
  Dynamic::ParameterList *parameter_list =
    TAO_RequestInfo_Util::make_parameter_list (TAO_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  Dynamic::ParameterList_var safe_parameter_list = parameter_list;

  parameter_list->length (3);
  CORBA::ULong len = 0;

    (*parameter_list)[len].argument <<=  this->limit_type_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
    (*parameter_list)[len].argument <<= CORBA::Any::from_boolean (this->exclude_inherited_);
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
    (*parameter_list)[len].argument <<= max_returned_objs_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;

  return safe_parameter_list._retn ();
}

Dynamic::ExceptionList *
TAO_ClientRequestInfo_CORBA_Container_describe_contents::exceptions (TAO_ENV_SINGLE_ARG_DECL)
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the exception list on demand.
  Dynamic::ExceptionList *exception_list =
    TAO_RequestInfo_Util::make_exception_list (TAO_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  return exception_list;
}


CORBA::Any *
TAO_ClientRequestInfo_CORBA_Container_describe_contents::result (TAO_ENV_SINGLE_ARG_DECL)
  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 TAO_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  CORBA::Any_var safe_result_any = result_any;

  (*result_any) <<= this->_result;
  return safe_result_any._retn ();
}

void
TAO_ClientRequestInfo_CORBA_Container_describe_contents::result (CORBA_Container::DescriptionSeq * result)
{
  // update the result
  this->_result = result;
}

class TAO_ClientRequestInfo_CORBA_Container_create_module : public TAO_ClientRequestInfo_i
{
public:
  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
      TAO_ENV_ARG_DECL_WITH_DEFAULTS);


  virtual Dynamic::ParameterList * arguments (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  virtual Dynamic::ExceptionList * exceptions (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  virtual CORBA::Any * result (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  void result (CORBA_ModuleDef_ptr result);

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_;
  CORBA_ModuleDef_ptr _result;
};

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
    TAO_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ClientRequestInfo_i (_tao_invocation, _tao_target),
    id_ (id),
    name_ (name),
    version_ (version)
{}

Dynamic::ParameterList *
TAO_ClientRequestInfo_CORBA_Container_create_module::arguments (TAO_ENV_SINGLE_ARG_DECL)
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the argument list on demand.
  Dynamic::ParameterList *parameter_list =
    TAO_RequestInfo_Util::make_parameter_list (TAO_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  Dynamic::ParameterList_var safe_parameter_list = parameter_list;

  parameter_list->length (3);
  CORBA::ULong len = 0;

    (*parameter_list)[len].argument <<= id_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
    (*parameter_list)[len].argument <<= name_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
    (*parameter_list)[len].argument <<= version_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;

  return safe_parameter_list._retn ();
}

Dynamic::ExceptionList *
TAO_ClientRequestInfo_CORBA_Container_create_module::exceptions (TAO_ENV_SINGLE_ARG_DECL)
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the exception list on demand.
  Dynamic::ExceptionList *exception_list =
    TAO_RequestInfo_Util::make_exception_list (TAO_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  return exception_list;
}


CORBA::Any *
TAO_ClientRequestInfo_CORBA_Container_create_module::result (TAO_ENV_SINGLE_ARG_DECL)
  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 TAO_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  CORBA::Any_var safe_result_any = result_any;

  (*result_any) <<= this->_result;
  return safe_result_any._retn ();
}

void
TAO_ClientRequestInfo_CORBA_Container_create_module::result (CORBA_ModuleDef_ptr result)
{
  // update the result
  this->_result = result;
}

class TAO_ClientRequestInfo_CORBA_Container_create_constant : public TAO_ClientRequestInfo_i
{
public:
  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
      TAO_ENV_ARG_DECL_WITH_DEFAULTS);


  virtual Dynamic::ParameterList * arguments (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  virtual Dynamic::ExceptionList * exceptions (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  virtual CORBA::Any * result (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  void result (CORBA_ConstantDef_ptr result);

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_;
  CORBA_ConstantDef_ptr _result;
};

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
    TAO_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ClientRequestInfo_i (_tao_invocation, _tao_target),
    id_ (id),
    name_ (name),
    version_ (version),
    type_ (type),
    value_ (value)
{}

Dynamic::ParameterList *
TAO_ClientRequestInfo_CORBA_Container_create_constant::arguments (TAO_ENV_SINGLE_ARG_DECL)
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the argument list on demand.
  Dynamic::ParameterList *parameter_list =
    TAO_RequestInfo_Util::make_parameter_list (TAO_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  Dynamic::ParameterList_var safe_parameter_list = parameter_list;

  parameter_list->length (5);
  CORBA::ULong len = 0;

    (*parameter_list)[len].argument <<= id_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
    (*parameter_list)[len].argument <<= name_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
    (*parameter_list)[len].argument <<= version_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
    (*parameter_list)[len].argument <<=  this->type_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
    (*parameter_list)[len].argument <<= value_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;

  return safe_parameter_list._retn ();
}

Dynamic::ExceptionList *
TAO_ClientRequestInfo_CORBA_Container_create_constant::exceptions (TAO_ENV_SINGLE_ARG_DECL)
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the exception list on demand.
  Dynamic::ExceptionList *exception_list =
    TAO_RequestInfo_Util::make_exception_list (TAO_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  return exception_list;
}


CORBA::Any *
TAO_ClientRequestInfo_CORBA_Container_create_constant::result (TAO_ENV_SINGLE_ARG_DECL)
  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 TAO_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  CORBA::Any_var safe_result_any = result_any;

  (*result_any) <<= this->_result;
  return safe_result_any._retn ();
}

void
TAO_ClientRequestInfo_CORBA_Container_create_constant::result (CORBA_ConstantDef_ptr result)
{
  // update the result
  this->_result = result;
}

class TAO_ClientRequestInfo_CORBA_Container_create_struct : public TAO_ClientRequestInfo_i
{
public:
  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
      TAO_ENV_ARG_DECL_WITH_DEFAULTS);


  virtual Dynamic::ParameterList * arguments (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  virtual Dynamic::ExceptionList * exceptions (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  virtual CORBA::Any * result (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  void result (CORBA_StructDef_ptr result);

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_;
  CORBA_StructDef_ptr _result;
};

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
    TAO_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ClientRequestInfo_i (_tao_invocation, _tao_target),
    id_ (id),
    name_ (name),
    version_ (version),
    members_ (members)
{}

Dynamic::ParameterList *
TAO_ClientRequestInfo_CORBA_Container_create_struct::arguments (TAO_ENV_SINGLE_ARG_DECL)
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the argument list on demand.
  Dynamic::ParameterList *parameter_list =
    TAO_RequestInfo_Util::make_parameter_list (TAO_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  Dynamic::ParameterList_var safe_parameter_list = parameter_list;

  parameter_list->length (4);
  CORBA::ULong len = 0;

    (*parameter_list)[len].argument <<= id_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
    (*parameter_list)[len].argument <<= name_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
    (*parameter_list)[len].argument <<= version_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
    (*parameter_list)[len].argument <<=  this->members_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;

  return safe_parameter_list._retn ();
}

Dynamic::ExceptionList *
TAO_ClientRequestInfo_CORBA_Container_create_struct::exceptions (TAO_ENV_SINGLE_ARG_DECL)
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the exception list on demand.
  Dynamic::ExceptionList *exception_list =
    TAO_RequestInfo_Util::make_exception_list (TAO_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  return exception_list;
}


CORBA::Any *
TAO_ClientRequestInfo_CORBA_Container_create_struct::result (TAO_ENV_SINGLE_ARG_DECL)
  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 TAO_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  CORBA::Any_var safe_result_any = result_any;

  (*result_any) <<= this->_result;
  return safe_result_any._retn ();
}

void
TAO_ClientRequestInfo_CORBA_Container_create_struct::result (CORBA_StructDef_ptr result)
{
  // update the result
  this->_result = result;
}

class TAO_ClientRequestInfo_CORBA_Container_create_union : public TAO_ClientRequestInfo_i
{
public:
  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
      TAO_ENV_ARG_DECL_WITH_DEFAULTS);


  virtual Dynamic::ParameterList * arguments (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  virtual Dynamic::ExceptionList * exceptions (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  virtual CORBA::Any * result (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  void result (CORBA_UnionDef_ptr result);

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_;
  CORBA_UnionDef_ptr _result;
};

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
    TAO_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ClientRequestInfo_i (_tao_invocation, _tao_target),
    id_ (id),
    name_ (name),
    version_ (version),
    discriminator_type_ (discriminator_type),
    members_ (members)
{}

Dynamic::ParameterList *
TAO_ClientRequestInfo_CORBA_Container_create_union::arguments (TAO_ENV_SINGLE_ARG_DECL)
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the argument list on demand.
  Dynamic::ParameterList *parameter_list =
    TAO_RequestInfo_Util::make_parameter_list (TAO_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  Dynamic::ParameterList_var safe_parameter_list = parameter_list;

  parameter_list->length (5);
  CORBA::ULong len = 0;

    (*parameter_list)[len].argument <<= id_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
    (*parameter_list)[len].argument <<= name_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
    (*parameter_list)[len].argument <<= version_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
    (*parameter_list)[len].argument <<=  this->discriminator_type_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
    (*parameter_list)[len].argument <<=  this->members_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;

  return safe_parameter_list._retn ();
}

Dynamic::ExceptionList *
TAO_ClientRequestInfo_CORBA_Container_create_union::exceptions (TAO_ENV_SINGLE_ARG_DECL)
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the exception list on demand.
  Dynamic::ExceptionList *exception_list =
    TAO_RequestInfo_Util::make_exception_list (TAO_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  return exception_list;
}


CORBA::Any *
TAO_ClientRequestInfo_CORBA_Container_create_union::result (TAO_ENV_SINGLE_ARG_DECL)
  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 TAO_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  CORBA::Any_var safe_result_any = result_any;

  (*result_any) <<= this->_result;
  return safe_result_any._retn ();
}

void
TAO_ClientRequestInfo_CORBA_Container_create_union::result (CORBA_UnionDef_ptr result)
{
  // update the result
  this->_result = result;
}

class TAO_ClientRequestInfo_CORBA_Container_create_enum : public TAO_ClientRequestInfo_i
{
public:
  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
      TAO_ENV_ARG_DECL_WITH_DEFAULTS);


  virtual Dynamic::ParameterList * arguments (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  virtual Dynamic::ExceptionList * exceptions (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  virtual CORBA::Any * result (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  void result (CORBA_EnumDef_ptr result);

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_;
  CORBA_EnumDef_ptr _result;
};

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
    TAO_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ClientRequestInfo_i (_tao_invocation, _tao_target),
    id_ (id),
    name_ (name),
    version_ (version),
    members_ (members)
{}

Dynamic::ParameterList *
TAO_ClientRequestInfo_CORBA_Container_create_enum::arguments (TAO_ENV_SINGLE_ARG_DECL)
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the argument list on demand.
  Dynamic::ParameterList *parameter_list =
    TAO_RequestInfo_Util::make_parameter_list (TAO_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  Dynamic::ParameterList_var safe_parameter_list = parameter_list;

  parameter_list->length (4);
  CORBA::ULong len = 0;

    (*parameter_list)[len].argument <<= id_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
    (*parameter_list)[len].argument <<= name_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
    (*parameter_list)[len].argument <<= version_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
    (*parameter_list)[len].argument <<=  this->members_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;

  return safe_parameter_list._retn ();
}

Dynamic::ExceptionList *
TAO_ClientRequestInfo_CORBA_Container_create_enum::exceptions (TAO_ENV_SINGLE_ARG_DECL)
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the exception list on demand.
  Dynamic::ExceptionList *exception_list =
    TAO_RequestInfo_Util::make_exception_list (TAO_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  return exception_list;
}


CORBA::Any *
TAO_ClientRequestInfo_CORBA_Container_create_enum::result (TAO_ENV_SINGLE_ARG_DECL)
  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 TAO_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  CORBA::Any_var safe_result_any = result_any;

  (*result_any) <<= this->_result;
  return safe_result_any._retn ();
}

void
TAO_ClientRequestInfo_CORBA_Container_create_enum::result (CORBA_EnumDef_ptr result)
{
  // update the result
  this->_result = result;
}

class TAO_ClientRequestInfo_CORBA_Container_create_alias : public TAO_ClientRequestInfo_i
{
public:
  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
      TAO_ENV_ARG_DECL_WITH_DEFAULTS);


  virtual Dynamic::ParameterList * arguments (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  virtual Dynamic::ExceptionList * exceptions (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  virtual CORBA::Any * result (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  void result (CORBA_AliasDef_ptr result);

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_;
  CORBA_AliasDef_ptr _result;
};

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
    TAO_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ClientRequestInfo_i (_tao_invocation, _tao_target),
    id_ (id),
    name_ (name),
    version_ (version),
    original_type_ (original_type)
{}

Dynamic::ParameterList *
TAO_ClientRequestInfo_CORBA_Container_create_alias::arguments (TAO_ENV_SINGLE_ARG_DECL)
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the argument list on demand.
  Dynamic::ParameterList *parameter_list =
    TAO_RequestInfo_Util::make_parameter_list (TAO_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  Dynamic::ParameterList_var safe_parameter_list = parameter_list;

  parameter_list->length (4);
  CORBA::ULong len = 0;

    (*parameter_list)[len].argument <<= id_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
    (*parameter_list)[len].argument <<= name_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
    (*parameter_list)[len].argument <<= version_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
    (*parameter_list)[len].argument <<=  this->original_type_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;

  return safe_parameter_list._retn ();
}

Dynamic::ExceptionList *
TAO_ClientRequestInfo_CORBA_Container_create_alias::exceptions (TAO_ENV_SINGLE_ARG_DECL)
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the exception list on demand.
  Dynamic::ExceptionList *exception_list =
    TAO_RequestInfo_Util::make_exception_list (TAO_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  return exception_list;
}


CORBA::Any *
TAO_ClientRequestInfo_CORBA_Container_create_alias::result (TAO_ENV_SINGLE_ARG_DECL)
  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 TAO_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  CORBA::Any_var safe_result_any = result_any;

  (*result_any) <<= this->_result;
  return safe_result_any._retn ();
}

void
TAO_ClientRequestInfo_CORBA_Container_create_alias::result (CORBA_AliasDef_ptr result)
{
  // update the result
  this->_result = result;
}

class TAO_ClientRequestInfo_CORBA_Container_create_interface : public TAO_ClientRequestInfo_i
{
public:
  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
      TAO_ENV_ARG_DECL_WITH_DEFAULTS);


  virtual Dynamic::ParameterList * arguments (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  virtual Dynamic::ExceptionList * exceptions (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  virtual CORBA::Any * result (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  void result (CORBA_InterfaceDef_ptr result);

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_;
  CORBA_InterfaceDef_ptr _result;
};

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
    TAO_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ClientRequestInfo_i (_tao_invocation, _tao_target),
    id_ (id),
    name_ (name),
    version_ (version),
    base_interfaces_ (base_interfaces)
{}

Dynamic::ParameterList *
TAO_ClientRequestInfo_CORBA_Container_create_interface::arguments (TAO_ENV_SINGLE_ARG_DECL)
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the argument list on demand.
  Dynamic::ParameterList *parameter_list =
    TAO_RequestInfo_Util::make_parameter_list (TAO_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  Dynamic::ParameterList_var safe_parameter_list = parameter_list;

  parameter_list->length (4);
  CORBA::ULong len = 0;

    (*parameter_list)[len].argument <<= id_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
    (*parameter_list)[len].argument <<= name_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
    (*parameter_list)[len].argument <<= version_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
    (*parameter_list)[len].argument <<=  this->base_interfaces_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;

  return safe_parameter_list._retn ();
}

Dynamic::ExceptionList *
TAO_ClientRequestInfo_CORBA_Container_create_interface::exceptions (TAO_ENV_SINGLE_ARG_DECL)
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the exception list on demand.
  Dynamic::ExceptionList *exception_list =
    TAO_RequestInfo_Util::make_exception_list (TAO_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  return exception_list;
}


CORBA::Any *
TAO_ClientRequestInfo_CORBA_Container_create_interface::result (TAO_ENV_SINGLE_ARG_DECL)
  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 TAO_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  CORBA::Any_var safe_result_any = result_any;

  (*result_any) <<= this->_result;
  return safe_result_any._retn ();
}

void
TAO_ClientRequestInfo_CORBA_Container_create_interface::result (CORBA_InterfaceDef_ptr result)
{
  // update the result
  this->_result = result;
}

class TAO_ClientRequestInfo_CORBA_Container_create_value : public TAO_ClientRequestInfo_i
{
public:
  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
      TAO_ENV_ARG_DECL_WITH_DEFAULTS);


  virtual Dynamic::ParameterList * arguments (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  virtual Dynamic::ExceptionList * exceptions (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  virtual CORBA::Any * result (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  void result (CORBA_ValueDef_ptr result);

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_;
  CORBA_ValueDef_ptr _result;
};

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
    TAO_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ClientRequestInfo_i (_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 *
TAO_ClientRequestInfo_CORBA_Container_create_value::arguments (TAO_ENV_SINGLE_ARG_DECL)
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the argument list on demand.
  Dynamic::ParameterList *parameter_list =
    TAO_RequestInfo_Util::make_parameter_list (TAO_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  Dynamic::ParameterList_var safe_parameter_list = parameter_list;

  parameter_list->length (10);
  CORBA::ULong len = 0;

    (*parameter_list)[len].argument <<= id_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
    (*parameter_list)[len].argument <<= name_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
    (*parameter_list)[len].argument <<= version_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
    (*parameter_list)[len].argument <<= CORBA::Any::from_boolean (this->is_custom_);
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
    (*parameter_list)[len].argument <<= CORBA::Any::from_boolean (this->is_abstract_);
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
    (*parameter_list)[len].argument <<=  this->base_value_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
    (*parameter_list)[len].argument <<= CORBA::Any::from_boolean (this->is_truncatable_);
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
    (*parameter_list)[len].argument <<=  this->abstract_base_values_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
    (*parameter_list)[len].argument <<=  this->supported_interfaces_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
    (*parameter_list)[len].argument <<=  this->initializers_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;

  return safe_parameter_list._retn ();
}

Dynamic::ExceptionList *
TAO_ClientRequestInfo_CORBA_Container_create_value::exceptions (TAO_ENV_SINGLE_ARG_DECL)
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the exception list on demand.
  Dynamic::ExceptionList *exception_list =
    TAO_RequestInfo_Util::make_exception_list (TAO_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  return exception_list;
}


CORBA::Any *
TAO_ClientRequestInfo_CORBA_Container_create_value::result (TAO_ENV_SINGLE_ARG_DECL)
  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 TAO_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  CORBA::Any_var safe_result_any = result_any;

  (*result_any) <<= this->_result;
  return safe_result_any._retn ();
}

void
TAO_ClientRequestInfo_CORBA_Container_create_value::result (CORBA_ValueDef_ptr result)
{
  // update the result
  this->_result = result;
}

class TAO_ClientRequestInfo_CORBA_Container_create_value_box : public TAO_ClientRequestInfo_i
{
public:
  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
      TAO_ENV_ARG_DECL_WITH_DEFAULTS);


  virtual Dynamic::ParameterList * arguments (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  virtual Dynamic::ExceptionList * exceptions (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  virtual CORBA::Any * result (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  void result (CORBA_ValueBoxDef_ptr result);

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_;
  CORBA_ValueBoxDef_ptr _result;
};

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
    TAO_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ClientRequestInfo_i (_tao_invocation, _tao_target),
    id_ (id),
    name_ (name),
    version_ (version),
    original_type_def_ (original_type_def)
{}

Dynamic::ParameterList *
TAO_ClientRequestInfo_CORBA_Container_create_value_box::arguments (TAO_ENV_SINGLE_ARG_DECL)
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the argument list on demand.
  Dynamic::ParameterList *parameter_list =
    TAO_RequestInfo_Util::make_parameter_list (TAO_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  Dynamic::ParameterList_var safe_parameter_list = parameter_list;

  parameter_list->length (4);
  CORBA::ULong len = 0;

    (*parameter_list)[len].argument <<= id_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
    (*parameter_list)[len].argument <<= name_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
    (*parameter_list)[len].argument <<= version_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
    (*parameter_list)[len].argument <<=  this->original_type_def_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;

  return safe_parameter_list._retn ();
}

Dynamic::ExceptionList *
TAO_ClientRequestInfo_CORBA_Container_create_value_box::exceptions (TAO_ENV_SINGLE_ARG_DECL)
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the exception list on demand.
  Dynamic::ExceptionList *exception_list =
    TAO_RequestInfo_Util::make_exception_list (TAO_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  return exception_list;
}


CORBA::Any *
TAO_ClientRequestInfo_CORBA_Container_create_value_box::result (TAO_ENV_SINGLE_ARG_DECL)
  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 TAO_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  CORBA::Any_var safe_result_any = result_any;

  (*result_any) <<= this->_result;
  return safe_result_any._retn ();
}

void
TAO_ClientRequestInfo_CORBA_Container_create_value_box::result (CORBA_ValueBoxDef_ptr result)
{
  // update the result
  this->_result = result;
}

class TAO_ClientRequestInfo_CORBA_Container_create_exception : public TAO_ClientRequestInfo_i
{
public:
  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
      TAO_ENV_ARG_DECL_WITH_DEFAULTS);


  virtual Dynamic::ParameterList * arguments (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  virtual Dynamic::ExceptionList * exceptions (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  virtual CORBA::Any * result (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  void result (CORBA_ExceptionDef_ptr result);

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_;
  CORBA_ExceptionDef_ptr _result;
};

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
    TAO_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ClientRequestInfo_i (_tao_invocation, _tao_target),
    id_ (id),
    name_ (name),
    version_ (version),
    members_ (members)
{}

Dynamic::ParameterList *
TAO_ClientRequestInfo_CORBA_Container_create_exception::arguments (TAO_ENV_SINGLE_ARG_DECL)
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the argument list on demand.
  Dynamic::ParameterList *parameter_list =
    TAO_RequestInfo_Util::make_parameter_list (TAO_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  Dynamic::ParameterList_var safe_parameter_list = parameter_list;

  parameter_list->length (4);
  CORBA::ULong len = 0;

    (*parameter_list)[len].argument <<= id_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
    (*parameter_list)[len].argument <<= name_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
    (*parameter_list)[len].argument <<= version_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
    (*parameter_list)[len].argument <<=  this->members_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;

  return safe_parameter_list._retn ();
}

Dynamic::ExceptionList *
TAO_ClientRequestInfo_CORBA_Container_create_exception::exceptions (TAO_ENV_SINGLE_ARG_DECL)
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the exception list on demand.
  Dynamic::ExceptionList *exception_list =
    TAO_RequestInfo_Util::make_exception_list (TAO_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  return exception_list;
}


CORBA::Any *
TAO_ClientRequestInfo_CORBA_Container_create_exception::result (TAO_ENV_SINGLE_ARG_DECL)
  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 TAO_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  CORBA::Any_var safe_result_any = result_any;

  (*result_any) <<= this->_result;
  return safe_result_any._retn ();
}

void
TAO_ClientRequestInfo_CORBA_Container_create_exception::result (CORBA_ExceptionDef_ptr result)
{
  // update the result
  this->_result = result;
}

class TAO_ClientRequestInfo_CORBA_Container_create_native : public TAO_ClientRequestInfo_i
{
public:
  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
      TAO_ENV_ARG_DECL_WITH_DEFAULTS);


  virtual Dynamic::ParameterList * arguments (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  virtual Dynamic::ExceptionList * exceptions (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  virtual CORBA::Any * result (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  void result (CORBA_NativeDef_ptr result);

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_;
  CORBA_NativeDef_ptr _result;
};

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
    TAO_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ClientRequestInfo_i (_tao_invocation, _tao_target),
    id_ (id),
    name_ (name),
    version_ (version)
{}

Dynamic::ParameterList *
TAO_ClientRequestInfo_CORBA_Container_create_native::arguments (TAO_ENV_SINGLE_ARG_DECL)
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the argument list on demand.
  Dynamic::ParameterList *parameter_list =
    TAO_RequestInfo_Util::make_parameter_list (TAO_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  Dynamic::ParameterList_var safe_parameter_list = parameter_list;

  parameter_list->length (3);
  CORBA::ULong len = 0;

    (*parameter_list)[len].argument <<= id_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
    (*parameter_list)[len].argument <<= name_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
    (*parameter_list)[len].argument <<= version_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;

  return safe_parameter_list._retn ();
}

Dynamic::ExceptionList *
TAO_ClientRequestInfo_CORBA_Container_create_native::exceptions (TAO_ENV_SINGLE_ARG_DECL)
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the exception list on demand.
  Dynamic::ExceptionList *exception_list =
    TAO_RequestInfo_Util::make_exception_list (TAO_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  return exception_list;
}


CORBA::Any *
TAO_ClientRequestInfo_CORBA_Container_create_native::result (TAO_ENV_SINGLE_ARG_DECL)
  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 TAO_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  CORBA::Any_var safe_result_any = result_any;

  (*result_any) <<= this->_result;
  return safe_result_any._retn ();
}

void
TAO_ClientRequestInfo_CORBA_Container_create_native::result (CORBA_NativeDef_ptr result)
{
  // update the result
  this->_result = result;
}

class TAO_ClientRequestInfo_CORBA_Container_create_abstract_interface : public TAO_ClientRequestInfo_i
{
public:
  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
      TAO_ENV_ARG_DECL_WITH_DEFAULTS);


  virtual Dynamic::ParameterList * arguments (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  virtual Dynamic::ExceptionList * exceptions (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  virtual CORBA::Any * result (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  void result (CORBA_AbstractInterfaceDef_ptr result);

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_;
  CORBA_AbstractInterfaceDef_ptr _result;
};

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
    TAO_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ClientRequestInfo_i (_tao_invocation, _tao_target),
    id_ (id),
    name_ (name),
    version_ (version),
    base_interfaces_ (base_interfaces)
{}

Dynamic::ParameterList *
TAO_ClientRequestInfo_CORBA_Container_create_abstract_interface::arguments (TAO_ENV_SINGLE_ARG_DECL)
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the argument list on demand.
  Dynamic::ParameterList *parameter_list =
    TAO_RequestInfo_Util::make_parameter_list (TAO_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  Dynamic::ParameterList_var safe_parameter_list = parameter_list;

  parameter_list->length (4);
  CORBA::ULong len = 0;

    (*parameter_list)[len].argument <<= id_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
    (*parameter_list)[len].argument <<= name_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
    (*parameter_list)[len].argument <<= version_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
    (*parameter_list)[len].argument <<=  this->base_interfaces_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;

  return safe_parameter_list._retn ();
}

Dynamic::ExceptionList *
TAO_ClientRequestInfo_CORBA_Container_create_abstract_interface::exceptions (TAO_ENV_SINGLE_ARG_DECL)
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the exception list on demand.
  Dynamic::ExceptionList *exception_list =
    TAO_RequestInfo_Util::make_exception_list (TAO_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  return exception_list;
}


CORBA::Any *
TAO_ClientRequestInfo_CORBA_Container_create_abstract_interface::result (TAO_ENV_SINGLE_ARG_DECL)
  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 TAO_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  CORBA::Any_var safe_result_any = result_any;

  (*result_any) <<= this->_result;
  return safe_result_any._retn ();
}

void
TAO_ClientRequestInfo_CORBA_Container_create_abstract_interface::result (CORBA_AbstractInterfaceDef_ptr result)
{
  // update the result
  this->_result = result;
}

class TAO_ClientRequestInfo_CORBA_Container_create_local_interface : public TAO_ClientRequestInfo_i
{
public:
  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
      TAO_ENV_ARG_DECL_WITH_DEFAULTS);


  virtual Dynamic::ParameterList * arguments (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  virtual Dynamic::ExceptionList * exceptions (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  virtual CORBA::Any * result (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  void result (CORBA_LocalInterfaceDef_ptr result);

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_;
  CORBA_LocalInterfaceDef_ptr _result;
};

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
    TAO_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ClientRequestInfo_i (_tao_invocation, _tao_target),
    id_ (id),
    name_ (name),
    version_ (version),
    base_interfaces_ (base_interfaces)
{}

Dynamic::ParameterList *
TAO_ClientRequestInfo_CORBA_Container_create_local_interface::arguments (TAO_ENV_SINGLE_ARG_DECL)
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the argument list on demand.
  Dynamic::ParameterList *parameter_list =
    TAO_RequestInfo_Util::make_parameter_list (TAO_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  Dynamic::ParameterList_var safe_parameter_list = parameter_list;

  parameter_list->length (4);
  CORBA::ULong len = 0;

    (*parameter_list)[len].argument <<= id_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
    (*parameter_list)[len].argument <<= name_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
    (*parameter_list)[len].argument <<= version_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
    (*parameter_list)[len].argument <<=  this->base_interfaces_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;

  return safe_parameter_list._retn ();
}

Dynamic::ExceptionList *
TAO_ClientRequestInfo_CORBA_Container_create_local_interface::exceptions (TAO_ENV_SINGLE_ARG_DECL)
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the exception list on demand.
  Dynamic::ExceptionList *exception_list =
    TAO_RequestInfo_Util::make_exception_list (TAO_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  return exception_list;
}


CORBA::Any *
TAO_ClientRequestInfo_CORBA_Container_create_local_interface::result (TAO_ENV_SINGLE_ARG_DECL)
  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 TAO_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  CORBA::Any_var safe_result_any = result_any;

  (*result_any) <<= this->_result;
  return safe_result_any._retn ();
}

void
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_CORBA_Container_Proxy_Impl::_TAO_CORBA_Container_Proxy_Impl (void)
{}

_TAO_CORBA_Container_Remote_Proxy_Impl::_TAO_CORBA_Container_Remote_Proxy_Impl (void)
{}

// Remote Implementation of the IDL interface methods

CORBA_Contained_ptr _TAO_CORBA_Container_Remote_Proxy_Impl::lookup (
    CORBA_Object *_collocated_tao_target_,
    const char * search_name
    TAO_ENV_ARG_DECL
  )
  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 ()
    );

  int _invoke_status;

#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
      istub->orb_core ()->client_request_interceptors (),
      &_tao_call,
      _invoke_status
    );

#endif  /* TAO_HAS_INTERCEPTORS */

  for (;;)
    {
      _invoke_status = TAO_INVOKE_EXCEPTION;

#if TAO_HAS_INTERCEPTORS == 1
      TAO_ClientRequestInfo_CORBA_Container_lookup ri (
        &_tao_call,
        _collocated_tao_target_,
        search_name
        TAO_ENV_ARG_PARAMETER
      );
      ACE_CHECK_RETURN (0);

#endif /* TAO_HAS_INTERCEPTORS */


      CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
      TAO_INTERCEPTOR (ri.response_expected (1));

#if TAO_HAS_INTERCEPTORS == 1

      ACE_TRY
        {
          _tao_vfr.send_request (
            &ri
            TAO_ENV_ARG_PARAMETER
          );
          ACE_TRY_CHECK;

          if (_invoke_status == TAO_INVOKE_RESTART)
            {
              _tao_call.restart_flag (1);
              continue;
            }

#endif /* TAO_HAS_INTERCEPTORS */

          _tao_call.start (TAO_ENV_SINGLE_ARG_PARAMETER);
          TAO_INTERCEPTOR_CHECK_RETURN (0);

          _tao_call.prepare_header (
              ACE_static_cast (CORBA::Octet, _tao_response_flag)
              TAO_ENV_ARG_PARAMETER
            );
          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 TAO_ENV_ARG_PARAMETER);
          TAO_INTERCEPTOR_CHECK_RETURN (0);

          if (_invoke_status == TAO_INVOKE_EXCEPTION)
            {
              TAO_INTERCEPTOR_THROW_RETURN (
                CORBA::UNKNOWN (TAO_OMG_VMCID | 1, CORBA::COMPLETED_YES),
                0
              );

            }
          else if (_invoke_status == TAO_INVOKE_RESTART)
            {
              TAO_INTERCEPTOR (
                ri.reply_status (_invoke_status);
                _tao_vfr.receive_other (
                  &ri
                  TAO_ENV_ARG_PARAMETER
                );
                ACE_TRY_CHECK;
              )

              continue;
            }

          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
              );

            }

#if TAO_HAS_INTERCEPTORS == 1
          CORBA_Contained_ptr _tao_retval_info = _tao_safe_retval._retn ();
          ri.result (_tao_retval_info);
          _tao_safe_retval = _tao_retval_info;

          ri.reply_status (_invoke_status);
          _tao_vfr.receive_reply (
            &ri
            TAO_ENV_ARG_PARAMETER
          );
          ACE_TRY_CHECK;

      }
    ACE_CATCHANY
      {
        ri.exception (&ACE_ANY_EXCEPTION);
        _tao_vfr.receive_exception (
          &ri
          TAO_ENV_ARG_PARAMETER
        );
        ACE_TRY_CHECK;

        PortableInterceptor::ReplyStatus _tao_status =
          ri.reply_status (TAO_ENV_SINGLE_ARG_PARAMETER);
        ACE_TRY_CHECK;

        if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION
            || _tao_status == PortableInterceptor::USER_EXCEPTION)
          ACE_RE_THROW;
      }
    ACE_ENDTRY;
    ACE_CHECK_RETURN (0);

    PortableInterceptor::ReplyStatus _tao_status =
      ri.reply_status (TAO_ENV_SINGLE_ARG_PARAMETER);
    ACE_CHECK_RETURN (0);

    if (_tao_status == PortableInterceptor::LOCATION_FORWARD
        || _tao_status == PortableInterceptor::TRANSPORT_RETRY)
      continue;

#endif  /* TAO_HAS_INTERCEPTORS */

    break;
  }
return _tao_safe_retval._retn ();
}

CORBA_ContainedSeq * _TAO_CORBA_Container_Remote_Proxy_Impl::contents (
    CORBA_Object *_collocated_tao_target_,
    CORBA::DefinitionKind limit_type,
    CORBA::Boolean exclude_inherited
    TAO_ENV_ARG_DECL
  )
  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 ()
    );

  int _invoke_status;

#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
      istub->orb_core ()->client_request_interceptors (),
      &_tao_call,
      _invoke_status
    );

#endif  /* TAO_HAS_INTERCEPTORS */

  for (;;)
    {
      _invoke_status = TAO_INVOKE_EXCEPTION;

#if TAO_HAS_INTERCEPTORS == 1
      TAO_ClientRequestInfo_CORBA_Container_contents ri (
        &_tao_call,
        _collocated_tao_target_,
        limit_type,
        exclude_inherited
        TAO_ENV_ARG_PARAMETER
      );
      ACE_CHECK_RETURN (0);

#endif /* TAO_HAS_INTERCEPTORS */


      CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
      TAO_INTERCEPTOR (ri.response_expected (1));

#if TAO_HAS_INTERCEPTORS == 1

      ACE_TRY
        {
          _tao_vfr.send_request (
            &ri
            TAO_ENV_ARG_PARAMETER
          );
          ACE_TRY_CHECK;

          if (_invoke_status == TAO_INVOKE_RESTART)
            {
              _tao_call.restart_flag (1);
              continue;
            }

#endif /* TAO_HAS_INTERCEPTORS */

          _tao_call.start (TAO_ENV_SINGLE_ARG_PARAMETER);
          TAO_INTERCEPTOR_CHECK_RETURN (0);

          _tao_call.prepare_header (
              ACE_static_cast (CORBA::Octet, _tao_response_flag)
              TAO_ENV_ARG_PARAMETER
            );
          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 TAO_ENV_ARG_PARAMETER);
          TAO_INTERCEPTOR_CHECK_RETURN (0);

          if (_invoke_status == TAO_INVOKE_EXCEPTION)
            {
              TAO_INTERCEPTOR_THROW_RETURN (
                CORBA::UNKNOWN (TAO_OMG_VMCID | 1, CORBA::COMPLETED_YES),
                0
              );

            }
          else if (_invoke_status == TAO_INVOKE_RESTART)
            {
              TAO_INTERCEPTOR (
                ri.reply_status (_invoke_status);
                _tao_vfr.receive_other (
                  &ri
                  TAO_ENV_ARG_PARAMETER
                );
                ACE_TRY_CHECK;
              )

              continue;
            }

          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
              );

            }

#if TAO_HAS_INTERCEPTORS == 1
          CORBA_ContainedSeq * _tao_retval_info = _tao_safe_retval._retn ();
          ri.result (_tao_retval_info);
          _tao_safe_retval = _tao_retval_info;

          ri.reply_status (_invoke_status);
          _tao_vfr.receive_reply (
            &ri
            TAO_ENV_ARG_PARAMETER
          );
          ACE_TRY_CHECK;

      }
    ACE_CATCHANY
      {
        ri.exception (&ACE_ANY_EXCEPTION);
        _tao_vfr.receive_exception (
          &ri
          TAO_ENV_ARG_PARAMETER
        );
        ACE_TRY_CHECK;

        PortableInterceptor::ReplyStatus _tao_status =
          ri.reply_status (TAO_ENV_SINGLE_ARG_PARAMETER);
        ACE_TRY_CHECK;

        if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION
            || _tao_status == PortableInterceptor::USER_EXCEPTION)
          ACE_RE_THROW;
      }
    ACE_ENDTRY;
    ACE_CHECK_RETURN (0);

    PortableInterceptor::ReplyStatus _tao_status =
      ri.reply_status (TAO_ENV_SINGLE_ARG_PARAMETER);
    ACE_CHECK_RETURN (0);

    if (_tao_status == PortableInterceptor::LOCATION_FORWARD
        || _tao_status == PortableInterceptor::TRANSPORT_RETRY)
      continue;

#endif  /* TAO_HAS_INTERCEPTORS */

    break;
  }
return _tao_safe_retval._retn ();
}

CORBA_ContainedSeq * _TAO_CORBA_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
    TAO_ENV_ARG_DECL
  )
  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 ()
    );

  int _invoke_status;

#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
      istub->orb_core ()->client_request_interceptors (),
      &_tao_call,
      _invoke_status
    );

#endif  /* TAO_HAS_INTERCEPTORS */

  for (;;)
    {
      _invoke_status = TAO_INVOKE_EXCEPTION;

#if TAO_HAS_INTERCEPTORS == 1
      TAO_ClientRequestInfo_CORBA_Container_lookup_name ri (
        &_tao_call,
        _collocated_tao_target_,
        search_name,
        levels_to_search,
        limit_type,
        exclude_inherited
        TAO_ENV_ARG_PARAMETER
      );
      ACE_CHECK_RETURN (0);

#endif /* TAO_HAS_INTERCEPTORS */


      CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
      TAO_INTERCEPTOR (ri.response_expected (1));

#if TAO_HAS_INTERCEPTORS == 1

      ACE_TRY
        {
          _tao_vfr.send_request (
            &ri
            TAO_ENV_ARG_PARAMETER
          );
          ACE_TRY_CHECK;

          if (_invoke_status == TAO_INVOKE_RESTART)
            {
              _tao_call.restart_flag (1);
              continue;
            }

#endif /* TAO_HAS_INTERCEPTORS */

          _tao_call.start (TAO_ENV_SINGLE_ARG_PARAMETER);
          TAO_INTERCEPTOR_CHECK_RETURN (0);

          _tao_call.prepare_header (
              ACE_static_cast (CORBA::Octet, _tao_response_flag)
              TAO_ENV_ARG_PARAMETER
            );
          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 TAO_ENV_ARG_PARAMETER);
          TAO_INTERCEPTOR_CHECK_RETURN (0);

          if (_invoke_status == TAO_INVOKE_EXCEPTION)
            {
              TAO_INTERCEPTOR_THROW_RETURN (
                CORBA::UNKNOWN (TAO_OMG_VMCID | 1, CORBA::COMPLETED_YES),
                0
              );

            }
          else if (_invoke_status == TAO_INVOKE_RESTART)
            {
              TAO_INTERCEPTOR (
                ri.reply_status (_invoke_status);
                _tao_vfr.receive_other (
                  &ri
                  TAO_ENV_ARG_PARAMETER
                );
                ACE_TRY_CHECK;
              )

              continue;
            }

          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
              );

            }

#if TAO_HAS_INTERCEPTORS == 1
          CORBA_ContainedSeq * _tao_retval_info = _tao_safe_retval._retn ();
          ri.result (_tao_retval_info);
          _tao_safe_retval = _tao_retval_info;

          ri.reply_status (_invoke_status);
          _tao_vfr.receive_reply (
            &ri
            TAO_ENV_ARG_PARAMETER
          );
          ACE_TRY_CHECK;

      }
    ACE_CATCHANY
      {
        ri.exception (&ACE_ANY_EXCEPTION);
        _tao_vfr.receive_exception (
          &ri
          TAO_ENV_ARG_PARAMETER
        );
        ACE_TRY_CHECK;

        PortableInterceptor::ReplyStatus _tao_status =
          ri.reply_status (TAO_ENV_SINGLE_ARG_PARAMETER);
        ACE_TRY_CHECK;

        if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION
            || _tao_status == PortableInterceptor::USER_EXCEPTION)
          ACE_RE_THROW;
      }
    ACE_ENDTRY;
    ACE_CHECK_RETURN (0);

    PortableInterceptor::ReplyStatus _tao_status =
      ri.reply_status (TAO_ENV_SINGLE_ARG_PARAMETER);
    ACE_CHECK_RETURN (0);

    if (_tao_status == PortableInterceptor::LOCATION_FORWARD
        || _tao_status == PortableInterceptor::TRANSPORT_RETRY)
      continue;

#endif  /* TAO_HAS_INTERCEPTORS */

    break;
  }
return _tao_safe_retval._retn ();
}

CORBA_Container::DescriptionSeq * _TAO_CORBA_Container_Remote_Proxy_Impl::describe_contents (
    CORBA_Object *_collocated_tao_target_,
    CORBA::DefinitionKind limit_type,
    CORBA::Boolean exclude_inherited,
    CORBA::Long max_returned_objs
    TAO_ENV_ARG_DECL
  )
  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 ()
    );

  int _invoke_status;

#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
      istub->orb_core ()->client_request_interceptors (),
      &_tao_call,
      _invoke_status
    );

#endif  /* TAO_HAS_INTERCEPTORS */

  for (;;)
    {
      _invoke_status = TAO_INVOKE_EXCEPTION;

#if TAO_HAS_INTERCEPTORS == 1
      TAO_ClientRequestInfo_CORBA_Container_describe_contents ri (
        &_tao_call,
        _collocated_tao_target_,
        limit_type,
        exclude_inherited,
        max_returned_objs
        TAO_ENV_ARG_PARAMETER
      );
      ACE_CHECK_RETURN (0);

#endif /* TAO_HAS_INTERCEPTORS */


      CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
      TAO_INTERCEPTOR (ri.response_expected (1));

#if TAO_HAS_INTERCEPTORS == 1

      ACE_TRY
        {
          _tao_vfr.send_request (
            &ri
            TAO_ENV_ARG_PARAMETER
          );
          ACE_TRY_CHECK;

          if (_invoke_status == TAO_INVOKE_RESTART)
            {
              _tao_call.restart_flag (1);
              continue;
            }

#endif /* TAO_HAS_INTERCEPTORS */

          _tao_call.start (TAO_ENV_SINGLE_ARG_PARAMETER);
          TAO_INTERCEPTOR_CHECK_RETURN (0);

          _tao_call.prepare_header (
              ACE_static_cast (CORBA::Octet, _tao_response_flag)
              TAO_ENV_ARG_PARAMETER
            );
          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 TAO_ENV_ARG_PARAMETER);
          TAO_INTERCEPTOR_CHECK_RETURN (0);

          if (_invoke_status == TAO_INVOKE_EXCEPTION)
            {
              TAO_INTERCEPTOR_THROW_RETURN (
                CORBA::UNKNOWN (TAO_OMG_VMCID | 1, CORBA::COMPLETED_YES),
                0
              );

            }
          else if (_invoke_status == TAO_INVOKE_RESTART)
            {
              TAO_INTERCEPTOR (
                ri.reply_status (_invoke_status);
                _tao_vfr.receive_other (
                  &ri
                  TAO_ENV_ARG_PARAMETER
                );
                ACE_TRY_CHECK;
              )

              continue;
            }

          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
              );

            }

#if TAO_HAS_INTERCEPTORS == 1
          CORBA_Container::DescriptionSeq * _tao_retval_info = _tao_safe_retval._retn ();
          ri.result (_tao_retval_info);
          _tao_safe_retval = _tao_retval_info;

          ri.reply_status (_invoke_status);
          _tao_vfr.receive_reply (
            &ri
            TAO_ENV_ARG_PARAMETER
          );
          ACE_TRY_CHECK;

      }
    ACE_CATCHANY
      {
        ri.exception (&ACE_ANY_EXCEPTION);
        _tao_vfr.receive_exception (
          &ri
          TAO_ENV_ARG_PARAMETER
        );
        ACE_TRY_CHECK;

        PortableInterceptor::ReplyStatus _tao_status =
          ri.reply_status (TAO_ENV_SINGLE_ARG_PARAMETER);
        ACE_TRY_CHECK;

        if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION
            || _tao_status == PortableInterceptor::USER_EXCEPTION)
          ACE_RE_THROW;
      }
    ACE_ENDTRY;
    ACE_CHECK_RETURN (0);

    PortableInterceptor::ReplyStatus _tao_status =
      ri.reply_status (TAO_ENV_SINGLE_ARG_PARAMETER);
    ACE_CHECK_RETURN (0);

    if (_tao_status == PortableInterceptor::LOCATION_FORWARD
        || _tao_status == PortableInterceptor::TRANSPORT_RETRY)
      continue;

#endif  /* TAO_HAS_INTERCEPTORS */

    break;
  }
return _tao_safe_retval._retn ();
}

CORBA_ModuleDef_ptr _TAO_CORBA_Container_Remote_Proxy_Impl::create_module (
    CORBA_Object *_collocated_tao_target_,
    const char * id,
    const char * name,
    const char * version
    TAO_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{

  CORBA_ModuleDef_ptr _tao_retval = tao_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 ()
    );

  int _invoke_status;

#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
      istub->orb_core ()->client_request_interceptors (),
      &_tao_call,
      _invoke_status
    );

#endif  /* TAO_HAS_INTERCEPTORS */

  for (;;)
    {
      _invoke_status = TAO_INVOKE_EXCEPTION;

#if TAO_HAS_INTERCEPTORS == 1
      TAO_ClientRequestInfo_CORBA_Container_create_module ri (
        &_tao_call,
        _collocated_tao_target_,
        id,
        name,
        version
        TAO_ENV_ARG_PARAMETER
      );
      ACE_CHECK_RETURN (0);

#endif /* TAO_HAS_INTERCEPTORS */


      CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
      TAO_INTERCEPTOR (ri.response_expected (1));

#if TAO_HAS_INTERCEPTORS == 1

      ACE_TRY
        {
          _tao_vfr.send_request (
            &ri
            TAO_ENV_ARG_PARAMETER
          );
          ACE_TRY_CHECK;

          if (_invoke_status == TAO_INVOKE_RESTART)
            {
              _tao_call.restart_flag (1);
              continue;
            }

#endif /* TAO_HAS_INTERCEPTORS */

          _tao_call.start (TAO_ENV_SINGLE_ARG_PARAMETER);
          TAO_INTERCEPTOR_CHECK_RETURN (0);

          _tao_call.prepare_header (
              ACE_static_cast (CORBA::Octet, _tao_response_flag)
              TAO_ENV_ARG_PARAMETER
            );
          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 TAO_ENV_ARG_PARAMETER);
          TAO_INTERCEPTOR_CHECK_RETURN (0);

          if (_invoke_status == TAO_INVOKE_EXCEPTION)
            {
              TAO_INTERCEPTOR_THROW_RETURN (
                CORBA::UNKNOWN (TAO_OMG_VMCID | 1, CORBA::COMPLETED_YES),
                0
              );

            }
          else if (_invoke_status == TAO_INVOKE_RESTART)
            {
              TAO_INTERCEPTOR (
                ri.reply_status (_invoke_status);
                _tao_vfr.receive_other (
                  &ri
                  TAO_ENV_ARG_PARAMETER
                );
                ACE_TRY_CHECK;
              )

              continue;
            }

          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
              );

            }

#if TAO_HAS_INTERCEPTORS == 1
          CORBA_ModuleDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
          ri.result (_tao_retval_info);
          _tao_safe_retval = _tao_retval_info;

          ri.reply_status (_invoke_status);
          _tao_vfr.receive_reply (
            &ri
            TAO_ENV_ARG_PARAMETER
          );
          ACE_TRY_CHECK;

      }
    ACE_CATCHANY
      {
        ri.exception (&ACE_ANY_EXCEPTION);
        _tao_vfr.receive_exception (
          &ri
          TAO_ENV_ARG_PARAMETER
        );
        ACE_TRY_CHECK;

        PortableInterceptor::ReplyStatus _tao_status =
          ri.reply_status (TAO_ENV_SINGLE_ARG_PARAMETER);
        ACE_TRY_CHECK;

        if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION
            || _tao_status == PortableInterceptor::USER_EXCEPTION)
          ACE_RE_THROW;
      }
    ACE_ENDTRY;
    ACE_CHECK_RETURN (0);

    PortableInterceptor::ReplyStatus _tao_status =
      ri.reply_status (TAO_ENV_SINGLE_ARG_PARAMETER);
    ACE_CHECK_RETURN (0);

    if (_tao_status == PortableInterceptor::LOCATION_FORWARD
        || _tao_status == PortableInterceptor::TRANSPORT_RETRY)
      continue;

#endif  /* TAO_HAS_INTERCEPTORS */

    break;
  }
return _tao_safe_retval._retn ();
}

CORBA_ConstantDef_ptr _TAO_CORBA_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
    TAO_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{

  CORBA_ConstantDef_ptr _tao_retval = tao_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 ()
    );

  int _invoke_status;

#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
      istub->orb_core ()->client_request_interceptors (),
      &_tao_call,
      _invoke_status
    );

#endif  /* TAO_HAS_INTERCEPTORS */

  for (;;)
    {
      _invoke_status = TAO_INVOKE_EXCEPTION;

#if TAO_HAS_INTERCEPTORS == 1
      TAO_ClientRequestInfo_CORBA_Container_create_constant ri (
        &_tao_call,
        _collocated_tao_target_,
        id,
        name,
        version,
        type,
        value
        TAO_ENV_ARG_PARAMETER
      );
      ACE_CHECK_RETURN (0);

#endif /* TAO_HAS_INTERCEPTORS */


      CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
      TAO_INTERCEPTOR (ri.response_expected (1));

#if TAO_HAS_INTERCEPTORS == 1

      ACE_TRY
        {
          _tao_vfr.send_request (
            &ri
            TAO_ENV_ARG_PARAMETER
          );
          ACE_TRY_CHECK;

          if (_invoke_status == TAO_INVOKE_RESTART)
            {
              _tao_call.restart_flag (1);
              continue;
            }

#endif /* TAO_HAS_INTERCEPTORS */

          _tao_call.start (TAO_ENV_SINGLE_ARG_PARAMETER);
          TAO_INTERCEPTOR_CHECK_RETURN (0);

          _tao_call.prepare_header (
              ACE_static_cast (CORBA::Octet, _tao_response_flag)
              TAO_ENV_ARG_PARAMETER
            );
          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 TAO_ENV_ARG_PARAMETER);
          TAO_INTERCEPTOR_CHECK_RETURN (0);

          if (_invoke_status == TAO_INVOKE_EXCEPTION)
            {
              TAO_INTERCEPTOR_THROW_RETURN (
                CORBA::UNKNOWN (TAO_OMG_VMCID | 1, CORBA::COMPLETED_YES),
                0
              );

            }
          else if (_invoke_status == TAO_INVOKE_RESTART)
            {
              TAO_INTERCEPTOR (
                ri.reply_status (_invoke_status);
                _tao_vfr.receive_other (
                  &ri
                  TAO_ENV_ARG_PARAMETER
                );
                ACE_TRY_CHECK;
              )

              continue;
            }

          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
              );

            }

#if TAO_HAS_INTERCEPTORS == 1
          CORBA_ConstantDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
          ri.result (_tao_retval_info);
          _tao_safe_retval = _tao_retval_info;

          ri.reply_status (_invoke_status);
          _tao_vfr.receive_reply (
            &ri
            TAO_ENV_ARG_PARAMETER
          );
          ACE_TRY_CHECK;

      }
    ACE_CATCHANY
      {
        ri.exception (&ACE_ANY_EXCEPTION);
        _tao_vfr.receive_exception (
          &ri
          TAO_ENV_ARG_PARAMETER
        );
        ACE_TRY_CHECK;

        PortableInterceptor::ReplyStatus _tao_status =
          ri.reply_status (TAO_ENV_SINGLE_ARG_PARAMETER);
        ACE_TRY_CHECK;

        if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION
            || _tao_status == PortableInterceptor::USER_EXCEPTION)
          ACE_RE_THROW;
      }
    ACE_ENDTRY;
    ACE_CHECK_RETURN (0);

    PortableInterceptor::ReplyStatus _tao_status =
      ri.reply_status (TAO_ENV_SINGLE_ARG_PARAMETER);
    ACE_CHECK_RETURN (0);

    if (_tao_status == PortableInterceptor::LOCATION_FORWARD
        || _tao_status == PortableInterceptor::TRANSPORT_RETRY)
      continue;

#endif  /* TAO_HAS_INTERCEPTORS */

    break;
  }
return _tao_safe_retval._retn ();
}

CORBA_StructDef_ptr _TAO_CORBA_Container_Remote_Proxy_Impl::create_struct (
    CORBA_Object *_collocated_tao_target_,
    const char * id,
    const char * name,
    const char * version,
    const CORBA_StructMemberSeq & members
    TAO_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{

  CORBA_StructDef_ptr _tao_retval = tao_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 ()
    );

  int _invoke_status;

#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
      istub->orb_core ()->client_request_interceptors (),
      &_tao_call,
      _invoke_status
    );

#endif  /* TAO_HAS_INTERCEPTORS */

  for (;;)
    {
      _invoke_status = TAO_INVOKE_EXCEPTION;

#if TAO_HAS_INTERCEPTORS == 1
      TAO_ClientRequestInfo_CORBA_Container_create_struct ri (
        &_tao_call,
        _collocated_tao_target_,
        id,
        name,
        version,
        members
        TAO_ENV_ARG_PARAMETER
      );
      ACE_CHECK_RETURN (0);

#endif /* TAO_HAS_INTERCEPTORS */


      CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
      TAO_INTERCEPTOR (ri.response_expected (1));

#if TAO_HAS_INTERCEPTORS == 1

      ACE_TRY
        {
          _tao_vfr.send_request (
            &ri
            TAO_ENV_ARG_PARAMETER
          );
          ACE_TRY_CHECK;

          if (_invoke_status == TAO_INVOKE_RESTART)
            {
              _tao_call.restart_flag (1);
              continue;
            }

#endif /* TAO_HAS_INTERCEPTORS */

          _tao_call.start (TAO_ENV_SINGLE_ARG_PARAMETER);
          TAO_INTERCEPTOR_CHECK_RETURN (0);

          _tao_call.prepare_header (
              ACE_static_cast (CORBA::Octet, _tao_response_flag)
              TAO_ENV_ARG_PARAMETER
            );
          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 TAO_ENV_ARG_PARAMETER);
          TAO_INTERCEPTOR_CHECK_RETURN (0);

          if (_invoke_status == TAO_INVOKE_EXCEPTION)
            {
              TAO_INTERCEPTOR_THROW_RETURN (
                CORBA::UNKNOWN (TAO_OMG_VMCID | 1, CORBA::COMPLETED_YES),
                0
              );

            }
          else if (_invoke_status == TAO_INVOKE_RESTART)
            {
              TAO_INTERCEPTOR (
                ri.reply_status (_invoke_status);
                _tao_vfr.receive_other (
                  &ri
                  TAO_ENV_ARG_PARAMETER
                );
                ACE_TRY_CHECK;
              )

              continue;
            }

          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
              );

            }

#if TAO_HAS_INTERCEPTORS == 1
          CORBA_StructDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
          ri.result (_tao_retval_info);
          _tao_safe_retval = _tao_retval_info;

          ri.reply_status (_invoke_status);
          _tao_vfr.receive_reply (
            &ri
            TAO_ENV_ARG_PARAMETER
          );
          ACE_TRY_CHECK;

      }
    ACE_CATCHANY
      {
        ri.exception (&ACE_ANY_EXCEPTION);
        _tao_vfr.receive_exception (
          &ri
          TAO_ENV_ARG_PARAMETER
        );
        ACE_TRY_CHECK;

        PortableInterceptor::ReplyStatus _tao_status =
          ri.reply_status (TAO_ENV_SINGLE_ARG_PARAMETER);
        ACE_TRY_CHECK;

        if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION
            || _tao_status == PortableInterceptor::USER_EXCEPTION)
          ACE_RE_THROW;
      }
    ACE_ENDTRY;
    ACE_CHECK_RETURN (0);

    PortableInterceptor::ReplyStatus _tao_status =
      ri.reply_status (TAO_ENV_SINGLE_ARG_PARAMETER);
    ACE_CHECK_RETURN (0);

    if (_tao_status == PortableInterceptor::LOCATION_FORWARD
        || _tao_status == PortableInterceptor::TRANSPORT_RETRY)
      continue;

#endif  /* TAO_HAS_INTERCEPTORS */

    break;
  }
return _tao_safe_retval._retn ();
}

CORBA_UnionDef_ptr _TAO_CORBA_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
    TAO_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{

  CORBA_UnionDef_ptr _tao_retval = tao_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 ()
    );

  int _invoke_status;

#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
      istub->orb_core ()->client_request_interceptors (),
      &_tao_call,
      _invoke_status
    );

#endif  /* TAO_HAS_INTERCEPTORS */

  for (;;)
    {
      _invoke_status = TAO_INVOKE_EXCEPTION;

#if TAO_HAS_INTERCEPTORS == 1
      TAO_ClientRequestInfo_CORBA_Container_create_union ri (
        &_tao_call,
        _collocated_tao_target_,
        id,
        name,
        version,
        discriminator_type,
        members
        TAO_ENV_ARG_PARAMETER
      );
      ACE_CHECK_RETURN (0);

#endif /* TAO_HAS_INTERCEPTORS */


      CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
      TAO_INTERCEPTOR (ri.response_expected (1));

#if TAO_HAS_INTERCEPTORS == 1

      ACE_TRY
        {
          _tao_vfr.send_request (
            &ri
            TAO_ENV_ARG_PARAMETER
          );
          ACE_TRY_CHECK;

          if (_invoke_status == TAO_INVOKE_RESTART)
            {
              _tao_call.restart_flag (1);
              continue;
            }

#endif /* TAO_HAS_INTERCEPTORS */

          _tao_call.start (TAO_ENV_SINGLE_ARG_PARAMETER);
          TAO_INTERCEPTOR_CHECK_RETURN (0);

          _tao_call.prepare_header (
              ACE_static_cast (CORBA::Octet, _tao_response_flag)
              TAO_ENV_ARG_PARAMETER
            );
          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 TAO_ENV_ARG_PARAMETER);
          TAO_INTERCEPTOR_CHECK_RETURN (0);

          if (_invoke_status == TAO_INVOKE_EXCEPTION)
            {
              TAO_INTERCEPTOR_THROW_RETURN (
                CORBA::UNKNOWN (TAO_OMG_VMCID | 1, CORBA::COMPLETED_YES),
                0
              );

            }
          else if (_invoke_status == TAO_INVOKE_RESTART)
            {
              TAO_INTERCEPTOR (
                ri.reply_status (_invoke_status);
                _tao_vfr.receive_other (
                  &ri
                  TAO_ENV_ARG_PARAMETER
                );
                ACE_TRY_CHECK;
              )

              continue;
            }

          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
              );

            }

#if TAO_HAS_INTERCEPTORS == 1
          CORBA_UnionDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
          ri.result (_tao_retval_info);
          _tao_safe_retval = _tao_retval_info;

          ri.reply_status (_invoke_status);
          _tao_vfr.receive_reply (
            &ri
            TAO_ENV_ARG_PARAMETER
          );
          ACE_TRY_CHECK;

      }
    ACE_CATCHANY
      {
        ri.exception (&ACE_ANY_EXCEPTION);
        _tao_vfr.receive_exception (
          &ri
          TAO_ENV_ARG_PARAMETER
        );
        ACE_TRY_CHECK;

        PortableInterceptor::ReplyStatus _tao_status =
          ri.reply_status (TAO_ENV_SINGLE_ARG_PARAMETER);
        ACE_TRY_CHECK;

        if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION
            || _tao_status == PortableInterceptor::USER_EXCEPTION)
          ACE_RE_THROW;
      }
    ACE_ENDTRY;
    ACE_CHECK_RETURN (0);

    PortableInterceptor::ReplyStatus _tao_status =
      ri.reply_status (TAO_ENV_SINGLE_ARG_PARAMETER);
    ACE_CHECK_RETURN (0);

    if (_tao_status == PortableInterceptor::LOCATION_FORWARD
        || _tao_status == PortableInterceptor::TRANSPORT_RETRY)
      continue;

#endif  /* TAO_HAS_INTERCEPTORS */

    break;
  }
return _tao_safe_retval._retn ();
}

CORBA_EnumDef_ptr _TAO_CORBA_Container_Remote_Proxy_Impl::create_enum (
    CORBA_Object *_collocated_tao_target_,
    const char * id,
    const char * name,
    const char * version,
    const CORBA_EnumMemberSeq & members
    TAO_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{

  CORBA_EnumDef_ptr _tao_retval = tao_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 ()
    );

  int _invoke_status;

#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
      istub->orb_core ()->client_request_interceptors (),
      &_tao_call,
      _invoke_status
    );

#endif  /* TAO_HAS_INTERCEPTORS */

  for (;;)
    {
      _invoke_status = TAO_INVOKE_EXCEPTION;

#if TAO_HAS_INTERCEPTORS == 1
      TAO_ClientRequestInfo_CORBA_Container_create_enum ri (
        &_tao_call,
        _collocated_tao_target_,
        id,
        name,
        version,
        members
        TAO_ENV_ARG_PARAMETER
      );
      ACE_CHECK_RETURN (0);

#endif /* TAO_HAS_INTERCEPTORS */


      CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
      TAO_INTERCEPTOR (ri.response_expected (1));

#if TAO_HAS_INTERCEPTORS == 1

      ACE_TRY
        {
          _tao_vfr.send_request (
            &ri
            TAO_ENV_ARG_PARAMETER
          );
          ACE_TRY_CHECK;

          if (_invoke_status == TAO_INVOKE_RESTART)
            {
              _tao_call.restart_flag (1);
              continue;
            }

#endif /* TAO_HAS_INTERCEPTORS */

          _tao_call.start (TAO_ENV_SINGLE_ARG_PARAMETER);
          TAO_INTERCEPTOR_CHECK_RETURN (0);

          _tao_call.prepare_header (
              ACE_static_cast (CORBA::Octet, _tao_response_flag)
              TAO_ENV_ARG_PARAMETER
            );
          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 TAO_ENV_ARG_PARAMETER);
          TAO_INTERCEPTOR_CHECK_RETURN (0);

          if (_invoke_status == TAO_INVOKE_EXCEPTION)
            {
              TAO_INTERCEPTOR_THROW_RETURN (
                CORBA::UNKNOWN (TAO_OMG_VMCID | 1, CORBA::COMPLETED_YES),
                0
              );

            }
          else if (_invoke_status == TAO_INVOKE_RESTART)
            {
              TAO_INTERCEPTOR (
                ri.reply_status (_invoke_status);
                _tao_vfr.receive_other (
                  &ri
                  TAO_ENV_ARG_PARAMETER
                );
                ACE_TRY_CHECK;
              )

              continue;
            }

          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
              );

            }

#if TAO_HAS_INTERCEPTORS == 1
          CORBA_EnumDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
          ri.result (_tao_retval_info);
          _tao_safe_retval = _tao_retval_info;

          ri.reply_status (_invoke_status);
          _tao_vfr.receive_reply (
            &ri
            TAO_ENV_ARG_PARAMETER
          );
          ACE_TRY_CHECK;

      }
    ACE_CATCHANY
      {
        ri.exception (&ACE_ANY_EXCEPTION);
        _tao_vfr.receive_exception (
          &ri
          TAO_ENV_ARG_PARAMETER
        );
        ACE_TRY_CHECK;

        PortableInterceptor::ReplyStatus _tao_status =
          ri.reply_status (TAO_ENV_SINGLE_ARG_PARAMETER);
        ACE_TRY_CHECK;

        if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION
            || _tao_status == PortableInterceptor::USER_EXCEPTION)
          ACE_RE_THROW;
      }
    ACE_ENDTRY;
    ACE_CHECK_RETURN (0);

    PortableInterceptor::ReplyStatus _tao_status =
      ri.reply_status (TAO_ENV_SINGLE_ARG_PARAMETER);
    ACE_CHECK_RETURN (0);

    if (_tao_status == PortableInterceptor::LOCATION_FORWARD
        || _tao_status == PortableInterceptor::TRANSPORT_RETRY)
      continue;

#endif  /* TAO_HAS_INTERCEPTORS */

    break;
  }
return _tao_safe_retval._retn ();
}

CORBA_AliasDef_ptr _TAO_CORBA_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
    TAO_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{

  CORBA_AliasDef_ptr _tao_retval = tao_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 ()
    );

  int _invoke_status;

#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
      istub->orb_core ()->client_request_interceptors (),
      &_tao_call,
      _invoke_status
    );

#endif  /* TAO_HAS_INTERCEPTORS */

  for (;;)
    {
      _invoke_status = TAO_INVOKE_EXCEPTION;

#if TAO_HAS_INTERCEPTORS == 1
      TAO_ClientRequestInfo_CORBA_Container_create_alias ri (
        &_tao_call,
        _collocated_tao_target_,
        id,
        name,
        version,
        original_type
        TAO_ENV_ARG_PARAMETER
      );
      ACE_CHECK_RETURN (0);

#endif /* TAO_HAS_INTERCEPTORS */


      CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
      TAO_INTERCEPTOR (ri.response_expected (1));

#if TAO_HAS_INTERCEPTORS == 1

      ACE_TRY
        {
          _tao_vfr.send_request (
            &ri
            TAO_ENV_ARG_PARAMETER
          );
          ACE_TRY_CHECK;

          if (_invoke_status == TAO_INVOKE_RESTART)
            {
              _tao_call.restart_flag (1);
              continue;
            }

#endif /* TAO_HAS_INTERCEPTORS */

          _tao_call.start (TAO_ENV_SINGLE_ARG_PARAMETER);
          TAO_INTERCEPTOR_CHECK_RETURN (0);

          _tao_call.prepare_header (
              ACE_static_cast (CORBA::Octet, _tao_response_flag)
              TAO_ENV_ARG_PARAMETER
            );
          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 TAO_ENV_ARG_PARAMETER);
          TAO_INTERCEPTOR_CHECK_RETURN (0);

          if (_invoke_status == TAO_INVOKE_EXCEPTION)
            {
              TAO_INTERCEPTOR_THROW_RETURN (
                CORBA::UNKNOWN (TAO_OMG_VMCID | 1, CORBA::COMPLETED_YES),
                0
              );

            }
          else if (_invoke_status == TAO_INVOKE_RESTART)
            {
              TAO_INTERCEPTOR (
                ri.reply_status (_invoke_status);
                _tao_vfr.receive_other (
                  &ri
                  TAO_ENV_ARG_PARAMETER
                );
                ACE_TRY_CHECK;
              )

              continue;
            }

          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
              );

            }

#if TAO_HAS_INTERCEPTORS == 1
          CORBA_AliasDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
          ri.result (_tao_retval_info);
          _tao_safe_retval = _tao_retval_info;

          ri.reply_status (_invoke_status);
          _tao_vfr.receive_reply (
            &ri
            TAO_ENV_ARG_PARAMETER
          );
          ACE_TRY_CHECK;

      }
    ACE_CATCHANY
      {
        ri.exception (&ACE_ANY_EXCEPTION);
        _tao_vfr.receive_exception (
          &ri
          TAO_ENV_ARG_PARAMETER
        );
        ACE_TRY_CHECK;

        PortableInterceptor::ReplyStatus _tao_status =
          ri.reply_status (TAO_ENV_SINGLE_ARG_PARAMETER);
        ACE_TRY_CHECK;

        if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION
            || _tao_status == PortableInterceptor::USER_EXCEPTION)
          ACE_RE_THROW;
      }
    ACE_ENDTRY;
    ACE_CHECK_RETURN (0);

    PortableInterceptor::ReplyStatus _tao_status =
      ri.reply_status (TAO_ENV_SINGLE_ARG_PARAMETER);
    ACE_CHECK_RETURN (0);

    if (_tao_status == PortableInterceptor::LOCATION_FORWARD
        || _tao_status == PortableInterceptor::TRANSPORT_RETRY)
      continue;

#endif  /* TAO_HAS_INTERCEPTORS */

    break;
  }
return _tao_safe_retval._retn ();
}

CORBA_InterfaceDef_ptr _TAO_CORBA_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
    TAO_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{

  CORBA_InterfaceDef_ptr _tao_retval = tao_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 ()
    );

  int _invoke_status;

#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
      istub->orb_core ()->client_request_interceptors (),
      &_tao_call,
      _invoke_status
    );

#endif  /* TAO_HAS_INTERCEPTORS */

  for (;;)
    {
      _invoke_status = TAO_INVOKE_EXCEPTION;

#if TAO_HAS_INTERCEPTORS == 1
      TAO_ClientRequestInfo_CORBA_Container_create_interface ri (
        &_tao_call,
        _collocated_tao_target_,
        id,
        name,
        version,
        base_interfaces
        TAO_ENV_ARG_PARAMETER
      );
      ACE_CHECK_RETURN (0);

#endif /* TAO_HAS_INTERCEPTORS */


      CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
      TAO_INTERCEPTOR (ri.response_expected (1));

#if TAO_HAS_INTERCEPTORS == 1

      ACE_TRY
        {
          _tao_vfr.send_request (
            &ri
            TAO_ENV_ARG_PARAMETER
          );
          ACE_TRY_CHECK;

          if (_invoke_status == TAO_INVOKE_RESTART)
            {
              _tao_call.restart_flag (1);
              continue;
            }

#endif /* TAO_HAS_INTERCEPTORS */

          _tao_call.start (TAO_ENV_SINGLE_ARG_PARAMETER);
          TAO_INTERCEPTOR_CHECK_RETURN (0);

          _tao_call.prepare_header (
              ACE_static_cast (CORBA::Octet, _tao_response_flag)
              TAO_ENV_ARG_PARAMETER
            );
          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 TAO_ENV_ARG_PARAMETER);
          TAO_INTERCEPTOR_CHECK_RETURN (0);

          if (_invoke_status == TAO_INVOKE_EXCEPTION)
            {
              TAO_INTERCEPTOR_THROW_RETURN (
                CORBA::UNKNOWN (TAO_OMG_VMCID | 1, CORBA::COMPLETED_YES),
                0
              );

            }
          else if (_invoke_status == TAO_INVOKE_RESTART)
            {
              TAO_INTERCEPTOR (
                ri.reply_status (_invoke_status);
                _tao_vfr.receive_other (
                  &ri
                  TAO_ENV_ARG_PARAMETER
                );
                ACE_TRY_CHECK;
              )

              continue;
            }

          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
              );

            }

#if TAO_HAS_INTERCEPTORS == 1
          CORBA_InterfaceDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
          ri.result (_tao_retval_info);
          _tao_safe_retval = _tao_retval_info;

          ri.reply_status (_invoke_status);
          _tao_vfr.receive_reply (
            &ri
            TAO_ENV_ARG_PARAMETER
          );
          ACE_TRY_CHECK;

      }
    ACE_CATCHANY
      {
        ri.exception (&ACE_ANY_EXCEPTION);
        _tao_vfr.receive_exception (
          &ri
          TAO_ENV_ARG_PARAMETER
        );
        ACE_TRY_CHECK;

        PortableInterceptor::ReplyStatus _tao_status =
          ri.reply_status (TAO_ENV_SINGLE_ARG_PARAMETER);
        ACE_TRY_CHECK;

        if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION
            || _tao_status == PortableInterceptor::USER_EXCEPTION)
          ACE_RE_THROW;
      }
    ACE_ENDTRY;
    ACE_CHECK_RETURN (0);

    PortableInterceptor::ReplyStatus _tao_status =
      ri.reply_status (TAO_ENV_SINGLE_ARG_PARAMETER);
    ACE_CHECK_RETURN (0);

    if (_tao_status == PortableInterceptor::LOCATION_FORWARD
        || _tao_status == PortableInterceptor::TRANSPORT_RETRY)
      continue;

#endif  /* TAO_HAS_INTERCEPTORS */

    break;
  }
return _tao_safe_retval._retn ();
}

CORBA_ValueDef_ptr _TAO_CORBA_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
    TAO_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{

  CORBA_ValueDef_ptr _tao_retval = tao_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 ()
    );

  int _invoke_status;

#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
      istub->orb_core ()->client_request_interceptors (),
      &_tao_call,
      _invoke_status
    );

#endif  /* TAO_HAS_INTERCEPTORS */

  for (;;)
    {
      _invoke_status = TAO_INVOKE_EXCEPTION;

#if TAO_HAS_INTERCEPTORS == 1
      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
        TAO_ENV_ARG_PARAMETER
      );
      ACE_CHECK_RETURN (0);

#endif /* TAO_HAS_INTERCEPTORS */


      CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
      TAO_INTERCEPTOR (ri.response_expected (1));

#if TAO_HAS_INTERCEPTORS == 1

      ACE_TRY
        {
          _tao_vfr.send_request (
            &ri
            TAO_ENV_ARG_PARAMETER
          );
          ACE_TRY_CHECK;

          if (_invoke_status == TAO_INVOKE_RESTART)
            {
              _tao_call.restart_flag (1);
              continue;
            }

#endif /* TAO_HAS_INTERCEPTORS */

          _tao_call.start (TAO_ENV_SINGLE_ARG_PARAMETER);
          TAO_INTERCEPTOR_CHECK_RETURN (0);

          _tao_call.prepare_header (
              ACE_static_cast (CORBA::Octet, _tao_response_flag)
              TAO_ENV_ARG_PARAMETER
            );
          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 TAO_ENV_ARG_PARAMETER);
          TAO_INTERCEPTOR_CHECK_RETURN (0);

          if (_invoke_status == TAO_INVOKE_EXCEPTION)
            {
              TAO_INTERCEPTOR_THROW_RETURN (
                CORBA::UNKNOWN (TAO_OMG_VMCID | 1, CORBA::COMPLETED_YES),
                0
              );

            }
          else if (_invoke_status == TAO_INVOKE_RESTART)
            {
              TAO_INTERCEPTOR (
                ri.reply_status (_invoke_status);
                _tao_vfr.receive_other (
                  &ri
                  TAO_ENV_ARG_PARAMETER
                );
                ACE_TRY_CHECK;
              )

              continue;
            }

          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
              );

            }

#if TAO_HAS_INTERCEPTORS == 1
          CORBA_ValueDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
          ri.result (_tao_retval_info);
          _tao_safe_retval = _tao_retval_info;

          ri.reply_status (_invoke_status);
          _tao_vfr.receive_reply (
            &ri
            TAO_ENV_ARG_PARAMETER
          );
          ACE_TRY_CHECK;

      }
    ACE_CATCHANY
      {
        ri.exception (&ACE_ANY_EXCEPTION);
        _tao_vfr.receive_exception (
          &ri
          TAO_ENV_ARG_PARAMETER
        );
        ACE_TRY_CHECK;

        PortableInterceptor::ReplyStatus _tao_status =
          ri.reply_status (TAO_ENV_SINGLE_ARG_PARAMETER);
        ACE_TRY_CHECK;

        if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION
            || _tao_status == PortableInterceptor::USER_EXCEPTION)
          ACE_RE_THROW;
      }
    ACE_ENDTRY;
    ACE_CHECK_RETURN (0);

    PortableInterceptor::ReplyStatus _tao_status =
      ri.reply_status (TAO_ENV_SINGLE_ARG_PARAMETER);
    ACE_CHECK_RETURN (0);

    if (_tao_status == PortableInterceptor::LOCATION_FORWARD
        || _tao_status == PortableInterceptor::TRANSPORT_RETRY)
      continue;

#endif  /* TAO_HAS_INTERCEPTORS */

    break;
  }
return _tao_safe_retval._retn ();
}

CORBA_ValueBoxDef_ptr _TAO_CORBA_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
    TAO_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{

  CORBA_ValueBoxDef_ptr _tao_retval = tao_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 ()
    );

  int _invoke_status;

#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
      istub->orb_core ()->client_request_interceptors (),
      &_tao_call,
      _invoke_status
    );

#endif  /* TAO_HAS_INTERCEPTORS */

  for (;;)
    {
      _invoke_status = TAO_INVOKE_EXCEPTION;

#if TAO_HAS_INTERCEPTORS == 1
      TAO_ClientRequestInfo_CORBA_Container_create_value_box ri (
        &_tao_call,
        _collocated_tao_target_,
        id,
        name,
        version,
        original_type_def
        TAO_ENV_ARG_PARAMETER
      );
      ACE_CHECK_RETURN (0);

#endif /* TAO_HAS_INTERCEPTORS */


      CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
      TAO_INTERCEPTOR (ri.response_expected (1));

#if TAO_HAS_INTERCEPTORS == 1

      ACE_TRY
        {
          _tao_vfr.send_request (
            &ri
            TAO_ENV_ARG_PARAMETER
          );
          ACE_TRY_CHECK;

          if (_invoke_status == TAO_INVOKE_RESTART)
            {
              _tao_call.restart_flag (1);
              continue;
            }

#endif /* TAO_HAS_INTERCEPTORS */

          _tao_call.start (TAO_ENV_SINGLE_ARG_PARAMETER);
          TAO_INTERCEPTOR_CHECK_RETURN (0);

          _tao_call.prepare_header (
              ACE_static_cast (CORBA::Octet, _tao_response_flag)
              TAO_ENV_ARG_PARAMETER
            );
          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 TAO_ENV_ARG_PARAMETER);
          TAO_INTERCEPTOR_CHECK_RETURN (0);

          if (_invoke_status == TAO_INVOKE_EXCEPTION)
            {
              TAO_INTERCEPTOR_THROW_RETURN (
                CORBA::UNKNOWN (TAO_OMG_VMCID | 1, CORBA::COMPLETED_YES),
                0
              );

            }
          else if (_invoke_status == TAO_INVOKE_RESTART)
            {
              TAO_INTERCEPTOR (
                ri.reply_status (_invoke_status);
                _tao_vfr.receive_other (
                  &ri
                  TAO_ENV_ARG_PARAMETER
                );
                ACE_TRY_CHECK;
              )

              continue;
            }

          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
              );

            }

#if TAO_HAS_INTERCEPTORS == 1
          CORBA_ValueBoxDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
          ri.result (_tao_retval_info);
          _tao_safe_retval = _tao_retval_info;

          ri.reply_status (_invoke_status);
          _tao_vfr.receive_reply (
            &ri
            TAO_ENV_ARG_PARAMETER
          );
          ACE_TRY_CHECK;

      }
    ACE_CATCHANY
      {
        ri.exception (&ACE_ANY_EXCEPTION);
        _tao_vfr.receive_exception (
          &ri
          TAO_ENV_ARG_PARAMETER
        );
        ACE_TRY_CHECK;

        PortableInterceptor::ReplyStatus _tao_status =
          ri.reply_status (TAO_ENV_SINGLE_ARG_PARAMETER);
        ACE_TRY_CHECK;

        if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION
            || _tao_status == PortableInterceptor::USER_EXCEPTION)
          ACE_RE_THROW;
      }
    ACE_ENDTRY;
    ACE_CHECK_RETURN (0);

    PortableInterceptor::ReplyStatus _tao_status =
      ri.reply_status (TAO_ENV_SINGLE_ARG_PARAMETER);
    ACE_CHECK_RETURN (0);

    if (_tao_status == PortableInterceptor::LOCATION_FORWARD
        || _tao_status == PortableInterceptor::TRANSPORT_RETRY)
      continue;

#endif  /* TAO_HAS_INTERCEPTORS */

    break;
  }
return _tao_safe_retval._retn ();
}

CORBA_ExceptionDef_ptr _TAO_CORBA_Container_Remote_Proxy_Impl::create_exception (
    CORBA_Object *_collocated_tao_target_,
    const char * id,
    const char * name,
    const char * version,
    const CORBA_StructMemberSeq & members
    TAO_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{

  CORBA_ExceptionDef_ptr _tao_retval = tao_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 ()
    );

  int _invoke_status;

#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
      istub->orb_core ()->client_request_interceptors (),
      &_tao_call,
      _invoke_status
    );

#endif  /* TAO_HAS_INTERCEPTORS */

  for (;;)
    {
      _invoke_status = TAO_INVOKE_EXCEPTION;

#if TAO_HAS_INTERCEPTORS == 1
      TAO_ClientRequestInfo_CORBA_Container_create_exception ri (
        &_tao_call,
        _collocated_tao_target_,
        id,
        name,
        version,
        members
        TAO_ENV_ARG_PARAMETER
      );
      ACE_CHECK_RETURN (0);

#endif /* TAO_HAS_INTERCEPTORS */


      CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
      TAO_INTERCEPTOR (ri.response_expected (1));

#if TAO_HAS_INTERCEPTORS == 1

      ACE_TRY
        {
          _tao_vfr.send_request (
            &ri
            TAO_ENV_ARG_PARAMETER
          );
          ACE_TRY_CHECK;

          if (_invoke_status == TAO_INVOKE_RESTART)
            {
              _tao_call.restart_flag (1);
              continue;
            }

#endif /* TAO_HAS_INTERCEPTORS */

          _tao_call.start (TAO_ENV_SINGLE_ARG_PARAMETER);
          TAO_INTERCEPTOR_CHECK_RETURN (0);

          _tao_call.prepare_header (
              ACE_static_cast (CORBA::Octet, _tao_response_flag)
              TAO_ENV_ARG_PARAMETER
            );
          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 TAO_ENV_ARG_PARAMETER);
          TAO_INTERCEPTOR_CHECK_RETURN (0);

          if (_invoke_status == TAO_INVOKE_EXCEPTION)
            {
              TAO_INTERCEPTOR_THROW_RETURN (
                CORBA::UNKNOWN (TAO_OMG_VMCID | 1, CORBA::COMPLETED_YES),
                0
              );

            }
          else if (_invoke_status == TAO_INVOKE_RESTART)
            {
              TAO_INTERCEPTOR (
                ri.reply_status (_invoke_status);
                _tao_vfr.receive_other (
                  &ri
                  TAO_ENV_ARG_PARAMETER
                );
                ACE_TRY_CHECK;
              )

              continue;
            }

          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
              );

            }

#if TAO_HAS_INTERCEPTORS == 1
          CORBA_ExceptionDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
          ri.result (_tao_retval_info);
          _tao_safe_retval = _tao_retval_info;

          ri.reply_status (_invoke_status);
          _tao_vfr.receive_reply (
            &ri
            TAO_ENV_ARG_PARAMETER
          );
          ACE_TRY_CHECK;

      }
    ACE_CATCHANY
      {
        ri.exception (&ACE_ANY_EXCEPTION);
        _tao_vfr.receive_exception (
          &ri
          TAO_ENV_ARG_PARAMETER
        );
        ACE_TRY_CHECK;

        PortableInterceptor::ReplyStatus _tao_status =
          ri.reply_status (TAO_ENV_SINGLE_ARG_PARAMETER);
        ACE_TRY_CHECK;

        if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION
            || _tao_status == PortableInterceptor::USER_EXCEPTION)
          ACE_RE_THROW;
      }
    ACE_ENDTRY;
    ACE_CHECK_RETURN (0);

    PortableInterceptor::ReplyStatus _tao_status =
      ri.reply_status (TAO_ENV_SINGLE_ARG_PARAMETER);
    ACE_CHECK_RETURN (0);

    if (_tao_status == PortableInterceptor::LOCATION_FORWARD
        || _tao_status == PortableInterceptor::TRANSPORT_RETRY)
      continue;

#endif  /* TAO_HAS_INTERCEPTORS */

    break;
  }
return _tao_safe_retval._retn ();
}

CORBA_NativeDef_ptr _TAO_CORBA_Container_Remote_Proxy_Impl::create_native (
    CORBA_Object *_collocated_tao_target_,
    const char * id,
    const char * name,
    const char * version
    TAO_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{

  CORBA_NativeDef_ptr _tao_retval = tao_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 ()
    );

  int _invoke_status;

#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
      istub->orb_core ()->client_request_interceptors (),
      &_tao_call,
      _invoke_status
    );

#endif  /* TAO_HAS_INTERCEPTORS */

  for (;;)
    {
      _invoke_status = TAO_INVOKE_EXCEPTION;

#if TAO_HAS_INTERCEPTORS == 1
      TAO_ClientRequestInfo_CORBA_Container_create_native ri (
        &_tao_call,
        _collocated_tao_target_,
        id,
        name,
        version
        TAO_ENV_ARG_PARAMETER
      );
      ACE_CHECK_RETURN (0);

#endif /* TAO_HAS_INTERCEPTORS */


      CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
      TAO_INTERCEPTOR (ri.response_expected (1));

#if TAO_HAS_INTERCEPTORS == 1

      ACE_TRY
        {
          _tao_vfr.send_request (
            &ri
            TAO_ENV_ARG_PARAMETER
          );
          ACE_TRY_CHECK;

          if (_invoke_status == TAO_INVOKE_RESTART)
            {
              _tao_call.restart_flag (1);
              continue;
            }

#endif /* TAO_HAS_INTERCEPTORS */

          _tao_call.start (TAO_ENV_SINGLE_ARG_PARAMETER);
          TAO_INTERCEPTOR_CHECK_RETURN (0);

          _tao_call.prepare_header (
              ACE_static_cast (CORBA::Octet, _tao_response_flag)
              TAO_ENV_ARG_PARAMETER
            );
          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 TAO_ENV_ARG_PARAMETER);
          TAO_INTERCEPTOR_CHECK_RETURN (0);

          if (_invoke_status == TAO_INVOKE_EXCEPTION)
            {
              TAO_INTERCEPTOR_THROW_RETURN (
                CORBA::UNKNOWN (TAO_OMG_VMCID | 1, CORBA::COMPLETED_YES),
                0
              );

            }
          else if (_invoke_status == TAO_INVOKE_RESTART)
            {
              TAO_INTERCEPTOR (
                ri.reply_status (_invoke_status);
                _tao_vfr.receive_other (
                  &ri
                  TAO_ENV_ARG_PARAMETER
                );
                ACE_TRY_CHECK;
              )

              continue;
            }

          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
              );

            }

#if TAO_HAS_INTERCEPTORS == 1
          CORBA_NativeDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
          ri.result (_tao_retval_info);
          _tao_safe_retval = _tao_retval_info;

          ri.reply_status (_invoke_status);
          _tao_vfr.receive_reply (
            &ri
            TAO_ENV_ARG_PARAMETER
          );
          ACE_TRY_CHECK;

      }
    ACE_CATCHANY
      {
        ri.exception (&ACE_ANY_EXCEPTION);
        _tao_vfr.receive_exception (
          &ri
          TAO_ENV_ARG_PARAMETER
        );
        ACE_TRY_CHECK;

        PortableInterceptor::ReplyStatus _tao_status =
          ri.reply_status (TAO_ENV_SINGLE_ARG_PARAMETER);
        ACE_TRY_CHECK;

        if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION
            || _tao_status == PortableInterceptor::USER_EXCEPTION)
          ACE_RE_THROW;
      }
    ACE_ENDTRY;
    ACE_CHECK_RETURN (0);

    PortableInterceptor::ReplyStatus _tao_status =
      ri.reply_status (TAO_ENV_SINGLE_ARG_PARAMETER);
    ACE_CHECK_RETURN (0);

    if (_tao_status == PortableInterceptor::LOCATION_FORWARD
        || _tao_status == PortableInterceptor::TRANSPORT_RETRY)
      continue;

#endif  /* TAO_HAS_INTERCEPTORS */

    break;
  }
return _tao_safe_retval._retn ();
}

CORBA_AbstractInterfaceDef_ptr _TAO_CORBA_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
    TAO_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{

  CORBA_AbstractInterfaceDef_ptr _tao_retval = tao_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 ()
    );

  int _invoke_status;

#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
      istub->orb_core ()->client_request_interceptors (),
      &_tao_call,
      _invoke_status
    );

#endif  /* TAO_HAS_INTERCEPTORS */

  for (;;)
    {
      _invoke_status = TAO_INVOKE_EXCEPTION;

#if TAO_HAS_INTERCEPTORS == 1
      TAO_ClientRequestInfo_CORBA_Container_create_abstract_interface ri (
        &_tao_call,
        _collocated_tao_target_,
        id,
        name,
        version,
        base_interfaces
        TAO_ENV_ARG_PARAMETER
      );
      ACE_CHECK_RETURN (0);

#endif /* TAO_HAS_INTERCEPTORS */


      CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
      TAO_INTERCEPTOR (ri.response_expected (1));

#if TAO_HAS_INTERCEPTORS == 1

      ACE_TRY
        {
          _tao_vfr.send_request (
            &ri
            TAO_ENV_ARG_PARAMETER
          );
          ACE_TRY_CHECK;

          if (_invoke_status == TAO_INVOKE_RESTART)
            {
              _tao_call.restart_flag (1);
              continue;
            }

#endif /* TAO_HAS_INTERCEPTORS */

          _tao_call.start (TAO_ENV_SINGLE_ARG_PARAMETER);
          TAO_INTERCEPTOR_CHECK_RETURN (0);

          _tao_call.prepare_header (
              ACE_static_cast (CORBA::Octet, _tao_response_flag)
              TAO_ENV_ARG_PARAMETER
            );
          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 TAO_ENV_ARG_PARAMETER);
          TAO_INTERCEPTOR_CHECK_RETURN (0);

          if (_invoke_status == TAO_INVOKE_EXCEPTION)
            {
              TAO_INTERCEPTOR_THROW_RETURN (
                CORBA::UNKNOWN (TAO_OMG_VMCID | 1, CORBA::COMPLETED_YES),
                0
              );

            }
          else if (_invoke_status == TAO_INVOKE_RESTART)
            {
              TAO_INTERCEPTOR (
                ri.reply_status (_invoke_status);
                _tao_vfr.receive_other (
                  &ri
                  TAO_ENV_ARG_PARAMETER
                );
                ACE_TRY_CHECK;
              )

              continue;
            }

          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
              );

            }

#if TAO_HAS_INTERCEPTORS == 1
          CORBA_AbstractInterfaceDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
          ri.result (_tao_retval_info);
          _tao_safe_retval = _tao_retval_info;

          ri.reply_status (_invoke_status);
          _tao_vfr.receive_reply (
            &ri
            TAO_ENV_ARG_PARAMETER
          );
          ACE_TRY_CHECK;

      }
    ACE_CATCHANY
      {
        ri.exception (&ACE_ANY_EXCEPTION);
        _tao_vfr.receive_exception (
          &ri
          TAO_ENV_ARG_PARAMETER
        );
        ACE_TRY_CHECK;

        PortableInterceptor::ReplyStatus _tao_status =
          ri.reply_status (TAO_ENV_SINGLE_ARG_PARAMETER);
        ACE_TRY_CHECK;

        if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION
            || _tao_status == PortableInterceptor::USER_EXCEPTION)
          ACE_RE_THROW;
      }
    ACE_ENDTRY;
    ACE_CHECK_RETURN (0);

    PortableInterceptor::ReplyStatus _tao_status =
      ri.reply_status (TAO_ENV_SINGLE_ARG_PARAMETER);
    ACE_CHECK_RETURN (0);

    if (_tao_status == PortableInterceptor::LOCATION_FORWARD
        || _tao_status == PortableInterceptor::TRANSPORT_RETRY)
      continue;

#endif  /* TAO_HAS_INTERCEPTORS */

    break;
  }
return _tao_safe_retval._retn ();
}

CORBA_LocalInterfaceDef_ptr _TAO_CORBA_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
    TAO_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{

  CORBA_LocalInterfaceDef_ptr _tao_retval = tao_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 ()
    );

  int _invoke_status;

#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
      istub->orb_core ()->client_request_interceptors (),
      &_tao_call,
      _invoke_status
    );

#endif  /* TAO_HAS_INTERCEPTORS */

  for (;;)
    {
      _invoke_status = TAO_INVOKE_EXCEPTION;

#if TAO_HAS_INTERCEPTORS == 1
      TAO_ClientRequestInfo_CORBA_Container_create_local_interface ri (
        &_tao_call,
        _collocated_tao_target_,
        id,
        name,
        version,
        base_interfaces
        TAO_ENV_ARG_PARAMETER
      );
      ACE_CHECK_RETURN (0);

#endif /* TAO_HAS_INTERCEPTORS */


      CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
      TAO_INTERCEPTOR (ri.response_expected (1));

#if TAO_HAS_INTERCEPTORS == 1

      ACE_TRY
        {
          _tao_vfr.send_request (
            &ri
            TAO_ENV_ARG_PARAMETER
          );
          ACE_TRY_CHECK;

          if (_invoke_status == TAO_INVOKE_RESTART)
            {
              _tao_call.restart_flag (1);
              continue;
            }

#endif /* TAO_HAS_INTERCEPTORS */

          _tao_call.start (TAO_ENV_SINGLE_ARG_PARAMETER);
          TAO_INTERCEPTOR_CHECK_RETURN (0);

          _tao_call.prepare_header (
              ACE_static_cast (CORBA::Octet, _tao_response_flag)
              TAO_ENV_ARG_PARAMETER
            );
          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 TAO_ENV_ARG_PARAMETER);
          TAO_INTERCEPTOR_CHECK_RETURN (0);

          if (_invoke_status == TAO_INVOKE_EXCEPTION)
            {
              TAO_INTERCEPTOR_THROW_RETURN (
                CORBA::UNKNOWN (TAO_OMG_VMCID | 1, CORBA::COMPLETED_YES),
                0
              );

            }
          else if (_invoke_status == TAO_INVOKE_RESTART)
            {
              TAO_INTERCEPTOR (
                ri.reply_status (_invoke_status);
                _tao_vfr.receive_other (
                  &ri
                  TAO_ENV_ARG_PARAMETER
                );
                ACE_TRY_CHECK;
              )

              continue;
            }

          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
              );

            }

#if TAO_HAS_INTERCEPTORS == 1
          CORBA_LocalInterfaceDef_ptr _tao_retval_info = _tao_safe_retval._retn ();
          ri.result (_tao_retval_info);
          _tao_safe_retval = _tao_retval_info;

          ri.reply_status (_invoke_status);
          _tao_vfr.receive_reply (
            &ri
            TAO_ENV_ARG_PARAMETER
          );
          ACE_TRY_CHECK;

      }
    ACE_CATCHANY
      {
        ri.exception (&ACE_ANY_EXCEPTION);
        _tao_vfr.receive_exception (
          &ri
          TAO_ENV_ARG_PARAMETER
        );
        ACE_TRY_CHECK;

        PortableInterceptor::ReplyStatus _tao_status =
          ri.reply_status (TAO_ENV_SINGLE_ARG_PARAMETER);
        ACE_TRY_CHECK;

        if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION
            || _tao_status == PortableInterceptor::USER_EXCEPTION)
          ACE_RE_THROW;
      }
    ACE_ENDTRY;
    ACE_CHECK_RETURN (0);

    PortableInterceptor::ReplyStatus _tao_status =
      ri.reply_status (TAO_ENV_SINGLE_ARG_PARAMETER);
    ACE_CHECK_RETURN (0);

    if (_tao_status == PortableInterceptor::LOCATION_FORWARD
        || _tao_status == PortableInterceptor::TRANSPORT_RETRY)
      continue;

#endif  /* TAO_HAS_INTERCEPTORS */

    break;
  }
return _tao_safe_retval._retn ();
}


//
//            End  Base & Remote  Proxy Implemeentation.
///////////////////////////////////////////////////////////////////////


///////////////////////////////////////////////////////////////////////
//           Remote & Base  Proxy Broker Implementation
//

_TAO_CORBA_Container_Proxy_Broker::_TAO_CORBA_Container_Proxy_Broker (void)
{
}

_TAO_CORBA_Container_Proxy_Broker::~_TAO_CORBA_Container_Proxy_Broker (void)
{
}

_TAO_CORBA_Container_Proxy_Broker * (*_TAO_CORBA_Container_Proxy_Broker_Factory_function_pointer) (
    CORBA::Object_ptr obj
  ) = 0;

// Factory Member function Implementation.
_TAO_CORBA_Container_Remote_Proxy_Broker *
_TAO_CORBA_Container_Remote_Proxy_Broker::the_TAO_CORBA_Container_Remote_Proxy_Broker (void)
{
  static ::_TAO_CORBA_Container_Remote_Proxy_Broker remote_proxy_broker;
  return &remote_proxy_broker;
}

_TAO_CORBA_Container_Remote_Proxy_Broker::_TAO_CORBA_Container_Remote_Proxy_Broker (void)
{
}

_TAO_CORBA_Container_Remote_Proxy_Broker::~_TAO_CORBA_Container_Remote_Proxy_Broker (void)
{
}

_TAO_CORBA_Container_Proxy_Impl&
_TAO_CORBA_Container_Remote_Proxy_Broker::select_proxy (
  ::CORBA_Container *
  TAO_ENV_ARG_DECL_NOT_USED
)
{
  return this->remote_proxy_impl_;
}


//
//           End Remote & Base Proxy Broker Implementation
///////////////////////////////////////////////////////////////////////


// default constructor
CORBA_Container::CORBA_Container (int collocated)
{
  this->CORBA_Container_setup_collocation (collocated);
}

// destructor
CORBA_Container::~CORBA_Container (void)
{}

void
CORBA_Container::CORBA_Container_setup_collocation (int collocated)
{
  if (collocated)
    this->the_TAO_CORBA_Container_Proxy_Broker_ =
      ::_TAO_CORBA_Container_Proxy_Broker_Factory_function_pointer (this);
  else
    this->the_TAO_CORBA_Container_Proxy_Broker_ =
      ::_TAO_CORBA_Container_Remote_Proxy_Broker::the_TAO_CORBA_Container_Remote_Proxy_Broker ();

  this->CORBA_IRObject_setup_collocation (collocated);
}

void CORBA_Container::_tao_any_destructor (void *_tao_void_pointer)
{
  CORBA_Container *tmp = ACE_static_cast (CORBA_Container*, _tao_void_pointer);
  CORBA::release (tmp);
}

CORBA_Container_ptr CORBA_Container::_narrow (
    CORBA::Object_ptr obj
    TAO_ENV_ARG_DECL
  )
{
  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" TAO_ENV_ARG_PARAMETER);
      ACE_CHECK_RETURN (CORBA_Container::_nil ());
      if (is_a == 0)
        return CORBA_Container::_nil ();
    }
  return CORBA_Container::_unchecked_narrow (obj TAO_ENV_ARG_PARAMETER);
}

CORBA_Container_ptr CORBA_Container::_unchecked_narrow (
    CORBA::Object_ptr obj
    TAO_ENV_ARG_DECL_NOT_USED
  )
{
  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 () &&_TAO_CORBA_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::_tao_class_id
                    )
                )
          );
}

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 TAO_ENV_ARG_DECL)
{
  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 TAO_ENV_ARG_PARAMETER);
}

void *CORBA_Container::_tao_QueryInterface (ptr_arith_t type)
{
  void *retv = 0;
  if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &CORBA_Container::_tao_class_id))
    retv = ACE_reinterpret_cast (void*, this);
  else if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &CORBA_IRObject::_tao_class_id))
    retv = ACE_reinterpret_cast
      (
        void *,
        ACE_static_cast
          (
            CORBA_IRObject_ptr,
            this
          )
      );
  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_tao_class_id))
    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
    TAO_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  _TAO_CORBA_Container_Proxy_Impl &proxy =
    this->the_TAO_CORBA_Container_Proxy_Broker_->select_proxy (this TAO_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  return proxy.lookup (
      this,
      search_name
      TAO_ENV_ARG_PARAMETER
    );
}

CORBA_ContainedSeq * CORBA_Container::contents (
    CORBA::DefinitionKind limit_type,
    CORBA::Boolean exclude_inherited
    TAO_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  _TAO_CORBA_Container_Proxy_Impl &proxy =
    this->the_TAO_CORBA_Container_Proxy_Broker_->select_proxy (this TAO_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  return proxy.contents (
      this,
      limit_type,
      exclude_inherited
      TAO_ENV_ARG_PARAMETER
    );
}

CORBA_ContainedSeq * CORBA_Container::lookup_name (
    const char * search_name,
    CORBA::Long levels_to_search,
    CORBA::DefinitionKind limit_type,
    CORBA::Boolean exclude_inherited
    TAO_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  _TAO_CORBA_Container_Proxy_Impl &proxy =
    this->the_TAO_CORBA_Container_Proxy_Broker_->select_proxy (this TAO_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  return proxy.lookup_name (
      this,
      search_name,
      levels_to_search,
      limit_type,
      exclude_inherited
      TAO_ENV_ARG_PARAMETER
    );
}

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 *_tao_void_pointer)
{
  Description *tmp = ACE_static_cast (Description*, _tao_void_pointer);
  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)
{
  CORBA_Container::Description* tmp = 0;
  tmp = _TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::allocbuf (length);

  if (this->buffer_ != 0)
  {
    CORBA_Container::Description *old = ACE_reinterpret_cast (CORBA_Container::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;

  CORBA_Container::Description *tmp = ACE_reinterpret_cast (CORBA_Container::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 *_tao_void_pointer)
{
  DescriptionSeq *tmp = ACE_static_cast (DescriptionSeq*, _tao_void_pointer);
  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
    TAO_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  _TAO_CORBA_Container_Proxy_Impl &proxy =
    this->the_TAO_CORBA_Container_Proxy_Broker_->select_proxy (this TAO_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  return proxy.describe_contents (
      this,
      limit_type,
      exclude_inherited,
      max_returned_objs
      TAO_ENV_ARG_PARAMETER
    );
}

CORBA_ModuleDef_ptr CORBA_Container::create_module (
    const char * id,
    const char * name,
    const char * version
    TAO_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  _TAO_CORBA_Container_Proxy_Impl &proxy =
    this->the_TAO_CORBA_Container_Proxy_Broker_->select_proxy (this TAO_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  return proxy.create_module (
      this,
      id,
      name,
      version
      TAO_ENV_ARG_PARAMETER
    );
}

CORBA_ConstantDef_ptr CORBA_Container::create_constant (
    const char * id,
    const char * name,
    const char * version,
    CORBA_IDLType_ptr type,
    const CORBA::Any & value
    TAO_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  _TAO_CORBA_Container_Proxy_Impl &proxy =
    this->the_TAO_CORBA_Container_Proxy_Broker_->select_proxy (this TAO_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  return proxy.create_constant (
      this,
      id,
      name,
      version,
      type,
      value
      TAO_ENV_ARG_PARAMETER
    );
}

CORBA_StructDef_ptr CORBA_Container::create_struct (
    const char * id,
    const char * name,
    const char * version,
    const CORBA_StructMemberSeq & members
    TAO_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  _TAO_CORBA_Container_Proxy_Impl &proxy =
    this->the_TAO_CORBA_Container_Proxy_Broker_->select_proxy (this TAO_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  return proxy.create_struct (
      this,
      id,
      name,
      version,
      members
      TAO_ENV_ARG_PARAMETER
    );
}

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
    TAO_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  _TAO_CORBA_Container_Proxy_Impl &proxy =
    this->the_TAO_CORBA_Container_Proxy_Broker_->select_proxy (this TAO_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  return proxy.create_union (
      this,
      id,
      name,
      version,
      discriminator_type,
      members
      TAO_ENV_ARG_PARAMETER
    );
}

CORBA_EnumDef_ptr CORBA_Container::create_enum (
    const char * id,
    const char * name,
    const char * version,
    const CORBA_EnumMemberSeq & members
    TAO_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  _TAO_CORBA_Container_Proxy_Impl &proxy =
    this->the_TAO_CORBA_Container_Proxy_Broker_->select_proxy (this TAO_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  return proxy.create_enum (
      this,
      id,
      name,
      version,
      members
      TAO_ENV_ARG_PARAMETER
    );
}

CORBA_AliasDef_ptr CORBA_Container::create_alias (
    const char * id,
    const char * name,
    const char * version,
    CORBA_IDLType_ptr original_type
    TAO_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  _TAO_CORBA_Container_Proxy_Impl &proxy =
    this->the_TAO_CORBA_Container_Proxy_Broker_->select_proxy (this TAO_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  return proxy.create_alias (
      this,
      id,
      name,
      version,
      original_type
      TAO_ENV_ARG_PARAMETER
    );
}

CORBA_InterfaceDef_ptr CORBA_Container::create_interface (
    const char * id,
    const char * name,
    const char * version,
    const CORBA_InterfaceDefSeq & base_interfaces
    TAO_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  _TAO_CORBA_Container_Proxy_Impl &proxy =
    this->the_TAO_CORBA_Container_Proxy_Broker_->select_proxy (this TAO_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  return proxy.create_interface (
      this,
      id,
      name,
      version,
      base_interfaces
      TAO_ENV_ARG_PARAMETER
    );
}

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
    TAO_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  _TAO_CORBA_Container_Proxy_Impl &proxy =
    this->the_TAO_CORBA_Container_Proxy_Broker_->select_proxy (this TAO_ENV_ARG_PARAMETER);
  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
      TAO_ENV_ARG_PARAMETER
    );
}

CORBA_ValueBoxDef_ptr CORBA_Container::create_value_box (
    const char * id,
    const char * name,
    const char * version,
    CORBA_IDLType_ptr original_type_def
    TAO_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  _TAO_CORBA_Container_Proxy_Impl &proxy =
    this->the_TAO_CORBA_Container_Proxy_Broker_->select_proxy (this TAO_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  return proxy.create_value_box (
      this,
      id,
      name,
      version,
      original_type_def
      TAO_ENV_ARG_PARAMETER
    );
}

CORBA_ExceptionDef_ptr CORBA_Container::create_exception (
    const char * id,
    const char * name,
    const char * version,
    const CORBA_StructMemberSeq & members
    TAO_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  _TAO_CORBA_Container_Proxy_Impl &proxy =
    this->the_TAO_CORBA_Container_Proxy_Broker_->select_proxy (this TAO_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  return proxy.create_exception (
      this,
      id,
      name,
      version,
      members
      TAO_ENV_ARG_PARAMETER
    );
}

CORBA_NativeDef_ptr CORBA_Container::create_native (
    const char * id,
    const char * name,
    const char * version
    TAO_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  _TAO_CORBA_Container_Proxy_Impl &proxy =
    this->the_TAO_CORBA_Container_Proxy_Broker_->select_proxy (this TAO_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  return proxy.create_native (
      this,
      id,
      name,
      version
      TAO_ENV_ARG_PARAMETER
    );
}

CORBA_AbstractInterfaceDef_ptr CORBA_Container::create_abstract_interface (
    const char * id,
    const char * name,
    const char * version,
    const CORBA_AbstractInterfaceDefSeq & base_interfaces
    TAO_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  _TAO_CORBA_Container_Proxy_Impl &proxy =
    this->the_TAO_CORBA_Container_Proxy_Broker_->select_proxy (this TAO_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  return proxy.create_abstract_interface (
      this,
      id,
      name,
      version,
      base_interfaces
      TAO_ENV_ARG_PARAMETER
    );
}

CORBA_LocalInterfaceDef_ptr CORBA_Container::create_local_interface (
    const char * id,
    const char * name,
    const char * version,
    const CORBA_InterfaceDefSeq & base_interfaces
    TAO_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  _TAO_CORBA_Container_Proxy_Impl &proxy =
    this->the_TAO_CORBA_Container_Proxy_Broker_->select_proxy (this TAO_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  return proxy.create_local_interface (
      this,
      id,
      name,
      version,
      base_interfaces
      TAO_ENV_ARG_PARAMETER
    );
}

CORBA_IDLType_ptr
tao_CORBA_IDLType_duplicate (
    CORBA_IDLType_ptr p
  )
{
  return CORBA_IDLType::_duplicate (p);
}

void
tao_CORBA_IDLType_release (
    CORBA_IDLType_ptr p
  )
{
  CORBA::release (p);
}

CORBA_IDLType_ptr
tao_CORBA_IDLType_nil (
    void
  )
{
  return CORBA_IDLType::_nil ();
}

CORBA_IDLType_ptr
tao_CORBA_IDLType_narrow (
    CORBA::Object *p
    TAO_ENV_ARG_DECL
  )
{
  return CORBA_IDLType::_narrow (p TAO_ENV_ARG_PARAMETER);
}

CORBA::Object *
tao_CORBA_IDLType_upcast (
    void *src
  )
{
  CORBA_IDLType **tmp =
    ACE_static_cast (CORBA_IDLType **, src);
  return *tmp;
}

int CORBA_IDLType::_tao_class_id = 0;

// *************************************************************
// Operations for class CORBA_IDLType_var
// *************************************************************

CORBA_IDLType_var::CORBA_IDLType_var (void) // default constructor
  : ptr_ (CORBA_IDLType::_nil ())
{}

::CORBA_IDLType_ptr
CORBA_IDLType_var::ptr (void) const
{
  return this->ptr_;
}

CORBA_IDLType_var::CORBA_IDLType_var (const ::CORBA_IDLType_var &p) // copy constructor
  : TAO_Base_var (),
    ptr_ (CORBA_IDLType::_duplicate (p.ptr ()))
{}

CORBA_IDLType_var::~CORBA_IDLType_var (void) // destructor
{
  CORBA::release (this->ptr_);
}

CORBA_IDLType_var &
CORBA_IDLType_var::operator= (CORBA_IDLType_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

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;
}

CORBA_IDLType_var::operator const ::CORBA_IDLType_ptr &() const // cast
{
  return this->ptr_;
}

CORBA_IDLType_var::operator ::CORBA_IDLType_ptr &() // cast
{
  return this->ptr_;
}

::CORBA_IDLType_ptr
CORBA_IDLType_var::operator-> (void) const
{
  return this->ptr_;
}

::CORBA_IDLType_ptr
CORBA_IDLType_var::in (void) const
{
  return this->ptr_;
}

::CORBA_IDLType_ptr &
CORBA_IDLType_var::inout (void)
{
  return this->ptr_;
}

::CORBA_IDLType_ptr &
CORBA_IDLType_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::CORBA_IDLType::_nil ();
  return this->ptr_;
}

::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;
}

::CORBA_IDLType_ptr
CORBA_IDLType_var::tao_duplicate (CORBA_IDLType_ptr p)
{
  return ::CORBA_IDLType::_duplicate (p);
}

void
CORBA_IDLType_var::tao_release (CORBA_IDLType_ptr p)
{
  CORBA::release (p);
}

::CORBA_IDLType_ptr
CORBA_IDLType_var::tao_nil (void)
{
  return ::CORBA_IDLType::_nil ();
}

::CORBA_IDLType_ptr
CORBA_IDLType_var::tao_narrow (
    CORBA::Object *p
    TAO_ENV_ARG_DECL
  )
{
  return ::CORBA_IDLType::_narrow (p TAO_ENV_ARG_PARAMETER);
}

CORBA::Object *
CORBA_IDLType_var::tao_upcast (void *src)
{
  CORBA_IDLType **tmp =
    ACE_static_cast (CORBA_IDLType **, src);
  return *tmp;
}

// *************************************************************
// Operations for class CORBA_IDLType_out
// *************************************************************

CORBA_IDLType_out::CORBA_IDLType_out (CORBA_IDLType_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = ::CORBA_IDLType::_nil ();
}

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 ();
}

CORBA_IDLType_out::CORBA_IDLType_out (const ::CORBA_IDLType_out &p) // copy constructor
  : ptr_ (ACE_const_cast (CORBA_IDLType_out &, p).ptr_)
{}

::CORBA_IDLType_out &
CORBA_IDLType_out::operator= (const ::CORBA_IDLType_out &p)
{
  this->ptr_ = ACE_const_cast (CORBA_IDLType_out&, p).ptr_;
  return *this;
}

CORBA_IDLType_out &
CORBA_IDLType_out::operator= (const ::CORBA_IDLType_var &p)
{
  this->ptr_ = ::CORBA_IDLType::_duplicate (p.ptr ());
  return *this;
}

CORBA_IDLType_out &
CORBA_IDLType_out::operator= (CORBA_IDLType_ptr p)
{
  this->ptr_ = p;
  return *this;
}

CORBA_IDLType_out::operator ::CORBA_IDLType_ptr &() // cast
{
  return this->ptr_;
}

::CORBA_IDLType_ptr &
CORBA_IDLType_out::ptr (void) // ptr
{
  return this->ptr_;
}

::CORBA_IDLType_ptr
CORBA_IDLType_out::operator-> (void)
{
  return this->ptr_;
}


#if (TAO_HAS_INTERCEPTORS == 1)
class TAO_ClientRequestInfo_CORBA_IDLType_type_get : public TAO_ClientRequestInfo_i
{
public:
  TAO_ClientRequestInfo_CORBA_IDLType_type_get (
      TAO_GIOP_Invocation *_tao_invocation,
      CORBA::Object_ptr _tao_target
      TAO_ENV_ARG_DECL_WITH_DEFAULTS);


  virtual Dynamic::ParameterList * arguments (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  virtual Dynamic::ExceptionList * exceptions (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  virtual CORBA::Any * result (
      TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)

    ACE_THROW_SPEC ((CORBA::SystemException));

  void result (CORBA::TypeCode_ptr result);

private:
  TAO_ClientRequestInfo_CORBA_IDLType_type_get (const TAO_ClientRequestInfo_CORBA_IDLType_type_get &);
  void operator= (const TAO_ClientRequestInfo_CORBA_IDLType_type_get &);

  CORBA::TypeCode_ptr _result;
};

TAO_ClientRequestInfo_CORBA_IDLType_type_get::TAO_ClientRequestInfo_CORBA_IDLType_type_get (
    TAO_GIOP_Invocation *_tao_invocation,
    CORBA::Object_ptr _tao_target
    TAO_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ClientRequestInfo_i (_tao_invocation, _tao_target)
{}

Dynamic::ParameterList *
TAO_ClientRequestInfo_CORBA_IDLType_type_get::arguments (TAO_ENV_SINGLE_ARG_DECL)
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the argument list on demand.
  Dynamic::ParameterList *parameter_list =
    TAO_RequestInfo_Util::make_parameter_list (TAO_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  return parameter_list;
}

Dynamic::ExceptionList *
TAO_ClientRequestInfo_CORBA_IDLType_type_get::exceptions (TAO_ENV_SINGLE_ARG_DECL)
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the exception list on demand.
  Dynamic::ExceptionList *exception_list =
    TAO_RequestInfo_Util::make_exception_list (TAO_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  return exception_list;
}


CORBA::Any *
TAO_ClientRequestInfo_CORBA_IDLType_type_get::result (TAO_ENV_SINGLE_ARG_DECL)
  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 TAO_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  CORBA::Any_var safe_result_any = result_any;

  (*result_any) <<= this->_result;
  return safe_result_any._retn ();
}

void
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_CORBA_IDLType_Proxy_Impl::_TAO_CORBA_IDLType_Proxy_Impl (void)
{}

_TAO_CORBA_IDLType_Remote_Proxy_Impl::_TAO_CORBA_IDLType_Remote_Proxy_Impl (void)
{}

// Remote Implementation of the IDL interface methods

CORBA::TypeCode_ptr _TAO_CORBA_IDLType_Remote_Proxy_Impl::type (
    CORBA_Object *_collocated_tao_target_
    TAO_ENV_ARG_DECL
  )
  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 ()
    );

  int _invoke_status;

#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
      istub->orb_core ()->client_request_interceptors (),
      &_tao_call,
      _invoke_status
    );

#endif  /* TAO_HAS_INTERCEPTORS */

  for (;;)
    {
      _invoke_status = TAO_INVOKE_EXCEPTION;

#if TAO_HAS_INTERCEPTORS == 1
      TAO_ClientRequestInfo_CORBA_IDLType_type_get ri (
        &_tao_call,
        _collocated_tao_target_
        TAO_ENV_ARG_PARAMETER
      );
      ACE_CHECK_RETURN (0);

#endif /* TAO_HAS_INTERCEPTORS */


      CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
      TAO_INTERCEPTOR (ri.response_expected (1));

#if TAO_HAS_INTERCEPTORS == 1

      ACE_TRY
        {
          _tao_vfr.send_request (
            &ri
            TAO_ENV_ARG_PARAMETER
          );
          ACE_TRY_CHECK;

          if (_invoke_status == TAO_INVOKE_RESTART)
            {
              _tao_call.restart_flag (1);
              continue;
            }

#endif /* TAO_HAS_INTERCEPTORS */

          _tao_call.start (TAO_ENV_SINGLE_ARG_PARAMETER);
          TAO_INTERCEPTOR_CHECK_RETURN (0);

          _tao_call.prepare_header (
              ACE_static_cast (CORBA::Octet, _tao_response_flag)
              TAO_ENV_ARG_PARAMETER
            );
          TAO_INTERCEPTOR_CHECK_RETURN (0);

          _invoke_status =
            _tao_call.invoke (0, 0 TAO_ENV_ARG_PARAMETER);
          TAO_INTERCEPTOR_CHECK_RETURN (0);

          if (_invoke_status == TAO_INVOKE_EXCEPTION)
            {
              TAO_INTERCEPTOR_THROW_RETURN (
                CORBA::UNKNOWN (TAO_OMG_VMCID | 1, CORBA::COMPLETED_YES),
                0
              );

            }
          else if (_invoke_status == TAO_INVOKE_RESTART)
            {
              TAO_INTERCEPTOR (
                ri.reply_status (_invoke_status);
                _tao_vfr.receive_other (
                  &ri
                  TAO_ENV_ARG_PARAMETER
                );
                ACE_TRY_CHECK;
              )

              continue;
            }

          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
              );

            }

#if TAO_HAS_INTERCEPTORS == 1
          CORBA::TypeCode_ptr _tao_retval_info = _tao_safe_retval._retn ();
          ri.result (_tao_retval_info);
          _tao_safe_retval = _tao_retval_info;

          ri.reply_status (_invoke_status);
          _tao_vfr.receive_reply (
            &ri
            TAO_ENV_ARG_PARAMETER
          );
          ACE_TRY_CHECK;

      }
    ACE_CATCHANY
      {
        ri.exception (&ACE_ANY_EXCEPTION);
        _tao_vfr.receive_exception (
          &ri
          TAO_ENV_ARG_PARAMETER
        );
        ACE_TRY_CHECK;

        PortableInterceptor::ReplyStatus _tao_status =
          ri.reply_status (TAO_ENV_SINGLE_ARG_PARAMETER);
        ACE_TRY_CHECK;

        if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION
            || _tao_status == PortableInterceptor::USER_EXCEPTION)
          ACE_RE_THROW;
      }
    ACE_ENDTRY;
    ACE_CHECK_RETURN (0);

    PortableInterceptor::ReplyStatus _tao_status =
      ri.reply_status (TAO_ENV_SINGLE_ARG_PARAMETER);
    ACE_CHECK_RETURN (0);

    if (_tao_status == PortableInterceptor::LOCATION_FORWARD
        || _tao_status == PortableInterceptor::TRANSPORT_RETRY)
      continue;

#endif  /* TAO_HAS_INTERCEPTORS */

    break;
  }
return _tao_safe_retval._retn ();
}


//
//            End  Base & Remote  Proxy Implemeentation.
///////////////////////////////////////////////////////////////////////


///////////////////////////////////////////////////////////////////////
//           Remote & Base  Proxy Broker Implementation
//

_TAO_CORBA_IDLType_Proxy_Broker::_TAO_CORBA_IDLType_Proxy_Broker (void)
{
}

_TAO_CORBA_IDLType_Proxy_Broker::~_TAO_CORBA_IDLType_Proxy_Broker (void)
{
}

_TAO_CORBA_IDLType_Proxy_Broker * (*_TAO_CORBA_IDLType_Proxy_Broker_Factory_function_pointer) (
    CORBA::Object_ptr obj
  ) = 0;

// Factory Member function Implementation.
_TAO_CORBA_IDLType_Remote_Proxy_Broker *
_TAO_CORBA_IDLType_Remote_Proxy_Broker::the_TAO_CORBA_IDLType_Remote_Proxy_Broker (void)
{
  static ::_TAO_CORBA_IDLType_Remote_Proxy_Broker remote_proxy_broker;
  return &remote_proxy_broker;
}

_TAO_CORBA_IDLType_Remote_Proxy_Broker::_TAO_CORBA_IDLType_Remote_Proxy_Broker (void)
{
}

_TAO_CORBA_IDLType_Remote_Proxy_Broker::~_TAO_CORBA_IDLType_Remote_Proxy_Broker (void)
{
}

_TAO_CORBA_IDLType_Proxy_Impl&
_TAO_CORBA_IDLType_Remote_Proxy_Broker::select_proxy (
  ::CORBA_IDLType *
  TAO_ENV_ARG_DECL_NOT_USED
)
{
  return this->remote_proxy_impl_;
}


//
//           End Remote & Base Proxy Broker Implementation
///////////////////////////////////////////////////////////////////////


// default constructor
CORBA_IDLType::CORBA_IDLType (int collocated)
{
  this->CORBA_IDLType_setup_collocation (collocated);
}

// destructor
CORBA_IDLType::~CORBA_IDLType (void)
{}

void
CORBA_IDLType::CORBA_IDLType_setup_collocation (int collocated)
{
  if (collocated)
    this->the_TAO_CORBA_IDLType_Proxy_Broker_ =
      ::_TAO_CORBA_IDLType_Proxy_Broker_Factory_function_pointer (this);
  else
    this->the_TAO_CORBA_IDLType_Proxy_Broker_ =
      ::_TAO_CORBA_IDLType_Remote_Proxy_Broker::the_TAO_CORBA_IDLType_Remote_Proxy_Broker ();

  this->CORBA_IRObject_setup_collocation (collocated);
}

void CORBA_IDLType::_tao_any_destructor (void *_tao_void_pointer)
{
  CORBA_IDLType *tmp = ACE_static_cast (CORBA_IDLType*, _tao_void_pointer);
  CORBA::release (tmp);
}

CORBA_IDLType_ptr CORBA_IDLType::_narrow (
    CORBA::Object_ptr obj
    TAO_ENV_ARG_DECL
  )
{
  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" TAO_ENV_ARG_PARAMETER);
      ACE_CHECK_RETURN (CORBA_IDLType::_nil ());
      if (is_a == 0)
        return CORBA_IDLType::_nil ();
    }
  return CORBA_IDLType::_unchecked_narrow (obj TAO_ENV_ARG_PARAMETER);
}

CORBA_IDLType_ptr CORBA_IDLType::_unchecked_narrow (
    CORBA::Object_ptr obj
    TAO_ENV_ARG_DECL_NOT_USED
  )
{
  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 () &&_TAO_CORBA_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::_tao_class_id
                    )
                )
          );
}

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 TAO_ENV_ARG_DECL)
{
  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 TAO_ENV_ARG_PARAMETER);
}

void *CORBA_IDLType::_tao_QueryInterface (ptr_arith_t type)
{
  void *retv = 0;
  if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &CORBA_IDLType::_tao_class_id))
    retv = ACE_reinterpret_cast (void*, this);
  else if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &CORBA_IRObject::_tao_class_id))
    retv = ACE_reinterpret_cast
      (
        void *,
        ACE_static_cast
          (
            CORBA_IRObject_ptr,
            this
          )
      );
  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_tao_class_id))
    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 (
    TAO_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  _TAO_CORBA_IDLType_Proxy_Impl &proxy =
    this->the_TAO_CORBA_IDLType_Proxy_Broker_->select_proxy (this TAO_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  return proxy.type (
      this
      TAO_ENV_ARG_PARAMETER
    );
}

CORBA_TypedefDef_ptr
tao_CORBA_TypedefDef_duplicate (
    CORBA_TypedefDef_ptr p
  )
{
  return CORBA_TypedefDef::_duplicate (p);
}

void
tao_CORBA_TypedefDef_release (
    CORBA_TypedefDef_ptr p
  )
{
  CORBA::release (p);
}

CORBA_TypedefDef_ptr
tao_CORBA_TypedefDef_nil (
    void
  )
{
  return CORBA_TypedefDef::_nil ();
}

CORBA_TypedefDef_ptr
tao_CORBA_TypedefDef_narrow (
    CORBA::Object *p
    TAO_ENV_ARG_DECL
  )
{
  return CORBA_TypedefDef::_narrow (p TAO_ENV_ARG_PARAMETER);
}

CORBA::Object *
tao_CORBA_TypedefDef_upcast (
    void *src
  )
{
  CORBA_TypedefDef **tmp =
    ACE_static_cast (CORBA_TypedefDef **, src);
  return *tmp;
}

int CORBA_TypedefDef::_tao_class_id = 0;

// *************************************************************
// Operations for class CORBA_TypedefDef_var
// *************************************************************

CORBA_TypedefDef_var::CORBA_TypedefDef_var (void) // default constructor
  : ptr_ (CORBA_TypedefDef::_nil ())
{}

::CORBA_TypedefDef_ptr
CORBA_TypedefDef_var::ptr (void) const
{
  return this->ptr_;
}

CORBA_TypedefDef_var::CORBA_TypedefDef_var (const ::CORBA_TypedefDef_var &p) // copy constructor
  : TAO_Base_var (),
    ptr_ (CORBA_TypedefDef::_duplicate (p.ptr ()))
{}

CORBA_TypedefDef_var::~CORBA_TypedefDef_var (void) // destructor
{
  CORBA::release (this->ptr_);
}

CORBA_TypedefDef_var &
CORBA_TypedefDef_var::operator= (CORBA_TypedefDef_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

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;
}

CORBA_TypedefDef_var::operator const ::CORBA_TypedefDef_ptr &() const // cast
{
  return this->ptr_;
}

CORBA_TypedefDef_var::operator ::CORBA_TypedefDef_ptr &() // cast
{
  return this->ptr_;
}

::CORBA_TypedefDef_ptr
CORBA_TypedefDef_var::operator-> (void) const
{
  return this->ptr_;
}

::CORBA_TypedefDef_ptr
CORBA_TypedefDef_var::in (void) const
{
  return this->ptr_;
}

::CORBA_TypedefDef_ptr &
CORBA_TypedefDef_var::inout (void)
{
  return this->ptr_;
}

::CORBA_TypedefDef_ptr &
CORBA_TypedefDef_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::CORBA_TypedefDef::_nil ();
  return this->ptr_;
}

::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;
}

::CORBA_TypedefDef_ptr
CORBA_TypedefDef_var::tao_duplicate (CORBA_TypedefDef_ptr p)
{
  return ::CORBA_TypedefDef::_duplicate (p);
}

void
CORBA_TypedefDef_var::tao_release (CORBA_TypedefDef_ptr p)
{
  CORBA::release (p);
}

::CORBA_TypedefDef_ptr
CORBA_TypedefDef_var::tao_nil (void)
{
  return ::CORBA_TypedefDef::_nil ();
}

::CORBA_TypedefDef_ptr
CORBA_TypedefDef_var::tao_narrow (
    CORBA::Object *p
    TAO_ENV_ARG_DECL
  )
{
  return ::CORBA_TypedefDef::_narrow (p TAO_ENV_ARG_PARAMETER);
}

CORBA::Object *
CORBA_TypedefDef_var::tao_upcast (void *src)
{
  CORBA_TypedefDef **tmp =
    ACE_static_cast (CORBA_TypedefDef **, src);
  return *tmp;
}

// *************************************************************
// Operations for class CORBA_TypedefDef_out
// *************************************************************

CORBA_TypedefDef_out::CORBA_TypedefDef_out (CORBA_TypedefDef_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = ::CORBA_TypedefDef::_nil ();
}

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 ();
}

CORBA_TypedefDef_out::CORBA_TypedefDef_out (const ::CORBA_TypedefDef_out &p) // copy constructor
  : ptr_ (ACE_const_cast (CORBA_TypedefDef_out &, p).ptr_)
{}

::CORBA_TypedefDef_out &
CORBA_TypedefDef_out::operator= (const ::CORBA_TypedefDef_out &p)
{
  this->ptr_ = ACE_const_cast (CORBA_TypedefDef_out&, p).ptr_;
  return *this;
}

CORBA_TypedefDef_out &
CORBA_TypedefDef_out::operator= (const ::CORBA_TypedefDef_var &p)
{
  this->ptr_ = ::CORBA_TypedefDef::_duplicate (p.ptr ());
  return *this;
}

CORBA_TypedefDef_out &
CORBA_TypedefDef_out::operator= (CORBA_TypedefDef_ptr p)
{
  this->ptr_ = p;
  return *this;
}

CORBA_TypedefDef_out::operator ::CORBA_TypedefDef_ptr &() // cast
{
  return this->ptr_;
}

::CORBA_TypedefDef_ptr &
CORBA_TypedefDef_out::ptr (void) // ptr
{
  return this->ptr_;
}

::CORBA_TypedefDef_ptr
CORBA_TypedefDef_out::operator-> (void)
{
  return this->ptr_;
}


#if (TAO_HAS_INTERCEPTORS == 1)
#endif /* TAO_HAS_INTERCEPTORS */

///////////////////////////////////////////////////////////////////////
//                Base & Remote Proxy  Implementation.
//

_TAO_CORBA_TypedefDef_Proxy_Impl::_TAO_CORBA_TypedefDef_Proxy_Impl (void)
{}

_TAO_CORBA_TypedefDef_Remote_Proxy_Impl::_TAO_CORBA_TypedefDef_Remote_Proxy_Impl (void)
{}

// Remote Implementation of the IDL interface methods


//
//            End  Base & Remote  Proxy Implemeentation.
///////////////////////////////////////////////////////////////////////


///////////////////////////////////////////////////////////////////////
//           Remote & Base  Proxy Broker Implementation
//

_TAO_CORBA_TypedefDef_Proxy_Broker::_TAO_CORBA_TypedefDef_Proxy_Broker (void)
{
}

_TAO_CORBA_TypedefDef_Proxy_Broker::~_TAO_CORBA_TypedefDef_Proxy_Broker (void)
{
}

_TAO_CORBA_TypedefDef_Proxy_Broker * (*_TAO_CORBA_TypedefDef_Proxy_Broker_Factory_function_pointer) (
    CORBA::Object_ptr obj
  ) = 0;

// Factory Member function Implementation.
_TAO_CORBA_TypedefDef_Remote_Proxy_Broker *
_TAO_CORBA_TypedefDef_Remote_Proxy_Broker::the_TAO_CORBA_TypedefDef_Remote_Proxy_Broker (void)
{
  static ::_TAO_CORBA_TypedefDef_Remote_Proxy_Broker remote_proxy_broker;
  return &remote_proxy_broker;
}

_TAO_CORBA_TypedefDef_Remote_Proxy_Broker::_TAO_CORBA_TypedefDef_Remote_Proxy_Broker (void)
{
}

_TAO_CORBA_TypedefDef_Remote_Proxy_Broker::~_TAO_CORBA_TypedefDef_Remote_Proxy_Broker (void)
{
}

_TAO_CORBA_TypedefDef_Proxy_Impl&
_TAO_CORBA_TypedefDef_Remote_Proxy_Broker::select_proxy (
  ::CORBA_TypedefDef *
  TAO_ENV_ARG_DECL_NOT_USED
)
{
  return this->remote_proxy_impl_;
}


//
//           End Remote & Base Proxy Broker Implementation
///////////////////////////////////////////////////////////////////////


// default constructor
CORBA_TypedefDef::CORBA_TypedefDef (int collocated)
{
  this->CORBA_TypedefDef_setup_collocation (collocated);
}

// destructor
CORBA_TypedefDef::~CORBA_TypedefDef (void)
{}

void
CORBA_TypedefDef::CORBA_TypedefDef_setup_collocation (int collocated)
{
  if (collocated)
    this->the_TAO_CORBA_TypedefDef_Proxy_Broker_ =
      ::_TAO_CORBA_TypedefDef_Proxy_Broker_Factory_function_pointer (this);
  else
    this->the_TAO_CORBA_TypedefDef_Proxy_Broker_ =
      ::_TAO_CORBA_TypedefDef_Remote_Proxy_Broker::the_TAO_CORBA_TypedefDef_Remote_Proxy_Broker ();

  this->CORBA_Contained_setup_collocation (collocated);

  this->CORBA_IDLType_setup_collocation (collocated);
}

void CORBA_TypedefDef::_tao_any_destructor (void *_tao_void_pointer)
{
  CORBA_TypedefDef *tmp = ACE_static_cast (CORBA_TypedefDef*, _tao_void_pointer);
  CORBA::release (tmp);
}

CORBA_TypedefDef_ptr CORBA_TypedefDef::_narrow (
    CORBA::Object_ptr obj
    TAO_ENV_ARG_DECL
  )
{
  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" TAO_ENV_ARG_PARAMETER);
      ACE_CHECK_RETURN (CORBA_TypedefDef::_nil ());
      if (is_a == 0)
        return CORBA_TypedefDef::_nil ();
    }
  return CORBA_TypedefDef::_unchecked_narrow (obj TAO_ENV_ARG_PARAMETER);
}

CORBA_TypedefDef_ptr CORBA_TypedefDef::_unchecked_narrow (
    CORBA::Object_ptr obj
    TAO_ENV_ARG_DECL_NOT_USED
  )
{
  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 () &&_TAO_CORBA_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::_tao_class_id
                    )
                )
          );
}

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 TAO_ENV_ARG_DECL)
{
  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 TAO_ENV_ARG_PARAMETER);
}

void *CORBA_TypedefDef::_tao_QueryInterface (ptr_arith_t type)
{
  void *retv = 0;
  if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &CORBA_TypedefDef::_tao_class_id))
    retv = ACE_reinterpret_cast (void*, this);
  else if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &CORBA_Contained::_tao_class_id))
    retv = ACE_reinterpret_cast
      (
        void *,
        ACE_static_cast
          (
            CORBA_Contained_ptr,
            this
          )
      );
  else if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &CORBA_IDLType::_tao_class_id))
    retv = ACE_reinterpret_cast
      (
        void *,
        ACE_static_cast
          (
            CORBA_IDLType_ptr,
            this
          )
      );
  else if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &CORBA_IRObject::_tao_class_id))
    retv = ACE_reinterpret_cast
      (
        void *,
        ACE_static_cast
          (
            CORBA_IRObject_ptr,
            this
          )
      );
  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_tao_class_id))
    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";
}

void CORBA_TypeDescription::_tao_any_destructor (void *_tao_void_pointer)
{
  CORBA_TypeDescription *tmp = ACE_static_cast (CORBA_TypeDescription*, _tao_void_pointer);
  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 TAO_ENV_ARG_PARAMETER);
    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 TAO_ENV_ARG_PARAMETER);
    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 TAO_ENV_ARG_PARAMETER);
    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 TAO_ENV_ARG_PARAMETER);
    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 TAO_ENV_ARG_PARAMETER);
    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_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 TAO_ENV_ARG_PARAMETER);
    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_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 TAO_ENV_ARG_PARAMETER);
    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,
    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 TAO_ENV_ARG_PARAMETER);
    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 TAO_ENV_ARG_PARAMETER);
    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, 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 TAO_ENV_ARG_PARAMETER);
    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 TAO_ENV_ARG_PARAMETER);
    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 TAO_ENV_ARG_PARAMETER);
    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 TAO_ENV_ARG_PARAMETER);
    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 TAO_ENV_ARG_PARAMETER);
    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 TAO_ENV_ARG_PARAMETER);
    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 TAO_ENV_ARG_PARAMETER);
    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 TAO_ENV_ARG_PARAMETER);
    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 TAO_ENV_ARG_PARAMETER);
    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 TAO_ENV_ARG_PARAMETER);
    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 TAO_ENV_ARG_PARAMETER);
    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 TAO_ENV_ARG_PARAMETER);
    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 TAO_ENV_ARG_PARAMETER);
    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_IRObject_ptr _tao_objref
  )
{
  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
  return (strm << _tao_corba_obj);
}

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 ()
          TAO_ENV_ARG_PARAMETER
        );
    ACE_TRY_CHECK;
    return 1;
  }
  ACE_CATCHANY
  {
    // do nothing
  }
  ACE_ENDTRY;
  return 0;
}

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);
}

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 ()
          TAO_ENV_ARG_PARAMETER
        );
    ACE_TRY_CHECK;
    return 1;
  }
  ACE_CATCHANY
  {
    // do nothing
  }
  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_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_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_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_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
}

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);
}

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 ()
          TAO_ENV_ARG_PARAMETER
        );
    ACE_TRY_CHECK;
    return 1;
  }
  ACE_CATCHANY
  {
    // do nothing
  }
  ACE_ENDTRY;
  return 0;
}

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);
}

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 ()
          TAO_ENV_ARG_PARAMETER
        );
    ACE_TRY_CHECK;
    return 1;
  }
  ACE_CATCHANY
  {
    // do nothing
  }
  ACE_ENDTRY;
  return 0;
}

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);
}

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 ()
          TAO_ENV_ARG_PARAMETER
        );
    ACE_TRY_CHECK;
    return 1;
  }
  ACE_CATCHANY
  {
    // do nothing
  }
  ACE_ENDTRY;
  return 0;
}