// -*- C++ -*-
//
// ImplRepoC.cpp,v 1.20 2003/01/02 16:51:39 boris 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

// TAO_IDL - Generated from
// be/be_codegen.cpp:314


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

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

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

// TAO_IDL - Generated from
// be/be_interface.cpp:721

// *************************************************************
// ImplementationRepository::ServerObject_var
// *************************************************************

ImplementationRepository::ServerObject_var::ServerObject_var (void)
  : 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)
  : TAO_Base_var (),
    ptr_ (ServerObject::_duplicate (p.ptr ()))
{}

ImplementationRepository::ServerObject_var::~ServerObject_var (void)
{
  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;
}

// TAO_IDL - Generated from
// be/be_interface.cpp:1030

// *************************************************************
// ImplementationRepository::ServerObject_out
// *************************************************************

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

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

ImplementationRepository::ServerObject_out::ServerObject_out (const ::ImplementationRepository::ServerObject_out &p)
  : 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)
{
  return this->ptr_;
}

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

// TAO_IDL - Generated from
// be/be_visitor_interface/interceptors_cs.cpp:56

#if (TAO_HAS_INTERCEPTORS == 1)

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_cs.cpp:76

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_IDL - Generated from
  // be/be_visitor_operation/interceptors_cs.cpp:378
  
  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;
}



// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_cs.cpp:76

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_IDL - Generated from
  // be/be_visitor_operation/interceptors_cs.cpp:378
  
  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 */

// TAO_IDL - Generated from
// be/be_visitor_interface/remote_proxy_impl_cs.cpp:31

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

// TAO_IDL - Generated from
// be/be_visitor_operation/remote_proxy_impl_cs.cpp:63

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 (
                      CORBA::OMGVMCID | 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;
            }
        }
      
# if defined (ACE_HAS_EXCEPTIONS) \
     && defined (ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS)
      ACE_CATCHALL
        {
          CORBA::UNKNOWN ex;
          
          _tao_ri.exception (&ex);
          _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)
            ACE_TRY_THROW (ex);
        }
# endif  /* ACE_HAS_EXCEPTIONS && ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS */
      
      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;
    }
}

// TAO_IDL - Generated from
// be/be_visitor_operation/remote_proxy_impl_cs.cpp:63

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 (
                      CORBA::OMGVMCID | 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;
            }
        }
      
# if defined (ACE_HAS_EXCEPTIONS) \
     && defined (ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS)
      ACE_CATCHALL
        {
          CORBA::UNKNOWN ex;
          
          _tao_ri.exception (&ex);
          _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)
            ACE_TRY_THROW (ex);
        }
# endif  /* ACE_HAS_EXCEPTIONS && ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS */
      
      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. 
///////////////////////////////////////////////////////////////////////

// TAO_IDL - Generated from
// be/be_visitor_interface/remote_proxy_broker_cs.cpp:31

///////////////////////////////////////////////////////////////////////
//           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:225

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

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

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

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 != 0)
        {
          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 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 != 0)
    {
      this->_add_ref ();
    }
  
  return retv;
}

const char* ImplementationRepository::ServerObject::_interface_repository_id (void) const
{
  return "IDL:ImplementationRepository/ServerObject:1.0";
}

// TAO_IDL - Generated from
// be/be_visitor_operation/operation_cs.cpp:80

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

// TAO_IDL - Generated from
// be/be_visitor_operation/operation_cs.cpp:80

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

// TAO_IDL - Generated from
// be/be_visitor_typecode/typecode_defn.cpp:284

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

// TAO_IDL - Generated from 
// be/be_visitor_exception/exception_cs.cpp:63

ImplementationRepository::AlreadyRegistered::AlreadyRegistered (void)
  : CORBA_UserException (
        "IDL:ImplementationRepository/AlreadyRegistered:1.0",
        "AlreadyRegistered"
      )
{
}

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

ImplementationRepository::AlreadyRegistered::AlreadyRegistered (const ::ImplementationRepository::AlreadyRegistered &_tao_excp)
  : CORBA_UserException (
        _tao_excp._rep_id (),
        _tao_excp._name ()
      )
{
}

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

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

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

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

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

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

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

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

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

// TAO_IDL - Generated from
// be/be_visitor_typecode/typecode_defn.cpp:284

static const CORBA::Long _oc_ImplementationRepository_AlreadyRegistered[] =
{
    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 (0x2f416c72), 
  ACE_NTOHL (0x65616479), 
  ACE_NTOHL (0x52656769), 
  ACE_NTOHL (0x73746572), 
  ACE_NTOHL (0x65643a31), 
  ACE_NTOHL (0x2e300000),  // repository ID = IDL:ImplementationRepository/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_AlreadyRegistered (
    CORBA::tk_except,
    sizeof (_oc_ImplementationRepository_AlreadyRegistered),
    (char *) &_oc_ImplementationRepository_AlreadyRegistered,
    0,
    sizeof (ImplementationRepository::AlreadyRegistered)
  );

TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
TAO_NAMESPACE_BEGIN (ImplementationRepository)
TAO_NAMESPACE_DEFINE (
    ::CORBA::TypeCode_ptr,
    _tc_AlreadyRegistered,
    &_tc_TAO_tc_ImplementationRepository_AlreadyRegistered
  )
TAO_NAMESPACE_END

// TAO_IDL - Generated from 
// be/be_visitor_exception/exception_cs.cpp:63

ImplementationRepository::CannotActivate::CannotActivate (void)
  : CORBA_UserException (
        "IDL:ImplementationRepository/CannotActivate:1.0",
        "CannotActivate"
      )
{
}

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

ImplementationRepository::CannotActivate::CannotActivate (const ::ImplementationRepository::CannotActivate &_tao_excp)
  : CORBA_UserException (
        _tao_excp._rep_id (),
        _tao_excp._name ()
      )
{
  this->reason = CORBA::string_dup (_tao_excp.reason.in ());
}

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

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

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

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

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

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

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

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



// TAO_IDL - Generated from
// be/be_visitor_exception/exception_ctor.cpp:66

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

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

// TAO_IDL - Generated from
// be/be_visitor_typecode/typecode_defn.cpp:284

static const CORBA::Long _oc_ImplementationRepository_CannotActivate[] =
{
    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 (0x2f43616e), 
  ACE_NTOHL (0x6e6f7441), 
  ACE_NTOHL (0x63746976), 
  ACE_NTOHL (0x6174653a), 
  ACE_NTOHL (0x312e3000),  // repository ID = IDL:ImplementationRepository/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_CannotActivate (
    CORBA::tk_except,
    sizeof (_oc_ImplementationRepository_CannotActivate),
    (char *) &_oc_ImplementationRepository_CannotActivate,
    0,
    sizeof (ImplementationRepository::CannotActivate)
  );

TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
TAO_NAMESPACE_BEGIN (ImplementationRepository)
TAO_NAMESPACE_DEFINE (
    ::CORBA::TypeCode_ptr,
    _tc_CannotActivate,
    &_tc_TAO_tc_ImplementationRepository_CannotActivate
  )
TAO_NAMESPACE_END

// TAO_IDL - Generated from 
// be/be_visitor_exception/exception_cs.cpp:63

ImplementationRepository::NotFound::NotFound (void)
  : CORBA_UserException (
        "IDL:ImplementationRepository/NotFound:1.0",
        "NotFound"
      )
{
}

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

ImplementationRepository::NotFound::NotFound (const ::ImplementationRepository::NotFound &_tao_excp)
  : CORBA_UserException (
        _tao_excp._rep_id (),
        _tao_excp._name ()
      )
{
}

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

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

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

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

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

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

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

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

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

// TAO_IDL - Generated from
// be/be_visitor_typecode/typecode_defn.cpp:284

static const CORBA::Long _oc_ImplementationRepository_NotFound[] =
{
    TAO_ENCAP_BYTE_ORDER, // byte order
  42,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x496d706c), 
  ACE_NTOHL (0x656d656e), 
  ACE_NTOHL (0x74617469), 
  ACE_NTOHL (0x6f6e5265), 
  ACE_NTOHL (0x706f7369), 
  ACE_NTOHL (0x746f7279), 
  ACE_NTOHL (0x2f4e6f74), 
  ACE_NTOHL (0x466f756e), 
  ACE_NTOHL (0x643a312e), 
  ACE_NTOHL (0x30000000),  // repository ID = IDL:ImplementationRepository/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_NotFound (
    CORBA::tk_except,
    sizeof (_oc_ImplementationRepository_NotFound),
    (char *) &_oc_ImplementationRepository_NotFound,
    0,
    sizeof (ImplementationRepository::NotFound)
  );

TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
TAO_NAMESPACE_BEGIN (ImplementationRepository)
TAO_NAMESPACE_DEFINE (
    ::CORBA::TypeCode_ptr,
    _tc_NotFound,
    &_tc_TAO_tc_ImplementationRepository_NotFound
  )
TAO_NAMESPACE_END

// TAO_IDL - Generated from
// be/be_visitor_typecode/typecode_defn.cpp:284

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

// TAO_IDL - Generated from 
// be/be_visitor_structure/structure_cs.cpp:67

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

// TAO_IDL - Generated from
// be/be_visitor_typecode/typecode_defn.cpp:284

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

// TAO_IDL - Generated from 
// be/be_visitor_sequence/gen_unbounded_sequence_cs.cpp:101

#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)
{
  this->_deallocate_buffer ();
}

#endif /* end #if !defined */

#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 

#if !defined (_IMPLEMENTATIONREPOSITORY_ENVIRONMENTLIST_CS_)
#define _IMPLEMENTATIONREPOSITORY_ENVIRONMENTLIST_CS_

// TAO_IDL - Generated from
// be/be_visitor_sequence/sequence_cs.cpp:250

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

ImplementationRepository::EnvironmentList::EnvironmentList (void)
{}

ImplementationRepository::EnvironmentList::EnvironmentList (CORBA::ULong max)
  : 

#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)
  : 

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

// TAO_IDL - Generated from
// be/be_visitor_typecode/typecode_defn.cpp:284

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

// TAO_IDL - Generated from
// be/be_visitor_typecode/typecode_defn.cpp:284

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

// TAO_IDL - Generated from
// be/be_visitor_typecode/typecode_defn.cpp:284

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
  5, // 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_string, 
  0U, // string length
};

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

// TAO_IDL - Generated from 
// be/be_visitor_structure/structure_cs.cpp:67

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

// TAO_IDL - Generated from
// be/be_visitor_typecode/typecode_defn.cpp:284

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
  584, // 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
    5, // 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_string, 
    0U, // string length

  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

// TAO_IDL - Generated from 
// be/be_visitor_structure/structure_cs.cpp:67

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

// TAO_IDL - Generated from 
// be/be_visitor_sequence/gen_unbounded_sequence_cs.cpp:101

#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)
{
  this->_deallocate_buffer ();
}

#endif /* end #if !defined */

#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 

#if !defined (_IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONLIST_CS_)
#define _IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONLIST_CS_

// TAO_IDL - Generated from
// be/be_visitor_sequence/sequence_cs.cpp:250

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

ImplementationRepository::ServerInformationList::ServerInformationList (void)
{}

ImplementationRepository::ServerInformationList::ServerInformationList (CORBA::ULong max)
  : 

#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)
  : 

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

// TAO_IDL - Generated from
// be/be_visitor_typecode/typecode_defn.cpp:284

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
  852, // encapsulation length
    TAO_ENCAP_BYTE_ORDER, // byte order
    CORBA::tk_struct, // typecode kind
    836, // 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
      584, // 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
        5, // 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_string, 
        0U, // string length

      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

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

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

// TAO_IDL - Generated from
// be/be_interface.cpp:721

// *************************************************************
// ImplementationRepository::Administration_var
// *************************************************************

ImplementationRepository::Administration_var::Administration_var (void)
  : 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)
  : TAO_Base_var (),
    ptr_ (Administration::_duplicate (p.ptr ()))
{}

ImplementationRepository::Administration_var::~Administration_var (void)
{
  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;
}

// TAO_IDL - Generated from
// be/be_interface.cpp:1030

// *************************************************************
// ImplementationRepository::Administration_out
// *************************************************************

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

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

ImplementationRepository::Administration_out::Administration_out (const ::ImplementationRepository::Administration_out &p)
  : 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)
{
  return this->ptr_;
}

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

// TAO_IDL - Generated from
// be/be_visitor_interface/interceptors_cs.cpp:56

#if (TAO_HAS_INTERCEPTORS == 1)

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_cs.cpp:76

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_IDL - Generated from
  // be/be_visitor_operation/interceptors_cs.cpp:378
  
  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::_tc_NotFound,
    ImplementationRepository::_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;
}



// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_cs.cpp:76

class TAO_ClientRequestInfo_ImplementationRepository_Administration_activate_server_with_startup : public TAO_ClientRequestInfo_i
{
public:
  TAO_ClientRequestInfo_ImplementationRepository_Administration_activate_server_with_startup (
      TAO_GIOP_Invocation *_tao_invocation,
      CORBA::Object_ptr _tao_target,
      const char * server,
      const CORBA::Long & check_startup
      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_activate_server_with_startup (const TAO_ClientRequestInfo_ImplementationRepository_Administration_activate_server_with_startup &);
    void operator= (const TAO_ClientRequestInfo_ImplementationRepository_Administration_activate_server_with_startup &);
    const char * server_;
    const CORBA::Long & check_startup_;
    
    char * _result;
  };
  
  // TAO_IDL - Generated from
  // be/be_visitor_operation/interceptors_cs.cpp:378
  
  TAO_ClientRequestInfo_ImplementationRepository_Administration_activate_server_with_startup::TAO_ClientRequestInfo_ImplementationRepository_Administration_activate_server_with_startup (
      TAO_GIOP_Invocation *_tao_invocation,
      CORBA::Object_ptr _tao_target,
      const char * server,
      const CORBA::Long & check_startup
      ACE_ENV_ARG_DECL_NOT_USED      
    )
      : TAO_ClientRequestInfo_i (_tao_invocation, _tao_target),
      server_ (server),
      check_startup_ (check_startup)
{}

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

Dynamic::ExceptionList *
TAO_ClientRequestInfo_ImplementationRepository_Administration_activate_server_with_startup::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_with_startup_exceptiondata[] = 
  {
    ImplementationRepository::_tc_NotFound,
    ImplementationRepository::_tc_CannotActivate
  };
  
  exception_list->length (2);
  for (CORBA::ULong i = 0; i < 2; ++i)
    {
      CORBA::TypeCode_ptr tcp = _tao_ImplementationRepository_Administration_activate_server_with_startup_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_with_startup::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_activate_server_with_startup::result (char * result)
{
  // Update the result. 
  this->_result = result;
}

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_cs.cpp:76

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_IDL - Generated from
  // be/be_visitor_operation/interceptors_cs.cpp:378
  
  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::_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;
}



// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_cs.cpp:76

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_IDL - Generated from
  // be/be_visitor_operation/interceptors_cs.cpp:378
  
  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;
}



// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_cs.cpp:76

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_IDL - Generated from
  // be/be_visitor_operation/interceptors_cs.cpp:378
  
  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::_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;
}



// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_cs.cpp:76

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_IDL - Generated from
  // be/be_visitor_operation/interceptors_cs.cpp:378
  
  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::_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;
}



// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_cs.cpp:76

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_IDL - Generated from
  // be/be_visitor_operation/interceptors_cs.cpp:378
  
  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::_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;
}

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_cs.cpp:76

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_IDL - Generated from
  // be/be_visitor_operation/interceptors_cs.cpp:378
  
  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::_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;
}



// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_cs.cpp:76

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_IDL - Generated from
  // be/be_visitor_operation/interceptors_cs.cpp:378
  
  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::_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;
}



// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_cs.cpp:76

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_IDL - Generated from
  // be/be_visitor_operation/interceptors_cs.cpp:378
  
  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 */

// TAO_IDL - Generated from
// be/be_visitor_interface/remote_proxy_impl_cs.cpp:31

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

// TAO_IDL - Generated from
// be/be_visitor_operation/remote_proxy_impl_cs.cpp:63

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::NotFound
    , ImplementationRepository::CannotActivate
  ))
{
    static TAO_Exception_Data _tao_ImplementationRepository_Administration_activate_server_exceptiondata [] = 
  {
    {
      "IDL:ImplementationRepository/NotFound:1.0",
      ImplementationRepository::NotFound::_alloc
    },
    {
      "IDL:ImplementationRepository/CannotActivate:1.0",
      ImplementationRepository::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 (
                      CORBA::OMGVMCID | 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;
            }
        }
      
# if defined (ACE_HAS_EXCEPTIONS) \
     && defined (ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS)
      ACE_CATCHALL
        {
          CORBA::UNKNOWN ex;
          
          _tao_ri.exception (&ex);
          _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)
            ACE_TRY_THROW (ex);
        }
# endif  /* ACE_HAS_EXCEPTIONS && ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS */
      
      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;
    }
}

// TAO_IDL - Generated from
// be/be_visitor_operation/remote_proxy_impl_cs.cpp:63

char * ImplementationRepository::_TAO_Administration_Remote_Proxy_Impl::activate_server_with_startup (
    CORBA_Object *_collocated_tao_target_,
    const char * server,
    CORBA::Long check_startup
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
    , ImplementationRepository::NotFound
    , ImplementationRepository::CannotActivate
  ))
{
    static TAO_Exception_Data _tao_ImplementationRepository_Administration_activate_server_with_startup_exceptiondata [] = 
  {
    {
      "IDL:ImplementationRepository/NotFound:1.0",
      ImplementationRepository::NotFound::_alloc
    },
    {
      "IDL:ImplementationRepository/CannotActivate:1.0",
      ImplementationRepository::CannotActivate::_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,
      "activate_server_with_startup",
      28,
      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_activate_server_with_startup _tao_ri (
          &_tao_call,
          _collocated_tao_target_,
          server,
          check_startup
          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 << check_startup)
              ))
            {
              TAO_INTERCEPTOR_THROW_RETURN (
                  CORBA::MARSHAL (
                      
                    ),
                  0
                );
            }
          
          _invoke_status =
            _tao_call.invoke (_tao_ImplementationRepository_Administration_activate_server_with_startup_exceptiondata, 2 ACE_ENV_ARG_PARAMETER);
          TAO_INTERCEPTOR_CHECK_RETURN (_tao_retval._retn ());

          if (_invoke_status == TAO_INVOKE_EXCEPTION)
            {
              TAO_INTERCEPTOR_THROW_RETURN (
                  CORBA::UNKNOWN (
                      CORBA::OMGVMCID | 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;
            }
        }
      
# if defined (ACE_HAS_EXCEPTIONS) \
     && defined (ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS)
      ACE_CATCHALL
        {
          CORBA::UNKNOWN ex;
          
          _tao_ri.exception (&ex);
          _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)
            ACE_TRY_THROW (ex);
        }
# endif  /* ACE_HAS_EXCEPTIONS && ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS */
      
      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 ();
}

// TAO_IDL - Generated from
// be/be_visitor_operation/remote_proxy_impl_cs.cpp:63

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::AlreadyRegistered
  ))
{
    static TAO_Exception_Data _tao_ImplementationRepository_Administration_register_server_exceptiondata [] = 
  {
    {
      "IDL:ImplementationRepository/AlreadyRegistered:1.0",
      ImplementationRepository::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 (
                      CORBA::OMGVMCID | 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;
            }
        }
      
# if defined (ACE_HAS_EXCEPTIONS) \
     && defined (ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS)
      ACE_CATCHALL
        {
          CORBA::UNKNOWN ex;
          
          _tao_ri.exception (&ex);
          _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)
            ACE_TRY_THROW (ex);
        }
# endif  /* ACE_HAS_EXCEPTIONS && ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS */
      
      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;
    }
}

// TAO_IDL - Generated from
// be/be_visitor_operation/remote_proxy_impl_cs.cpp:63

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 (
                      CORBA::OMGVMCID | 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;
            }
        }
      
# if defined (ACE_HAS_EXCEPTIONS) \
     && defined (ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS)
      ACE_CATCHALL
        {
          CORBA::UNKNOWN ex;
          
          _tao_ri.exception (&ex);
          _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)
            ACE_TRY_THROW (ex);
        }
# endif  /* ACE_HAS_EXCEPTIONS && ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS */
      
      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;
    }
}

// TAO_IDL - Generated from
// be/be_visitor_operation/remote_proxy_impl_cs.cpp:63

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::NotFound
  ))
{
    static TAO_Exception_Data _tao_ImplementationRepository_Administration_remove_server_exceptiondata [] = 
  {
    {
      "IDL:ImplementationRepository/NotFound:1.0",
      ImplementationRepository::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 (
                      CORBA::OMGVMCID | 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;
            }
        }
      
# if defined (ACE_HAS_EXCEPTIONS) \
     && defined (ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS)
      ACE_CATCHALL
        {
          CORBA::UNKNOWN ex;
          
          _tao_ri.exception (&ex);
          _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)
            ACE_TRY_THROW (ex);
        }
# endif  /* ACE_HAS_EXCEPTIONS && ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS */
      
      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;
    }
}

// TAO_IDL - Generated from
// be/be_visitor_operation/remote_proxy_impl_cs.cpp:63

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::NotFound
  ))
{
    static TAO_Exception_Data _tao_ImplementationRepository_Administration_shutdown_server_exceptiondata [] = 
  {
    {
      "IDL:ImplementationRepository/NotFound:1.0",
      ImplementationRepository::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 (
                      CORBA::OMGVMCID | 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;
            }
        }
      
# if defined (ACE_HAS_EXCEPTIONS) \
     && defined (ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS)
      ACE_CATCHALL
        {
          CORBA::UNKNOWN ex;
          
          _tao_ri.exception (&ex);
          _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)
            ACE_TRY_THROW (ex);
        }
# endif  /* ACE_HAS_EXCEPTIONS && ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS */
      
      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;
    }
}

// TAO_IDL - Generated from
// be/be_visitor_operation/remote_proxy_impl_cs.cpp:63

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::NotFound
  ))
{
    static TAO_Exception_Data _tao_ImplementationRepository_Administration_server_is_running_exceptiondata [] = 
  {
    {
      "IDL:ImplementationRepository/NotFound:1.0",
      ImplementationRepository::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 (
                      CORBA::OMGVMCID | 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;
            }
        }
      
# if defined (ACE_HAS_EXCEPTIONS) \
     && defined (ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS)
      ACE_CATCHALL
        {
          CORBA::UNKNOWN ex;
          
          _tao_ri.exception (&ex);
          _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)
            ACE_TRY_THROW (ex);
        }
# endif  /* ACE_HAS_EXCEPTIONS && ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS */
      
      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 ();
}

// TAO_IDL - Generated from
// be/be_visitor_operation/remote_proxy_impl_cs.cpp:63

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::NotFound
  ))
{
    static TAO_Exception_Data _tao_ImplementationRepository_Administration_server_is_shutting_down_exceptiondata [] = 
  {
    {
      "IDL:ImplementationRepository/NotFound:1.0",
      ImplementationRepository::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 (
                      CORBA::OMGVMCID | 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;
            }
        }
      
# if defined (ACE_HAS_EXCEPTIONS) \
     && defined (ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS)
      ACE_CATCHALL
        {
          CORBA::UNKNOWN ex;
          
          _tao_ri.exception (&ex);
          _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)
            ACE_TRY_THROW (ex);
        }
# endif  /* ACE_HAS_EXCEPTIONS && ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS */
      
      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;
    }
}

// TAO_IDL - Generated from
// be/be_visitor_operation/remote_proxy_impl_cs.cpp:63

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::NotFound
  ))
{
    static TAO_Exception_Data _tao_ImplementationRepository_Administration_find_exceptiondata [] = 
  {
    {
      "IDL:ImplementationRepository/NotFound:1.0",
      ImplementationRepository::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 (
                      CORBA::OMGVMCID | 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;
            }
        }
      
# if defined (ACE_HAS_EXCEPTIONS) \
     && defined (ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS)
      ACE_CATCHALL
        {
          CORBA::UNKNOWN ex;
          
          _tao_ri.exception (&ex);
          _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)
            ACE_TRY_THROW (ex);
        }
# endif  /* ACE_HAS_EXCEPTIONS && ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS */
      
      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;
    }
}

// TAO_IDL - Generated from
// be/be_visitor_operation/remote_proxy_impl_cs.cpp:63

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 (
                      CORBA::OMGVMCID | 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;
            }
        }
      
# if defined (ACE_HAS_EXCEPTIONS) \
     && defined (ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS)
      ACE_CATCHALL
        {
          CORBA::UNKNOWN ex;
          
          _tao_ri.exception (&ex);
          _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)
            ACE_TRY_THROW (ex);
        }
# endif  /* ACE_HAS_EXCEPTIONS && ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS */
      
      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. 
///////////////////////////////////////////////////////////////////////

// TAO_IDL - Generated from
// be/be_visitor_interface/remote_proxy_broker_cs.cpp:31

///////////////////////////////////////////////////////////////////////
//           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:225

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

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

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

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 != 0)
        {
          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 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 != 0)
    {
      this->_add_ref ();
    }
  
  return retv;
}

const char* ImplementationRepository::Administration::_interface_repository_id (void) const
{
  return "IDL:ImplementationRepository/Administration:1.0";
}

// TAO_IDL - Generated from
// be/be_visitor_operation/operation_cs.cpp:80

void ImplementationRepository::Administration::activate_server (
    const char * server
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
    , ImplementationRepository::NotFound
    , ImplementationRepository::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
    );
}

// TAO_IDL - Generated from
// be/be_visitor_operation/operation_cs.cpp:80

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

// TAO_IDL - Generated from
// be/be_visitor_operation/operation_cs.cpp:80

void ImplementationRepository::Administration::register_server (
    const char * server,
    const ImplementationRepository::StartupOptions & options
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
    , ImplementationRepository::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
    );
}

// TAO_IDL - Generated from
// be/be_visitor_operation/operation_cs.cpp:80

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

// TAO_IDL - Generated from
// be/be_visitor_operation/operation_cs.cpp:80

void ImplementationRepository::Administration::remove_server (
    const char * server
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
    , ImplementationRepository::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
    );
}

// TAO_IDL - Generated from
// be/be_visitor_operation/operation_cs.cpp:80

void ImplementationRepository::Administration::shutdown_server (
    const char * server
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
    , ImplementationRepository::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
    );
}

// TAO_IDL - Generated from
// be/be_visitor_operation/operation_cs.cpp:80

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

// TAO_IDL - Generated from
// be/be_visitor_operation/operation_cs.cpp:80

void ImplementationRepository::Administration::server_is_shutting_down (
    const char * server
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
    , ImplementationRepository::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
    );
}

// TAO_IDL - Generated from
// be/be_visitor_operation/operation_cs.cpp:80

void ImplementationRepository::Administration::find (
    const char * server,
    ImplementationRepository::ServerInformation_out info
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
    , ImplementationRepository::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
    );
}

// TAO_IDL - Generated from
// be/be_visitor_operation/operation_cs.cpp:80

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

// TAO_IDL - Generated from
// be/be_visitor_typecode/typecode_defn.cpp:284

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

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

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

// TAO_IDL - Generated from
// be/be_interface.cpp:721

// *************************************************************
// ImplementationRepository::ServerInformationIterator_var
// *************************************************************

ImplementationRepository::ServerInformationIterator_var::ServerInformationIterator_var (void)
  : 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)
  : TAO_Base_var (),
    ptr_ (ServerInformationIterator::_duplicate (p.ptr ()))
{}

ImplementationRepository::ServerInformationIterator_var::~ServerInformationIterator_var (void)
{
  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;
}

// TAO_IDL - Generated from
// be/be_interface.cpp:1030

// *************************************************************
// ImplementationRepository::ServerInformationIterator_out
// *************************************************************

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

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

ImplementationRepository::ServerInformationIterator_out::ServerInformationIterator_out (const ::ImplementationRepository::ServerInformationIterator_out &p)
  : 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)
{
  return this->ptr_;
}

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

// TAO_IDL - Generated from
// be/be_visitor_interface/interceptors_cs.cpp:56

#if (TAO_HAS_INTERCEPTORS == 1)

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_cs.cpp:76

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_IDL - Generated from
  // be/be_visitor_operation/interceptors_cs.cpp:378
  
  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;
}

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_cs.cpp:76

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_IDL - Generated from
  // be/be_visitor_operation/interceptors_cs.cpp:378
  
  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 */

// TAO_IDL - Generated from
// be/be_visitor_interface/remote_proxy_impl_cs.cpp:31

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

// TAO_IDL - Generated from
// be/be_visitor_operation/remote_proxy_impl_cs.cpp:63

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 (
                      CORBA::OMGVMCID | 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;
            }
        }
      
# if defined (ACE_HAS_EXCEPTIONS) \
     && defined (ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS)
      ACE_CATCHALL
        {
          CORBA::UNKNOWN ex;
          
          _tao_ri.exception (&ex);
          _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)
            ACE_TRY_THROW (ex);
        }
# endif  /* ACE_HAS_EXCEPTIONS && ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS */
      
      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;
}

// TAO_IDL - Generated from
// be/be_visitor_operation/remote_proxy_impl_cs.cpp:63

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 (
                      CORBA::OMGVMCID | 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;
            }
        }
      
# if defined (ACE_HAS_EXCEPTIONS) \
     && defined (ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS)
      ACE_CATCHALL
        {
          CORBA::UNKNOWN ex;
          
          _tao_ri.exception (&ex);
          _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)
            ACE_TRY_THROW (ex);
        }
# endif  /* ACE_HAS_EXCEPTIONS && ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS */
      
      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. 
///////////////////////////////////////////////////////////////////////

// TAO_IDL - Generated from
// be/be_visitor_interface/remote_proxy_broker_cs.cpp:31

///////////////////////////////////////////////////////////////////////
//           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:225

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

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

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

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 != 0)
        {
          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 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 != 0)
    {
      this->_add_ref ();
    }
  
  return retv;
}

const char* ImplementationRepository::ServerInformationIterator::_interface_repository_id (void) const
{
  return "IDL:ImplementationRepository/ServerInformationIterator:1.0";
}

// TAO_IDL - Generated from
// be/be_visitor_operation/operation_cs.cpp:80

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

// TAO_IDL - Generated from
// be/be_visitor_operation/operation_cs.cpp:80

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

// TAO_IDL - Generated from
// be/be_visitor_typecode/typecode_defn.cpp:284

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

// TAO_IDL - Generated from
// be/be_visitor_interface/any_op_cs.cpp:52

// Copying version.
void
operator<<= (
    CORBA::Any &_tao_any,
    ImplementationRepository::ServerObject_ptr _tao_elem
  )
{
  ImplementationRepository::ServerObject_ptr _tao_objptr =
    ImplementationRepository::ServerObject::_duplicate (_tao_elem);
  _tao_any <<= &_tao_objptr;
}

// Non-copying version.
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,
          *_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 _tao_result =
      type->equivalent (
          ImplementationRepository::_tc_ServerObject
          ACE_ENV_ARG_PARAMETER
        );
    ACE_TRY_CHECK;
    
    if (!_tao_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 */

// TAO_IDL - Generated from 
// be/be_visitor_exception/any_op_cs.cpp:54

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

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

// Extraction to non-const pointer (deprecated).
CORBA::Boolean operator>>= (
    const CORBA::Any &_tao_any,ImplementationRepository::AlreadyRegistered *&_tao_elem
  )
{
  return _tao_any >>= ACE_const_cast(
      const ImplementationRepository::AlreadyRegistered*&,
      _tao_elem
    );
}

// Extraction to const pointer.
CORBA::Boolean operator>>= (
    const CORBA::Any &_tao_any,
    const ImplementationRepository::AlreadyRegistered *&_tao_elem
  )
{
  _tao_elem = 0;
  ACE_TRY_NEW_ENV
  {
    CORBA::TypeCode_var type = _tao_any.type ();
    
    CORBA::Boolean _tao_result =
      type->equivalent (
          ImplementationRepository::_tc_AlreadyRegistered
          ACE_ENV_ARG_PARAMETER
        );
    ACE_TRY_CHECK;
    
    if (_tao_result == 0)
      {
        return 0; // not equivalent
      }
    
    if (_tao_any.any_owns_data ())
      {
        _tao_elem = (ImplementationRepository::AlreadyRegistered *)_tao_any.value ();
        return 1;
      }
    else
      {
        ImplementationRepository::AlreadyRegistered *tmp = 0;
        ACE_NEW_RETURN (
            tmp,
            ImplementationRepository::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/AlreadyRegistered:1.0")
              )
          {
            return 0;
          }
        
        if (stream >> *tmp)
          {
            ((CORBA::Any *)&_tao_any)->_tao_replace (
                ImplementationRepository::_tc_AlreadyRegistered,
                1,
                tmp,
                ImplementationRepository::AlreadyRegistered::_tao_any_destructor
              );
            
            _tao_elem = tmp;
            return 1;
          }
        else
          {
            delete tmp;
          }
      }
  }
  ACE_CATCHANY
  {
  }
  ACE_ENDTRY;
  
  return 0;
}

// TAO_IDL - Generated from 
// be/be_visitor_exception/any_op_cs.cpp:54

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

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

// Extraction to non-const pointer (deprecated).
CORBA::Boolean operator>>= (
    const CORBA::Any &_tao_any,ImplementationRepository::CannotActivate *&_tao_elem
  )
{
  return _tao_any >>= ACE_const_cast(
      const ImplementationRepository::CannotActivate*&,
      _tao_elem
    );
}

// Extraction to const pointer.
CORBA::Boolean operator>>= (
    const CORBA::Any &_tao_any,
    const ImplementationRepository::CannotActivate *&_tao_elem
  )
{
  _tao_elem = 0;
  ACE_TRY_NEW_ENV
  {
    CORBA::TypeCode_var type = _tao_any.type ();
    
    CORBA::Boolean _tao_result =
      type->equivalent (
          ImplementationRepository::_tc_CannotActivate
          ACE_ENV_ARG_PARAMETER
        );
    ACE_TRY_CHECK;
    
    if (_tao_result == 0)
      {
        return 0; // not equivalent
      }
    
    if (_tao_any.any_owns_data ())
      {
        _tao_elem = (ImplementationRepository::CannotActivate *)_tao_any.value ();
        return 1;
      }
    else
      {
        ImplementationRepository::CannotActivate *tmp = 0;
        ACE_NEW_RETURN (
            tmp,
            ImplementationRepository::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/CannotActivate:1.0")
              )
          {
            return 0;
          }
        
        if (stream >> *tmp)
          {
            ((CORBA::Any *)&_tao_any)->_tao_replace (
                ImplementationRepository::_tc_CannotActivate,
                1,
                tmp,
                ImplementationRepository::CannotActivate::_tao_any_destructor
              );
            
            _tao_elem = tmp;
            return 1;
          }
        else
          {
            delete tmp;
          }
      }
  }
  ACE_CATCHANY
  {
  }
  ACE_ENDTRY;
  
  return 0;
}

// TAO_IDL - Generated from 
// be/be_visitor_exception/any_op_cs.cpp:54

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

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

// Extraction to non-const pointer (deprecated).
CORBA::Boolean operator>>= (
    const CORBA::Any &_tao_any,ImplementationRepository::NotFound *&_tao_elem
  )
{
  return _tao_any >>= ACE_const_cast(
      const ImplementationRepository::NotFound*&,
      _tao_elem
    );
}

// Extraction to const pointer.
CORBA::Boolean operator>>= (
    const CORBA::Any &_tao_any,
    const ImplementationRepository::NotFound *&_tao_elem
  )
{
  _tao_elem = 0;
  ACE_TRY_NEW_ENV
  {
    CORBA::TypeCode_var type = _tao_any.type ();
    
    CORBA::Boolean _tao_result =
      type->equivalent (
          ImplementationRepository::_tc_NotFound
          ACE_ENV_ARG_PARAMETER
        );
    ACE_TRY_CHECK;
    
    if (_tao_result == 0)
      {
        return 0; // not equivalent
      }
    
    if (_tao_any.any_owns_data ())
      {
        _tao_elem = (ImplementationRepository::NotFound *)_tao_any.value ();
        return 1;
      }
    else
      {
        ImplementationRepository::NotFound *tmp = 0;
        ACE_NEW_RETURN (
            tmp,
            ImplementationRepository::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/NotFound:1.0")
              )
          {
            return 0;
          }
        
        if (stream >> *tmp)
          {
            ((CORBA::Any *)&_tao_any)->_tao_replace (
                ImplementationRepository::_tc_NotFound,
                1,
                tmp,
                ImplementationRepository::NotFound::_tao_any_destructor
              );
            
            _tao_elem = tmp;
            return 1;
          }
        else
          {
            delete tmp;
          }
      }
  }
  ACE_CATCHANY
  {
  }
  ACE_ENDTRY;
  
  return 0;
}

// TAO_IDL - Generated from 
// be/be_visitor_structure/any_op_cs.cpp:54

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

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

// Extraction to non-const pointer (deprecated).
CORBA::Boolean operator>>= (
    const CORBA::Any &_tao_any,
    ImplementationRepository::EnvironmentVariable *&_tao_elem
  )
{
  return _tao_any >>= ACE_const_cast (
      const ImplementationRepository::EnvironmentVariable *&,
      _tao_elem
    );
}

// Extraction to const pointer.
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 _tao_result =
      type->equivalent (
          ImplementationRepository::_tc_EnvironmentVariable
          ACE_ENV_ARG_PARAMETER
        );
    ACE_TRY_CHECK;
    
    if (_tao_result == 0)
      {
        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;
}

// TAO_IDL - Generated from 
// be/be_visitor_sequence/any_op_cs.cpp:54

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

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

// Extraction to non-const pointer (deprecated).
CORBA::Boolean operator>>= (
    const CORBA::Any &_tao_any,
    ImplementationRepository::EnvironmentList *&_tao_elem
  )
{
  return _tao_any >>= ACE_const_cast(
      const ImplementationRepository::EnvironmentList*&,
      _tao_elem
    );
}

// Extraction to const pointer.
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 _tao_result =
      type->equivalent (
          ImplementationRepository::_tc_EnvironmentList
          ACE_ENV_ARG_PARAMETER
        );
    ACE_TRY_CHECK;
    
    if (!_tao_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 = 0;
        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;
}

// TAO_IDL - Generated from
// be/be_visitor_enum/any_op_cs.cpp:52

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 _tao_result = type->equivalent (ImplementationRepository::_tc_ActivationMode ACE_ENV_ARG_PARAMETER);
    ACE_TRY_CHECK;
    
    if (!_tao_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;
}

// TAO_IDL - Generated from 
// be/be_visitor_structure/any_op_cs.cpp:54

// Copying insertion.
void operator<<= (
    CORBA::Any &_tao_any,
    const ImplementationRepository::StartupOptions &_tao_elem
  )
{
  TAO_OutputCDR stream;
  
  if (stream << _tao_elem)
    {
      _tao_any._tao_replace (
          ImplementationRepository::_tc_StartupOptions,
          TAO_ENCAP_BYTE_ORDER,
          stream.begin ()
        );
    }
}

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

// Extraction to non-const pointer (deprecated).
CORBA::Boolean operator>>= (
    const CORBA::Any &_tao_any,
    ImplementationRepository::StartupOptions *&_tao_elem
  )
{
  return _tao_any >>= ACE_const_cast (
      const ImplementationRepository::StartupOptions *&,
      _tao_elem
    );
}

// Extraction to const pointer.
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 _tao_result =
      type->equivalent (
          ImplementationRepository::_tc_StartupOptions
          ACE_ENV_ARG_PARAMETER
        );
    ACE_TRY_CHECK;
    
    if (_tao_result == 0)
      {
        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;
}

// TAO_IDL - Generated from 
// be/be_visitor_structure/any_op_cs.cpp:54

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

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

// Extraction to non-const pointer (deprecated).
CORBA::Boolean operator>>= (
    const CORBA::Any &_tao_any,
    ImplementationRepository::ServerInformation *&_tao_elem
  )
{
  return _tao_any >>= ACE_const_cast (
      const ImplementationRepository::ServerInformation *&,
      _tao_elem
    );
}

// Extraction to const pointer.
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 _tao_result =
      type->equivalent (
          ImplementationRepository::_tc_ServerInformation
          ACE_ENV_ARG_PARAMETER
        );
    ACE_TRY_CHECK;
    
    if (_tao_result == 0)
      {
        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;
}

// TAO_IDL - Generated from 
// be/be_visitor_sequence/any_op_cs.cpp:54

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

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

// Extraction to non-const pointer (deprecated).
CORBA::Boolean operator>>= (
    const CORBA::Any &_tao_any,
    ImplementationRepository::ServerInformationList *&_tao_elem
  )
{
  return _tao_any >>= ACE_const_cast(
      const ImplementationRepository::ServerInformationList*&,
      _tao_elem
    );
}

// Extraction to const pointer.
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 _tao_result =
      type->equivalent (
          ImplementationRepository::_tc_ServerInformationList
          ACE_ENV_ARG_PARAMETER
        );
    ACE_TRY_CHECK;
    
    if (!_tao_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 = 0;
        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;
}

// TAO_IDL - Generated from
// be/be_visitor_interface/any_op_cs.cpp:52

// Copying version.
void
operator<<= (
    CORBA::Any &_tao_any,
    ImplementationRepository::Administration_ptr _tao_elem
  )
{
  ImplementationRepository::Administration_ptr _tao_objptr =
    ImplementationRepository::Administration::_duplicate (_tao_elem);
  _tao_any <<= &_tao_objptr;
}

// Non-copying version.
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,
          *_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 _tao_result =
      type->equivalent (
          ImplementationRepository::_tc_Administration
          ACE_ENV_ARG_PARAMETER
        );
    ACE_TRY_CHECK;
    
    if (!_tao_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 */

// TAO_IDL - Generated from
// be/be_visitor_interface/any_op_cs.cpp:52

// Copying version.
void
operator<<= (
    CORBA::Any &_tao_any,
    ImplementationRepository::ServerInformationIterator_ptr _tao_elem
  )
{
  ImplementationRepository::ServerInformationIterator_ptr _tao_objptr =
    ImplementationRepository::ServerInformationIterator::_duplicate (_tao_elem);
  _tao_any <<= &_tao_objptr;
}

// Non-copying version.
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,
          *_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 _tao_result =
      type->equivalent (
          ImplementationRepository::_tc_ServerInformationIterator
          ACE_ENV_ARG_PARAMETER
        );
    ACE_TRY_CHECK;
    
    if (!_tao_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 */

// TAO_IDL - Generated from
// be/be_visitor_interface/cdr_op_cs.cpp:63

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

// TAO_IDL - Generated from
// be/be_visitor_sequence/cdr_op_cs.cpp:103

CORBA::Boolean operator<< (
    TAO_OutputCDR &strm,
    const ImplementationRepository::EnvironmentList &_tao_sequence
  )
{
  CORBA::ULong _tao_seq_len = _tao_sequence.length ();
  
  if (strm << _tao_seq_len)
    {
      // Encode all elements.
      CORBA::Boolean _tao_marshal_flag = 1;
      
      for (CORBA::ULong i = 0; i < _tao_seq_len && _tao_marshal_flag; ++i)
        {
          _tao_marshal_flag = (strm << _tao_sequence[i]);
        }
      
      return _tao_marshal_flag;
    }
  
  return 0;
}

CORBA::Boolean operator>> (
    TAO_InputCDR &strm,
    ImplementationRepository::EnvironmentList &_tao_sequence
  )
{
  CORBA::ULong _tao_seq_len;
  
  if (strm >> _tao_seq_len)
    {
      // 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;
        }
      
      // Set the length of the sequence.
      _tao_sequence.length (_tao_seq_len);
      
      // If length is 0 we return true.
      if (0 >= _tao_seq_len) 
        {
          return 1;
        }
      
      // Retrieve all the elements.
      CORBA::Boolean _tao_marshal_flag = 1;
      
      for (CORBA::ULong i = 0; i < _tao_seq_len && _tao_marshal_flag; ++i)
        {
          _tao_marshal_flag = (strm >> _tao_sequence[i]);
        }
      
      return _tao_marshal_flag;
    }
  
  return 0;
}

// TAO_IDL - Generated from
// be/be_visitor_sequence/cdr_op_cs.cpp:103

CORBA::Boolean operator<< (
    TAO_OutputCDR &strm,
    const ImplementationRepository::ServerInformationList &_tao_sequence
  )
{
  CORBA::ULong _tao_seq_len = _tao_sequence.length ();
  
  if (strm << _tao_seq_len)
    {
      // Encode all elements.
      CORBA::Boolean _tao_marshal_flag = 1;
      
      for (CORBA::ULong i = 0; i < _tao_seq_len && _tao_marshal_flag; ++i)
        {
          _tao_marshal_flag = (strm << _tao_sequence[i]);
        }
      
      return _tao_marshal_flag;
    }
  
  return 0;
}

CORBA::Boolean operator>> (
    TAO_InputCDR &strm,
    ImplementationRepository::ServerInformationList &_tao_sequence
  )
{
  CORBA::ULong _tao_seq_len;
  
  if (strm >> _tao_seq_len)
    {
      // 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;
        }
      
      // Set the length of the sequence.
      _tao_sequence.length (_tao_seq_len);
      
      // If length is 0 we return true.
      if (0 >= _tao_seq_len) 
        {
          return 1;
        }
      
      // Retrieve all the elements.
      CORBA::Boolean _tao_marshal_flag = 1;
      
      for (CORBA::ULong i = 0; i < _tao_seq_len && _tao_marshal_flag; ++i)
        {
          _tao_marshal_flag = (strm >> _tao_sequence[i]);
        }
      
      return _tao_marshal_flag;
    }
  
  return 0;
}

// TAO_IDL - Generated from
// be/be_visitor_interface/cdr_op_cs.cpp:63

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

// TAO_IDL - Generated from
// be/be_visitor_interface/cdr_op_cs.cpp:63

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

