// -*- C++ -*-
//
// ImplRepoC.cpp,v 1.15 2002/02/08 01:07:36 coryan Exp

// ****  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 "ImplRepoC.h"

#include "tao/Stub.h"
#include "tao/Invocation.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 -w-sig
#endif /* __BORLANDC__ */

#if !defined (__ACE_INLINE__)
#include "ImplRepoC.i"
#endif /* !defined INLINE */

int ImplementationRepository::ServerObject::_tao_class_id = 0;

ImplementationRepository::ServerObject_ptr
tao_ImplementationRepository_ServerObject_duplicate (
    ImplementationRepository::ServerObject_ptr p
  )
{
  return ImplementationRepository::ServerObject::_duplicate (p);
}

void
tao_ImplementationRepository_ServerObject_release (
    ImplementationRepository::ServerObject_ptr p
  )
{
  CORBA::release (p);
}

ImplementationRepository::ServerObject_ptr
tao_ImplementationRepository_ServerObject_nil (
    void
  )
{
  return ImplementationRepository::ServerObject::_nil ();
}

ImplementationRepository::ServerObject_ptr
tao_ImplementationRepository_ServerObject_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return ImplementationRepository::ServerObject::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
tao_ImplementationRepository_ServerObject_upcast (
    void *src
  )
{
  ImplementationRepository::ServerObject **tmp =
    ACE_static_cast (ImplementationRepository::ServerObject **, src);
  return *tmp;
}

// *************************************************************
// ImplementationRepository::ServerObject_var
// TAO_IDL - Generated from
// be/be_interface.cpp:654
// *************************************************************

ImplementationRepository::ServerObject_var::ServerObject_var (void) // default constructor
  : ptr_ (ServerObject::_nil ())
{}

::ImplementationRepository::ServerObject_ptr
ImplementationRepository::ServerObject_var::ptr (void) const
{
  return this->ptr_;
}

ImplementationRepository::ServerObject_var::ServerObject_var (const ::ImplementationRepository::ServerObject_var &p) // copy constructor
  : TAO_Base_var (),
    ptr_ (ServerObject::_duplicate (p.ptr ()))
{}

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

ImplementationRepository::ServerObject_var &
ImplementationRepository::ServerObject_var::operator= (ServerObject_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

ImplementationRepository::ServerObject_var &
ImplementationRepository::ServerObject_var::operator= (const ::ImplementationRepository::ServerObject_var &p)
{
  if (this != &p)
  {
    CORBA::release (this->ptr_);
    this->ptr_ = ::ImplementationRepository::ServerObject::_duplicate (p.ptr ());
  }
  return *this;
}

ImplementationRepository::ServerObject_var::operator const ::ImplementationRepository::ServerObject_ptr &() const // cast
{
  return this->ptr_;
}

ImplementationRepository::ServerObject_var::operator ::ImplementationRepository::ServerObject_ptr &() // cast 
{
  return this->ptr_;
}

::ImplementationRepository::ServerObject_ptr
ImplementationRepository::ServerObject_var::operator-> (void) const
{
  return this->ptr_;
}

::ImplementationRepository::ServerObject_ptr
ImplementationRepository::ServerObject_var::in (void) const
{
  return this->ptr_;
}

::ImplementationRepository::ServerObject_ptr &
ImplementationRepository::ServerObject_var::inout (void)
{
  return this->ptr_;
}

::ImplementationRepository::ServerObject_ptr &
ImplementationRepository::ServerObject_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::ImplementationRepository::ServerObject::_nil ();
  return this->ptr_;
}

::ImplementationRepository::ServerObject_ptr
ImplementationRepository::ServerObject_var::_retn (void)
{
  // yield ownership of managed obj reference
  ::ImplementationRepository::ServerObject_ptr val = this->ptr_;
  this->ptr_ = ::ImplementationRepository::ServerObject::_nil ();
  return val;
}

::ImplementationRepository::ServerObject_ptr
ImplementationRepository::ServerObject_var::tao_duplicate (ServerObject_ptr p)
{
  return ::ImplementationRepository::ServerObject::_duplicate (p);
}

void
ImplementationRepository::ServerObject_var::tao_release (ServerObject_ptr p)
{
  CORBA::release (p);
}

::ImplementationRepository::ServerObject_ptr
ImplementationRepository::ServerObject_var::tao_nil (void)
{
  return ::ImplementationRepository::ServerObject::_nil ();
}

::ImplementationRepository::ServerObject_ptr
ImplementationRepository::ServerObject_var::tao_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return ::ImplementationRepository::ServerObject::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
ImplementationRepository::ServerObject_var::tao_upcast (void *src)
{
  ServerObject **tmp =
    ACE_static_cast (ServerObject **, src);
  return *tmp;
}

// *************************************************************
// ImplementationRepository::ServerObject_out
// TAO_IDL - Generated from
// be/be_interface.cpp:932
// *************************************************************

ImplementationRepository::ServerObject_out::ServerObject_out (ServerObject_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = ::ImplementationRepository::ServerObject::_nil ();
}

ImplementationRepository::ServerObject_out::ServerObject_out (ServerObject_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::ImplementationRepository::ServerObject::_nil ();
}

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

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

ImplementationRepository::ServerObject_out &
ImplementationRepository::ServerObject_out::operator= (const ::ImplementationRepository::ServerObject_var &p)
{
  this->ptr_ = ::ImplementationRepository::ServerObject::_duplicate (p.ptr ());
  return *this;
}

ImplementationRepository::ServerObject_out &
ImplementationRepository::ServerObject_out::operator= (ServerObject_ptr p)
{
  this->ptr_ = p;
  return *this;
}

ImplementationRepository::ServerObject_out::operator ::ImplementationRepository::ServerObject_ptr &() // cast
{
  return this->ptr_;
}

::ImplementationRepository::ServerObject_ptr &
ImplementationRepository::ServerObject_out::ptr (void) // ptr
{
  return this->ptr_;
}

::ImplementationRepository::ServerObject_ptr
ImplementationRepository::ServerObject_out::operator-> (void)
{
  return this->ptr_;
}


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

  virtual Dynamic::ParameterList * arguments (ACE_ENV_SINGLE_ARG_DECL)
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual Dynamic::ExceptionList * exceptions (ACE_ENV_SINGLE_ARG_DECL)
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual CORBA::Any * result (ACE_ENV_SINGLE_ARG_DECL)
    ACE_THROW_SPEC ((CORBA::SystemException));

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

  
};

TAO_ClientRequestInfo_ImplementationRepository_ServerObject_ping::TAO_ClientRequestInfo_ImplementationRepository_ServerObject_ping (
    TAO_GIOP_Invocation *_tao_invocation,
    CORBA::Object_ptr _tao_target ACE_ENV_ARG_DECL_NOT_USED    
  )
  : TAO_ClientRequestInfo_i (_tao_invocation, _tao_target)
{}

Dynamic::ParameterList *
TAO_ClientRequestInfo_ImplementationRepository_ServerObject_ping::arguments (ACE_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 (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  return parameter_list;

}

Dynamic::ExceptionList *
TAO_ClientRequestInfo_ImplementationRepository_ServerObject_ping::exceptions (ACE_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 (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  return exception_list;
}

CORBA::Any * 
TAO_ClientRequestInfo_ImplementationRepository_ServerObject_ping::result (ACE_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 ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  return result_any;
}

class TAO_ClientRequestInfo_ImplementationRepository_ServerObject_shutdown : public TAO_ClientRequestInfo_i
{
public:
  TAO_ClientRequestInfo_ImplementationRepository_ServerObject_shutdown (
      TAO_GIOP_Invocation *_tao_invocation,
      CORBA::Object_ptr _tao_target ACE_ENV_ARG_DECL_WITH_DEFAULTS
    );

  virtual Dynamic::ParameterList * arguments (ACE_ENV_SINGLE_ARG_DECL)
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual Dynamic::ExceptionList * exceptions (ACE_ENV_SINGLE_ARG_DECL)
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual CORBA::Any * result (ACE_ENV_SINGLE_ARG_DECL)
    ACE_THROW_SPEC ((CORBA::SystemException));

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

  
};

TAO_ClientRequestInfo_ImplementationRepository_ServerObject_shutdown::TAO_ClientRequestInfo_ImplementationRepository_ServerObject_shutdown (
    TAO_GIOP_Invocation *_tao_invocation,
    CORBA::Object_ptr _tao_target ACE_ENV_ARG_DECL_NOT_USED    
  )
  : TAO_ClientRequestInfo_i (_tao_invocation, _tao_target)
{}

Dynamic::ParameterList *
TAO_ClientRequestInfo_ImplementationRepository_ServerObject_shutdown::arguments (ACE_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 (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  return parameter_list;

}

Dynamic::ExceptionList *
TAO_ClientRequestInfo_ImplementationRepository_ServerObject_shutdown::exceptions (ACE_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 (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  return exception_list;
}

CORBA::Any * 
TAO_ClientRequestInfo_ImplementationRepository_ServerObject_shutdown::result (ACE_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 ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  return result_any;
}

#endif /* TAO_HAS_INTERCEPTORS */

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

ImplementationRepository::_TAO_ServerObject_Proxy_Impl::_TAO_ServerObject_Proxy_Impl (void)
{}

ImplementationRepository::_TAO_ServerObject_Remote_Proxy_Impl::_TAO_ServerObject_Remote_Proxy_Impl (void)
{}

// Remote Implementation of the IDL interface methods

void ImplementationRepository::_TAO_ServerObject_Remote_Proxy_Impl::ping (
    CORBA_Object *_collocated_tao_target_
    ACE_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,
      "ping",
      4,
      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_ImplementationRepository_ServerObject_ping _tao_ri (
        &_tao_call,
        _collocated_tao_target_ ACE_ENV_ARG_PARAMETER
      );
            ACE_CHECK;

#endif /* TAO_HAS_INTERCEPTORS */
      
      
      CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
      TAO_INTERCEPTOR (_tao_ri.response_expected (1));
      
#if TAO_HAS_INTERCEPTORS == 1
      
      ACE_TRY
        {
          _tao_vfr.send_request (
            &_tao_ri
            ACE_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 (ACE_ENV_SINGLE_ARG_PARAMETER);
                    TAO_INTERCEPTOR_CHECK;

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

          _invoke_status =
            _tao_call.invoke (0, 0 ACE_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 (
                _tao_ri.reply_status (_invoke_status);
                _tao_vfr.receive_other (
                  &_tao_ri
                  ACE_ENV_ARG_PARAMETER
                );
                ACE_TRY_CHECK;
              )
              
              continue;
            }
          
          
#if TAO_HAS_INTERCEPTORS == 1
          
          _tao_ri.reply_status (_invoke_status);
          _tao_vfr.receive_reply (
            &_tao_ri
            ACE_ENV_ARG_PARAMETER
          );
          ACE_TRY_CHECK;
        
      }
    ACE_CATCHANY
      {
        _tao_ri.exception (&ACE_ANY_EXCEPTION);
        _tao_vfr.receive_exception (
          &_tao_ri
          ACE_ENV_ARG_PARAMETER
        );
        ACE_TRY_CHECK;
        
        PortableInterceptor::ReplyStatus _tao_status =
          _tao_ri.reply_status (ACE_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 =
      _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
        ACE_CHECK;

    if (_tao_status == PortableInterceptor::LOCATION_FORWARD
        || _tao_status == PortableInterceptor::TRANSPORT_RETRY)
      continue;
    
#endif  /* TAO_HAS_INTERCEPTORS */
    
    break;
  }

}

void ImplementationRepository::_TAO_ServerObject_Remote_Proxy_Impl::shutdown (
    CORBA_Object *_collocated_tao_target_
    ACE_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,
      "shutdown",
      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_ImplementationRepository_ServerObject_shutdown _tao_ri (
        &_tao_call,
        _collocated_tao_target_ ACE_ENV_ARG_PARAMETER
      );
            ACE_CHECK;

#endif /* TAO_HAS_INTERCEPTORS */
      
      
      CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
      TAO_INTERCEPTOR (_tao_ri.response_expected (1));
      
#if TAO_HAS_INTERCEPTORS == 1
      
      ACE_TRY
        {
          _tao_vfr.send_request (
            &_tao_ri
            ACE_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 (ACE_ENV_SINGLE_ARG_PARAMETER);
                    TAO_INTERCEPTOR_CHECK;

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

          _invoke_status =
            _tao_call.invoke (0, 0 ACE_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 (
                _tao_ri.reply_status (_invoke_status);
                _tao_vfr.receive_other (
                  &_tao_ri
                  ACE_ENV_ARG_PARAMETER
                );
                ACE_TRY_CHECK;
              )
              
              continue;
            }
          
          
#if TAO_HAS_INTERCEPTORS == 1
          
          _tao_ri.reply_status (_invoke_status);
          _tao_vfr.receive_reply (
            &_tao_ri
            ACE_ENV_ARG_PARAMETER
          );
          ACE_TRY_CHECK;
        
      }
    ACE_CATCHANY
      {
        _tao_ri.exception (&ACE_ANY_EXCEPTION);
        _tao_vfr.receive_exception (
          &_tao_ri
          ACE_ENV_ARG_PARAMETER
        );
        ACE_TRY_CHECK;
        
        PortableInterceptor::ReplyStatus _tao_status =
          _tao_ri.reply_status (ACE_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 =
      _tao_ri.reply_status (ACE_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
//

ImplementationRepository::_TAO_ServerObject_Proxy_Broker::_TAO_ServerObject_Proxy_Broker (void)
{
}

ImplementationRepository::_TAO_ServerObject_Proxy_Broker::~_TAO_ServerObject_Proxy_Broker (void)
{
}

ImplementationRepository::_TAO_ServerObject_Proxy_Broker * (*ImplementationRepository__TAO_ServerObject_Proxy_Broker_Factory_function_pointer) (
    CORBA::Object_ptr obj
  ) = 0;

// Factory Member function Implementation.
ImplementationRepository::_TAO_ServerObject_Remote_Proxy_Broker *
ImplementationRepository::_TAO_ServerObject_Remote_Proxy_Broker::the_TAO_ServerObject_Remote_Proxy_Broker (void)
{
  static ::ImplementationRepository::_TAO_ServerObject_Remote_Proxy_Broker remote_proxy_broker;
  return &remote_proxy_broker;
}

ImplementationRepository::_TAO_ServerObject_Remote_Proxy_Broker::_TAO_ServerObject_Remote_Proxy_Broker (void)
{
}

ImplementationRepository::_TAO_ServerObject_Remote_Proxy_Broker::~_TAO_ServerObject_Remote_Proxy_Broker (void)
{
}

ImplementationRepository::_TAO_ServerObject_Proxy_Impl&
ImplementationRepository::_TAO_ServerObject_Remote_Proxy_Broker::select_proxy (
  ::ImplementationRepository::ServerObject *
  ACE_ENV_ARG_DECL_NOT_USED
)
{
  return this->remote_proxy_impl_;
}


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


// TAO_IDL - Generated from 
// be/be_visitor_interface/interface_cs.cpp:209

ImplementationRepository::ServerObject::ServerObject (int collocated)
{
  this->ImplementationRepository_ServerObject_setup_collocation (collocated);
}

ImplementationRepository::ServerObject::~ServerObject (void)
{}

void
ImplementationRepository::ServerObject::ImplementationRepository_ServerObject_setup_collocation (int collocated)
{
  if (collocated)
    this->the_TAO_ServerObject_Proxy_Broker_ =
      ::ImplementationRepository__TAO_ServerObject_Proxy_Broker_Factory_function_pointer (this);
  else
    this->the_TAO_ServerObject_Proxy_Broker_ =
      ::ImplementationRepository::_TAO_ServerObject_Remote_Proxy_Broker::the_TAO_ServerObject_Remote_Proxy_Broker ();
}

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

ImplementationRepository::ServerObject_ptr ImplementationRepository::ServerObject::_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL
  )
{
  if (CORBA::is_nil (obj))
    return ServerObject::_nil ();
  if (! obj->_is_local ())
    {
      CORBA::Boolean is_a = obj->_is_a ("IDL:ImplementationRepository/ServerObject:1.0" ACE_ENV_ARG_PARAMETER);
      ACE_CHECK_RETURN (ServerObject::_nil ());
      if (is_a == 0)
        return ServerObject::_nil ();
    }
  return ServerObject::_unchecked_narrow (obj ACE_ENV_ARG_PARAMETER);
}

ImplementationRepository::ServerObject_ptr 
ImplementationRepository::ServerObject::_unchecked_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  if (CORBA::is_nil (obj))
    return ServerObject::_nil ();
  if (! obj->_is_local ())
    {
      TAO_Stub* stub = obj->_stubobj ();
      if (stub)
        stub->_incr_refcnt ();
      ServerObject_ptr default_proxy = ServerObject::_nil ();

      if (
          !CORBA::is_nil (stub->servant_orb_var ().ptr ()) &&
          stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects () &&
          obj->_is_collocated () &&
          ImplementationRepository__TAO_ServerObject_Proxy_Broker_Factory_function_pointer != 0
        )
        {
          ACE_NEW_RETURN (
              default_proxy,
              ::ImplementationRepository::ServerObject (
                  stub,
                  1,
                  obj->_servant ()
                ),
              ServerObject::_nil ()
            );
        }
      
      if (CORBA::is_nil (default_proxy))
        {
          ACE_NEW_RETURN (
              default_proxy,
              ::ImplementationRepository::ServerObject (
                  stub,
                  0,
                  obj->_servant ()
                ),
              ServerObject::_nil ()
            );
        }
      
      return default_proxy;
    }
  else 
    return
      ACE_reinterpret_cast
        (
          ServerObject_ptr,
            obj->_tao_QueryInterface
              (
                ACE_reinterpret_cast
                  (
                    ptr_arith_t,
                    &ServerObject::_tao_class_id
                  )
              )
        );
}

ImplementationRepository::ServerObject_ptr
ImplementationRepository::ServerObject::_duplicate (ServerObject_ptr obj)
{
  if (!CORBA::is_nil (obj))
    obj->_add_ref ();
  return obj;
}

CORBA::Boolean ImplementationRepository::ServerObject::_is_a (const CORBA::Char *value ACE_ENV_ARG_DECL)
{
  if (
    (!ACE_OS::strcmp ((char *)value, "IDL:ImplementationRepository/ServerObject:1.0")) ||
    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
  return 1; // success using local knowledge
  else
    return this->CORBA_Object::_is_a (value ACE_ENV_ARG_PARAMETER);
}

void *ImplementationRepository::ServerObject::_tao_QueryInterface (ptr_arith_t type)
{
  void *retv = 0;
  if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &ACE_NESTED_CLASS (::ImplementationRepository, ServerObject)::_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* ImplementationRepository::ServerObject::_interface_repository_id (void) const
{
  return "IDL:ImplementationRepository/ServerObject:1.0";
}

void ImplementationRepository::ServerObject::ping (
    
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  _TAO_ServerObject_Proxy_Impl &proxy = 
    this->the_TAO_ServerObject_Proxy_Broker_->select_proxy (this ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
  
  proxy.ping (
      this ACE_ENV_ARG_PARAMETER
    );
}

void ImplementationRepository::ServerObject::shutdown (
    
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  _TAO_ServerObject_Proxy_Impl &proxy = 
    this->the_TAO_ServerObject_Proxy_Broker_->select_proxy (this ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
  
  proxy.shutdown (
      this ACE_ENV_ARG_PARAMETER
    );
}

static const CORBA::Long _oc_ImplementationRepository_ServerObject[] =
{
  TAO_ENCAP_BYTE_ORDER, // byte order
  46,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x496d706c), 
  ACE_NTOHL (0x656d656e), 
  ACE_NTOHL (0x74617469), 
  ACE_NTOHL (0x6f6e5265), 
  ACE_NTOHL (0x706f7369), 
  ACE_NTOHL (0x746f7279), 
  ACE_NTOHL (0x2f536572), 
  ACE_NTOHL (0x7665724f), 
  ACE_NTOHL (0x626a6563), 
  ACE_NTOHL (0x743a312e), 
  ACE_NTOHL (0x30000000),  // repository ID = IDL:ImplementationRepository/ServerObject:1.0
  13,
  ACE_NTOHL (0x53657276), 
  ACE_NTOHL (0x65724f62), 
  ACE_NTOHL (0x6a656374), 
  ACE_NTOHL (0x0),  // name = ServerObject
};

static CORBA::TypeCode _tc_TAO_tc_ImplementationRepository_ServerObject (
    CORBA::tk_objref,
    sizeof (_oc_ImplementationRepository_ServerObject),
    (char *) &_oc_ImplementationRepository_ServerObject,
    0,
    sizeof (ImplementationRepository::ServerObject)
  );

TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
TAO_NAMESPACE_BEGIN (ImplementationRepository)
TAO_NAMESPACE_DEFINE (::CORBA::TypeCode_ptr, _tc_ServerObject, &_tc_TAO_tc_ImplementationRepository_ServerObject)
TAO_NAMESPACE_END

static const CORBA::Long _oc_ImplementationRepository_EnvironmentVariable[] =
{
  TAO_ENCAP_BYTE_ORDER, // byte order
  53,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x496d706c), 
  ACE_NTOHL (0x656d656e), 
  ACE_NTOHL (0x74617469), 
  ACE_NTOHL (0x6f6e5265), 
  ACE_NTOHL (0x706f7369), 
  ACE_NTOHL (0x746f7279), 
  ACE_NTOHL (0x2f456e76), 
  ACE_NTOHL (0x69726f6e), 
  ACE_NTOHL (0x6d656e74), 
  ACE_NTOHL (0x56617269), 
  ACE_NTOHL (0x61626c65), 
  ACE_NTOHL (0x3a312e30), 
  ACE_NTOHL (0x0),  // repository ID = IDL:ImplementationRepository/EnvironmentVariable:1.0
  20,
  ACE_NTOHL (0x456e7669), 
  ACE_NTOHL (0x726f6e6d), 
  ACE_NTOHL (0x656e7456), 
  ACE_NTOHL (0x61726961), 
  ACE_NTOHL (0x626c6500),  // name = EnvironmentVariable
  2, // member count
  5,
  ACE_NTOHL (0x6e616d65), 
  ACE_NTOHL (0x0),  // name = name
  CORBA::tk_string, 
  0U, // string length
  6,
  ACE_NTOHL (0x76616c75), 
  ACE_NTOHL (0x65000000),  // name = value
  CORBA::tk_string, 
  0U, // string length
};

static CORBA::TypeCode _tc_TAO_tc_ImplementationRepository_EnvironmentVariable (
    CORBA::tk_struct,
    sizeof (_oc_ImplementationRepository_EnvironmentVariable),
    (char *) &_oc_ImplementationRepository_EnvironmentVariable,
    0,
    sizeof (ImplementationRepository::EnvironmentVariable)
  );

TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
TAO_NAMESPACE_BEGIN (ImplementationRepository)
TAO_NAMESPACE_DEFINE (::CORBA::TypeCode_ptr, _tc_EnvironmentVariable, &_tc_TAO_tc_ImplementationRepository_EnvironmentVariable)
TAO_NAMESPACE_END

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

static const CORBA::Long _oc_ImplementationRepository_Address[] =
{
  TAO_ENCAP_BYTE_ORDER, // byte order
  41,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x496d706c), 
  ACE_NTOHL (0x656d656e), 
  ACE_NTOHL (0x74617469), 
  ACE_NTOHL (0x6f6e5265), 
  ACE_NTOHL (0x706f7369), 
  ACE_NTOHL (0x746f7279), 
  ACE_NTOHL (0x2f416464), 
  ACE_NTOHL (0x72657373), 
  ACE_NTOHL (0x3a312e30), 
  ACE_NTOHL (0x0),  // repository ID = IDL:ImplementationRepository/Address:1.0
  8,
  ACE_NTOHL (0x41646472), 
  ACE_NTOHL (0x65737300),  // name = Address
  CORBA::tk_string, 
  0U, // string length
};

static CORBA::TypeCode _tc_TAO_tc_ImplementationRepository_Address (
    CORBA::tk_alias,
    sizeof (_oc_ImplementationRepository_Address),
    (char *) &_oc_ImplementationRepository_Address,
    0,
    sizeof (ImplementationRepository::Address)
  );

TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
TAO_NAMESPACE_BEGIN (ImplementationRepository)
TAO_NAMESPACE_DEFINE (::CORBA::TypeCode_ptr, _tc_Address, &_tc_TAO_tc_ImplementationRepository_Address)
TAO_NAMESPACE_END


#if !defined (TAO_USE_SEQUENCE_TEMPLATES)

#if !defined (__TAO_UNBOUNDED_SEQUENCE_IMPLEMENTATIONREPOSITORY_ENVIRONMENTLIST_CS_)
#define __TAO_UNBOUNDED_SEQUENCE_IMPLEMENTATIONREPOSITORY_ENVIRONMENTLIST_CS_

void
ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList::_allocate_buffer (CORBA::ULong length)
{
  ImplementationRepository::EnvironmentVariable* tmp = 0;
  tmp = _TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList::allocbuf (length);
  
  if (this->buffer_ != 0)
  {
    ImplementationRepository::EnvironmentVariable *old = ACE_reinterpret_cast (ImplementationRepository::EnvironmentVariable *,this->buffer_);
    
    for (CORBA::ULong i = 0; i < this->length_; ++i)
      tmp[i] = old[i];
    
    if (this->release_)
      _TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList::freebuf (old);
    
  }
  this->buffer_ = tmp;
}

void
ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList::_deallocate_buffer (void)
{
  if (this->buffer_ == 0 || this->release_ == 0)
    return;
  
  ImplementationRepository::EnvironmentVariable *tmp = ACE_reinterpret_cast (ImplementationRepository::EnvironmentVariable *,this->buffer_);
  
  _TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList::freebuf (tmp);
  this->buffer_ = 0;
} 

ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList::~_TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList (void) // Dtor.
{
  this->_deallocate_buffer ();
}


#endif /* end #if !defined */


#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 

#if !defined (_IMPLEMENTATIONREPOSITORY_ENVIRONMENTLIST_CS_)
#define _IMPLEMENTATIONREPOSITORY_ENVIRONMENTLIST_CS_

// *************************************************************
// ImplementationRepository::EnvironmentList
// *************************************************************

ImplementationRepository::EnvironmentList::EnvironmentList (void)
{}
ImplementationRepository::EnvironmentList::EnvironmentList (CORBA::ULong max) // uses max size
  : 
#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
_TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList
#else /* TAO_USE_SEQUENCE_TEMPLATES */
TAO_Unbounded_Sequence<ImplementationRepository::EnvironmentVariable>
#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
 (max)
{}
ImplementationRepository::EnvironmentList::EnvironmentList (CORBA::ULong max, CORBA::ULong length, ImplementationRepository::EnvironmentVariable *buffer, CORBA::Boolean release)
  : 
#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
_TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList
#else /* TAO_USE_SEQUENCE_TEMPLATES */
TAO_Unbounded_Sequence<ImplementationRepository::EnvironmentVariable>
#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
 (max, length, buffer, release)
{}
ImplementationRepository::EnvironmentList::EnvironmentList (const EnvironmentList &seq) // copy ctor
  : 
#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
_TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList
#else /* TAO_USE_SEQUENCE_TEMPLATES */
TAO_Unbounded_Sequence<ImplementationRepository::EnvironmentVariable>
#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
 (seq)
{}
ImplementationRepository::EnvironmentList::~EnvironmentList (void) // dtor
{}
void ImplementationRepository::EnvironmentList::_tao_any_destructor (void *_tao_void_pointer)
{
  EnvironmentList *tmp = ACE_static_cast (EnvironmentList*, _tao_void_pointer);
  delete tmp;
}


#endif /* end #if !defined */

static const CORBA::Long _oc_ImplementationRepository_EnvironmentList[] =
{
  TAO_ENCAP_BYTE_ORDER, // byte order
  49,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x496d706c), 
  ACE_NTOHL (0x656d656e), 
  ACE_NTOHL (0x74617469), 
  ACE_NTOHL (0x6f6e5265), 
  ACE_NTOHL (0x706f7369), 
  ACE_NTOHL (0x746f7279), 
  ACE_NTOHL (0x2f456e76), 
  ACE_NTOHL (0x69726f6e), 
  ACE_NTOHL (0x6d656e74), 
  ACE_NTOHL (0x4c697374), 
  ACE_NTOHL (0x3a312e30), 
  ACE_NTOHL (0x0),  // repository ID = IDL:ImplementationRepository/EnvironmentList:1.0
  16,
  ACE_NTOHL (0x456e7669), 
  ACE_NTOHL (0x726f6e6d), 
  ACE_NTOHL (0x656e744c), 
  ACE_NTOHL (0x69737400),  // name = EnvironmentList
  CORBA::tk_sequence, // typecode kind
  148, // encapsulation length
    TAO_ENCAP_BYTE_ORDER, // byte order
    CORBA::tk_struct, // typecode kind
    132, // encapsulation length
      TAO_ENCAP_BYTE_ORDER, // byte order
      53,
      ACE_NTOHL (0x49444c3a), 
      ACE_NTOHL (0x496d706c), 
      ACE_NTOHL (0x656d656e), 
      ACE_NTOHL (0x74617469), 
      ACE_NTOHL (0x6f6e5265), 
      ACE_NTOHL (0x706f7369), 
      ACE_NTOHL (0x746f7279), 
      ACE_NTOHL (0x2f456e76), 
      ACE_NTOHL (0x69726f6e), 
      ACE_NTOHL (0x6d656e74), 
      ACE_NTOHL (0x56617269), 
      ACE_NTOHL (0x61626c65), 
      ACE_NTOHL (0x3a312e30), 
      ACE_NTOHL (0x0),  // repository ID = IDL:ImplementationRepository/EnvironmentVariable:1.0
      20,
      ACE_NTOHL (0x456e7669), 
      ACE_NTOHL (0x726f6e6d), 
      ACE_NTOHL (0x656e7456), 
      ACE_NTOHL (0x61726961), 
      ACE_NTOHL (0x626c6500),  // name = EnvironmentVariable
      2, // member count
      5,
      ACE_NTOHL (0x6e616d65), 
      ACE_NTOHL (0x0),  // name = name
      CORBA::tk_string, 
      0U, // string length
      6,
      ACE_NTOHL (0x76616c75), 
      ACE_NTOHL (0x65000000),  // name = value
      CORBA::tk_string, 
      0U, // string length

    0U,

};

static CORBA::TypeCode _tc_TAO_tc_ImplementationRepository_EnvironmentList (
    CORBA::tk_alias,
    sizeof (_oc_ImplementationRepository_EnvironmentList),
    (char *) &_oc_ImplementationRepository_EnvironmentList,
    0,
    sizeof (ImplementationRepository::EnvironmentList)
  );

TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
TAO_NAMESPACE_BEGIN (ImplementationRepository)
TAO_NAMESPACE_DEFINE (::CORBA::TypeCode_ptr, _tc_EnvironmentList, &_tc_TAO_tc_ImplementationRepository_EnvironmentList)
TAO_NAMESPACE_END

static const CORBA::Long _oc_ImplementationRepository_ActivationMode[] =
{
  TAO_ENCAP_BYTE_ORDER, // byte order
  48,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x496d706c), 
  ACE_NTOHL (0x656d656e), 
  ACE_NTOHL (0x74617469), 
  ACE_NTOHL (0x6f6e5265), 
  ACE_NTOHL (0x706f7369), 
  ACE_NTOHL (0x746f7279), 
  ACE_NTOHL (0x2f416374), 
  ACE_NTOHL (0x69766174), 
  ACE_NTOHL (0x696f6e4d), 
  ACE_NTOHL (0x6f64653a), 
  ACE_NTOHL (0x312e3000),  // repository ID = IDL:ImplementationRepository/ActivationMode:1.0
  15,
  ACE_NTOHL (0x41637469), 
  ACE_NTOHL (0x76617469), 
  ACE_NTOHL (0x6f6e4d6f), 
  ACE_NTOHL (0x64650000),  // name = ActivationMode
  4, // member count
  7,
  ACE_NTOHL (0x4e4f524d), 
  ACE_NTOHL (0x414c0000),  // name = NORMAL
  7,
  ACE_NTOHL (0x4d414e55), 
  ACE_NTOHL (0x414c0000),  // name = MANUAL
  11,
  ACE_NTOHL (0x5045525f), 
  ACE_NTOHL (0x434c4945), 
  ACE_NTOHL (0x4e540000),  // name = PER_CLIENT
  11,
  ACE_NTOHL (0x4155544f), 
  ACE_NTOHL (0x5f535441), 
  ACE_NTOHL (0x52540000),  // name = AUTO_START
};

static CORBA::TypeCode _tc_TAO_tc_ImplementationRepository_ActivationMode (
    CORBA::tk_enum,
    sizeof (_oc_ImplementationRepository_ActivationMode),
    (char *) &_oc_ImplementationRepository_ActivationMode,
    0,
    sizeof (ImplementationRepository::ActivationMode)
  );

TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
TAO_NAMESPACE_BEGIN (ImplementationRepository)
TAO_NAMESPACE_DEFINE (::CORBA::TypeCode_ptr, _tc_ActivationMode, &_tc_TAO_tc_ImplementationRepository_ActivationMode)
TAO_NAMESPACE_END

static const CORBA::Long _oc_ImplementationRepository_StartupOptions[] =
{
  TAO_ENCAP_BYTE_ORDER, // byte order
  48,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x496d706c), 
  ACE_NTOHL (0x656d656e), 
  ACE_NTOHL (0x74617469), 
  ACE_NTOHL (0x6f6e5265), 
  ACE_NTOHL (0x706f7369), 
  ACE_NTOHL (0x746f7279), 
  ACE_NTOHL (0x2f537461), 
  ACE_NTOHL (0x72747570), 
  ACE_NTOHL (0x4f707469), 
  ACE_NTOHL (0x6f6e733a), 
  ACE_NTOHL (0x312e3000),  // repository ID = IDL:ImplementationRepository/StartupOptions:1.0
  15,
  ACE_NTOHL (0x53746172), 
  ACE_NTOHL (0x7475704f), 
  ACE_NTOHL (0x7074696f), 
  ACE_NTOHL (0x6e730000),  // name = StartupOptions
  4, // member count
  13,
  ACE_NTOHL (0x636f6d6d), 
  ACE_NTOHL (0x616e645f), 
  ACE_NTOHL (0x6c696e65), 
  ACE_NTOHL (0x0),  // name = command_line
  CORBA::tk_string, 
  0U, // string length
  12,
  ACE_NTOHL (0x656e7669), 
  ACE_NTOHL (0x726f6e6d), 
  ACE_NTOHL (0x656e7400),  // name = environment
  CORBA::tk_alias, // typecode kind for typedefs
  236, // encapsulation length
    TAO_ENCAP_BYTE_ORDER, // byte order
    49,
    ACE_NTOHL (0x49444c3a), 
    ACE_NTOHL (0x496d706c), 
    ACE_NTOHL (0x656d656e), 
    ACE_NTOHL (0x74617469), 
    ACE_NTOHL (0x6f6e5265), 
    ACE_NTOHL (0x706f7369), 
    ACE_NTOHL (0x746f7279), 
    ACE_NTOHL (0x2f456e76), 
    ACE_NTOHL (0x69726f6e), 
    ACE_NTOHL (0x6d656e74), 
    ACE_NTOHL (0x4c697374), 
    ACE_NTOHL (0x3a312e30), 
    ACE_NTOHL (0x0),  // repository ID = IDL:ImplementationRepository/EnvironmentList:1.0
    16,
    ACE_NTOHL (0x456e7669), 
    ACE_NTOHL (0x726f6e6d), 
    ACE_NTOHL (0x656e744c), 
    ACE_NTOHL (0x69737400),  // name = EnvironmentList
    CORBA::tk_sequence, // typecode kind
    148, // encapsulation length
      TAO_ENCAP_BYTE_ORDER, // byte order
      CORBA::tk_struct, // typecode kind
      132, // encapsulation length
        TAO_ENCAP_BYTE_ORDER, // byte order
        53,
        ACE_NTOHL (0x49444c3a), 
        ACE_NTOHL (0x496d706c), 
        ACE_NTOHL (0x656d656e), 
        ACE_NTOHL (0x74617469), 
        ACE_NTOHL (0x6f6e5265), 
        ACE_NTOHL (0x706f7369), 
        ACE_NTOHL (0x746f7279), 
        ACE_NTOHL (0x2f456e76), 
        ACE_NTOHL (0x69726f6e), 
        ACE_NTOHL (0x6d656e74), 
        ACE_NTOHL (0x56617269), 
        ACE_NTOHL (0x61626c65), 
        ACE_NTOHL (0x3a312e30), 
        ACE_NTOHL (0x0),  // repository ID = IDL:ImplementationRepository/EnvironmentVariable:1.0
        20,
        ACE_NTOHL (0x456e7669), 
        ACE_NTOHL (0x726f6e6d), 
        ACE_NTOHL (0x656e7456), 
        ACE_NTOHL (0x61726961), 
        ACE_NTOHL (0x626c6500),  // name = EnvironmentVariable
        2, // member count
        5,
        ACE_NTOHL (0x6e616d65), 
        ACE_NTOHL (0x0),  // name = name
        CORBA::tk_string, 
        0U, // string length
        6,
        ACE_NTOHL (0x76616c75), 
        ACE_NTOHL (0x65000000),  // name = value
        CORBA::tk_string, 
        0U, // string length

      0U,


  18,
  ACE_NTOHL (0x776f726b), 
  ACE_NTOHL (0x696e675f), 
  ACE_NTOHL (0x64697265), 
  ACE_NTOHL (0x63746f72), 
  ACE_NTOHL (0x79000000),  // name = working_directory
  CORBA::tk_string, 
  0U, // string length
  11,
  ACE_NTOHL (0x61637469), 
  ACE_NTOHL (0x76617469), 
  ACE_NTOHL (0x6f6e0000),  // name = activation
  CORBA::tk_enum, // typecode kind
  136, // encapsulation length
    TAO_ENCAP_BYTE_ORDER, // byte order
    48,
    ACE_NTOHL (0x49444c3a), 
    ACE_NTOHL (0x496d706c), 
    ACE_NTOHL (0x656d656e), 
    ACE_NTOHL (0x74617469), 
    ACE_NTOHL (0x6f6e5265), 
    ACE_NTOHL (0x706f7369), 
    ACE_NTOHL (0x746f7279), 
    ACE_NTOHL (0x2f416374), 
    ACE_NTOHL (0x69766174), 
    ACE_NTOHL (0x696f6e4d), 
    ACE_NTOHL (0x6f64653a), 
    ACE_NTOHL (0x312e3000),  // repository ID = IDL:ImplementationRepository/ActivationMode:1.0
    15,
    ACE_NTOHL (0x41637469), 
    ACE_NTOHL (0x76617469), 
    ACE_NTOHL (0x6f6e4d6f), 
    ACE_NTOHL (0x64650000),  // name = ActivationMode
    4, // member count
    7,
    ACE_NTOHL (0x4e4f524d), 
    ACE_NTOHL (0x414c0000),  // name = NORMAL
    7,
    ACE_NTOHL (0x4d414e55), 
    ACE_NTOHL (0x414c0000),  // name = MANUAL
    11,
    ACE_NTOHL (0x5045525f), 
    ACE_NTOHL (0x434c4945), 
    ACE_NTOHL (0x4e540000),  // name = PER_CLIENT
    11,
    ACE_NTOHL (0x4155544f), 
    ACE_NTOHL (0x5f535441), 
    ACE_NTOHL (0x52540000),  // name = AUTO_START

};

static CORBA::TypeCode _tc_TAO_tc_ImplementationRepository_StartupOptions (
    CORBA::tk_struct,
    sizeof (_oc_ImplementationRepository_StartupOptions),
    (char *) &_oc_ImplementationRepository_StartupOptions,
    0,
    sizeof (ImplementationRepository::StartupOptions)
  );

TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
TAO_NAMESPACE_BEGIN (ImplementationRepository)
TAO_NAMESPACE_DEFINE (::CORBA::TypeCode_ptr, _tc_StartupOptions, &_tc_TAO_tc_ImplementationRepository_StartupOptions)
TAO_NAMESPACE_END

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

static const CORBA::Long _oc_ImplementationRepository_ServerInformation[] =
{
  TAO_ENCAP_BYTE_ORDER, // byte order
  51,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x496d706c), 
  ACE_NTOHL (0x656d656e), 
  ACE_NTOHL (0x74617469), 
  ACE_NTOHL (0x6f6e5265), 
  ACE_NTOHL (0x706f7369), 
  ACE_NTOHL (0x746f7279), 
  ACE_NTOHL (0x2f536572), 
  ACE_NTOHL (0x76657249), 
  ACE_NTOHL (0x6e666f72), 
  ACE_NTOHL (0x6d617469), 
  ACE_NTOHL (0x6f6e3a31), 
  ACE_NTOHL (0x2e300000),  // repository ID = IDL:ImplementationRepository/ServerInformation:1.0
  18,
  ACE_NTOHL (0x53657276), 
  ACE_NTOHL (0x6572496e), 
  ACE_NTOHL (0x666f726d), 
  ACE_NTOHL (0x6174696f), 
  ACE_NTOHL (0x6e000000),  // name = ServerInformation
  4, // member count
  15,
  ACE_NTOHL (0x6c6f6769), 
  ACE_NTOHL (0x63616c5f), 
  ACE_NTOHL (0x73657276), 
  ACE_NTOHL (0x65720000),  // name = logical_server
  CORBA::tk_string, 
  0U, // string length
  7,
  ACE_NTOHL (0x73657276), 
  ACE_NTOHL (0x65720000),  // name = server
  CORBA::tk_string, 
  0U, // string length
  8,
  ACE_NTOHL (0x73746172), 
  ACE_NTOHL (0x74757000),  // name = startup
  CORBA::tk_struct, // typecode kind
  560, // encapsulation length
    TAO_ENCAP_BYTE_ORDER, // byte order
    48,
    ACE_NTOHL (0x49444c3a), 
    ACE_NTOHL (0x496d706c), 
    ACE_NTOHL (0x656d656e), 
    ACE_NTOHL (0x74617469), 
    ACE_NTOHL (0x6f6e5265), 
    ACE_NTOHL (0x706f7369), 
    ACE_NTOHL (0x746f7279), 
    ACE_NTOHL (0x2f537461), 
    ACE_NTOHL (0x72747570), 
    ACE_NTOHL (0x4f707469), 
    ACE_NTOHL (0x6f6e733a), 
    ACE_NTOHL (0x312e3000),  // repository ID = IDL:ImplementationRepository/StartupOptions:1.0
    15,
    ACE_NTOHL (0x53746172), 
    ACE_NTOHL (0x7475704f), 
    ACE_NTOHL (0x7074696f), 
    ACE_NTOHL (0x6e730000),  // name = StartupOptions
    4, // member count
    13,
    ACE_NTOHL (0x636f6d6d), 
    ACE_NTOHL (0x616e645f), 
    ACE_NTOHL (0x6c696e65), 
    ACE_NTOHL (0x0),  // name = command_line
    CORBA::tk_string, 
    0U, // string length
    12,
    ACE_NTOHL (0x656e7669), 
    ACE_NTOHL (0x726f6e6d), 
    ACE_NTOHL (0x656e7400),  // name = environment
    CORBA::tk_alias, // typecode kind for typedefs
    236, // encapsulation length
      TAO_ENCAP_BYTE_ORDER, // byte order
      49,
      ACE_NTOHL (0x49444c3a), 
      ACE_NTOHL (0x496d706c), 
      ACE_NTOHL (0x656d656e), 
      ACE_NTOHL (0x74617469), 
      ACE_NTOHL (0x6f6e5265), 
      ACE_NTOHL (0x706f7369), 
      ACE_NTOHL (0x746f7279), 
      ACE_NTOHL (0x2f456e76), 
      ACE_NTOHL (0x69726f6e), 
      ACE_NTOHL (0x6d656e74), 
      ACE_NTOHL (0x4c697374), 
      ACE_NTOHL (0x3a312e30), 
      ACE_NTOHL (0x0),  // repository ID = IDL:ImplementationRepository/EnvironmentList:1.0
      16,
      ACE_NTOHL (0x456e7669), 
      ACE_NTOHL (0x726f6e6d), 
      ACE_NTOHL (0x656e744c), 
      ACE_NTOHL (0x69737400),  // name = EnvironmentList
      CORBA::tk_sequence, // typecode kind
      148, // encapsulation length
        TAO_ENCAP_BYTE_ORDER, // byte order
        CORBA::tk_struct, // typecode kind
        132, // encapsulation length
          TAO_ENCAP_BYTE_ORDER, // byte order
          53,
          ACE_NTOHL (0x49444c3a), 
          ACE_NTOHL (0x496d706c), 
          ACE_NTOHL (0x656d656e), 
          ACE_NTOHL (0x74617469), 
          ACE_NTOHL (0x6f6e5265), 
          ACE_NTOHL (0x706f7369), 
          ACE_NTOHL (0x746f7279), 
          ACE_NTOHL (0x2f456e76), 
          ACE_NTOHL (0x69726f6e), 
          ACE_NTOHL (0x6d656e74), 
          ACE_NTOHL (0x56617269), 
          ACE_NTOHL (0x61626c65), 
          ACE_NTOHL (0x3a312e30), 
          ACE_NTOHL (0x0),  // repository ID = IDL:ImplementationRepository/EnvironmentVariable:1.0
          20,
          ACE_NTOHL (0x456e7669), 
          ACE_NTOHL (0x726f6e6d), 
          ACE_NTOHL (0x656e7456), 
          ACE_NTOHL (0x61726961), 
          ACE_NTOHL (0x626c6500),  // name = EnvironmentVariable
          2, // member count
          5,
          ACE_NTOHL (0x6e616d65), 
          ACE_NTOHL (0x0),  // name = name
          CORBA::tk_string, 
          0U, // string length
          6,
          ACE_NTOHL (0x76616c75), 
          ACE_NTOHL (0x65000000),  // name = value
          CORBA::tk_string, 
          0U, // string length

        0U,


    18,
    ACE_NTOHL (0x776f726b), 
    ACE_NTOHL (0x696e675f), 
    ACE_NTOHL (0x64697265), 
    ACE_NTOHL (0x63746f72), 
    ACE_NTOHL (0x79000000),  // name = working_directory
    CORBA::tk_string, 
    0U, // string length
    11,
    ACE_NTOHL (0x61637469), 
    ACE_NTOHL (0x76617469), 
    ACE_NTOHL (0x6f6e0000),  // name = activation
    CORBA::tk_enum, // typecode kind
    136, // encapsulation length
      TAO_ENCAP_BYTE_ORDER, // byte order
      48,
      ACE_NTOHL (0x49444c3a), 
      ACE_NTOHL (0x496d706c), 
      ACE_NTOHL (0x656d656e), 
      ACE_NTOHL (0x74617469), 
      ACE_NTOHL (0x6f6e5265), 
      ACE_NTOHL (0x706f7369), 
      ACE_NTOHL (0x746f7279), 
      ACE_NTOHL (0x2f416374), 
      ACE_NTOHL (0x69766174), 
      ACE_NTOHL (0x696f6e4d), 
      ACE_NTOHL (0x6f64653a), 
      ACE_NTOHL (0x312e3000),  // repository ID = IDL:ImplementationRepository/ActivationMode:1.0
      15,
      ACE_NTOHL (0x41637469), 
      ACE_NTOHL (0x76617469), 
      ACE_NTOHL (0x6f6e4d6f), 
      ACE_NTOHL (0x64650000),  // name = ActivationMode
      4, // member count
      7,
      ACE_NTOHL (0x4e4f524d), 
      ACE_NTOHL (0x414c0000),  // name = NORMAL
      7,
      ACE_NTOHL (0x4d414e55), 
      ACE_NTOHL (0x414c0000),  // name = MANUAL
      11,
      ACE_NTOHL (0x5045525f), 
      ACE_NTOHL (0x434c4945), 
      ACE_NTOHL (0x4e540000),  // name = PER_CLIENT
      11,
      ACE_NTOHL (0x4155544f), 
      ACE_NTOHL (0x5f535441), 
      ACE_NTOHL (0x52540000),  // name = AUTO_START


  9,
  ACE_NTOHL (0x6c6f6361), 
  ACE_NTOHL (0x74696f6e), 
  ACE_NTOHL (0x0),  // name = location
  CORBA::tk_alias, // typecode kind for typedefs
  72, // encapsulation length
    TAO_ENCAP_BYTE_ORDER, // byte order
    41,
    ACE_NTOHL (0x49444c3a), 
    ACE_NTOHL (0x496d706c), 
    ACE_NTOHL (0x656d656e), 
    ACE_NTOHL (0x74617469), 
    ACE_NTOHL (0x6f6e5265), 
    ACE_NTOHL (0x706f7369), 
    ACE_NTOHL (0x746f7279), 
    ACE_NTOHL (0x2f416464), 
    ACE_NTOHL (0x72657373), 
    ACE_NTOHL (0x3a312e30), 
    ACE_NTOHL (0x0),  // repository ID = IDL:ImplementationRepository/Address:1.0
    8,
    ACE_NTOHL (0x41646472), 
    ACE_NTOHL (0x65737300),  // name = Address
    CORBA::tk_string, 
    0U, // string length

};

static CORBA::TypeCode _tc_TAO_tc_ImplementationRepository_ServerInformation (
    CORBA::tk_struct,
    sizeof (_oc_ImplementationRepository_ServerInformation),
    (char *) &_oc_ImplementationRepository_ServerInformation,
    0,
    sizeof (ImplementationRepository::ServerInformation)
  );

TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
TAO_NAMESPACE_BEGIN (ImplementationRepository)
TAO_NAMESPACE_DEFINE (::CORBA::TypeCode_ptr, _tc_ServerInformation, &_tc_TAO_tc_ImplementationRepository_ServerInformation)
TAO_NAMESPACE_END

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


#if !defined (TAO_USE_SEQUENCE_TEMPLATES)

#if !defined (__TAO_UNBOUNDED_SEQUENCE_IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONLIST_CS_)
#define __TAO_UNBOUNDED_SEQUENCE_IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONLIST_CS_

void
ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList::_allocate_buffer (CORBA::ULong length)
{
  ImplementationRepository::ServerInformation* tmp = 0;
  tmp = _TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList::allocbuf (length);
  
  if (this->buffer_ != 0)
  {
    ImplementationRepository::ServerInformation *old = ACE_reinterpret_cast (ImplementationRepository::ServerInformation *,this->buffer_);
    
    for (CORBA::ULong i = 0; i < this->length_; ++i)
      tmp[i] = old[i];
    
    if (this->release_)
      _TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList::freebuf (old);
    
  }
  this->buffer_ = tmp;
}

void
ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList::_deallocate_buffer (void)
{
  if (this->buffer_ == 0 || this->release_ == 0)
    return;
  
  ImplementationRepository::ServerInformation *tmp = ACE_reinterpret_cast (ImplementationRepository::ServerInformation *,this->buffer_);
  
  _TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList::freebuf (tmp);
  this->buffer_ = 0;
} 

ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList::~_TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList (void) // Dtor.
{
  this->_deallocate_buffer ();
}


#endif /* end #if !defined */


#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 

#if !defined (_IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONLIST_CS_)
#define _IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONLIST_CS_

// *************************************************************
// ImplementationRepository::ServerInformationList
// *************************************************************

ImplementationRepository::ServerInformationList::ServerInformationList (void)
{}
ImplementationRepository::ServerInformationList::ServerInformationList (CORBA::ULong max) // uses max size
  : 
#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
_TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList
#else /* TAO_USE_SEQUENCE_TEMPLATES */
TAO_Unbounded_Sequence<ImplementationRepository::ServerInformation>
#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
 (max)
{}
ImplementationRepository::ServerInformationList::ServerInformationList (CORBA::ULong max, CORBA::ULong length, ImplementationRepository::ServerInformation *buffer, CORBA::Boolean release)
  : 
#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
_TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList
#else /* TAO_USE_SEQUENCE_TEMPLATES */
TAO_Unbounded_Sequence<ImplementationRepository::ServerInformation>
#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
 (max, length, buffer, release)
{}
ImplementationRepository::ServerInformationList::ServerInformationList (const ServerInformationList &seq) // copy ctor
  : 
#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
_TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList
#else /* TAO_USE_SEQUENCE_TEMPLATES */
TAO_Unbounded_Sequence<ImplementationRepository::ServerInformation>
#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
 (seq)
{}
ImplementationRepository::ServerInformationList::~ServerInformationList (void) // dtor
{}
void ImplementationRepository::ServerInformationList::_tao_any_destructor (void *_tao_void_pointer)
{
  ServerInformationList *tmp = ACE_static_cast (ServerInformationList*, _tao_void_pointer);
  delete tmp;
}


#endif /* end #if !defined */

static const CORBA::Long _oc_ImplementationRepository_ServerInformationList[] =
{
  TAO_ENCAP_BYTE_ORDER, // byte order
  55,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x496d706c), 
  ACE_NTOHL (0x656d656e), 
  ACE_NTOHL (0x74617469), 
  ACE_NTOHL (0x6f6e5265), 
  ACE_NTOHL (0x706f7369), 
  ACE_NTOHL (0x746f7279), 
  ACE_NTOHL (0x2f536572), 
  ACE_NTOHL (0x76657249), 
  ACE_NTOHL (0x6e666f72), 
  ACE_NTOHL (0x6d617469), 
  ACE_NTOHL (0x6f6e4c69), 
  ACE_NTOHL (0x73743a31), 
  ACE_NTOHL (0x2e300000),  // repository ID = IDL:ImplementationRepository/ServerInformationList:1.0
  22,
  ACE_NTOHL (0x53657276), 
  ACE_NTOHL (0x6572496e), 
  ACE_NTOHL (0x666f726d), 
  ACE_NTOHL (0x6174696f), 
  ACE_NTOHL (0x6e4c6973), 
  ACE_NTOHL (0x74000000),  // name = ServerInformationList
  CORBA::tk_sequence, // typecode kind
  828, // encapsulation length
    TAO_ENCAP_BYTE_ORDER, // byte order
    CORBA::tk_struct, // typecode kind
    812, // encapsulation length
      TAO_ENCAP_BYTE_ORDER, // byte order
      51,
      ACE_NTOHL (0x49444c3a), 
      ACE_NTOHL (0x496d706c), 
      ACE_NTOHL (0x656d656e), 
      ACE_NTOHL (0x74617469), 
      ACE_NTOHL (0x6f6e5265), 
      ACE_NTOHL (0x706f7369), 
      ACE_NTOHL (0x746f7279), 
      ACE_NTOHL (0x2f536572), 
      ACE_NTOHL (0x76657249), 
      ACE_NTOHL (0x6e666f72), 
      ACE_NTOHL (0x6d617469), 
      ACE_NTOHL (0x6f6e3a31), 
      ACE_NTOHL (0x2e300000),  // repository ID = IDL:ImplementationRepository/ServerInformation:1.0
      18,
      ACE_NTOHL (0x53657276), 
      ACE_NTOHL (0x6572496e), 
      ACE_NTOHL (0x666f726d), 
      ACE_NTOHL (0x6174696f), 
      ACE_NTOHL (0x6e000000),  // name = ServerInformation
      4, // member count
      15,
      ACE_NTOHL (0x6c6f6769), 
      ACE_NTOHL (0x63616c5f), 
      ACE_NTOHL (0x73657276), 
      ACE_NTOHL (0x65720000),  // name = logical_server
      CORBA::tk_string, 
      0U, // string length
      7,
      ACE_NTOHL (0x73657276), 
      ACE_NTOHL (0x65720000),  // name = server
      CORBA::tk_string, 
      0U, // string length
      8,
      ACE_NTOHL (0x73746172), 
      ACE_NTOHL (0x74757000),  // name = startup
      CORBA::tk_struct, // typecode kind
      560, // encapsulation length
        TAO_ENCAP_BYTE_ORDER, // byte order
        48,
        ACE_NTOHL (0x49444c3a), 
        ACE_NTOHL (0x496d706c), 
        ACE_NTOHL (0x656d656e), 
        ACE_NTOHL (0x74617469), 
        ACE_NTOHL (0x6f6e5265), 
        ACE_NTOHL (0x706f7369), 
        ACE_NTOHL (0x746f7279), 
        ACE_NTOHL (0x2f537461), 
        ACE_NTOHL (0x72747570), 
        ACE_NTOHL (0x4f707469), 
        ACE_NTOHL (0x6f6e733a), 
        ACE_NTOHL (0x312e3000),  // repository ID = IDL:ImplementationRepository/StartupOptions:1.0
        15,
        ACE_NTOHL (0x53746172), 
        ACE_NTOHL (0x7475704f), 
        ACE_NTOHL (0x7074696f), 
        ACE_NTOHL (0x6e730000),  // name = StartupOptions
        4, // member count
        13,
        ACE_NTOHL (0x636f6d6d), 
        ACE_NTOHL (0x616e645f), 
        ACE_NTOHL (0x6c696e65), 
        ACE_NTOHL (0x0),  // name = command_line
        CORBA::tk_string, 
        0U, // string length
        12,
        ACE_NTOHL (0x656e7669), 
        ACE_NTOHL (0x726f6e6d), 
        ACE_NTOHL (0x656e7400),  // name = environment
        CORBA::tk_alias, // typecode kind for typedefs
        236, // encapsulation length
          TAO_ENCAP_BYTE_ORDER, // byte order
          49,
          ACE_NTOHL (0x49444c3a), 
          ACE_NTOHL (0x496d706c), 
          ACE_NTOHL (0x656d656e), 
          ACE_NTOHL (0x74617469), 
          ACE_NTOHL (0x6f6e5265), 
          ACE_NTOHL (0x706f7369), 
          ACE_NTOHL (0x746f7279), 
          ACE_NTOHL (0x2f456e76), 
          ACE_NTOHL (0x69726f6e), 
          ACE_NTOHL (0x6d656e74), 
          ACE_NTOHL (0x4c697374), 
          ACE_NTOHL (0x3a312e30), 
          ACE_NTOHL (0x0),  // repository ID = IDL:ImplementationRepository/EnvironmentList:1.0
          16,
          ACE_NTOHL (0x456e7669), 
          ACE_NTOHL (0x726f6e6d), 
          ACE_NTOHL (0x656e744c), 
          ACE_NTOHL (0x69737400),  // name = EnvironmentList
          CORBA::tk_sequence, // typecode kind
          148, // encapsulation length
            TAO_ENCAP_BYTE_ORDER, // byte order
            CORBA::tk_struct, // typecode kind
            132, // encapsulation length
              TAO_ENCAP_BYTE_ORDER, // byte order
              53,
              ACE_NTOHL (0x49444c3a), 
              ACE_NTOHL (0x496d706c), 
              ACE_NTOHL (0x656d656e), 
              ACE_NTOHL (0x74617469), 
              ACE_NTOHL (0x6f6e5265), 
              ACE_NTOHL (0x706f7369), 
              ACE_NTOHL (0x746f7279), 
              ACE_NTOHL (0x2f456e76), 
              ACE_NTOHL (0x69726f6e), 
              ACE_NTOHL (0x6d656e74), 
              ACE_NTOHL (0x56617269), 
              ACE_NTOHL (0x61626c65), 
              ACE_NTOHL (0x3a312e30), 
              ACE_NTOHL (0x0),  // repository ID = IDL:ImplementationRepository/EnvironmentVariable:1.0
              20,
              ACE_NTOHL (0x456e7669), 
              ACE_NTOHL (0x726f6e6d), 
              ACE_NTOHL (0x656e7456), 
              ACE_NTOHL (0x61726961), 
              ACE_NTOHL (0x626c6500),  // name = EnvironmentVariable
              2, // member count
              5,
              ACE_NTOHL (0x6e616d65), 
              ACE_NTOHL (0x0),  // name = name
              CORBA::tk_string, 
              0U, // string length
              6,
              ACE_NTOHL (0x76616c75), 
              ACE_NTOHL (0x65000000),  // name = value
              CORBA::tk_string, 
              0U, // string length

            0U,


        18,
        ACE_NTOHL (0x776f726b), 
        ACE_NTOHL (0x696e675f), 
        ACE_NTOHL (0x64697265), 
        ACE_NTOHL (0x63746f72), 
        ACE_NTOHL (0x79000000),  // name = working_directory
        CORBA::tk_string, 
        0U, // string length
        11,
        ACE_NTOHL (0x61637469), 
        ACE_NTOHL (0x76617469), 
        ACE_NTOHL (0x6f6e0000),  // name = activation
        CORBA::tk_enum, // typecode kind
        136, // encapsulation length
          TAO_ENCAP_BYTE_ORDER, // byte order
          48,
          ACE_NTOHL (0x49444c3a), 
          ACE_NTOHL (0x496d706c), 
          ACE_NTOHL (0x656d656e), 
          ACE_NTOHL (0x74617469), 
          ACE_NTOHL (0x6f6e5265), 
          ACE_NTOHL (0x706f7369), 
          ACE_NTOHL (0x746f7279), 
          ACE_NTOHL (0x2f416374), 
          ACE_NTOHL (0x69766174), 
          ACE_NTOHL (0x696f6e4d), 
          ACE_NTOHL (0x6f64653a), 
          ACE_NTOHL (0x312e3000),  // repository ID = IDL:ImplementationRepository/ActivationMode:1.0
          15,
          ACE_NTOHL (0x41637469), 
          ACE_NTOHL (0x76617469), 
          ACE_NTOHL (0x6f6e4d6f), 
          ACE_NTOHL (0x64650000),  // name = ActivationMode
          4, // member count
          7,
          ACE_NTOHL (0x4e4f524d), 
          ACE_NTOHL (0x414c0000),  // name = NORMAL
          7,
          ACE_NTOHL (0x4d414e55), 
          ACE_NTOHL (0x414c0000),  // name = MANUAL
          11,
          ACE_NTOHL (0x5045525f), 
          ACE_NTOHL (0x434c4945), 
          ACE_NTOHL (0x4e540000),  // name = PER_CLIENT
          11,
          ACE_NTOHL (0x4155544f), 
          ACE_NTOHL (0x5f535441), 
          ACE_NTOHL (0x52540000),  // name = AUTO_START


      9,
      ACE_NTOHL (0x6c6f6361), 
      ACE_NTOHL (0x74696f6e), 
      ACE_NTOHL (0x0),  // name = location
      CORBA::tk_alias, // typecode kind for typedefs
      72, // encapsulation length
        TAO_ENCAP_BYTE_ORDER, // byte order
        41,
        ACE_NTOHL (0x49444c3a), 
        ACE_NTOHL (0x496d706c), 
        ACE_NTOHL (0x656d656e), 
        ACE_NTOHL (0x74617469), 
        ACE_NTOHL (0x6f6e5265), 
        ACE_NTOHL (0x706f7369), 
        ACE_NTOHL (0x746f7279), 
        ACE_NTOHL (0x2f416464), 
        ACE_NTOHL (0x72657373), 
        ACE_NTOHL (0x3a312e30), 
        ACE_NTOHL (0x0),  // repository ID = IDL:ImplementationRepository/Address:1.0
        8,
        ACE_NTOHL (0x41646472), 
        ACE_NTOHL (0x65737300),  // name = Address
        CORBA::tk_string, 
        0U, // string length


    0U,

};

static CORBA::TypeCode _tc_TAO_tc_ImplementationRepository_ServerInformationList (
    CORBA::tk_alias,
    sizeof (_oc_ImplementationRepository_ServerInformationList),
    (char *) &_oc_ImplementationRepository_ServerInformationList,
    0,
    sizeof (ImplementationRepository::ServerInformationList)
  );

TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
TAO_NAMESPACE_BEGIN (ImplementationRepository)
TAO_NAMESPACE_DEFINE (::CORBA::TypeCode_ptr, _tc_ServerInformationList, &_tc_TAO_tc_ImplementationRepository_ServerInformationList)
TAO_NAMESPACE_END

int ImplementationRepository::Administration::_tao_class_id = 0;

ImplementationRepository::Administration_ptr
tao_ImplementationRepository_Administration_duplicate (
    ImplementationRepository::Administration_ptr p
  )
{
  return ImplementationRepository::Administration::_duplicate (p);
}

void
tao_ImplementationRepository_Administration_release (
    ImplementationRepository::Administration_ptr p
  )
{
  CORBA::release (p);
}

ImplementationRepository::Administration_ptr
tao_ImplementationRepository_Administration_nil (
    void
  )
{
  return ImplementationRepository::Administration::_nil ();
}

ImplementationRepository::Administration_ptr
tao_ImplementationRepository_Administration_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return ImplementationRepository::Administration::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
tao_ImplementationRepository_Administration_upcast (
    void *src
  )
{
  ImplementationRepository::Administration **tmp =
    ACE_static_cast (ImplementationRepository::Administration **, src);
  return *tmp;
}

// *************************************************************
// ImplementationRepository::Administration_var
// TAO_IDL - Generated from
// be/be_interface.cpp:654
// *************************************************************

ImplementationRepository::Administration_var::Administration_var (void) // default constructor
  : ptr_ (Administration::_nil ())
{}

::ImplementationRepository::Administration_ptr
ImplementationRepository::Administration_var::ptr (void) const
{
  return this->ptr_;
}

ImplementationRepository::Administration_var::Administration_var (const ::ImplementationRepository::Administration_var &p) // copy constructor
  : TAO_Base_var (),
    ptr_ (Administration::_duplicate (p.ptr ()))
{}

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

ImplementationRepository::Administration_var &
ImplementationRepository::Administration_var::operator= (Administration_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

ImplementationRepository::Administration_var &
ImplementationRepository::Administration_var::operator= (const ::ImplementationRepository::Administration_var &p)
{
  if (this != &p)
  {
    CORBA::release (this->ptr_);
    this->ptr_ = ::ImplementationRepository::Administration::_duplicate (p.ptr ());
  }
  return *this;
}

ImplementationRepository::Administration_var::operator const ::ImplementationRepository::Administration_ptr &() const // cast
{
  return this->ptr_;
}

ImplementationRepository::Administration_var::operator ::ImplementationRepository::Administration_ptr &() // cast 
{
  return this->ptr_;
}

::ImplementationRepository::Administration_ptr
ImplementationRepository::Administration_var::operator-> (void) const
{
  return this->ptr_;
}

::ImplementationRepository::Administration_ptr
ImplementationRepository::Administration_var::in (void) const
{
  return this->ptr_;
}

::ImplementationRepository::Administration_ptr &
ImplementationRepository::Administration_var::inout (void)
{
  return this->ptr_;
}

::ImplementationRepository::Administration_ptr &
ImplementationRepository::Administration_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::ImplementationRepository::Administration::_nil ();
  return this->ptr_;
}

::ImplementationRepository::Administration_ptr
ImplementationRepository::Administration_var::_retn (void)
{
  // yield ownership of managed obj reference
  ::ImplementationRepository::Administration_ptr val = this->ptr_;
  this->ptr_ = ::ImplementationRepository::Administration::_nil ();
  return val;
}

::ImplementationRepository::Administration_ptr
ImplementationRepository::Administration_var::tao_duplicate (Administration_ptr p)
{
  return ::ImplementationRepository::Administration::_duplicate (p);
}

void
ImplementationRepository::Administration_var::tao_release (Administration_ptr p)
{
  CORBA::release (p);
}

::ImplementationRepository::Administration_ptr
ImplementationRepository::Administration_var::tao_nil (void)
{
  return ::ImplementationRepository::Administration::_nil ();
}

::ImplementationRepository::Administration_ptr
ImplementationRepository::Administration_var::tao_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return ::ImplementationRepository::Administration::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
ImplementationRepository::Administration_var::tao_upcast (void *src)
{
  Administration **tmp =
    ACE_static_cast (Administration **, src);
  return *tmp;
}

// *************************************************************
// ImplementationRepository::Administration_out
// TAO_IDL - Generated from
// be/be_interface.cpp:932
// *************************************************************

ImplementationRepository::Administration_out::Administration_out (Administration_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = ::ImplementationRepository::Administration::_nil ();
}

ImplementationRepository::Administration_out::Administration_out (Administration_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::ImplementationRepository::Administration::_nil ();
}

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

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

ImplementationRepository::Administration_out &
ImplementationRepository::Administration_out::operator= (const ::ImplementationRepository::Administration_var &p)
{
  this->ptr_ = ::ImplementationRepository::Administration::_duplicate (p.ptr ());
  return *this;
}

ImplementationRepository::Administration_out &
ImplementationRepository::Administration_out::operator= (Administration_ptr p)
{
  this->ptr_ = p;
  return *this;
}

ImplementationRepository::Administration_out::operator ::ImplementationRepository::Administration_ptr &() // cast
{
  return this->ptr_;
}

::ImplementationRepository::Administration_ptr &
ImplementationRepository::Administration_out::ptr (void) // ptr
{
  return this->ptr_;
}

::ImplementationRepository::Administration_ptr
ImplementationRepository::Administration_out::operator-> (void)
{
  return this->ptr_;
}


#if (TAO_HAS_INTERCEPTORS == 1)
class TAO_ClientRequestInfo_ImplementationRepository_Administration_activate_server : public TAO_ClientRequestInfo_i
{
public:
  TAO_ClientRequestInfo_ImplementationRepository_Administration_activate_server (
      TAO_GIOP_Invocation *_tao_invocation,
      CORBA::Object_ptr _tao_target,
      const char * server ACE_ENV_ARG_DECL_WITH_DEFAULTS
    );

  virtual Dynamic::ParameterList * arguments (ACE_ENV_SINGLE_ARG_DECL)
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual Dynamic::ExceptionList * exceptions (ACE_ENV_SINGLE_ARG_DECL)
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual CORBA::Any * result (ACE_ENV_SINGLE_ARG_DECL)
    ACE_THROW_SPEC ((CORBA::SystemException));

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

  const char * server_;
  
};

TAO_ClientRequestInfo_ImplementationRepository_Administration_activate_server::TAO_ClientRequestInfo_ImplementationRepository_Administration_activate_server (
    TAO_GIOP_Invocation *_tao_invocation,
    CORBA::Object_ptr _tao_target,
    const char * server ACE_ENV_ARG_DECL_NOT_USED    
  )
  : TAO_ClientRequestInfo_i (_tao_invocation, _tao_target),
    server_ (server)
{}

Dynamic::ParameterList *
TAO_ClientRequestInfo_ImplementationRepository_Administration_activate_server::arguments (ACE_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 (ACE_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 <<= server_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
  
  return safe_parameter_list._retn ();
}

Dynamic::ExceptionList *
TAO_ClientRequestInfo_ImplementationRepository_Administration_activate_server::exceptions (ACE_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 (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  Dynamic::ExceptionList_var safe_exception_list = exception_list;
    
  static CORBA::TypeCode_ptr _tao_ImplementationRepository_Administration_activate_server_exceptiondata[] = 
  {
    ImplementationRepository::Administration::_tc_NotFound,
    ImplementationRepository::Administration::_tc_CannotActivate
  };
  
  exception_list->length (2);
  for (CORBA::ULong i = 0; i < 2; ++i)
    {
      CORBA::TypeCode_ptr tcp = _tao_ImplementationRepository_Administration_activate_server_exceptiondata[i];
      TAO_Pseudo_Object_Manager<CORBA::TypeCode, CORBA::TypeCode_var> tcp_object (&tcp, 1);
      (*exception_list)[i] = tcp_object;
    }

  return safe_exception_list._retn ();
}

CORBA::Any * 
TAO_ClientRequestInfo_ImplementationRepository_Administration_activate_server::result (ACE_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 ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  return result_any;
}

class TAO_ClientRequestInfo_ImplementationRepository_Administration_register_server : public TAO_ClientRequestInfo_i
{
public:
  TAO_ClientRequestInfo_ImplementationRepository_Administration_register_server (
      TAO_GIOP_Invocation *_tao_invocation,
      CORBA::Object_ptr _tao_target,
      const char * server,
      const ImplementationRepository::StartupOptions & options ACE_ENV_ARG_DECL_WITH_DEFAULTS
    );

  virtual Dynamic::ParameterList * arguments (ACE_ENV_SINGLE_ARG_DECL)
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual Dynamic::ExceptionList * exceptions (ACE_ENV_SINGLE_ARG_DECL)
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual CORBA::Any * result (ACE_ENV_SINGLE_ARG_DECL)
    ACE_THROW_SPEC ((CORBA::SystemException));

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

  const char * server_;
  const ImplementationRepository::StartupOptions & options_;
  
};

TAO_ClientRequestInfo_ImplementationRepository_Administration_register_server::TAO_ClientRequestInfo_ImplementationRepository_Administration_register_server (
    TAO_GIOP_Invocation *_tao_invocation,
    CORBA::Object_ptr _tao_target,
    const char * server,
    const ImplementationRepository::StartupOptions & options ACE_ENV_ARG_DECL_NOT_USED    
  )
  : TAO_ClientRequestInfo_i (_tao_invocation, _tao_target),
    server_ (server),
    options_ (options)
{}

Dynamic::ParameterList *
TAO_ClientRequestInfo_ImplementationRepository_Administration_register_server::arguments (ACE_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 (ACE_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 <<= server_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
    (*parameter_list)[len].argument <<=  this->options_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
  
  return safe_parameter_list._retn ();
}

Dynamic::ExceptionList *
TAO_ClientRequestInfo_ImplementationRepository_Administration_register_server::exceptions (ACE_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 (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  Dynamic::ExceptionList_var safe_exception_list = exception_list;
    
  static CORBA::TypeCode_ptr _tao_ImplementationRepository_Administration_register_server_exceptiondata[] = 
  {
    ImplementationRepository::Administration::_tc_AlreadyRegistered
  };
  
  exception_list->length (1);
  for (CORBA::ULong i = 0; i < 1; ++i)
    {
      CORBA::TypeCode_ptr tcp = _tao_ImplementationRepository_Administration_register_server_exceptiondata[i];
      TAO_Pseudo_Object_Manager<CORBA::TypeCode, CORBA::TypeCode_var> tcp_object (&tcp, 1);
      (*exception_list)[i] = tcp_object;
    }

  return safe_exception_list._retn ();
}

CORBA::Any * 
TAO_ClientRequestInfo_ImplementationRepository_Administration_register_server::result (ACE_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 ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  return result_any;
}

class TAO_ClientRequestInfo_ImplementationRepository_Administration_reregister_server : public TAO_ClientRequestInfo_i
{
public:
  TAO_ClientRequestInfo_ImplementationRepository_Administration_reregister_server (
      TAO_GIOP_Invocation *_tao_invocation,
      CORBA::Object_ptr _tao_target,
      const char * server,
      const ImplementationRepository::StartupOptions & options ACE_ENV_ARG_DECL_WITH_DEFAULTS
    );

  virtual Dynamic::ParameterList * arguments (ACE_ENV_SINGLE_ARG_DECL)
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual Dynamic::ExceptionList * exceptions (ACE_ENV_SINGLE_ARG_DECL)
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual CORBA::Any * result (ACE_ENV_SINGLE_ARG_DECL)
    ACE_THROW_SPEC ((CORBA::SystemException));

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

  const char * server_;
  const ImplementationRepository::StartupOptions & options_;
  
};

TAO_ClientRequestInfo_ImplementationRepository_Administration_reregister_server::TAO_ClientRequestInfo_ImplementationRepository_Administration_reregister_server (
    TAO_GIOP_Invocation *_tao_invocation,
    CORBA::Object_ptr _tao_target,
    const char * server,
    const ImplementationRepository::StartupOptions & options ACE_ENV_ARG_DECL_NOT_USED    
  )
  : TAO_ClientRequestInfo_i (_tao_invocation, _tao_target),
    server_ (server),
    options_ (options)
{}

Dynamic::ParameterList *
TAO_ClientRequestInfo_ImplementationRepository_Administration_reregister_server::arguments (ACE_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 (ACE_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 <<= server_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
    (*parameter_list)[len].argument <<=  this->options_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
  
  return safe_parameter_list._retn ();
}

Dynamic::ExceptionList *
TAO_ClientRequestInfo_ImplementationRepository_Administration_reregister_server::exceptions (ACE_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 (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  return exception_list;
}

CORBA::Any * 
TAO_ClientRequestInfo_ImplementationRepository_Administration_reregister_server::result (ACE_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 ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  return result_any;
}

class TAO_ClientRequestInfo_ImplementationRepository_Administration_remove_server : public TAO_ClientRequestInfo_i
{
public:
  TAO_ClientRequestInfo_ImplementationRepository_Administration_remove_server (
      TAO_GIOP_Invocation *_tao_invocation,
      CORBA::Object_ptr _tao_target,
      const char * server ACE_ENV_ARG_DECL_WITH_DEFAULTS
    );

  virtual Dynamic::ParameterList * arguments (ACE_ENV_SINGLE_ARG_DECL)
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual Dynamic::ExceptionList * exceptions (ACE_ENV_SINGLE_ARG_DECL)
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual CORBA::Any * result (ACE_ENV_SINGLE_ARG_DECL)
    ACE_THROW_SPEC ((CORBA::SystemException));

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

  const char * server_;
  
};

TAO_ClientRequestInfo_ImplementationRepository_Administration_remove_server::TAO_ClientRequestInfo_ImplementationRepository_Administration_remove_server (
    TAO_GIOP_Invocation *_tao_invocation,
    CORBA::Object_ptr _tao_target,
    const char * server ACE_ENV_ARG_DECL_NOT_USED    
  )
  : TAO_ClientRequestInfo_i (_tao_invocation, _tao_target),
    server_ (server)
{}

Dynamic::ParameterList *
TAO_ClientRequestInfo_ImplementationRepository_Administration_remove_server::arguments (ACE_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 (ACE_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 <<= server_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
  
  return safe_parameter_list._retn ();
}

Dynamic::ExceptionList *
TAO_ClientRequestInfo_ImplementationRepository_Administration_remove_server::exceptions (ACE_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 (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  Dynamic::ExceptionList_var safe_exception_list = exception_list;
    
  static CORBA::TypeCode_ptr _tao_ImplementationRepository_Administration_remove_server_exceptiondata[] = 
  {
    ImplementationRepository::Administration::_tc_NotFound
  };
  
  exception_list->length (1);
  for (CORBA::ULong i = 0; i < 1; ++i)
    {
      CORBA::TypeCode_ptr tcp = _tao_ImplementationRepository_Administration_remove_server_exceptiondata[i];
      TAO_Pseudo_Object_Manager<CORBA::TypeCode, CORBA::TypeCode_var> tcp_object (&tcp, 1);
      (*exception_list)[i] = tcp_object;
    }

  return safe_exception_list._retn ();
}

CORBA::Any * 
TAO_ClientRequestInfo_ImplementationRepository_Administration_remove_server::result (ACE_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 ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  return result_any;
}

class TAO_ClientRequestInfo_ImplementationRepository_Administration_shutdown_server : public TAO_ClientRequestInfo_i
{
public:
  TAO_ClientRequestInfo_ImplementationRepository_Administration_shutdown_server (
      TAO_GIOP_Invocation *_tao_invocation,
      CORBA::Object_ptr _tao_target,
      const char * server ACE_ENV_ARG_DECL_WITH_DEFAULTS
    );

  virtual Dynamic::ParameterList * arguments (ACE_ENV_SINGLE_ARG_DECL)
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual Dynamic::ExceptionList * exceptions (ACE_ENV_SINGLE_ARG_DECL)
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual CORBA::Any * result (ACE_ENV_SINGLE_ARG_DECL)
    ACE_THROW_SPEC ((CORBA::SystemException));

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

  const char * server_;
  
};

TAO_ClientRequestInfo_ImplementationRepository_Administration_shutdown_server::TAO_ClientRequestInfo_ImplementationRepository_Administration_shutdown_server (
    TAO_GIOP_Invocation *_tao_invocation,
    CORBA::Object_ptr _tao_target,
    const char * server ACE_ENV_ARG_DECL_NOT_USED    
  )
  : TAO_ClientRequestInfo_i (_tao_invocation, _tao_target),
    server_ (server)
{}

Dynamic::ParameterList *
TAO_ClientRequestInfo_ImplementationRepository_Administration_shutdown_server::arguments (ACE_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 (ACE_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 <<= server_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
  
  return safe_parameter_list._retn ();
}

Dynamic::ExceptionList *
TAO_ClientRequestInfo_ImplementationRepository_Administration_shutdown_server::exceptions (ACE_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 (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  Dynamic::ExceptionList_var safe_exception_list = exception_list;
    
  static CORBA::TypeCode_ptr _tao_ImplementationRepository_Administration_shutdown_server_exceptiondata[] = 
  {
    ImplementationRepository::Administration::_tc_NotFound
  };
  
  exception_list->length (1);
  for (CORBA::ULong i = 0; i < 1; ++i)
    {
      CORBA::TypeCode_ptr tcp = _tao_ImplementationRepository_Administration_shutdown_server_exceptiondata[i];
      TAO_Pseudo_Object_Manager<CORBA::TypeCode, CORBA::TypeCode_var> tcp_object (&tcp, 1);
      (*exception_list)[i] = tcp_object;
    }

  return safe_exception_list._retn ();
}

CORBA::Any * 
TAO_ClientRequestInfo_ImplementationRepository_Administration_shutdown_server::result (ACE_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 ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  return result_any;
}

class TAO_ClientRequestInfo_ImplementationRepository_Administration_server_is_running : public TAO_ClientRequestInfo_i
{
public:
  TAO_ClientRequestInfo_ImplementationRepository_Administration_server_is_running (
      TAO_GIOP_Invocation *_tao_invocation,
      CORBA::Object_ptr _tao_target,
      const char * server,
      const char * addr,
      ImplementationRepository::ServerObject_ptr server_object ACE_ENV_ARG_DECL_WITH_DEFAULTS
    );

  virtual Dynamic::ParameterList * arguments (ACE_ENV_SINGLE_ARG_DECL)
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual Dynamic::ExceptionList * exceptions (ACE_ENV_SINGLE_ARG_DECL)
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual CORBA::Any * result (ACE_ENV_SINGLE_ARG_DECL)
    ACE_THROW_SPEC ((CORBA::SystemException));

  void result (char * result);

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

  const char * server_;
  const char * addr_;
  ImplementationRepository::ServerObject_ptr server_object_;
  char * _result;
};

TAO_ClientRequestInfo_ImplementationRepository_Administration_server_is_running::TAO_ClientRequestInfo_ImplementationRepository_Administration_server_is_running (
    TAO_GIOP_Invocation *_tao_invocation,
    CORBA::Object_ptr _tao_target,
    const char * server,
    const char * addr,
    ImplementationRepository::ServerObject_ptr server_object ACE_ENV_ARG_DECL_NOT_USED    
  )
  : TAO_ClientRequestInfo_i (_tao_invocation, _tao_target),
    server_ (server),
    addr_ (addr),
    server_object_ (server_object)
{}

Dynamic::ParameterList *
TAO_ClientRequestInfo_ImplementationRepository_Administration_server_is_running::arguments (ACE_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 (ACE_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 <<= server_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
    (*parameter_list)[len].argument <<= addr_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
    (*parameter_list)[len].argument <<=  this->server_object_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
  
  return safe_parameter_list._retn ();
}

Dynamic::ExceptionList *
TAO_ClientRequestInfo_ImplementationRepository_Administration_server_is_running::exceptions (ACE_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 (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  Dynamic::ExceptionList_var safe_exception_list = exception_list;
    
  static CORBA::TypeCode_ptr _tao_ImplementationRepository_Administration_server_is_running_exceptiondata[] = 
  {
    ImplementationRepository::Administration::_tc_NotFound
  };
  
  exception_list->length (1);
  for (CORBA::ULong i = 0; i < 1; ++i)
    {
      CORBA::TypeCode_ptr tcp = _tao_ImplementationRepository_Administration_server_is_running_exceptiondata[i];
      TAO_Pseudo_Object_Manager<CORBA::TypeCode, CORBA::TypeCode_var> tcp_object (&tcp, 1);
      (*exception_list)[i] = tcp_object;
    }

  return safe_exception_list._retn ();
}

CORBA::Any * 
TAO_ClientRequestInfo_ImplementationRepository_Administration_server_is_running::result (ACE_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 ACE_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_ImplementationRepository_Administration_server_is_running::result (char * result)
{
  // update the result 
  this->_result = result;
}

class TAO_ClientRequestInfo_ImplementationRepository_Administration_server_is_shutting_down : public TAO_ClientRequestInfo_i
{
public:
  TAO_ClientRequestInfo_ImplementationRepository_Administration_server_is_shutting_down (
      TAO_GIOP_Invocation *_tao_invocation,
      CORBA::Object_ptr _tao_target,
      const char * server ACE_ENV_ARG_DECL_WITH_DEFAULTS
    );

  virtual Dynamic::ParameterList * arguments (ACE_ENV_SINGLE_ARG_DECL)
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual Dynamic::ExceptionList * exceptions (ACE_ENV_SINGLE_ARG_DECL)
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual CORBA::Any * result (ACE_ENV_SINGLE_ARG_DECL)
    ACE_THROW_SPEC ((CORBA::SystemException));

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

  const char * server_;
  
};

TAO_ClientRequestInfo_ImplementationRepository_Administration_server_is_shutting_down::TAO_ClientRequestInfo_ImplementationRepository_Administration_server_is_shutting_down (
    TAO_GIOP_Invocation *_tao_invocation,
    CORBA::Object_ptr _tao_target,
    const char * server ACE_ENV_ARG_DECL_NOT_USED    
  )
  : TAO_ClientRequestInfo_i (_tao_invocation, _tao_target),
    server_ (server)
{}

Dynamic::ParameterList *
TAO_ClientRequestInfo_ImplementationRepository_Administration_server_is_shutting_down::arguments (ACE_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 (ACE_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 <<= server_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
  
  return safe_parameter_list._retn ();
}

Dynamic::ExceptionList *
TAO_ClientRequestInfo_ImplementationRepository_Administration_server_is_shutting_down::exceptions (ACE_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 (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  Dynamic::ExceptionList_var safe_exception_list = exception_list;
    
  static CORBA::TypeCode_ptr _tao_ImplementationRepository_Administration_server_is_shutting_down_exceptiondata[] = 
  {
    ImplementationRepository::Administration::_tc_NotFound
  };
  
  exception_list->length (1);
  for (CORBA::ULong i = 0; i < 1; ++i)
    {
      CORBA::TypeCode_ptr tcp = _tao_ImplementationRepository_Administration_server_is_shutting_down_exceptiondata[i];
      TAO_Pseudo_Object_Manager<CORBA::TypeCode, CORBA::TypeCode_var> tcp_object (&tcp, 1);
      (*exception_list)[i] = tcp_object;
    }

  return safe_exception_list._retn ();
}

CORBA::Any * 
TAO_ClientRequestInfo_ImplementationRepository_Administration_server_is_shutting_down::result (ACE_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 ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  return result_any;
}

class TAO_ClientRequestInfo_ImplementationRepository_Administration_find : public TAO_ClientRequestInfo_i
{
public:
  TAO_ClientRequestInfo_ImplementationRepository_Administration_find (
      TAO_GIOP_Invocation *_tao_invocation,
      CORBA::Object_ptr _tao_target,
      const char * server ACE_ENV_ARG_DECL_WITH_DEFAULTS
    );

  virtual Dynamic::ParameterList * arguments (ACE_ENV_SINGLE_ARG_DECL)
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual Dynamic::ExceptionList * exceptions (ACE_ENV_SINGLE_ARG_DECL)
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual CORBA::Any * result (ACE_ENV_SINGLE_ARG_DECL)
    ACE_THROW_SPEC ((CORBA::SystemException));

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

  const char * server_;
  
};

TAO_ClientRequestInfo_ImplementationRepository_Administration_find::TAO_ClientRequestInfo_ImplementationRepository_Administration_find (
    TAO_GIOP_Invocation *_tao_invocation,
    CORBA::Object_ptr _tao_target,
    const char * server ACE_ENV_ARG_DECL_NOT_USED    
  )
  : TAO_ClientRequestInfo_i (_tao_invocation, _tao_target),
    server_ (server)
{}

Dynamic::ParameterList *
TAO_ClientRequestInfo_ImplementationRepository_Administration_find::arguments (ACE_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 (ACE_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 <<= server_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
  
  return safe_parameter_list._retn ();
}

Dynamic::ExceptionList *
TAO_ClientRequestInfo_ImplementationRepository_Administration_find::exceptions (ACE_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 (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  Dynamic::ExceptionList_var safe_exception_list = exception_list;
    
  static CORBA::TypeCode_ptr _tao_ImplementationRepository_Administration_find_exceptiondata[] = 
  {
    ImplementationRepository::Administration::_tc_NotFound
  };
  
  exception_list->length (1);
  for (CORBA::ULong i = 0; i < 1; ++i)
    {
      CORBA::TypeCode_ptr tcp = _tao_ImplementationRepository_Administration_find_exceptiondata[i];
      TAO_Pseudo_Object_Manager<CORBA::TypeCode, CORBA::TypeCode_var> tcp_object (&tcp, 1);
      (*exception_list)[i] = tcp_object;
    }

  return safe_exception_list._retn ();
}

CORBA::Any * 
TAO_ClientRequestInfo_ImplementationRepository_Administration_find::result (ACE_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 ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  return result_any;
}

class TAO_ClientRequestInfo_ImplementationRepository_Administration_list : public TAO_ClientRequestInfo_i
{
public:
  TAO_ClientRequestInfo_ImplementationRepository_Administration_list (
      TAO_GIOP_Invocation *_tao_invocation,
      CORBA::Object_ptr _tao_target,
      const CORBA::ULong & how_many      
 ACE_ENV_ARG_DECL_WITH_DEFAULTS
    );

  virtual Dynamic::ParameterList * arguments (ACE_ENV_SINGLE_ARG_DECL)
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual Dynamic::ExceptionList * exceptions (ACE_ENV_SINGLE_ARG_DECL)
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual CORBA::Any * result (ACE_ENV_SINGLE_ARG_DECL)
    ACE_THROW_SPEC ((CORBA::SystemException));

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

  const CORBA::ULong & how_many_;
    

};

TAO_ClientRequestInfo_ImplementationRepository_Administration_list::TAO_ClientRequestInfo_ImplementationRepository_Administration_list (
    TAO_GIOP_Invocation *_tao_invocation,
    CORBA::Object_ptr _tao_target,
    const CORBA::ULong & how_many    
 ACE_ENV_ARG_DECL_NOT_USED    
  )
  : TAO_ClientRequestInfo_i (_tao_invocation, _tao_target),
    how_many_ (how_many)

{}

Dynamic::ParameterList *
TAO_ClientRequestInfo_ImplementationRepository_Administration_list::arguments (ACE_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 (ACE_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 <<= how_many_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
    

  return safe_parameter_list._retn ();
}

Dynamic::ExceptionList *
TAO_ClientRequestInfo_ImplementationRepository_Administration_list::exceptions (ACE_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 (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  return exception_list;
}

CORBA::Any * 
TAO_ClientRequestInfo_ImplementationRepository_Administration_list::result (ACE_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 ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  return result_any;
}

#endif /* TAO_HAS_INTERCEPTORS */

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

ImplementationRepository::_TAO_Administration_Proxy_Impl::_TAO_Administration_Proxy_Impl (void)
{}

ImplementationRepository::_TAO_Administration_Remote_Proxy_Impl::_TAO_Administration_Remote_Proxy_Impl (void)
{}

// Remote Implementation of the IDL interface methods

void ImplementationRepository::_TAO_Administration_Remote_Proxy_Impl::activate_server (
    CORBA_Object *_collocated_tao_target_,
    const char * server
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
    , ImplementationRepository::Administration::NotFound
    , ImplementationRepository::Administration::CannotActivate
  ))
{
  
  static TAO_Exception_Data _tao_ImplementationRepository_Administration_activate_server_exceptiondata [] = 
  {
    {
      "IDL:ImplementationRepository/Administration/NotFound:1.0",
      ImplementationRepository::Administration::NotFound::_alloc
    },
    {
      "IDL:ImplementationRepository/Administration/CannotActivate:1.0",
      ImplementationRepository::Administration::CannotActivate::_alloc
    }
  };

  
  
  
  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
  if (istub == 0)
    ACE_THROW (CORBA::INTERNAL ());

  
  TAO_GIOP_Twoway_Invocation _tao_call (
      istub,
      "activate_server",
      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_ImplementationRepository_Administration_activate_server _tao_ri (
        &_tao_call,
        _collocated_tao_target_,
        server ACE_ENV_ARG_PARAMETER
      );
            ACE_CHECK;

#endif /* TAO_HAS_INTERCEPTORS */
      
      
      CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
      TAO_INTERCEPTOR (_tao_ri.response_expected (1));
      
#if TAO_HAS_INTERCEPTORS == 1
      
      ACE_TRY
        {
          _tao_vfr.send_request (
            &_tao_ri
            ACE_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 (ACE_ENV_SINGLE_ARG_PARAMETER);
                    TAO_INTERCEPTOR_CHECK;

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

          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
          if (!(
                            (_tao_out << server)
            ))
            TAO_INTERCEPTOR_THROW (
              CORBA::MARSHAL ()
            );
            
          _invoke_status =
            _tao_call.invoke (_tao_ImplementationRepository_Administration_activate_server_exceptiondata, 2 ACE_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 (
                _tao_ri.reply_status (_invoke_status);
                _tao_vfr.receive_other (
                  &_tao_ri
                  ACE_ENV_ARG_PARAMETER
                );
                ACE_TRY_CHECK;
              )
              
              continue;
            }
          
          
#if TAO_HAS_INTERCEPTORS == 1
          
          _tao_ri.reply_status (_invoke_status);
          _tao_vfr.receive_reply (
            &_tao_ri
            ACE_ENV_ARG_PARAMETER
          );
          ACE_TRY_CHECK;
        
      }
    ACE_CATCHANY
      {
        _tao_ri.exception (&ACE_ANY_EXCEPTION);
        _tao_vfr.receive_exception (
          &_tao_ri
          ACE_ENV_ARG_PARAMETER
        );
        ACE_TRY_CHECK;
        
        PortableInterceptor::ReplyStatus _tao_status =
          _tao_ri.reply_status (ACE_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 =
      _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
        ACE_CHECK;

    if (_tao_status == PortableInterceptor::LOCATION_FORWARD
        || _tao_status == PortableInterceptor::TRANSPORT_RETRY)
      continue;
    
#endif  /* TAO_HAS_INTERCEPTORS */
    
    break;
  }

}

void ImplementationRepository::_TAO_Administration_Remote_Proxy_Impl::register_server (
    CORBA_Object *_collocated_tao_target_,
    const char * server,
    const ImplementationRepository::StartupOptions & options
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
    , ImplementationRepository::Administration::AlreadyRegistered
  ))
{
  
  static TAO_Exception_Data _tao_ImplementationRepository_Administration_register_server_exceptiondata [] = 
  {
    {
      "IDL:ImplementationRepository/Administration/AlreadyRegistered:1.0",
      ImplementationRepository::Administration::AlreadyRegistered::_alloc
    }
  };

  
  
  
  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
  if (istub == 0)
    ACE_THROW (CORBA::INTERNAL ());

  
  TAO_GIOP_Twoway_Invocation _tao_call (
      istub,
      "register_server",
      15,
      2,
      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_ImplementationRepository_Administration_register_server _tao_ri (
        &_tao_call,
        _collocated_tao_target_,
        server,
        options ACE_ENV_ARG_PARAMETER
      );
            ACE_CHECK;

#endif /* TAO_HAS_INTERCEPTORS */
      
      
      CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
      TAO_INTERCEPTOR (_tao_ri.response_expected (1));
      
#if TAO_HAS_INTERCEPTORS == 1
      
      ACE_TRY
        {
          _tao_vfr.send_request (
            &_tao_ri
            ACE_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 (ACE_ENV_SINGLE_ARG_PARAMETER);
                    TAO_INTERCEPTOR_CHECK;

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

          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
          if (!(
                            (_tao_out << server) &&
              (_tao_out << options)
            ))
            TAO_INTERCEPTOR_THROW (
              CORBA::MARSHAL ()
            );
            
          _invoke_status =
            _tao_call.invoke (_tao_ImplementationRepository_Administration_register_server_exceptiondata, 1 ACE_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 (
                _tao_ri.reply_status (_invoke_status);
                _tao_vfr.receive_other (
                  &_tao_ri
                  ACE_ENV_ARG_PARAMETER
                );
                ACE_TRY_CHECK;
              )
              
              continue;
            }
          
          
#if TAO_HAS_INTERCEPTORS == 1
          
          _tao_ri.reply_status (_invoke_status);
          _tao_vfr.receive_reply (
            &_tao_ri
            ACE_ENV_ARG_PARAMETER
          );
          ACE_TRY_CHECK;
        
      }
    ACE_CATCHANY
      {
        _tao_ri.exception (&ACE_ANY_EXCEPTION);
        _tao_vfr.receive_exception (
          &_tao_ri
          ACE_ENV_ARG_PARAMETER
        );
        ACE_TRY_CHECK;
        
        PortableInterceptor::ReplyStatus _tao_status =
          _tao_ri.reply_status (ACE_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 =
      _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
        ACE_CHECK;

    if (_tao_status == PortableInterceptor::LOCATION_FORWARD
        || _tao_status == PortableInterceptor::TRANSPORT_RETRY)
      continue;
    
#endif  /* TAO_HAS_INTERCEPTORS */
    
    break;
  }

}

void ImplementationRepository::_TAO_Administration_Remote_Proxy_Impl::reregister_server (
    CORBA_Object *_collocated_tao_target_,
    const char * server,
    const ImplementationRepository::StartupOptions & options
    ACE_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,
      "reregister_server",
      17,
      2,
      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_ImplementationRepository_Administration_reregister_server _tao_ri (
        &_tao_call,
        _collocated_tao_target_,
        server,
        options ACE_ENV_ARG_PARAMETER
      );
            ACE_CHECK;

#endif /* TAO_HAS_INTERCEPTORS */
      
      
      CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
      TAO_INTERCEPTOR (_tao_ri.response_expected (1));
      
#if TAO_HAS_INTERCEPTORS == 1
      
      ACE_TRY
        {
          _tao_vfr.send_request (
            &_tao_ri
            ACE_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 (ACE_ENV_SINGLE_ARG_PARAMETER);
                    TAO_INTERCEPTOR_CHECK;

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

          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
          if (!(
                            (_tao_out << server) &&
              (_tao_out << options)
            ))
            TAO_INTERCEPTOR_THROW (
              CORBA::MARSHAL ()
            );
            
          _invoke_status =
            _tao_call.invoke (0, 0 ACE_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 (
                _tao_ri.reply_status (_invoke_status);
                _tao_vfr.receive_other (
                  &_tao_ri
                  ACE_ENV_ARG_PARAMETER
                );
                ACE_TRY_CHECK;
              )
              
              continue;
            }
          
          
#if TAO_HAS_INTERCEPTORS == 1
          
          _tao_ri.reply_status (_invoke_status);
          _tao_vfr.receive_reply (
            &_tao_ri
            ACE_ENV_ARG_PARAMETER
          );
          ACE_TRY_CHECK;
        
      }
    ACE_CATCHANY
      {
        _tao_ri.exception (&ACE_ANY_EXCEPTION);
        _tao_vfr.receive_exception (
          &_tao_ri
          ACE_ENV_ARG_PARAMETER
        );
        ACE_TRY_CHECK;
        
        PortableInterceptor::ReplyStatus _tao_status =
          _tao_ri.reply_status (ACE_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 =
      _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
        ACE_CHECK;

    if (_tao_status == PortableInterceptor::LOCATION_FORWARD
        || _tao_status == PortableInterceptor::TRANSPORT_RETRY)
      continue;
    
#endif  /* TAO_HAS_INTERCEPTORS */
    
    break;
  }

}

void ImplementationRepository::_TAO_Administration_Remote_Proxy_Impl::remove_server (
    CORBA_Object *_collocated_tao_target_,
    const char * server
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
    , ImplementationRepository::Administration::NotFound
  ))
{
  
  static TAO_Exception_Data _tao_ImplementationRepository_Administration_remove_server_exceptiondata [] = 
  {
    {
      "IDL:ImplementationRepository/Administration/NotFound:1.0",
      ImplementationRepository::Administration::NotFound::_alloc
    }
  };

  
  
  
  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
  if (istub == 0)
    ACE_THROW (CORBA::INTERNAL ());

  
  TAO_GIOP_Twoway_Invocation _tao_call (
      istub,
      "remove_server",
      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_ImplementationRepository_Administration_remove_server _tao_ri (
        &_tao_call,
        _collocated_tao_target_,
        server ACE_ENV_ARG_PARAMETER
      );
            ACE_CHECK;

#endif /* TAO_HAS_INTERCEPTORS */
      
      
      CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
      TAO_INTERCEPTOR (_tao_ri.response_expected (1));
      
#if TAO_HAS_INTERCEPTORS == 1
      
      ACE_TRY
        {
          _tao_vfr.send_request (
            &_tao_ri
            ACE_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 (ACE_ENV_SINGLE_ARG_PARAMETER);
                    TAO_INTERCEPTOR_CHECK;

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

          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
          if (!(
                            (_tao_out << server)
            ))
            TAO_INTERCEPTOR_THROW (
              CORBA::MARSHAL ()
            );
            
          _invoke_status =
            _tao_call.invoke (_tao_ImplementationRepository_Administration_remove_server_exceptiondata, 1 ACE_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 (
                _tao_ri.reply_status (_invoke_status);
                _tao_vfr.receive_other (
                  &_tao_ri
                  ACE_ENV_ARG_PARAMETER
                );
                ACE_TRY_CHECK;
              )
              
              continue;
            }
          
          
#if TAO_HAS_INTERCEPTORS == 1
          
          _tao_ri.reply_status (_invoke_status);
          _tao_vfr.receive_reply (
            &_tao_ri
            ACE_ENV_ARG_PARAMETER
          );
          ACE_TRY_CHECK;
        
      }
    ACE_CATCHANY
      {
        _tao_ri.exception (&ACE_ANY_EXCEPTION);
        _tao_vfr.receive_exception (
          &_tao_ri
          ACE_ENV_ARG_PARAMETER
        );
        ACE_TRY_CHECK;
        
        PortableInterceptor::ReplyStatus _tao_status =
          _tao_ri.reply_status (ACE_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 =
      _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
        ACE_CHECK;

    if (_tao_status == PortableInterceptor::LOCATION_FORWARD
        || _tao_status == PortableInterceptor::TRANSPORT_RETRY)
      continue;
    
#endif  /* TAO_HAS_INTERCEPTORS */
    
    break;
  }

}

void ImplementationRepository::_TAO_Administration_Remote_Proxy_Impl::shutdown_server (
    CORBA_Object *_collocated_tao_target_,
    const char * server
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
    , ImplementationRepository::Administration::NotFound
  ))
{
  
  static TAO_Exception_Data _tao_ImplementationRepository_Administration_shutdown_server_exceptiondata [] = 
  {
    {
      "IDL:ImplementationRepository/Administration/NotFound:1.0",
      ImplementationRepository::Administration::NotFound::_alloc
    }
  };

  
  
  
  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
  if (istub == 0)
    ACE_THROW (CORBA::INTERNAL ());

  
  TAO_GIOP_Twoway_Invocation _tao_call (
      istub,
      "shutdown_server",
      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_ImplementationRepository_Administration_shutdown_server _tao_ri (
        &_tao_call,
        _collocated_tao_target_,
        server ACE_ENV_ARG_PARAMETER
      );
            ACE_CHECK;

#endif /* TAO_HAS_INTERCEPTORS */
      
      
      CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
      TAO_INTERCEPTOR (_tao_ri.response_expected (1));
      
#if TAO_HAS_INTERCEPTORS == 1
      
      ACE_TRY
        {
          _tao_vfr.send_request (
            &_tao_ri
            ACE_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 (ACE_ENV_SINGLE_ARG_PARAMETER);
                    TAO_INTERCEPTOR_CHECK;

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

          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
          if (!(
                            (_tao_out << server)
            ))
            TAO_INTERCEPTOR_THROW (
              CORBA::MARSHAL ()
            );
            
          _invoke_status =
            _tao_call.invoke (_tao_ImplementationRepository_Administration_shutdown_server_exceptiondata, 1 ACE_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 (
                _tao_ri.reply_status (_invoke_status);
                _tao_vfr.receive_other (
                  &_tao_ri
                  ACE_ENV_ARG_PARAMETER
                );
                ACE_TRY_CHECK;
              )
              
              continue;
            }
          
          
#if TAO_HAS_INTERCEPTORS == 1
          
          _tao_ri.reply_status (_invoke_status);
          _tao_vfr.receive_reply (
            &_tao_ri
            ACE_ENV_ARG_PARAMETER
          );
          ACE_TRY_CHECK;
        
      }
    ACE_CATCHANY
      {
        _tao_ri.exception (&ACE_ANY_EXCEPTION);
        _tao_vfr.receive_exception (
          &_tao_ri
          ACE_ENV_ARG_PARAMETER
        );
        ACE_TRY_CHECK;
        
        PortableInterceptor::ReplyStatus _tao_status =
          _tao_ri.reply_status (ACE_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 =
      _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
        ACE_CHECK;

    if (_tao_status == PortableInterceptor::LOCATION_FORWARD
        || _tao_status == PortableInterceptor::TRANSPORT_RETRY)
      continue;
    
#endif  /* TAO_HAS_INTERCEPTORS */
    
    break;
  }

}

char * ImplementationRepository::_TAO_Administration_Remote_Proxy_Impl::server_is_running (
    CORBA_Object *_collocated_tao_target_,
    const char * server,
    const char * addr,
    ImplementationRepository::ServerObject_ptr server_object
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
    , ImplementationRepository::Administration::NotFound
  ))
{
  
  static TAO_Exception_Data _tao_ImplementationRepository_Administration_server_is_running_exceptiondata [] = 
  {
    {
      "IDL:ImplementationRepository/Administration/NotFound:1.0",
      ImplementationRepository::Administration::NotFound::_alloc
    }
  };

  CORBA::String_var _tao_retval;
  
  
  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
  if (istub == 0)
    ACE_THROW_RETURN (CORBA::INTERNAL (),_tao_retval._retn ());

  
  TAO_GIOP_Twoway_Invocation _tao_call (
      istub,
      "server_is_running",
      17,
      3,
      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_ImplementationRepository_Administration_server_is_running _tao_ri (
        &_tao_call,
        _collocated_tao_target_,
        server,
        addr,
        server_object ACE_ENV_ARG_PARAMETER
      );
            ACE_CHECK_RETURN (_tao_retval._retn ());

#endif /* TAO_HAS_INTERCEPTORS */
      
      
      CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
      TAO_INTERCEPTOR (_tao_ri.response_expected (1));
      
#if TAO_HAS_INTERCEPTORS == 1
      
      ACE_TRY
        {
          _tao_vfr.send_request (
            &_tao_ri
            ACE_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 (ACE_ENV_SINGLE_ARG_PARAMETER);
                    TAO_INTERCEPTOR_CHECK_RETURN (_tao_retval._retn ());

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

          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
          if (!(
                            (_tao_out << server) &&
              (_tao_out << addr) &&
              (_tao_out << server_object)
            ))
            TAO_INTERCEPTOR_THROW_RETURN (
              CORBA::MARSHAL (),
              0
            );
            
          _invoke_status =
            _tao_call.invoke (_tao_ImplementationRepository_Administration_server_is_running_exceptiondata, 1 ACE_ENV_ARG_PARAMETER);
                    TAO_INTERCEPTOR_CHECK_RETURN (_tao_retval._retn ());

          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 (
                _tao_ri.reply_status (_invoke_status);
                _tao_vfr.receive_other (
                  &_tao_ri
                  ACE_ENV_ARG_PARAMETER
                );
                ACE_TRY_CHECK;
              )
              
              continue;
            }
          
          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
          if (!(
                            (_tao_in >> _tao_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_retval._retn ();
          _tao_ri.result (_tao_retval_info);
          _tao_retval = _tao_retval_info;
          
          _tao_ri.reply_status (_invoke_status);
          _tao_vfr.receive_reply (
            &_tao_ri
            ACE_ENV_ARG_PARAMETER
          );
          ACE_TRY_CHECK;
        
      }
    ACE_CATCHANY
      {
        _tao_ri.exception (&ACE_ANY_EXCEPTION);
        _tao_vfr.receive_exception (
          &_tao_ri
          ACE_ENV_ARG_PARAMETER
        );
        ACE_TRY_CHECK;
        
        PortableInterceptor::ReplyStatus _tao_status =
          _tao_ri.reply_status (ACE_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._retn ());

    PortableInterceptor::ReplyStatus _tao_status =
      _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
        ACE_CHECK_RETURN (_tao_retval._retn ());

    if (_tao_status == PortableInterceptor::LOCATION_FORWARD
        || _tao_status == PortableInterceptor::TRANSPORT_RETRY)
      continue;
    
#endif  /* TAO_HAS_INTERCEPTORS */
    
    break;
  }
return _tao_retval._retn ();
}

void ImplementationRepository::_TAO_Administration_Remote_Proxy_Impl::server_is_shutting_down (
    CORBA_Object *_collocated_tao_target_,
    const char * server
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
    , ImplementationRepository::Administration::NotFound
  ))
{
  
  static TAO_Exception_Data _tao_ImplementationRepository_Administration_server_is_shutting_down_exceptiondata [] = 
  {
    {
      "IDL:ImplementationRepository/Administration/NotFound:1.0",
      ImplementationRepository::Administration::NotFound::_alloc
    }
  };

  
  
  
  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
  if (istub == 0)
    ACE_THROW (CORBA::INTERNAL ());

  
  TAO_GIOP_Twoway_Invocation _tao_call (
      istub,
      "server_is_shutting_down",
      23,
      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_ImplementationRepository_Administration_server_is_shutting_down _tao_ri (
        &_tao_call,
        _collocated_tao_target_,
        server ACE_ENV_ARG_PARAMETER
      );
            ACE_CHECK;

#endif /* TAO_HAS_INTERCEPTORS */
      
      
      CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
      TAO_INTERCEPTOR (_tao_ri.response_expected (1));
      
#if TAO_HAS_INTERCEPTORS == 1
      
      ACE_TRY
        {
          _tao_vfr.send_request (
            &_tao_ri
            ACE_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 (ACE_ENV_SINGLE_ARG_PARAMETER);
                    TAO_INTERCEPTOR_CHECK;

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

          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
          if (!(
                            (_tao_out << server)
            ))
            TAO_INTERCEPTOR_THROW (
              CORBA::MARSHAL ()
            );
            
          _invoke_status =
            _tao_call.invoke (_tao_ImplementationRepository_Administration_server_is_shutting_down_exceptiondata, 1 ACE_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 (
                _tao_ri.reply_status (_invoke_status);
                _tao_vfr.receive_other (
                  &_tao_ri
                  ACE_ENV_ARG_PARAMETER
                );
                ACE_TRY_CHECK;
              )
              
              continue;
            }
          
          
#if TAO_HAS_INTERCEPTORS == 1
          
          _tao_ri.reply_status (_invoke_status);
          _tao_vfr.receive_reply (
            &_tao_ri
            ACE_ENV_ARG_PARAMETER
          );
          ACE_TRY_CHECK;
        
      }
    ACE_CATCHANY
      {
        _tao_ri.exception (&ACE_ANY_EXCEPTION);
        _tao_vfr.receive_exception (
          &_tao_ri
          ACE_ENV_ARG_PARAMETER
        );
        ACE_TRY_CHECK;
        
        PortableInterceptor::ReplyStatus _tao_status =
          _tao_ri.reply_status (ACE_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 =
      _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
        ACE_CHECK;

    if (_tao_status == PortableInterceptor::LOCATION_FORWARD
        || _tao_status == PortableInterceptor::TRANSPORT_RETRY)
      continue;
    
#endif  /* TAO_HAS_INTERCEPTORS */
    
    break;
  }

}

void ImplementationRepository::_TAO_Administration_Remote_Proxy_Impl::find (
    CORBA_Object *_collocated_tao_target_,
    const char * server,
    ImplementationRepository::ServerInformation_out info
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
    , ImplementationRepository::Administration::NotFound
  ))
{
  
  static TAO_Exception_Data _tao_ImplementationRepository_Administration_find_exceptiondata [] = 
  {
    {
      "IDL:ImplementationRepository/Administration/NotFound:1.0",
      ImplementationRepository::Administration::NotFound::_alloc
    }
  };

  
  
  
  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
  if (istub == 0)
    ACE_THROW (CORBA::INTERNAL ());

  
  ACE_NEW (
      info.ptr (),
      ImplementationRepository::ServerInformation
    );
  
  TAO_GIOP_Twoway_Invocation _tao_call (
      istub,
      "find",
      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_ImplementationRepository_Administration_find _tao_ri (
        &_tao_call,
        _collocated_tao_target_,
        server ACE_ENV_ARG_PARAMETER
      );
            ACE_CHECK;

#endif /* TAO_HAS_INTERCEPTORS */
      
      
      CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
      TAO_INTERCEPTOR (_tao_ri.response_expected (1));
      
#if TAO_HAS_INTERCEPTORS == 1
      
      ACE_TRY
        {
          _tao_vfr.send_request (
            &_tao_ri
            ACE_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 (ACE_ENV_SINGLE_ARG_PARAMETER);
                    TAO_INTERCEPTOR_CHECK;

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

          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
          if (!(
                            (_tao_out << server)              
            ))
            TAO_INTERCEPTOR_THROW (
              CORBA::MARSHAL ()
            );
            
          _invoke_status =
            _tao_call.invoke (_tao_ImplementationRepository_Administration_find_exceptiondata, 1 ACE_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 (
                _tao_ri.reply_status (_invoke_status);
                _tao_vfr.receive_other (
                  &_tao_ri
                  ACE_ENV_ARG_PARAMETER
                );
                ACE_TRY_CHECK;
              )
              
              continue;
            }
          
          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
          if (!(
                                          (_tao_in >> *info.ptr ())
              ))
            {
              TAO_INTERCEPTOR_THROW (
                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)
              );
              
            }
          
#if TAO_HAS_INTERCEPTORS == 1
          
          _tao_ri.reply_status (_invoke_status);
          _tao_vfr.receive_reply (
            &_tao_ri
            ACE_ENV_ARG_PARAMETER
          );
          ACE_TRY_CHECK;
        
      }
    ACE_CATCHANY
      {
        _tao_ri.exception (&ACE_ANY_EXCEPTION);
        _tao_vfr.receive_exception (
          &_tao_ri
          ACE_ENV_ARG_PARAMETER
        );
        ACE_TRY_CHECK;
        
        PortableInterceptor::ReplyStatus _tao_status =
          _tao_ri.reply_status (ACE_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 =
      _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
        ACE_CHECK;

    if (_tao_status == PortableInterceptor::LOCATION_FORWARD
        || _tao_status == PortableInterceptor::TRANSPORT_RETRY)
      continue;
    
#endif  /* TAO_HAS_INTERCEPTORS */
    
    break;
  }

}

void ImplementationRepository::_TAO_Administration_Remote_Proxy_Impl::list (
    CORBA_Object *_collocated_tao_target_,
    CORBA::ULong how_many,
    ImplementationRepository::ServerInformationList_out server_list,
    ImplementationRepository::ServerInformationIterator_out server_iterator
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  
  
  
  
  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
  if (istub == 0)
    ACE_THROW (CORBA::INTERNAL ());

  
  ACE_NEW (
      server_list.ptr (),
      ImplementationRepository::ServerInformationList
    );
  
  TAO_GIOP_Twoway_Invocation _tao_call (
      istub,
      "list",
      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_ImplementationRepository_Administration_list _tao_ri (
        &_tao_call,
        _collocated_tao_target_,
        how_many        
 ACE_ENV_ARG_PARAMETER
      );
            ACE_CHECK;

#endif /* TAO_HAS_INTERCEPTORS */
      
      
      CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
      TAO_INTERCEPTOR (_tao_ri.response_expected (1));
      
#if TAO_HAS_INTERCEPTORS == 1
      
      ACE_TRY
        {
          _tao_vfr.send_request (
            &_tao_ri
            ACE_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 (ACE_ENV_SINGLE_ARG_PARAMETER);
                    TAO_INTERCEPTOR_CHECK;

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

          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
          if (!(
                            (_tao_out << how_many)                            
            ))
            TAO_INTERCEPTOR_THROW (
              CORBA::MARSHAL ()
            );
            
          _invoke_status =
            _tao_call.invoke (0, 0 ACE_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 (
                _tao_ri.reply_status (_invoke_status);
                _tao_vfr.receive_other (
                  &_tao_ri
                  ACE_ENV_ARG_PARAMETER
                );
                ACE_TRY_CHECK;
              )
              
              continue;
            }
          
          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
          if (!(
                                          (_tao_in >> *server_list.ptr ()) &&
              (_tao_in >> server_iterator.ptr ())
              ))
            {
              TAO_INTERCEPTOR_THROW (
                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)
              );
              
            }
          
#if TAO_HAS_INTERCEPTORS == 1
          
          _tao_ri.reply_status (_invoke_status);
          _tao_vfr.receive_reply (
            &_tao_ri
            ACE_ENV_ARG_PARAMETER
          );
          ACE_TRY_CHECK;
        
      }
    ACE_CATCHANY
      {
        _tao_ri.exception (&ACE_ANY_EXCEPTION);
        _tao_vfr.receive_exception (
          &_tao_ri
          ACE_ENV_ARG_PARAMETER
        );
        ACE_TRY_CHECK;
        
        PortableInterceptor::ReplyStatus _tao_status =
          _tao_ri.reply_status (ACE_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 =
      _tao_ri.reply_status (ACE_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
//

ImplementationRepository::_TAO_Administration_Proxy_Broker::_TAO_Administration_Proxy_Broker (void)
{
}

ImplementationRepository::_TAO_Administration_Proxy_Broker::~_TAO_Administration_Proxy_Broker (void)
{
}

ImplementationRepository::_TAO_Administration_Proxy_Broker * (*ImplementationRepository__TAO_Administration_Proxy_Broker_Factory_function_pointer) (
    CORBA::Object_ptr obj
  ) = 0;

// Factory Member function Implementation.
ImplementationRepository::_TAO_Administration_Remote_Proxy_Broker *
ImplementationRepository::_TAO_Administration_Remote_Proxy_Broker::the_TAO_Administration_Remote_Proxy_Broker (void)
{
  static ::ImplementationRepository::_TAO_Administration_Remote_Proxy_Broker remote_proxy_broker;
  return &remote_proxy_broker;
}

ImplementationRepository::_TAO_Administration_Remote_Proxy_Broker::_TAO_Administration_Remote_Proxy_Broker (void)
{
}

ImplementationRepository::_TAO_Administration_Remote_Proxy_Broker::~_TAO_Administration_Remote_Proxy_Broker (void)
{
}

ImplementationRepository::_TAO_Administration_Proxy_Impl&
ImplementationRepository::_TAO_Administration_Remote_Proxy_Broker::select_proxy (
  ::ImplementationRepository::Administration *
  ACE_ENV_ARG_DECL_NOT_USED
)
{
  return this->remote_proxy_impl_;
}


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


// TAO_IDL - Generated from 
// be/be_visitor_interface/interface_cs.cpp:209

ImplementationRepository::Administration::Administration (int collocated)
{
  this->ImplementationRepository_Administration_setup_collocation (collocated);
}

ImplementationRepository::Administration::~Administration (void)
{}

void
ImplementationRepository::Administration::ImplementationRepository_Administration_setup_collocation (int collocated)
{
  if (collocated)
    this->the_TAO_Administration_Proxy_Broker_ =
      ::ImplementationRepository__TAO_Administration_Proxy_Broker_Factory_function_pointer (this);
  else
    this->the_TAO_Administration_Proxy_Broker_ =
      ::ImplementationRepository::_TAO_Administration_Remote_Proxy_Broker::the_TAO_Administration_Remote_Proxy_Broker ();
}

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

ImplementationRepository::Administration_ptr ImplementationRepository::Administration::_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL
  )
{
  if (CORBA::is_nil (obj))
    return Administration::_nil ();
  if (! obj->_is_local ())
    {
      CORBA::Boolean is_a = obj->_is_a ("IDL:ImplementationRepository/Administration:1.0" ACE_ENV_ARG_PARAMETER);
      ACE_CHECK_RETURN (Administration::_nil ());
      if (is_a == 0)
        return Administration::_nil ();
    }
  return Administration::_unchecked_narrow (obj ACE_ENV_ARG_PARAMETER);
}

ImplementationRepository::Administration_ptr 
ImplementationRepository::Administration::_unchecked_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  if (CORBA::is_nil (obj))
    return Administration::_nil ();
  if (! obj->_is_local ())
    {
      TAO_Stub* stub = obj->_stubobj ();
      if (stub)
        stub->_incr_refcnt ();
      Administration_ptr default_proxy = Administration::_nil ();

      if (
          !CORBA::is_nil (stub->servant_orb_var ().ptr ()) &&
          stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects () &&
          obj->_is_collocated () &&
          ImplementationRepository__TAO_Administration_Proxy_Broker_Factory_function_pointer != 0
        )
        {
          ACE_NEW_RETURN (
              default_proxy,
              ::ImplementationRepository::Administration (
                  stub,
                  1,
                  obj->_servant ()
                ),
              Administration::_nil ()
            );
        }
      
      if (CORBA::is_nil (default_proxy))
        {
          ACE_NEW_RETURN (
              default_proxy,
              ::ImplementationRepository::Administration (
                  stub,
                  0,
                  obj->_servant ()
                ),
              Administration::_nil ()
            );
        }
      
      return default_proxy;
    }
  else 
    return
      ACE_reinterpret_cast
        (
          Administration_ptr,
            obj->_tao_QueryInterface
              (
                ACE_reinterpret_cast
                  (
                    ptr_arith_t,
                    &Administration::_tao_class_id
                  )
              )
        );
}

ImplementationRepository::Administration_ptr
ImplementationRepository::Administration::_duplicate (Administration_ptr obj)
{
  if (!CORBA::is_nil (obj))
    obj->_add_ref ();
  return obj;
}

CORBA::Boolean ImplementationRepository::Administration::_is_a (const CORBA::Char *value ACE_ENV_ARG_DECL)
{
  if (
    (!ACE_OS::strcmp ((char *)value, "IDL:ImplementationRepository/Administration:1.0")) ||
    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
  return 1; // success using local knowledge
  else
    return this->CORBA_Object::_is_a (value ACE_ENV_ARG_PARAMETER);
}

void *ImplementationRepository::Administration::_tao_QueryInterface (ptr_arith_t type)
{
  void *retv = 0;
  if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &ACE_NESTED_CLASS (::ImplementationRepository, Administration)::_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* ImplementationRepository::Administration::_interface_repository_id (void) const
{
  return "IDL:ImplementationRepository/Administration:1.0";
}

// Default constructor.
ImplementationRepository::Administration::AlreadyRegistered::AlreadyRegistered (void)
  : CORBA_UserException ("IDL:ImplementationRepository/Administration/AlreadyRegistered:1.0")
{
}

// Destructor - all members are of self managing types.
ImplementationRepository::Administration::AlreadyRegistered::~AlreadyRegistered (void)
{
}

// Copy constructor.
ImplementationRepository::Administration::AlreadyRegistered::AlreadyRegistered (const ::ImplementationRepository::Administration::AlreadyRegistered &_tao_excp)
  : CORBA_UserException (_tao_excp._id ())
{
}

// Assignment operator.
ImplementationRepository::Administration::AlreadyRegistered&
ImplementationRepository::Administration::AlreadyRegistered::operator= (const ::ImplementationRepository::Administration::AlreadyRegistered &_tao_excp)
{
  this->CORBA_UserException::operator= (_tao_excp);
  return *this;
}

void ImplementationRepository::Administration::AlreadyRegistered::_tao_any_destructor (void *_tao_void_pointer)
{
  AlreadyRegistered *tmp = ACE_static_cast (AlreadyRegistered*, _tao_void_pointer);
  delete tmp;
}

ImplementationRepository::Administration::AlreadyRegistered *
ImplementationRepository::Administration::AlreadyRegistered::_downcast (CORBA::Exception *exc)
{
  if (!ACE_OS::strcmp ("IDL:ImplementationRepository/Administration/AlreadyRegistered:1.0", exc->_id ()))
    {
      return ACE_dynamic_cast (AlreadyRegistered *, exc);
    }
  else
    {
      return 0;
    }
}

CORBA::Exception *ImplementationRepository::Administration::AlreadyRegistered::_alloc (void)
{
  CORBA::Exception *retval = 0;
  ACE_NEW_RETURN (retval, ::ImplementationRepository::Administration::AlreadyRegistered, 0);
  return retval;
}

CORBA::Exception *
ImplementationRepository::Administration::AlreadyRegistered::_tao_duplicate (void) const
{
  CORBA::Exception *result;
  ACE_NEW_RETURN (
      result,
      ImplementationRepository::Administration::AlreadyRegistered (*this),
      0
    );
  return result;
}

void ImplementationRepository::Administration::AlreadyRegistered::_raise ()
{
  TAO_RAISE (*this);
}

void ImplementationRepository::Administration::AlreadyRegistered::_tao_encode (
    TAO_OutputCDR &cdr
    ACE_ENV_ARG_DECL
  ) const
{
  if (cdr << *this)
    {
      return;
    }
  
  ACE_THROW (CORBA::MARSHAL ());
}

void ImplementationRepository::Administration::AlreadyRegistered::_tao_decode (
    TAO_InputCDR &cdr
    ACE_ENV_ARG_DECL
  )
{
  if (cdr >> *this)
    {
      return;
    }
  
  ACE_THROW (CORBA::MARSHAL ());
}

static const CORBA::Long _oc_ImplementationRepository_Administration_AlreadyRegistered[] =
{
  TAO_ENCAP_BYTE_ORDER, // byte order
  66,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x496d706c), 
  ACE_NTOHL (0x656d656e), 
  ACE_NTOHL (0x74617469), 
  ACE_NTOHL (0x6f6e5265), 
  ACE_NTOHL (0x706f7369), 
  ACE_NTOHL (0x746f7279), 
  ACE_NTOHL (0x2f41646d), 
  ACE_NTOHL (0x696e6973), 
  ACE_NTOHL (0x74726174), 
  ACE_NTOHL (0x696f6e2f), 
  ACE_NTOHL (0x416c7265), 
  ACE_NTOHL (0x61647952), 
  ACE_NTOHL (0x65676973), 
  ACE_NTOHL (0x74657265), 
  ACE_NTOHL (0x643a312e), 
  ACE_NTOHL (0x30000000),  // repository ID = IDL:ImplementationRepository/Administration/AlreadyRegistered:1.0
  18,
  ACE_NTOHL (0x416c7265), 
  ACE_NTOHL (0x61647952), 
  ACE_NTOHL (0x65676973), 
  ACE_NTOHL (0x74657265), 
  ACE_NTOHL (0x64000000),  // name = AlreadyRegistered
  0, // member count
};

static CORBA::TypeCode _tc_TAO_tc_ImplementationRepository_Administration_AlreadyRegistered (
    CORBA::tk_except,
    sizeof (_oc_ImplementationRepository_Administration_AlreadyRegistered),
    (char *) &_oc_ImplementationRepository_Administration_AlreadyRegistered,
    0,
    sizeof (ImplementationRepository::Administration::AlreadyRegistered)
  );

::CORBA::TypeCode_ptr ImplementationRepository::Administration::_tc_AlreadyRegistered =
  &_tc_TAO_tc_ImplementationRepository_Administration_AlreadyRegistered;


// TAO extension - the virtual _type method.
CORBA::TypeCode_ptr ImplementationRepository::Administration::AlreadyRegistered::_type (void) const
{
  return ::ImplementationRepository::Administration::_tc_AlreadyRegistered;
}

// Default constructor.
ImplementationRepository::Administration::CannotActivate::CannotActivate (void)
  : CORBA_UserException ("IDL:ImplementationRepository/Administration/CannotActivate:1.0")
{
}

// Destructor - all members are of self managing types.
ImplementationRepository::Administration::CannotActivate::~CannotActivate (void)
{
}

// Copy constructor.
ImplementationRepository::Administration::CannotActivate::CannotActivate (const ::ImplementationRepository::Administration::CannotActivate &_tao_excp)
  : CORBA_UserException (_tao_excp._id ())
{
  this->reason = CORBA::string_dup (_tao_excp.reason.in ());
}

// Assignment operator.
ImplementationRepository::Administration::CannotActivate&
ImplementationRepository::Administration::CannotActivate::operator= (const ::ImplementationRepository::Administration::CannotActivate &_tao_excp)
{
  this->CORBA_UserException::operator= (_tao_excp);
  this->reason = CORBA::string_dup (_tao_excp.reason.in ());
  return *this;
}

void ImplementationRepository::Administration::CannotActivate::_tao_any_destructor (void *_tao_void_pointer)
{
  CannotActivate *tmp = ACE_static_cast (CannotActivate*, _tao_void_pointer);
  delete tmp;
}

ImplementationRepository::Administration::CannotActivate *
ImplementationRepository::Administration::CannotActivate::_downcast (CORBA::Exception *exc)
{
  if (!ACE_OS::strcmp ("IDL:ImplementationRepository/Administration/CannotActivate:1.0", exc->_id ()))
    {
      return ACE_dynamic_cast (CannotActivate *, exc);
    }
  else
    {
      return 0;
    }
}

CORBA::Exception *ImplementationRepository::Administration::CannotActivate::_alloc (void)
{
  CORBA::Exception *retval = 0;
  ACE_NEW_RETURN (retval, ::ImplementationRepository::Administration::CannotActivate, 0);
  return retval;
}

CORBA::Exception *
ImplementationRepository::Administration::CannotActivate::_tao_duplicate (void) const
{
  CORBA::Exception *result;
  ACE_NEW_RETURN (
      result,
      ImplementationRepository::Administration::CannotActivate (*this),
      0
    );
  return result;
}

void ImplementationRepository::Administration::CannotActivate::_raise ()
{
  TAO_RAISE (*this);
}

void ImplementationRepository::Administration::CannotActivate::_tao_encode (
    TAO_OutputCDR &cdr
    ACE_ENV_ARG_DECL
  ) const
{
  if (cdr << *this)
    {
      return;
    }
  
  ACE_THROW (CORBA::MARSHAL ());
}

void ImplementationRepository::Administration::CannotActivate::_tao_decode (
    TAO_InputCDR &cdr
    ACE_ENV_ARG_DECL
  )
{
  if (cdr >> *this)
    {
      return;
    }
  
  ACE_THROW (CORBA::MARSHAL ());
}

ImplementationRepository::Administration::CannotActivate::CannotActivate (
    const char * _tao_reason
  )
  : CORBA_UserException ("IDL:ImplementationRepository/Administration/CannotActivate:1.0")
{
  this->reason = CORBA::string_dup (_tao_reason);
}

static const CORBA::Long _oc_ImplementationRepository_Administration_CannotActivate[] =
{
  TAO_ENCAP_BYTE_ORDER, // byte order
  63,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x496d706c), 
  ACE_NTOHL (0x656d656e), 
  ACE_NTOHL (0x74617469), 
  ACE_NTOHL (0x6f6e5265), 
  ACE_NTOHL (0x706f7369), 
  ACE_NTOHL (0x746f7279), 
  ACE_NTOHL (0x2f41646d), 
  ACE_NTOHL (0x696e6973), 
  ACE_NTOHL (0x74726174), 
  ACE_NTOHL (0x696f6e2f), 
  ACE_NTOHL (0x43616e6e), 
  ACE_NTOHL (0x6f744163), 
  ACE_NTOHL (0x74697661), 
  ACE_NTOHL (0x74653a31), 
  ACE_NTOHL (0x2e300000),  // repository ID = IDL:ImplementationRepository/Administration/CannotActivate:1.0
  15,
  ACE_NTOHL (0x43616e6e), 
  ACE_NTOHL (0x6f744163), 
  ACE_NTOHL (0x74697661), 
  ACE_NTOHL (0x74650000),  // name = CannotActivate
  1, // member count
  7,
  ACE_NTOHL (0x72656173), 
  ACE_NTOHL (0x6f6e0000),  // name = reason
  CORBA::tk_string, 
  0U, // string length
};

static CORBA::TypeCode _tc_TAO_tc_ImplementationRepository_Administration_CannotActivate (
    CORBA::tk_except,
    sizeof (_oc_ImplementationRepository_Administration_CannotActivate),
    (char *) &_oc_ImplementationRepository_Administration_CannotActivate,
    0,
    sizeof (ImplementationRepository::Administration::CannotActivate)
  );

::CORBA::TypeCode_ptr ImplementationRepository::Administration::_tc_CannotActivate =
  &_tc_TAO_tc_ImplementationRepository_Administration_CannotActivate;


// TAO extension - the virtual _type method.
CORBA::TypeCode_ptr ImplementationRepository::Administration::CannotActivate::_type (void) const
{
  return ::ImplementationRepository::Administration::_tc_CannotActivate;
}

// Default constructor.
ImplementationRepository::Administration::NotFound::NotFound (void)
  : CORBA_UserException ("IDL:ImplementationRepository/Administration/NotFound:1.0")
{
}

// Destructor - all members are of self managing types.
ImplementationRepository::Administration::NotFound::~NotFound (void)
{
}

// Copy constructor.
ImplementationRepository::Administration::NotFound::NotFound (const ::ImplementationRepository::Administration::NotFound &_tao_excp)
  : CORBA_UserException (_tao_excp._id ())
{
}

// Assignment operator.
ImplementationRepository::Administration::NotFound&
ImplementationRepository::Administration::NotFound::operator= (const ::ImplementationRepository::Administration::NotFound &_tao_excp)
{
  this->CORBA_UserException::operator= (_tao_excp);
  return *this;
}

void ImplementationRepository::Administration::NotFound::_tao_any_destructor (void *_tao_void_pointer)
{
  NotFound *tmp = ACE_static_cast (NotFound*, _tao_void_pointer);
  delete tmp;
}

ImplementationRepository::Administration::NotFound *
ImplementationRepository::Administration::NotFound::_downcast (CORBA::Exception *exc)
{
  if (!ACE_OS::strcmp ("IDL:ImplementationRepository/Administration/NotFound:1.0", exc->_id ()))
    {
      return ACE_dynamic_cast (NotFound *, exc);
    }
  else
    {
      return 0;
    }
}

CORBA::Exception *ImplementationRepository::Administration::NotFound::_alloc (void)
{
  CORBA::Exception *retval = 0;
  ACE_NEW_RETURN (retval, ::ImplementationRepository::Administration::NotFound, 0);
  return retval;
}

CORBA::Exception *
ImplementationRepository::Administration::NotFound::_tao_duplicate (void) const
{
  CORBA::Exception *result;
  ACE_NEW_RETURN (
      result,
      ImplementationRepository::Administration::NotFound (*this),
      0
    );
  return result;
}

void ImplementationRepository::Administration::NotFound::_raise ()
{
  TAO_RAISE (*this);
}

void ImplementationRepository::Administration::NotFound::_tao_encode (
    TAO_OutputCDR &cdr
    ACE_ENV_ARG_DECL
  ) const
{
  if (cdr << *this)
    {
      return;
    }
  
  ACE_THROW (CORBA::MARSHAL ());
}

void ImplementationRepository::Administration::NotFound::_tao_decode (
    TAO_InputCDR &cdr
    ACE_ENV_ARG_DECL
  )
{
  if (cdr >> *this)
    {
      return;
    }
  
  ACE_THROW (CORBA::MARSHAL ());
}

static const CORBA::Long _oc_ImplementationRepository_Administration_NotFound[] =
{
  TAO_ENCAP_BYTE_ORDER, // byte order
  57,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x496d706c), 
  ACE_NTOHL (0x656d656e), 
  ACE_NTOHL (0x74617469), 
  ACE_NTOHL (0x6f6e5265), 
  ACE_NTOHL (0x706f7369), 
  ACE_NTOHL (0x746f7279), 
  ACE_NTOHL (0x2f41646d), 
  ACE_NTOHL (0x696e6973), 
  ACE_NTOHL (0x74726174), 
  ACE_NTOHL (0x696f6e2f), 
  ACE_NTOHL (0x4e6f7446), 
  ACE_NTOHL (0x6f756e64), 
  ACE_NTOHL (0x3a312e30), 
  ACE_NTOHL (0x0),  // repository ID = IDL:ImplementationRepository/Administration/NotFound:1.0
  9,
  ACE_NTOHL (0x4e6f7446), 
  ACE_NTOHL (0x6f756e64), 
  ACE_NTOHL (0x0),  // name = NotFound
  0, // member count
};

static CORBA::TypeCode _tc_TAO_tc_ImplementationRepository_Administration_NotFound (
    CORBA::tk_except,
    sizeof (_oc_ImplementationRepository_Administration_NotFound),
    (char *) &_oc_ImplementationRepository_Administration_NotFound,
    0,
    sizeof (ImplementationRepository::Administration::NotFound)
  );

::CORBA::TypeCode_ptr ImplementationRepository::Administration::_tc_NotFound =
  &_tc_TAO_tc_ImplementationRepository_Administration_NotFound;


// TAO extension - the virtual _type method.
CORBA::TypeCode_ptr ImplementationRepository::Administration::NotFound::_type (void) const
{
  return ::ImplementationRepository::Administration::_tc_NotFound;
}

void ImplementationRepository::Administration::activate_server (
    const char * server
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
    , ImplementationRepository::Administration::NotFound
    , ImplementationRepository::Administration::CannotActivate
  ))
{
  _TAO_Administration_Proxy_Impl &proxy = 
    this->the_TAO_Administration_Proxy_Broker_->select_proxy (this ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
  
  proxy.activate_server (
      this,
      server ACE_ENV_ARG_PARAMETER
    );
}

void ImplementationRepository::Administration::register_server (
    const char * server,
    const ImplementationRepository::StartupOptions & options
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
    , ImplementationRepository::Administration::AlreadyRegistered
  ))
{
  _TAO_Administration_Proxy_Impl &proxy = 
    this->the_TAO_Administration_Proxy_Broker_->select_proxy (this ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
  
  proxy.register_server (
      this,
      server,
      options ACE_ENV_ARG_PARAMETER
    );
}

void ImplementationRepository::Administration::reregister_server (
    const char * server,
    const ImplementationRepository::StartupOptions & options
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  _TAO_Administration_Proxy_Impl &proxy = 
    this->the_TAO_Administration_Proxy_Broker_->select_proxy (this ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
  
  proxy.reregister_server (
      this,
      server,
      options ACE_ENV_ARG_PARAMETER
    );
}

void ImplementationRepository::Administration::remove_server (
    const char * server
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
    , ImplementationRepository::Administration::NotFound
  ))
{
  _TAO_Administration_Proxy_Impl &proxy = 
    this->the_TAO_Administration_Proxy_Broker_->select_proxy (this ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
  
  proxy.remove_server (
      this,
      server ACE_ENV_ARG_PARAMETER
    );
}

void ImplementationRepository::Administration::shutdown_server (
    const char * server
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
    , ImplementationRepository::Administration::NotFound
  ))
{
  _TAO_Administration_Proxy_Impl &proxy = 
    this->the_TAO_Administration_Proxy_Broker_->select_proxy (this ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
  
  proxy.shutdown_server (
      this,
      server ACE_ENV_ARG_PARAMETER
    );
}

char * ImplementationRepository::Administration::server_is_running (
    const char * server,
    const char * addr,
    ImplementationRepository::ServerObject_ptr server_object
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
    , ImplementationRepository::Administration::NotFound
  ))
{
  _TAO_Administration_Proxy_Impl &proxy = 
    this->the_TAO_Administration_Proxy_Broker_->select_proxy (this ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  return proxy.server_is_running (
      this,
      server,
      addr,
      server_object ACE_ENV_ARG_PARAMETER
    );
}

void ImplementationRepository::Administration::server_is_shutting_down (
    const char * server
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
    , ImplementationRepository::Administration::NotFound
  ))
{
  _TAO_Administration_Proxy_Impl &proxy = 
    this->the_TAO_Administration_Proxy_Broker_->select_proxy (this ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
  
  proxy.server_is_shutting_down (
      this,
      server ACE_ENV_ARG_PARAMETER
    );
}

void ImplementationRepository::Administration::find (
    const char * server,
    ImplementationRepository::ServerInformation_out info
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
    , ImplementationRepository::Administration::NotFound
  ))
{
  _TAO_Administration_Proxy_Impl &proxy = 
    this->the_TAO_Administration_Proxy_Broker_->select_proxy (this ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
  
  proxy.find (
      this,
      server,
      info ACE_ENV_ARG_PARAMETER
    );
}

void ImplementationRepository::Administration::list (
    CORBA::ULong how_many,
    ImplementationRepository::ServerInformationList_out server_list,
    ImplementationRepository::ServerInformationIterator_out server_iterator
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  _TAO_Administration_Proxy_Impl &proxy = 
    this->the_TAO_Administration_Proxy_Broker_->select_proxy (this ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
  
  proxy.list (
      this,
      how_many,
      server_list,
      server_iterator ACE_ENV_ARG_PARAMETER
    );
}

static const CORBA::Long _oc_ImplementationRepository_Administration[] =
{
  TAO_ENCAP_BYTE_ORDER, // byte order
  48,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x496d706c), 
  ACE_NTOHL (0x656d656e), 
  ACE_NTOHL (0x74617469), 
  ACE_NTOHL (0x6f6e5265), 
  ACE_NTOHL (0x706f7369), 
  ACE_NTOHL (0x746f7279), 
  ACE_NTOHL (0x2f41646d), 
  ACE_NTOHL (0x696e6973), 
  ACE_NTOHL (0x74726174), 
  ACE_NTOHL (0x696f6e3a), 
  ACE_NTOHL (0x312e3000),  // repository ID = IDL:ImplementationRepository/Administration:1.0
  15,
  ACE_NTOHL (0x41646d69), 
  ACE_NTOHL (0x6e697374), 
  ACE_NTOHL (0x72617469), 
  ACE_NTOHL (0x6f6e0000),  // name = Administration
};

static CORBA::TypeCode _tc_TAO_tc_ImplementationRepository_Administration (
    CORBA::tk_objref,
    sizeof (_oc_ImplementationRepository_Administration),
    (char *) &_oc_ImplementationRepository_Administration,
    0,
    sizeof (ImplementationRepository::Administration)
  );

TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
TAO_NAMESPACE_BEGIN (ImplementationRepository)
TAO_NAMESPACE_DEFINE (::CORBA::TypeCode_ptr, _tc_Administration, &_tc_TAO_tc_ImplementationRepository_Administration)
TAO_NAMESPACE_END

int ImplementationRepository::ServerInformationIterator::_tao_class_id = 0;

ImplementationRepository::ServerInformationIterator_ptr
tao_ImplementationRepository_ServerInformationIterator_duplicate (
    ImplementationRepository::ServerInformationIterator_ptr p
  )
{
  return ImplementationRepository::ServerInformationIterator::_duplicate (p);
}

void
tao_ImplementationRepository_ServerInformationIterator_release (
    ImplementationRepository::ServerInformationIterator_ptr p
  )
{
  CORBA::release (p);
}

ImplementationRepository::ServerInformationIterator_ptr
tao_ImplementationRepository_ServerInformationIterator_nil (
    void
  )
{
  return ImplementationRepository::ServerInformationIterator::_nil ();
}

ImplementationRepository::ServerInformationIterator_ptr
tao_ImplementationRepository_ServerInformationIterator_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return ImplementationRepository::ServerInformationIterator::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
tao_ImplementationRepository_ServerInformationIterator_upcast (
    void *src
  )
{
  ImplementationRepository::ServerInformationIterator **tmp =
    ACE_static_cast (ImplementationRepository::ServerInformationIterator **, src);
  return *tmp;
}

// *************************************************************
// ImplementationRepository::ServerInformationIterator_var
// TAO_IDL - Generated from
// be/be_interface.cpp:654
// *************************************************************

ImplementationRepository::ServerInformationIterator_var::ServerInformationIterator_var (void) // default constructor
  : ptr_ (ServerInformationIterator::_nil ())
{}

::ImplementationRepository::ServerInformationIterator_ptr
ImplementationRepository::ServerInformationIterator_var::ptr (void) const
{
  return this->ptr_;
}

ImplementationRepository::ServerInformationIterator_var::ServerInformationIterator_var (const ::ImplementationRepository::ServerInformationIterator_var &p) // copy constructor
  : TAO_Base_var (),
    ptr_ (ServerInformationIterator::_duplicate (p.ptr ()))
{}

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

ImplementationRepository::ServerInformationIterator_var &
ImplementationRepository::ServerInformationIterator_var::operator= (ServerInformationIterator_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

ImplementationRepository::ServerInformationIterator_var &
ImplementationRepository::ServerInformationIterator_var::operator= (const ::ImplementationRepository::ServerInformationIterator_var &p)
{
  if (this != &p)
  {
    CORBA::release (this->ptr_);
    this->ptr_ = ::ImplementationRepository::ServerInformationIterator::_duplicate (p.ptr ());
  }
  return *this;
}

ImplementationRepository::ServerInformationIterator_var::operator const ::ImplementationRepository::ServerInformationIterator_ptr &() const // cast
{
  return this->ptr_;
}

ImplementationRepository::ServerInformationIterator_var::operator ::ImplementationRepository::ServerInformationIterator_ptr &() // cast 
{
  return this->ptr_;
}

::ImplementationRepository::ServerInformationIterator_ptr
ImplementationRepository::ServerInformationIterator_var::operator-> (void) const
{
  return this->ptr_;
}

::ImplementationRepository::ServerInformationIterator_ptr
ImplementationRepository::ServerInformationIterator_var::in (void) const
{
  return this->ptr_;
}

::ImplementationRepository::ServerInformationIterator_ptr &
ImplementationRepository::ServerInformationIterator_var::inout (void)
{
  return this->ptr_;
}

::ImplementationRepository::ServerInformationIterator_ptr &
ImplementationRepository::ServerInformationIterator_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::ImplementationRepository::ServerInformationIterator::_nil ();
  return this->ptr_;
}

::ImplementationRepository::ServerInformationIterator_ptr
ImplementationRepository::ServerInformationIterator_var::_retn (void)
{
  // yield ownership of managed obj reference
  ::ImplementationRepository::ServerInformationIterator_ptr val = this->ptr_;
  this->ptr_ = ::ImplementationRepository::ServerInformationIterator::_nil ();
  return val;
}

::ImplementationRepository::ServerInformationIterator_ptr
ImplementationRepository::ServerInformationIterator_var::tao_duplicate (ServerInformationIterator_ptr p)
{
  return ::ImplementationRepository::ServerInformationIterator::_duplicate (p);
}

void
ImplementationRepository::ServerInformationIterator_var::tao_release (ServerInformationIterator_ptr p)
{
  CORBA::release (p);
}

::ImplementationRepository::ServerInformationIterator_ptr
ImplementationRepository::ServerInformationIterator_var::tao_nil (void)
{
  return ::ImplementationRepository::ServerInformationIterator::_nil ();
}

::ImplementationRepository::ServerInformationIterator_ptr
ImplementationRepository::ServerInformationIterator_var::tao_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return ::ImplementationRepository::ServerInformationIterator::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
ImplementationRepository::ServerInformationIterator_var::tao_upcast (void *src)
{
  ServerInformationIterator **tmp =
    ACE_static_cast (ServerInformationIterator **, src);
  return *tmp;
}

// *************************************************************
// ImplementationRepository::ServerInformationIterator_out
// TAO_IDL - Generated from
// be/be_interface.cpp:932
// *************************************************************

ImplementationRepository::ServerInformationIterator_out::ServerInformationIterator_out (ServerInformationIterator_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = ::ImplementationRepository::ServerInformationIterator::_nil ();
}

ImplementationRepository::ServerInformationIterator_out::ServerInformationIterator_out (ServerInformationIterator_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::ImplementationRepository::ServerInformationIterator::_nil ();
}

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

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

ImplementationRepository::ServerInformationIterator_out &
ImplementationRepository::ServerInformationIterator_out::operator= (const ::ImplementationRepository::ServerInformationIterator_var &p)
{
  this->ptr_ = ::ImplementationRepository::ServerInformationIterator::_duplicate (p.ptr ());
  return *this;
}

ImplementationRepository::ServerInformationIterator_out &
ImplementationRepository::ServerInformationIterator_out::operator= (ServerInformationIterator_ptr p)
{
  this->ptr_ = p;
  return *this;
}

ImplementationRepository::ServerInformationIterator_out::operator ::ImplementationRepository::ServerInformationIterator_ptr &() // cast
{
  return this->ptr_;
}

::ImplementationRepository::ServerInformationIterator_ptr &
ImplementationRepository::ServerInformationIterator_out::ptr (void) // ptr
{
  return this->ptr_;
}

::ImplementationRepository::ServerInformationIterator_ptr
ImplementationRepository::ServerInformationIterator_out::operator-> (void)
{
  return this->ptr_;
}


#if (TAO_HAS_INTERCEPTORS == 1)
class TAO_ClientRequestInfo_ImplementationRepository_ServerInformationIterator_next_n : public TAO_ClientRequestInfo_i
{
public:
  TAO_ClientRequestInfo_ImplementationRepository_ServerInformationIterator_next_n (
      TAO_GIOP_Invocation *_tao_invocation,
      CORBA::Object_ptr _tao_target,
      const CORBA::ULong & how_many ACE_ENV_ARG_DECL_WITH_DEFAULTS
    );

  virtual Dynamic::ParameterList * arguments (ACE_ENV_SINGLE_ARG_DECL)
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual Dynamic::ExceptionList * exceptions (ACE_ENV_SINGLE_ARG_DECL)
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual CORBA::Any * result (ACE_ENV_SINGLE_ARG_DECL)
    ACE_THROW_SPEC ((CORBA::SystemException));

  void result (CORBA::Boolean result);

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

  const CORBA::ULong & how_many_;
  CORBA::Boolean _result;
};

TAO_ClientRequestInfo_ImplementationRepository_ServerInformationIterator_next_n::TAO_ClientRequestInfo_ImplementationRepository_ServerInformationIterator_next_n (
    TAO_GIOP_Invocation *_tao_invocation,
    CORBA::Object_ptr _tao_target,
    const CORBA::ULong & how_many ACE_ENV_ARG_DECL_NOT_USED    
  )
  : TAO_ClientRequestInfo_i (_tao_invocation, _tao_target),
    how_many_ (how_many)
{}

Dynamic::ParameterList *
TAO_ClientRequestInfo_ImplementationRepository_ServerInformationIterator_next_n::arguments (ACE_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 (ACE_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 <<= how_many_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
  
  return safe_parameter_list._retn ();
}

Dynamic::ExceptionList *
TAO_ClientRequestInfo_ImplementationRepository_ServerInformationIterator_next_n::exceptions (ACE_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 (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  return exception_list;
}

CORBA::Any * 
TAO_ClientRequestInfo_ImplementationRepository_ServerInformationIterator_next_n::result (ACE_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 ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  CORBA::Any_var safe_result_any = result_any;
  
  (*result_any) <<= CORBA::Any::from_boolean (this->_result);
  return safe_result_any._retn ();
}

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

class TAO_ClientRequestInfo_ImplementationRepository_ServerInformationIterator_destroy : public TAO_ClientRequestInfo_i
{
public:
  TAO_ClientRequestInfo_ImplementationRepository_ServerInformationIterator_destroy (
      TAO_GIOP_Invocation *_tao_invocation,
      CORBA::Object_ptr _tao_target ACE_ENV_ARG_DECL_WITH_DEFAULTS
    );

  virtual Dynamic::ParameterList * arguments (ACE_ENV_SINGLE_ARG_DECL)
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual Dynamic::ExceptionList * exceptions (ACE_ENV_SINGLE_ARG_DECL)
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual CORBA::Any * result (ACE_ENV_SINGLE_ARG_DECL)
    ACE_THROW_SPEC ((CORBA::SystemException));

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

  
};

TAO_ClientRequestInfo_ImplementationRepository_ServerInformationIterator_destroy::TAO_ClientRequestInfo_ImplementationRepository_ServerInformationIterator_destroy (
    TAO_GIOP_Invocation *_tao_invocation,
    CORBA::Object_ptr _tao_target ACE_ENV_ARG_DECL_NOT_USED    
  )
  : TAO_ClientRequestInfo_i (_tao_invocation, _tao_target)
{}

Dynamic::ParameterList *
TAO_ClientRequestInfo_ImplementationRepository_ServerInformationIterator_destroy::arguments (ACE_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 (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  return parameter_list;

}

Dynamic::ExceptionList *
TAO_ClientRequestInfo_ImplementationRepository_ServerInformationIterator_destroy::exceptions (ACE_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 (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  return exception_list;
}

CORBA::Any * 
TAO_ClientRequestInfo_ImplementationRepository_ServerInformationIterator_destroy::result (ACE_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 ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  return result_any;
}

#endif /* TAO_HAS_INTERCEPTORS */

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

ImplementationRepository::_TAO_ServerInformationIterator_Proxy_Impl::_TAO_ServerInformationIterator_Proxy_Impl (void)
{}

ImplementationRepository::_TAO_ServerInformationIterator_Remote_Proxy_Impl::_TAO_ServerInformationIterator_Remote_Proxy_Impl (void)
{}

// Remote Implementation of the IDL interface methods

CORBA::Boolean ImplementationRepository::_TAO_ServerInformationIterator_Remote_Proxy_Impl::next_n (
    CORBA_Object *_collocated_tao_target_,
    CORBA::ULong how_many,
    ImplementationRepository::ServerInformationList_out server_list
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  
  CORBA::Boolean _tao_retval = 0;
  
  
  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
  if (istub == 0)
    ACE_THROW_RETURN (CORBA::INTERNAL (),_tao_retval);

  
  ACE_NEW_RETURN (
      server_list.ptr (),
      ImplementationRepository::ServerInformationList,
      0
    );
  
  TAO_GIOP_Twoway_Invocation _tao_call (
      istub,
      "next_n",
      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_ImplementationRepository_ServerInformationIterator_next_n _tao_ri (
        &_tao_call,
        _collocated_tao_target_,
        how_many ACE_ENV_ARG_PARAMETER
      );
            ACE_CHECK_RETURN (_tao_retval);

#endif /* TAO_HAS_INTERCEPTORS */
      
      
      CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
      TAO_INTERCEPTOR (_tao_ri.response_expected (1));
      
#if TAO_HAS_INTERCEPTORS == 1
      
      ACE_TRY
        {
          _tao_vfr.send_request (
            &_tao_ri
            ACE_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 (ACE_ENV_SINGLE_ARG_PARAMETER);
                    TAO_INTERCEPTOR_CHECK_RETURN (_tao_retval);

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

          TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
          if (!(
                            (_tao_out << how_many)              
            ))
            TAO_INTERCEPTOR_THROW_RETURN (
              CORBA::MARSHAL (),
              _tao_retval
            );
            
          _invoke_status =
            _tao_call.invoke (0, 0 ACE_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 (
                _tao_ri.reply_status (_invoke_status);
                _tao_vfr.receive_other (
                  &_tao_ri
                  ACE_ENV_ARG_PARAMETER
                );
                ACE_TRY_CHECK;
              )
              
              continue;
            }
          
          TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
          if (!(
                            (_tao_in >> CORBA::Any::to_boolean (_tao_retval)) &&
                                          (_tao_in >> *server_list.ptr ())
              ))
            {
              TAO_INTERCEPTOR_THROW_RETURN (
                CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
                _tao_retval
              );
              
            }
          
#if TAO_HAS_INTERCEPTORS == 1
          CORBA::Boolean _tao_retval_info = _tao_retval;
          _tao_ri.result (_tao_retval_info);
          
          _tao_ri.reply_status (_invoke_status);
          _tao_vfr.receive_reply (
            &_tao_ri
            ACE_ENV_ARG_PARAMETER
          );
          ACE_TRY_CHECK;
        
      }
    ACE_CATCHANY
      {
        _tao_ri.exception (&ACE_ANY_EXCEPTION);
        _tao_vfr.receive_exception (
          &_tao_ri
          ACE_ENV_ARG_PARAMETER
        );
        ACE_TRY_CHECK;
        
        PortableInterceptor::ReplyStatus _tao_status =
          _tao_ri.reply_status (ACE_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 =
      _tao_ri.reply_status (ACE_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 ImplementationRepository::_TAO_ServerInformationIterator_Remote_Proxy_Impl::destroy (
    CORBA_Object *_collocated_tao_target_
    ACE_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_ImplementationRepository_ServerInformationIterator_destroy _tao_ri (
        &_tao_call,
        _collocated_tao_target_ ACE_ENV_ARG_PARAMETER
      );
            ACE_CHECK;

#endif /* TAO_HAS_INTERCEPTORS */
      
      
      CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
      TAO_INTERCEPTOR (_tao_ri.response_expected (1));
      
#if TAO_HAS_INTERCEPTORS == 1
      
      ACE_TRY
        {
          _tao_vfr.send_request (
            &_tao_ri
            ACE_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 (ACE_ENV_SINGLE_ARG_PARAMETER);
                    TAO_INTERCEPTOR_CHECK;

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

          _invoke_status =
            _tao_call.invoke (0, 0 ACE_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 (
                _tao_ri.reply_status (_invoke_status);
                _tao_vfr.receive_other (
                  &_tao_ri
                  ACE_ENV_ARG_PARAMETER
                );
                ACE_TRY_CHECK;
              )
              
              continue;
            }
          
          
#if TAO_HAS_INTERCEPTORS == 1
          
          _tao_ri.reply_status (_invoke_status);
          _tao_vfr.receive_reply (
            &_tao_ri
            ACE_ENV_ARG_PARAMETER
          );
          ACE_TRY_CHECK;
        
      }
    ACE_CATCHANY
      {
        _tao_ri.exception (&ACE_ANY_EXCEPTION);
        _tao_vfr.receive_exception (
          &_tao_ri
          ACE_ENV_ARG_PARAMETER
        );
        ACE_TRY_CHECK;
        
        PortableInterceptor::ReplyStatus _tao_status =
          _tao_ri.reply_status (ACE_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 =
      _tao_ri.reply_status (ACE_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
//

ImplementationRepository::_TAO_ServerInformationIterator_Proxy_Broker::_TAO_ServerInformationIterator_Proxy_Broker (void)
{
}

ImplementationRepository::_TAO_ServerInformationIterator_Proxy_Broker::~_TAO_ServerInformationIterator_Proxy_Broker (void)
{
}

ImplementationRepository::_TAO_ServerInformationIterator_Proxy_Broker * (*ImplementationRepository__TAO_ServerInformationIterator_Proxy_Broker_Factory_function_pointer) (
    CORBA::Object_ptr obj
  ) = 0;

// Factory Member function Implementation.
ImplementationRepository::_TAO_ServerInformationIterator_Remote_Proxy_Broker *
ImplementationRepository::_TAO_ServerInformationIterator_Remote_Proxy_Broker::the_TAO_ServerInformationIterator_Remote_Proxy_Broker (void)
{
  static ::ImplementationRepository::_TAO_ServerInformationIterator_Remote_Proxy_Broker remote_proxy_broker;
  return &remote_proxy_broker;
}

ImplementationRepository::_TAO_ServerInformationIterator_Remote_Proxy_Broker::_TAO_ServerInformationIterator_Remote_Proxy_Broker (void)
{
}

ImplementationRepository::_TAO_ServerInformationIterator_Remote_Proxy_Broker::~_TAO_ServerInformationIterator_Remote_Proxy_Broker (void)
{
}

ImplementationRepository::_TAO_ServerInformationIterator_Proxy_Impl&
ImplementationRepository::_TAO_ServerInformationIterator_Remote_Proxy_Broker::select_proxy (
  ::ImplementationRepository::ServerInformationIterator *
  ACE_ENV_ARG_DECL_NOT_USED
)
{
  return this->remote_proxy_impl_;
}


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


// TAO_IDL - Generated from 
// be/be_visitor_interface/interface_cs.cpp:209

ImplementationRepository::ServerInformationIterator::ServerInformationIterator (int collocated)
{
  this->ImplementationRepository_ServerInformationIterator_setup_collocation (collocated);
}

ImplementationRepository::ServerInformationIterator::~ServerInformationIterator (void)
{}

void
ImplementationRepository::ServerInformationIterator::ImplementationRepository_ServerInformationIterator_setup_collocation (int collocated)
{
  if (collocated)
    this->the_TAO_ServerInformationIterator_Proxy_Broker_ =
      ::ImplementationRepository__TAO_ServerInformationIterator_Proxy_Broker_Factory_function_pointer (this);
  else
    this->the_TAO_ServerInformationIterator_Proxy_Broker_ =
      ::ImplementationRepository::_TAO_ServerInformationIterator_Remote_Proxy_Broker::the_TAO_ServerInformationIterator_Remote_Proxy_Broker ();
}

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

ImplementationRepository::ServerInformationIterator_ptr ImplementationRepository::ServerInformationIterator::_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL
  )
{
  if (CORBA::is_nil (obj))
    return ServerInformationIterator::_nil ();
  if (! obj->_is_local ())
    {
      CORBA::Boolean is_a = obj->_is_a ("IDL:ImplementationRepository/ServerInformationIterator:1.0" ACE_ENV_ARG_PARAMETER);
      ACE_CHECK_RETURN (ServerInformationIterator::_nil ());
      if (is_a == 0)
        return ServerInformationIterator::_nil ();
    }
  return ServerInformationIterator::_unchecked_narrow (obj ACE_ENV_ARG_PARAMETER);
}

ImplementationRepository::ServerInformationIterator_ptr 
ImplementationRepository::ServerInformationIterator::_unchecked_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  if (CORBA::is_nil (obj))
    return ServerInformationIterator::_nil ();
  if (! obj->_is_local ())
    {
      TAO_Stub* stub = obj->_stubobj ();
      if (stub)
        stub->_incr_refcnt ();
      ServerInformationIterator_ptr default_proxy = ServerInformationIterator::_nil ();

      if (
          !CORBA::is_nil (stub->servant_orb_var ().ptr ()) &&
          stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects () &&
          obj->_is_collocated () &&
          ImplementationRepository__TAO_ServerInformationIterator_Proxy_Broker_Factory_function_pointer != 0
        )
        {
          ACE_NEW_RETURN (
              default_proxy,
              ::ImplementationRepository::ServerInformationIterator (
                  stub,
                  1,
                  obj->_servant ()
                ),
              ServerInformationIterator::_nil ()
            );
        }
      
      if (CORBA::is_nil (default_proxy))
        {
          ACE_NEW_RETURN (
              default_proxy,
              ::ImplementationRepository::ServerInformationIterator (
                  stub,
                  0,
                  obj->_servant ()
                ),
              ServerInformationIterator::_nil ()
            );
        }
      
      return default_proxy;
    }
  else 
    return
      ACE_reinterpret_cast
        (
          ServerInformationIterator_ptr,
            obj->_tao_QueryInterface
              (
                ACE_reinterpret_cast
                  (
                    ptr_arith_t,
                    &ServerInformationIterator::_tao_class_id
                  )
              )
        );
}

ImplementationRepository::ServerInformationIterator_ptr
ImplementationRepository::ServerInformationIterator::_duplicate (ServerInformationIterator_ptr obj)
{
  if (!CORBA::is_nil (obj))
    obj->_add_ref ();
  return obj;
}

CORBA::Boolean ImplementationRepository::ServerInformationIterator::_is_a (const CORBA::Char *value ACE_ENV_ARG_DECL)
{
  if (
    (!ACE_OS::strcmp ((char *)value, "IDL:ImplementationRepository/ServerInformationIterator:1.0")) ||
    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
  return 1; // success using local knowledge
  else
    return this->CORBA_Object::_is_a (value ACE_ENV_ARG_PARAMETER);
}

void *ImplementationRepository::ServerInformationIterator::_tao_QueryInterface (ptr_arith_t type)
{
  void *retv = 0;
  if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &ACE_NESTED_CLASS (::ImplementationRepository, ServerInformationIterator)::_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* ImplementationRepository::ServerInformationIterator::_interface_repository_id (void) const
{
  return "IDL:ImplementationRepository/ServerInformationIterator:1.0";
}

CORBA::Boolean ImplementationRepository::ServerInformationIterator::next_n (
    CORBA::ULong how_many,
    ImplementationRepository::ServerInformationList_out server_list
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  _TAO_ServerInformationIterator_Proxy_Impl &proxy = 
    this->the_TAO_ServerInformationIterator_Proxy_Broker_->select_proxy (this ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  return proxy.next_n (
      this,
      how_many,
      server_list ACE_ENV_ARG_PARAMETER
    );
}

void ImplementationRepository::ServerInformationIterator::destroy (
    
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  _TAO_ServerInformationIterator_Proxy_Impl &proxy = 
    this->the_TAO_ServerInformationIterator_Proxy_Broker_->select_proxy (this ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
  
  proxy.destroy (
      this ACE_ENV_ARG_PARAMETER
    );
}

static const CORBA::Long _oc_ImplementationRepository_ServerInformationIterator[] =
{
  TAO_ENCAP_BYTE_ORDER, // byte order
  59,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x496d706c), 
  ACE_NTOHL (0x656d656e), 
  ACE_NTOHL (0x74617469), 
  ACE_NTOHL (0x6f6e5265), 
  ACE_NTOHL (0x706f7369), 
  ACE_NTOHL (0x746f7279), 
  ACE_NTOHL (0x2f536572), 
  ACE_NTOHL (0x76657249), 
  ACE_NTOHL (0x6e666f72), 
  ACE_NTOHL (0x6d617469), 
  ACE_NTOHL (0x6f6e4974), 
  ACE_NTOHL (0x65726174), 
  ACE_NTOHL (0x6f723a31), 
  ACE_NTOHL (0x2e300000),  // repository ID = IDL:ImplementationRepository/ServerInformationIterator:1.0
  26,
  ACE_NTOHL (0x53657276), 
  ACE_NTOHL (0x6572496e), 
  ACE_NTOHL (0x666f726d), 
  ACE_NTOHL (0x6174696f), 
  ACE_NTOHL (0x6e497465), 
  ACE_NTOHL (0x7261746f), 
  ACE_NTOHL (0x72000000),  // name = ServerInformationIterator
};

static CORBA::TypeCode _tc_TAO_tc_ImplementationRepository_ServerInformationIterator (
    CORBA::tk_objref,
    sizeof (_oc_ImplementationRepository_ServerInformationIterator),
    (char *) &_oc_ImplementationRepository_ServerInformationIterator,
    0,
    sizeof (ImplementationRepository::ServerInformationIterator)
  );

TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
TAO_NAMESPACE_BEGIN (ImplementationRepository)
TAO_NAMESPACE_DEFINE (::CORBA::TypeCode_ptr, _tc_ServerInformationIterator, &_tc_TAO_tc_ImplementationRepository_ServerInformationIterator)
TAO_NAMESPACE_END

void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::ServerObject_ptr _tao_elem)
{
  TAO_OutputCDR stream;
  if (stream << _tao_elem)
  {
    _tao_any._tao_replace (
        ImplementationRepository::_tc_ServerObject, 
        TAO_ENCAP_BYTE_ORDER,
        stream.begin (),
        1,
        ImplementationRepository::ServerObject::_duplicate (_tao_elem),
        ImplementationRepository::ServerObject::_tao_any_destructor
      );
  }
}

CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository::ServerObject_ptr &_tao_elem)
{
  ACE_TRY_NEW_ENV
  {
    _tao_elem = ImplementationRepository::ServerObject::_nil ();
    CORBA::TypeCode_var type = _tao_any.type ();
    
    CORBA::Boolean result = type->equivalent (ImplementationRepository::_tc_ServerObject ACE_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 (
          ImplementationRepository::_tc_ServerObject,
          1,
          _tao_elem,
          ImplementationRepository::ServerObject::_tao_any_destructor
        );
      return 1;
    }
  }
  ACE_CATCHANY
  {
    _tao_elem = ImplementationRepository::ServerObject::_nil ();
    return 0;
  }
  ACE_ENDTRY;
  _tao_elem = ImplementationRepository::ServerObject::_nil ();
  return 0;
}

#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
    defined (ACE_HAS_GNU_REPO)
    template class TAO_Object_Manager<ImplementationRepository::ServerObject,ImplementationRepository::ServerObject_var>;
  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
  #  pragma instantiate TAO_Object_Manager<ImplementationRepository::ServerObject,ImplementationRepository::ServerObject_var>
#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */

void operator<<= (CORBA::Any &_tao_any, const ImplementationRepository::EnvironmentVariable &_tao_elem) // copying
{
  TAO_OutputCDR stream;
  stream << _tao_elem;
  _tao_any._tao_replace (
      ImplementationRepository::_tc_EnvironmentVariable,
      TAO_ENCAP_BYTE_ORDER,
      stream.begin ()
    );
}

void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::EnvironmentVariable *_tao_elem) // non copying
{
  TAO_OutputCDR stream;
  stream << *_tao_elem;
  _tao_any._tao_replace (
      ImplementationRepository::_tc_EnvironmentVariable,
      TAO_ENCAP_BYTE_ORDER,
      stream.begin (),
      1,
      _tao_elem,
      ImplementationRepository::EnvironmentVariable::_tao_any_destructor
    );
}

CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository::EnvironmentVariable *&_tao_elem)
{
  return _tao_any >>= ACE_const_cast(const ImplementationRepository::EnvironmentVariable*&,_tao_elem);
}

CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const ImplementationRepository::EnvironmentVariable *&_tao_elem)
{
  _tao_elem = 0;
  ACE_TRY_NEW_ENV
  {
    CORBA::TypeCode_var type = _tao_any.type ();
    
    CORBA::Boolean result = type->equivalent (ImplementationRepository::_tc_EnvironmentVariable ACE_ENV_ARG_PARAMETER);
    ACE_TRY_CHECK;
    
    if (!result)
      return 0; // not equivalent
    
    if (_tao_any.any_owns_data ())
    {
      _tao_elem = ACE_static_cast(
          const ImplementationRepository::EnvironmentVariable*,
          _tao_any.value ()
        );
      return 1;
    }
    else
    {
      ImplementationRepository::EnvironmentVariable *tmp;
      ACE_NEW_RETURN (tmp, ImplementationRepository::EnvironmentVariable, 0);
      TAO_InputCDR stream (
          _tao_any._tao_get_cdr (),
          _tao_any._tao_byte_order ()
        );
      if (stream >> *tmp)
      {
        ((CORBA::Any *)&_tao_any)->_tao_replace (
            ImplementationRepository::_tc_EnvironmentVariable,
            1,
            ACE_static_cast (void *, tmp),
            ImplementationRepository::EnvironmentVariable::_tao_any_destructor
          );
        _tao_elem = tmp;
        return 1;
      }
      else
      {
        delete tmp;
      }
    }
  }
  ACE_CATCHANY
  {
  }
  ACE_ENDTRY;
  return 0;
}

void operator<<= (
    CORBA::Any &_tao_any,
    const ImplementationRepository::EnvironmentList &_tao_elem
  ) // copying
{
  TAO_OutputCDR stream;
  if (stream << _tao_elem)
  {
    _tao_any._tao_replace (
        ImplementationRepository::_tc_EnvironmentList,
        TAO_ENCAP_BYTE_ORDER,
        stream.begin ()
      );
  }
}

void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::EnvironmentList *_tao_elem) // non copying
{
  TAO_OutputCDR stream;
  stream << *_tao_elem;
  _tao_any._tao_replace (
      ImplementationRepository::_tc_EnvironmentList,
      TAO_ENCAP_BYTE_ORDER,
      stream.begin (),
      1,
      _tao_elem,
      ImplementationRepository::EnvironmentList::_tao_any_destructor
    );
}

CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository::EnvironmentList *&_tao_elem)
{
  return _tao_any >>= ACE_const_cast(
      const ImplementationRepository::EnvironmentList*&,
      _tao_elem
    );
}

CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const ImplementationRepository::EnvironmentList *&_tao_elem)
{
  _tao_elem = 0;
  ACE_TRY_NEW_ENV
  {
    CORBA::TypeCode_var type = _tao_any.type ();
    
    CORBA::Boolean result = type->equivalent (ImplementationRepository::_tc_EnvironmentList ACE_ENV_ARG_PARAMETER);
    ACE_TRY_CHECK;
    
    if (!result)
      return 0; // not equivalent
    
    if (_tao_any.any_owns_data ())
    {
      _tao_elem = ACE_static_cast(
          const ImplementationRepository::EnvironmentList*,
          _tao_any.value ()
        );
      return 1;
    }
    else
    {
      ImplementationRepository::EnvironmentList *tmp;
      ACE_NEW_RETURN (tmp, ImplementationRepository::EnvironmentList, 0);
      TAO_InputCDR stream (
          _tao_any._tao_get_cdr (),
          _tao_any._tao_byte_order ()
        );
      if (stream >> *tmp)
      {
        ((CORBA::Any *)&_tao_any)->_tao_replace (
            ImplementationRepository::_tc_EnvironmentList,
            1,
            ACE_static_cast (void *, tmp),
            ImplementationRepository::EnvironmentList::_tao_any_destructor
          );
        _tao_elem = tmp;
        return 1;
      }
      else
      {
        delete tmp;
      }
    }
  }
  ACE_CATCHANY
  {
  }
  ACE_ENDTRY;
  return 0;
}

void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::ActivationMode _tao_elem)
{
  TAO_OutputCDR stream;
  stream << _tao_elem;
  _tao_any._tao_replace (
      ImplementationRepository::_tc_ActivationMode,
      TAO_ENCAP_BYTE_ORDER,
      stream.begin ()
    );
}

CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository::ActivationMode &_tao_elem)
{
  ACE_TRY_NEW_ENV
  {
    CORBA::TypeCode_var type = _tao_any.type ();
    
    CORBA::Boolean result = type->equivalent (ImplementationRepository::_tc_ActivationMode ACE_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, const ImplementationRepository::StartupOptions &_tao_elem) // copying
{
  TAO_OutputCDR stream;
  stream << _tao_elem;
  _tao_any._tao_replace (
      ImplementationRepository::_tc_StartupOptions,
      TAO_ENCAP_BYTE_ORDER,
      stream.begin ()
    );
}

void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::StartupOptions *_tao_elem) // non copying
{
  TAO_OutputCDR stream;
  stream << *_tao_elem;
  _tao_any._tao_replace (
      ImplementationRepository::_tc_StartupOptions,
      TAO_ENCAP_BYTE_ORDER,
      stream.begin (),
      1,
      _tao_elem,
      ImplementationRepository::StartupOptions::_tao_any_destructor
    );
}

CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository::StartupOptions *&_tao_elem)
{
  return _tao_any >>= ACE_const_cast(const ImplementationRepository::StartupOptions*&,_tao_elem);
}

CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const ImplementationRepository::StartupOptions *&_tao_elem)
{
  _tao_elem = 0;
  ACE_TRY_NEW_ENV
  {
    CORBA::TypeCode_var type = _tao_any.type ();
    
    CORBA::Boolean result = type->equivalent (ImplementationRepository::_tc_StartupOptions ACE_ENV_ARG_PARAMETER);
    ACE_TRY_CHECK;
    
    if (!result)
      return 0; // not equivalent
    
    if (_tao_any.any_owns_data ())
    {
      _tao_elem = ACE_static_cast(
          const ImplementationRepository::StartupOptions*,
          _tao_any.value ()
        );
      return 1;
    }
    else
    {
      ImplementationRepository::StartupOptions *tmp;
      ACE_NEW_RETURN (tmp, ImplementationRepository::StartupOptions, 0);
      TAO_InputCDR stream (
          _tao_any._tao_get_cdr (),
          _tao_any._tao_byte_order ()
        );
      if (stream >> *tmp)
      {
        ((CORBA::Any *)&_tao_any)->_tao_replace (
            ImplementationRepository::_tc_StartupOptions,
            1,
            ACE_static_cast (void *, tmp),
            ImplementationRepository::StartupOptions::_tao_any_destructor
          );
        _tao_elem = tmp;
        return 1;
      }
      else
      {
        delete tmp;
      }
    }
  }
  ACE_CATCHANY
  {
  }
  ACE_ENDTRY;
  return 0;
}

void operator<<= (CORBA::Any &_tao_any, const ImplementationRepository::ServerInformation &_tao_elem) // copying
{
  TAO_OutputCDR stream;
  stream << _tao_elem;
  _tao_any._tao_replace (
      ImplementationRepository::_tc_ServerInformation,
      TAO_ENCAP_BYTE_ORDER,
      stream.begin ()
    );
}

void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::ServerInformation *_tao_elem) // non copying
{
  TAO_OutputCDR stream;
  stream << *_tao_elem;
  _tao_any._tao_replace (
      ImplementationRepository::_tc_ServerInformation,
      TAO_ENCAP_BYTE_ORDER,
      stream.begin (),
      1,
      _tao_elem,
      ImplementationRepository::ServerInformation::_tao_any_destructor
    );
}

CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository::ServerInformation *&_tao_elem)
{
  return _tao_any >>= ACE_const_cast(const ImplementationRepository::ServerInformation*&,_tao_elem);
}

CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const ImplementationRepository::ServerInformation *&_tao_elem)
{
  _tao_elem = 0;
  ACE_TRY_NEW_ENV
  {
    CORBA::TypeCode_var type = _tao_any.type ();
    
    CORBA::Boolean result = type->equivalent (ImplementationRepository::_tc_ServerInformation ACE_ENV_ARG_PARAMETER);
    ACE_TRY_CHECK;
    
    if (!result)
      return 0; // not equivalent
    
    if (_tao_any.any_owns_data ())
    {
      _tao_elem = ACE_static_cast(
          const ImplementationRepository::ServerInformation*,
          _tao_any.value ()
        );
      return 1;
    }
    else
    {
      ImplementationRepository::ServerInformation *tmp;
      ACE_NEW_RETURN (tmp, ImplementationRepository::ServerInformation, 0);
      TAO_InputCDR stream (
          _tao_any._tao_get_cdr (),
          _tao_any._tao_byte_order ()
        );
      if (stream >> *tmp)
      {
        ((CORBA::Any *)&_tao_any)->_tao_replace (
            ImplementationRepository::_tc_ServerInformation,
            1,
            ACE_static_cast (void *, tmp),
            ImplementationRepository::ServerInformation::_tao_any_destructor
          );
        _tao_elem = tmp;
        return 1;
      }
      else
      {
        delete tmp;
      }
    }
  }
  ACE_CATCHANY
  {
  }
  ACE_ENDTRY;
  return 0;
}

void operator<<= (
    CORBA::Any &_tao_any,
    const ImplementationRepository::ServerInformationList &_tao_elem
  ) // copying
{
  TAO_OutputCDR stream;
  if (stream << _tao_elem)
  {
    _tao_any._tao_replace (
        ImplementationRepository::_tc_ServerInformationList,
        TAO_ENCAP_BYTE_ORDER,
        stream.begin ()
      );
  }
}

void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::ServerInformationList *_tao_elem) // non copying
{
  TAO_OutputCDR stream;
  stream << *_tao_elem;
  _tao_any._tao_replace (
      ImplementationRepository::_tc_ServerInformationList,
      TAO_ENCAP_BYTE_ORDER,
      stream.begin (),
      1,
      _tao_elem,
      ImplementationRepository::ServerInformationList::_tao_any_destructor
    );
}

CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository::ServerInformationList *&_tao_elem)
{
  return _tao_any >>= ACE_const_cast(
      const ImplementationRepository::ServerInformationList*&,
      _tao_elem
    );
}

CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const ImplementationRepository::ServerInformationList *&_tao_elem)
{
  _tao_elem = 0;
  ACE_TRY_NEW_ENV
  {
    CORBA::TypeCode_var type = _tao_any.type ();
    
    CORBA::Boolean result = type->equivalent (ImplementationRepository::_tc_ServerInformationList ACE_ENV_ARG_PARAMETER);
    ACE_TRY_CHECK;
    
    if (!result)
      return 0; // not equivalent
    
    if (_tao_any.any_owns_data ())
    {
      _tao_elem = ACE_static_cast(
          const ImplementationRepository::ServerInformationList*,
          _tao_any.value ()
        );
      return 1;
    }
    else
    {
      ImplementationRepository::ServerInformationList *tmp;
      ACE_NEW_RETURN (tmp, ImplementationRepository::ServerInformationList, 0);
      TAO_InputCDR stream (
          _tao_any._tao_get_cdr (),
          _tao_any._tao_byte_order ()
        );
      if (stream >> *tmp)
      {
        ((CORBA::Any *)&_tao_any)->_tao_replace (
            ImplementationRepository::_tc_ServerInformationList,
            1,
            ACE_static_cast (void *, tmp),
            ImplementationRepository::ServerInformationList::_tao_any_destructor
          );
        _tao_elem = tmp;
        return 1;
      }
      else
      {
        delete tmp;
      }
    }
  }
  ACE_CATCHANY
  {
  }
  ACE_ENDTRY;
  return 0;
}

void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::Administration_ptr _tao_elem)
{
  TAO_OutputCDR stream;
  if (stream << _tao_elem)
  {
    _tao_any._tao_replace (
        ImplementationRepository::_tc_Administration, 
        TAO_ENCAP_BYTE_ORDER,
        stream.begin (),
        1,
        ImplementationRepository::Administration::_duplicate (_tao_elem),
        ImplementationRepository::Administration::_tao_any_destructor
      );
  }
}

CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository::Administration_ptr &_tao_elem)
{
  ACE_TRY_NEW_ENV
  {
    _tao_elem = ImplementationRepository::Administration::_nil ();
    CORBA::TypeCode_var type = _tao_any.type ();
    
    CORBA::Boolean result = type->equivalent (ImplementationRepository::_tc_Administration ACE_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 (
          ImplementationRepository::_tc_Administration,
          1,
          _tao_elem,
          ImplementationRepository::Administration::_tao_any_destructor
        );
      return 1;
    }
  }
  ACE_CATCHANY
  {
    _tao_elem = ImplementationRepository::Administration::_nil ();
    return 0;
  }
  ACE_ENDTRY;
  _tao_elem = ImplementationRepository::Administration::_nil ();
  return 0;
}

#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
    defined (ACE_HAS_GNU_REPO)
    template class TAO_Object_Manager<ImplementationRepository::Administration,ImplementationRepository::Administration_var>;
  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
  #  pragma instantiate TAO_Object_Manager<ImplementationRepository::Administration,ImplementationRepository::Administration_var>
#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */

void operator<<= (CORBA::Any &_tao_any, const ImplementationRepository::Administration::AlreadyRegistered &_tao_elem) // copying
{
  TAO_OutputCDR stream;
  stream << _tao_elem;
  _tao_any._tao_replace (
      ImplementationRepository::Administration::_tc_AlreadyRegistered,
      TAO_ENCAP_BYTE_ORDER,
      stream.begin ()
    );
}

void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::Administration::AlreadyRegistered *_tao_elem) // non copying
{
  TAO_OutputCDR stream;
  stream << *_tao_elem;
  _tao_any._tao_replace (
      ImplementationRepository::Administration::_tc_AlreadyRegistered,
      TAO_ENCAP_BYTE_ORDER,
      stream.begin (),
      1,
      _tao_elem,
      ImplementationRepository::Administration::AlreadyRegistered::_tao_any_destructor
    );
}

CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository::Administration::AlreadyRegistered *&_tao_elem)
{
  return _tao_any >>= ACE_const_cast(
      const ImplementationRepository::Administration::AlreadyRegistered*&,
      _tao_elem
    );
}

CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const ImplementationRepository::Administration::AlreadyRegistered *&_tao_elem)
{
  _tao_elem = 0;
  ACE_TRY_NEW_ENV
  {
    CORBA::TypeCode_var type = _tao_any.type ();
    
    CORBA::Boolean result = type->equivalent (ImplementationRepository::Administration::_tc_AlreadyRegistered ACE_ENV_ARG_PARAMETER);
    ACE_TRY_CHECK;
    
    if (!result)
      return 0; // not equivalent
    
    if (_tao_any.any_owns_data ())
    {
      _tao_elem = (ImplementationRepository::Administration::AlreadyRegistered *)_tao_any.value ();
      return 1;
    }
    else
    {
      ImplementationRepository::Administration::AlreadyRegistered *tmp;
      ACE_NEW_RETURN (tmp, ImplementationRepository::Administration::AlreadyRegistered, 0);
      TAO_InputCDR stream (
          _tao_any._tao_get_cdr (),
          _tao_any._tao_byte_order ()
        );
      CORBA::String_var interface_repository_id;
      if (!(stream >> interface_repository_id.out ()))
        return 0;
      if (ACE_OS::strcmp (
          interface_repository_id.in (),
          "IDL:ImplementationRepository/Administration/AlreadyRegistered:1.0"))
        return 0;
      if (stream >> *tmp)
      {
        ((CORBA::Any *)&_tao_any)->_tao_replace (
            ImplementationRepository::Administration::_tc_AlreadyRegistered,
            1,
            tmp,
            ImplementationRepository::Administration::AlreadyRegistered::_tao_any_destructor
          );
        _tao_elem = tmp;
        return 1;
      }
      else
      {
        delete tmp;
      }
    }
  }
  ACE_CATCHANY
  {
  }
  ACE_ENDTRY;
  return 0;
}

void operator<<= (CORBA::Any &_tao_any, const ImplementationRepository::Administration::CannotActivate &_tao_elem) // copying
{
  TAO_OutputCDR stream;
  stream << _tao_elem;
  _tao_any._tao_replace (
      ImplementationRepository::Administration::_tc_CannotActivate,
      TAO_ENCAP_BYTE_ORDER,
      stream.begin ()
    );
}

void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::Administration::CannotActivate *_tao_elem) // non copying
{
  TAO_OutputCDR stream;
  stream << *_tao_elem;
  _tao_any._tao_replace (
      ImplementationRepository::Administration::_tc_CannotActivate,
      TAO_ENCAP_BYTE_ORDER,
      stream.begin (),
      1,
      _tao_elem,
      ImplementationRepository::Administration::CannotActivate::_tao_any_destructor
    );
}

CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository::Administration::CannotActivate *&_tao_elem)
{
  return _tao_any >>= ACE_const_cast(
      const ImplementationRepository::Administration::CannotActivate*&,
      _tao_elem
    );
}

CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const ImplementationRepository::Administration::CannotActivate *&_tao_elem)
{
  _tao_elem = 0;
  ACE_TRY_NEW_ENV
  {
    CORBA::TypeCode_var type = _tao_any.type ();
    
    CORBA::Boolean result = type->equivalent (ImplementationRepository::Administration::_tc_CannotActivate ACE_ENV_ARG_PARAMETER);
    ACE_TRY_CHECK;
    
    if (!result)
      return 0; // not equivalent
    
    if (_tao_any.any_owns_data ())
    {
      _tao_elem = (ImplementationRepository::Administration::CannotActivate *)_tao_any.value ();
      return 1;
    }
    else
    {
      ImplementationRepository::Administration::CannotActivate *tmp;
      ACE_NEW_RETURN (tmp, ImplementationRepository::Administration::CannotActivate, 0);
      TAO_InputCDR stream (
          _tao_any._tao_get_cdr (),
          _tao_any._tao_byte_order ()
        );
      CORBA::String_var interface_repository_id;
      if (!(stream >> interface_repository_id.out ()))
        return 0;
      if (ACE_OS::strcmp (
          interface_repository_id.in (),
          "IDL:ImplementationRepository/Administration/CannotActivate:1.0"))
        return 0;
      if (stream >> *tmp)
      {
        ((CORBA::Any *)&_tao_any)->_tao_replace (
            ImplementationRepository::Administration::_tc_CannotActivate,
            1,
            tmp,
            ImplementationRepository::Administration::CannotActivate::_tao_any_destructor
          );
        _tao_elem = tmp;
        return 1;
      }
      else
      {
        delete tmp;
      }
    }
  }
  ACE_CATCHANY
  {
  }
  ACE_ENDTRY;
  return 0;
}

void operator<<= (CORBA::Any &_tao_any, const ImplementationRepository::Administration::NotFound &_tao_elem) // copying
{
  TAO_OutputCDR stream;
  stream << _tao_elem;
  _tao_any._tao_replace (
      ImplementationRepository::Administration::_tc_NotFound,
      TAO_ENCAP_BYTE_ORDER,
      stream.begin ()
    );
}

void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::Administration::NotFound *_tao_elem) // non copying
{
  TAO_OutputCDR stream;
  stream << *_tao_elem;
  _tao_any._tao_replace (
      ImplementationRepository::Administration::_tc_NotFound,
      TAO_ENCAP_BYTE_ORDER,
      stream.begin (),
      1,
      _tao_elem,
      ImplementationRepository::Administration::NotFound::_tao_any_destructor
    );
}

CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository::Administration::NotFound *&_tao_elem)
{
  return _tao_any >>= ACE_const_cast(
      const ImplementationRepository::Administration::NotFound*&,
      _tao_elem
    );
}

CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const ImplementationRepository::Administration::NotFound *&_tao_elem)
{
  _tao_elem = 0;
  ACE_TRY_NEW_ENV
  {
    CORBA::TypeCode_var type = _tao_any.type ();
    
    CORBA::Boolean result = type->equivalent (ImplementationRepository::Administration::_tc_NotFound ACE_ENV_ARG_PARAMETER);
    ACE_TRY_CHECK;
    
    if (!result)
      return 0; // not equivalent
    
    if (_tao_any.any_owns_data ())
    {
      _tao_elem = (ImplementationRepository::Administration::NotFound *)_tao_any.value ();
      return 1;
    }
    else
    {
      ImplementationRepository::Administration::NotFound *tmp;
      ACE_NEW_RETURN (tmp, ImplementationRepository::Administration::NotFound, 0);
      TAO_InputCDR stream (
          _tao_any._tao_get_cdr (),
          _tao_any._tao_byte_order ()
        );
      CORBA::String_var interface_repository_id;
      if (!(stream >> interface_repository_id.out ()))
        return 0;
      if (ACE_OS::strcmp (
          interface_repository_id.in (),
          "IDL:ImplementationRepository/Administration/NotFound:1.0"))
        return 0;
      if (stream >> *tmp)
      {
        ((CORBA::Any *)&_tao_any)->_tao_replace (
            ImplementationRepository::Administration::_tc_NotFound,
            1,
            tmp,
            ImplementationRepository::Administration::NotFound::_tao_any_destructor
          );
        _tao_elem = tmp;
        return 1;
      }
      else
      {
        delete tmp;
      }
    }
  }
  ACE_CATCHANY
  {
  }
  ACE_ENDTRY;
  return 0;
}

void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::ServerInformationIterator_ptr _tao_elem)
{
  TAO_OutputCDR stream;
  if (stream << _tao_elem)
  {
    _tao_any._tao_replace (
        ImplementationRepository::_tc_ServerInformationIterator, 
        TAO_ENCAP_BYTE_ORDER,
        stream.begin (),
        1,
        ImplementationRepository::ServerInformationIterator::_duplicate (_tao_elem),
        ImplementationRepository::ServerInformationIterator::_tao_any_destructor
      );
  }
}

CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository::ServerInformationIterator_ptr &_tao_elem)
{
  ACE_TRY_NEW_ENV
  {
    _tao_elem = ImplementationRepository::ServerInformationIterator::_nil ();
    CORBA::TypeCode_var type = _tao_any.type ();
    
    CORBA::Boolean result = type->equivalent (ImplementationRepository::_tc_ServerInformationIterator ACE_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 (
          ImplementationRepository::_tc_ServerInformationIterator,
          1,
          _tao_elem,
          ImplementationRepository::ServerInformationIterator::_tao_any_destructor
        );
      return 1;
    }
  }
  ACE_CATCHANY
  {
    _tao_elem = ImplementationRepository::ServerInformationIterator::_nil ();
    return 0;
  }
  ACE_ENDTRY;
  _tao_elem = ImplementationRepository::ServerInformationIterator::_nil ();
  return 0;
}

#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
    defined (ACE_HAS_GNU_REPO)
    template class TAO_Object_Manager<ImplementationRepository::ServerInformationIterator,ImplementationRepository::ServerInformationIterator_var>;
  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
  #  pragma instantiate TAO_Object_Manager<ImplementationRepository::ServerInformationIterator,ImplementationRepository::ServerInformationIterator_var>
#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */

CORBA::Boolean operator<< (
    TAO_OutputCDR &strm,
    const ImplementationRepository::ServerObject_ptr _tao_objref
  )
{
  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
  return (strm << _tao_corba_obj);
}

CORBA::Boolean operator>> (
    TAO_InputCDR &strm,
    ImplementationRepository::ServerObject_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 =
      ImplementationRepository::ServerObject::_unchecked_narrow (
          obj.in ()
          ACE_ENV_ARG_PARAMETER
        );
    ACE_TRY_CHECK;
    return 1;
  }
  ACE_CATCHANY
  {
    // do nothing
  }
  ACE_ENDTRY;
  return 0;
}

CORBA::Boolean operator<< (
    TAO_OutputCDR &strm,
    const ImplementationRepository::EnvironmentList &_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,
    ImplementationRepository::EnvironmentList &_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;
    // Add a check to the length of the sequence
    // to make sure it does not exceed the length
    // of the stream. (See bug 58.)
    if (_tao_seq_len > strm.length())
      return 0;
    // 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 ImplementationRepository::ServerInformationList &_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,
    ImplementationRepository::ServerInformationList &_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;
    // Add a check to the length of the sequence
    // to make sure it does not exceed the length
    // of the stream. (See bug 58.)
    if (_tao_seq_len > strm.length())
      return 0;
    // 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 ImplementationRepository::Administration_ptr _tao_objref
  )
{
  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
  return (strm << _tao_corba_obj);
}

CORBA::Boolean operator>> (
    TAO_InputCDR &strm,
    ImplementationRepository::Administration_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 =
      ImplementationRepository::Administration::_unchecked_narrow (
          obj.in ()
          ACE_ENV_ARG_PARAMETER
        );
    ACE_TRY_CHECK;
    return 1;
  }
  ACE_CATCHANY
  {
    // do nothing
  }
  ACE_ENDTRY;
  return 0;
}

CORBA::Boolean operator<< (
    TAO_OutputCDR &strm,
    const ImplementationRepository::ServerInformationIterator_ptr _tao_objref
  )
{
  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
  return (strm << _tao_corba_obj);
}

CORBA::Boolean operator>> (
    TAO_InputCDR &strm,
    ImplementationRepository::ServerInformationIterator_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 =
      ImplementationRepository::ServerInformationIterator::_unchecked_narrow (
          obj.in ()
          ACE_ENV_ARG_PARAMETER
        );
    ACE_TRY_CHECK;
    return 1;
  }
  ACE_CATCHANY
  {
    // do nothing
  }
  ACE_ENDTRY;
  return 0;
}

