// -*- C++ -*-
//
// ImR_LocatorS.cpp,v 1.1 2002/09/04 18:31:34 pgontla 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:663

#ifndef _TAO_IDL_IMR_LOCATORS_CPP_
#define _TAO_IDL_IMR_LOCATORS_CPP_

#include "ImR_LocatorS.h"

#include "tao/PortableServer/Object_Adapter.h"
#include "tao/PortableServer/Operation_Table.h"
#include "tao/TAO_Server_Request.h"
#include "tao/ORB_Core.h"
#include "tao/Stub.h"
#include "tao/IFR_Client_Adapter.h"
#include "tao/PortableInterceptor.h"

#if TAO_HAS_INTERCEPTORS == 1
#include "tao/RequestInfo_Util.h"
#include "tao/PICurrent.h"
#include "tao/PortableServer/ServerRequestInfo.h"
#include "tao/PortableServer/ServerInterceptorAdapter.h"
#endif  /* TAO_HAS_INTERCEPTORS == 1 */

#include "ace/Dynamic_Service.h"
#if defined (__BORLANDC__)
#pragma option -w-rvl -w-rch -w-ccc -w-aus
#endif /* __BORLANDC__ */

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

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

class TAO_ImplementationRepository_Locator_Perfect_Hash_OpTable : public TAO_Perfect_Hash_OpTable
{
private:
  unsigned int hash (const char *str, unsigned int len);
public:
 const TAO_operation_db_entry * lookup (const char *str, unsigned int len);
};
/* C++ code produced by gperf version 2.8 (ACE version) */
/* Command-line: /project/doctmp/pgontla/ImR/ACE_wrappers/bin/gperf -m -M -J -c -C -D -E -T -f 0 -F 0 -a -o -t -p -K opname_ -L C++ -Z TAO_ImplementationRepository_Locator_Perfect_Hash_OpTable -N lookup  */
unsigned int
TAO_ImplementationRepository_Locator_Perfect_Hash_OpTable::hash (const char *str, unsigned int len)
{
  static const unsigned char asso_values[] =
    {
#if defined (ACE_MVS)
     56, 56, 56, 56, 56, 56, 56, 56, 56, 56,
     56, 56, 56, 56, 56, 56, 56, 56, 56, 56,
     56, 56, 56, 56, 56, 56, 56, 56, 56, 56,
     56, 56, 56, 56, 56, 56, 56, 56, 56, 56,
     56, 56, 56, 56, 56, 56, 56, 56, 56, 56,
     56, 56, 56, 56, 56, 56, 56, 56, 56, 56,
     56, 56, 56, 56, 56, 56, 56, 56, 56, 56,
     56, 56, 56, 56, 56, 56, 56, 56, 56, 56,
     56, 56, 56, 56, 56, 56, 56, 56, 56, 56,
     56, 56, 56, 56, 56, 56, 56, 56, 56, 56,
     56, 56, 56, 56, 56, 56, 56, 56, 56, 25,
     56, 56, 56, 56, 56, 56, 56, 56, 56, 56,
     56, 56, 56, 56, 56, 56, 56, 56, 56, 15,
     56, 56,  5, 20,  0,  0, 56, 56, 56, 56,
     56, 56, 56, 56, 56, 56, 56,  0, 56,  0,
     56,  0, 56,  0, 56, 56, 56, 56, 56, 56,
     56, 56,  5,  0, 30, 56, 56, 56, 56, 56,
     56, 56, 56, 56, 56, 56, 56, 56, 56, 56,
     56, 56, 56, 56, 56, 56, 56, 56, 56, 56,
     56, 56, 56, 56, 56, 56, 56, 56, 56, 56,
     56, 56, 56, 56, 56, 56, 56, 56, 56, 56,
     56, 56, 56, 56, 56, 56, 56, 56, 56, 56,
     56, 56, 56, 56, 56, 56, 56, 56, 56, 56,
     56, 56, 56, 56, 56, 56, 56, 56, 56, 56,
     56, 56, 56, 56, 56, 56, 56, 56, 56, 56,
     56, 56, 56, 56, 56, 56,
#else
     56, 56, 56, 56, 56, 56, 56, 56, 56, 56,
     56, 56, 56, 56, 56, 56, 56, 56, 56, 56,
     56, 56, 56, 56, 56, 56, 56, 56, 56, 56,
     56, 56, 56, 56, 56, 56, 56, 56, 56, 56,
     56, 56, 56, 56, 56, 56, 56, 56, 56, 56,
     56, 56, 56, 56, 56, 56, 56, 56, 56, 56,
     56, 56, 56, 56, 56, 56, 56, 56, 56, 56,
     56, 56, 56, 56, 56, 56, 56, 56, 56, 56,
     56, 56, 56, 56, 56, 56, 56, 56, 56, 56,
     56, 56, 56, 56, 56, 25, 56, 15, 56, 56,
      5, 20,  0,  0, 56, 56, 56, 56,  0, 56,
      0, 56,  0, 56,  0,  5,  0, 30, 56, 56,
     56, 56, 56, 56, 56, 56, 56, 56,
#endif /* ACE_MVS */
    };
  return len + asso_values[str[len - 1]] + asso_values[str[0]];
}

const class TAO_operation_db_entry *
TAO_ImplementationRepository_Locator_Perfect_Hash_OpTable::lookup (const char *str, unsigned int len)
{
  enum
    {
      TOTAL_KEYWORDS = 20,
      MIN_WORD_LENGTH = 4,
      MAX_WORD_LENGTH = 35,
      MIN_HASH_VALUE = 4,
      MAX_HASH_VALUE = 55,
      HASH_VALUE_RANGE = 52,
      DUPLICATES = 0,
      WORDLIST_SIZE = 24
    };

  static const class TAO_operation_db_entry  wordlist[] =
    {
      {"",0},{"",0},{"",0},{"",0},
      {"list", 	&POA_ImplementationRepository::Locator::list_skel},
      {"",0},{"",0},{"",0},{"",0},
      {"find", 	&POA_ImplementationRepository::Locator::find_skel},
      {"",0},{"",0},{"",0},
      {"remove_server", 	&POA_ImplementationRepository::Locator::remove_server_skel},
      {"",0},
      {"register_server", 	&POA_ImplementationRepository::Locator::register_server_skel},
      {"",0},
      {"reregister_server", 	&POA_ImplementationRepository::Locator::reregister_server_skel},
      {"register_activator", 	&POA_ImplementationRepository::Locator::register_activator_skel},
      {"",0},
      {"shutdown_server", 	&POA_ImplementationRepository::Locator::shutdown_server_skel},
      {"",0},
      {"server_is_running", 	&POA_ImplementationRepository::Locator::server_is_running_skel},
      {"",0},{"",0},
      {"remove_server_in_location", 	&POA_ImplementationRepository::Locator::remove_server_in_location_skel},
      {"",0},{"",0},
      {"server_is_shutting_down", 	&POA_ImplementationRepository::Locator::server_is_shutting_down_skel},
      {"",0},
      {"activate_server", 	&POA_ImplementationRepository::Locator::activate_server_skel},
      {"",0},
      {"shutdown_server_in_location", 	&POA_ImplementationRepository::Locator::shutdown_server_in_location_skel},
      {"",0},{"",0},
      {"_component",  &POA_ImplementationRepository::Locator::_component_skel},
      {"",0},{"",0},
      {"_non_existent",  &POA_ImplementationRepository::Locator::_non_existent_skel},
      {"",0},
      {"server_is_shutting_down_in_location", 	&POA_ImplementationRepository::Locator::server_is_shutting_down_in_location_skel},
      {"",0},
      {"activate_server_in_location", 	&POA_ImplementationRepository::Locator::activate_server_in_location_skel},
      {"activate_server_with_startup", 	&POA_ImplementationRepository::Locator::activate_server_with_startup_skel},
      {"",0},
      {"_is_a",  &POA_ImplementationRepository::Locator::_is_a_skel},
      {"",0},{"",0},{"",0},{"",0},
      {"unregister_activator", 	&POA_ImplementationRepository::Locator::unregister_activator_skel},
      {"",0},{"",0},{"",0},{"",0},
      {"_interface",  &POA_ImplementationRepository::Locator::_interface_skel},
    };

  if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH)
    {
      unsigned int key = hash (str, len);

      if (key <= MAX_HASH_VALUE && key >= MIN_HASH_VALUE)
        {
          const char *s = wordlist[key].opname_;

          if (*str == *s && !strncmp (str + 1, s + 1, len - 1))
            return &wordlist[key];
        }
    }
  return 0;
}
static TAO_ImplementationRepository_Locator_Perfect_Hash_OpTable tao_ImplementationRepository_Locator_optable;

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

#if (TAO_HAS_INTERCEPTORS == 1)
class TAO_ServerRequestInfo_ImplementationRepository_Locator_activate_server_in_location : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_ImplementationRepository_Locator_activate_server_in_location (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_ImplementationRepository::Locator *tao_impl,
      const char * server,
      const char * location ACE_ENV_ARG_DECL_WITH_DEFAULTS
    
  );

virtual Dynamic::ParameterList * arguments (
    ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
  )
  ACE_THROW_SPEC ((CORBA::SystemException));

virtual Dynamic::ExceptionList * exceptions (
    ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
  )
  ACE_THROW_SPEC ((CORBA::SystemException));

virtual CORBA::Any * result (
    ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
  )
  ACE_THROW_SPEC ((CORBA::SystemException));

virtual char * target_most_derived_interface (
    ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
  )
  ACE_THROW_SPEC ((CORBA::SystemException));

virtual CORBA::Boolean target_is_a (
    const char * id
    ACE_ENV_ARG_DECL_WITH_DEFAULTS
  )
  ACE_THROW_SPEC ((CORBA::SystemException));

private:
  TAO_ServerRequestInfo_ImplementationRepository_Locator_activate_server_in_location (
      const TAO_ServerRequestInfo_ImplementationRepository_Locator_activate_server_in_location &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_ImplementationRepository_Locator_activate_server_in_location &
    );
  
private:
  POA_ImplementationRepository::Locator *_tao_impl;
  const char * server_;
  const char * location_;
  
};

TAO_ServerRequestInfo_ImplementationRepository_Locator_activate_server_in_location::TAO_ServerRequestInfo_ImplementationRepository_Locator_activate_server_in_location (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_ImplementationRepository::Locator *tao_impl,
    const char * server,
    const char * location ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl),
    server_ (server),
    location_ (location)
{}

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

Dynamic::ExceptionList *
TAO_ServerRequestInfo_ImplementationRepository_Locator_activate_server_in_location::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_Locator_activate_server_in_location_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_Locator_activate_server_in_location_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_ServerRequestInfo_ImplementationRepository_Locator_activate_server_in_location::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;
}

char *
TAO_ServerRequestInfo_ImplementationRepository_Locator_activate_server_in_location::target_most_derived_interface (
    ACE_ENV_SINGLE_ARG_DECL_NOT_USED
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  return
    CORBA::string_dup (this->_tao_impl->_interface_repository_id ());
}

CORBA::Boolean
TAO_ServerRequestInfo_ImplementationRepository_Locator_activate_server_in_location::target_is_a (
    const char * id
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  return this->_tao_impl->_is_a (id ACE_ENV_ARG_PARAMETER);
}

class TAO_ServerRequestInfo_ImplementationRepository_Locator_remove_server_in_location : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_ImplementationRepository_Locator_remove_server_in_location (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_ImplementationRepository::Locator *tao_impl,
      const char * server,
      const char * location ACE_ENV_ARG_DECL_WITH_DEFAULTS
    
  );

virtual Dynamic::ParameterList * arguments (
    ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
  )
  ACE_THROW_SPEC ((CORBA::SystemException));

virtual Dynamic::ExceptionList * exceptions (
    ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
  )
  ACE_THROW_SPEC ((CORBA::SystemException));

virtual CORBA::Any * result (
    ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
  )
  ACE_THROW_SPEC ((CORBA::SystemException));

virtual char * target_most_derived_interface (
    ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
  )
  ACE_THROW_SPEC ((CORBA::SystemException));

virtual CORBA::Boolean target_is_a (
    const char * id
    ACE_ENV_ARG_DECL_WITH_DEFAULTS
  )
  ACE_THROW_SPEC ((CORBA::SystemException));

private:
  TAO_ServerRequestInfo_ImplementationRepository_Locator_remove_server_in_location (
      const TAO_ServerRequestInfo_ImplementationRepository_Locator_remove_server_in_location &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_ImplementationRepository_Locator_remove_server_in_location &
    );
  
private:
  POA_ImplementationRepository::Locator *_tao_impl;
  const char * server_;
  const char * location_;
  
};

TAO_ServerRequestInfo_ImplementationRepository_Locator_remove_server_in_location::TAO_ServerRequestInfo_ImplementationRepository_Locator_remove_server_in_location (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_ImplementationRepository::Locator *tao_impl,
    const char * server,
    const char * location ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl),
    server_ (server),
    location_ (location)
{}

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

Dynamic::ExceptionList *
TAO_ServerRequestInfo_ImplementationRepository_Locator_remove_server_in_location::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_Locator_remove_server_in_location_exceptiondata[] = 
  {
    ImplementationRepository::_tc_NotFound
  };
  
  exception_list->length (1);
  for (CORBA::ULong i = 0; i < 1; ++i)
    {
      CORBA::TypeCode_ptr tcp = _tao_ImplementationRepository_Locator_remove_server_in_location_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_ServerRequestInfo_ImplementationRepository_Locator_remove_server_in_location::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;
}

char *
TAO_ServerRequestInfo_ImplementationRepository_Locator_remove_server_in_location::target_most_derived_interface (
    ACE_ENV_SINGLE_ARG_DECL_NOT_USED
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  return
    CORBA::string_dup (this->_tao_impl->_interface_repository_id ());
}

CORBA::Boolean
TAO_ServerRequestInfo_ImplementationRepository_Locator_remove_server_in_location::target_is_a (
    const char * id
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  return this->_tao_impl->_is_a (id ACE_ENV_ARG_PARAMETER);
}

class TAO_ServerRequestInfo_ImplementationRepository_Locator_shutdown_server_in_location : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_ImplementationRepository_Locator_shutdown_server_in_location (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_ImplementationRepository::Locator *tao_impl,
      const char * server,
      const char * location ACE_ENV_ARG_DECL_WITH_DEFAULTS
    
  );

virtual Dynamic::ParameterList * arguments (
    ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
  )
  ACE_THROW_SPEC ((CORBA::SystemException));

virtual Dynamic::ExceptionList * exceptions (
    ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
  )
  ACE_THROW_SPEC ((CORBA::SystemException));

virtual CORBA::Any * result (
    ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
  )
  ACE_THROW_SPEC ((CORBA::SystemException));

virtual char * target_most_derived_interface (
    ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
  )
  ACE_THROW_SPEC ((CORBA::SystemException));

virtual CORBA::Boolean target_is_a (
    const char * id
    ACE_ENV_ARG_DECL_WITH_DEFAULTS
  )
  ACE_THROW_SPEC ((CORBA::SystemException));

private:
  TAO_ServerRequestInfo_ImplementationRepository_Locator_shutdown_server_in_location (
      const TAO_ServerRequestInfo_ImplementationRepository_Locator_shutdown_server_in_location &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_ImplementationRepository_Locator_shutdown_server_in_location &
    );
  
private:
  POA_ImplementationRepository::Locator *_tao_impl;
  const char * server_;
  const char * location_;
  
};

TAO_ServerRequestInfo_ImplementationRepository_Locator_shutdown_server_in_location::TAO_ServerRequestInfo_ImplementationRepository_Locator_shutdown_server_in_location (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_ImplementationRepository::Locator *tao_impl,
    const char * server,
    const char * location ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl),
    server_ (server),
    location_ (location)
{}

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

Dynamic::ExceptionList *
TAO_ServerRequestInfo_ImplementationRepository_Locator_shutdown_server_in_location::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_Locator_shutdown_server_in_location_exceptiondata[] = 
  {
    ImplementationRepository::_tc_NotFound
  };
  
  exception_list->length (1);
  for (CORBA::ULong i = 0; i < 1; ++i)
    {
      CORBA::TypeCode_ptr tcp = _tao_ImplementationRepository_Locator_shutdown_server_in_location_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_ServerRequestInfo_ImplementationRepository_Locator_shutdown_server_in_location::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;
}

char *
TAO_ServerRequestInfo_ImplementationRepository_Locator_shutdown_server_in_location::target_most_derived_interface (
    ACE_ENV_SINGLE_ARG_DECL_NOT_USED
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  return
    CORBA::string_dup (this->_tao_impl->_interface_repository_id ());
}

CORBA::Boolean
TAO_ServerRequestInfo_ImplementationRepository_Locator_shutdown_server_in_location::target_is_a (
    const char * id
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  return this->_tao_impl->_is_a (id ACE_ENV_ARG_PARAMETER);
}

class TAO_ServerRequestInfo_ImplementationRepository_Locator_server_is_shutting_down_in_location : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_ImplementationRepository_Locator_server_is_shutting_down_in_location (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_ImplementationRepository::Locator *tao_impl,
      const char * server,
      const char * location ACE_ENV_ARG_DECL_WITH_DEFAULTS
    
  );

virtual Dynamic::ParameterList * arguments (
    ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
  )
  ACE_THROW_SPEC ((CORBA::SystemException));

virtual Dynamic::ExceptionList * exceptions (
    ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
  )
  ACE_THROW_SPEC ((CORBA::SystemException));

virtual CORBA::Any * result (
    ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
  )
  ACE_THROW_SPEC ((CORBA::SystemException));

virtual char * target_most_derived_interface (
    ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
  )
  ACE_THROW_SPEC ((CORBA::SystemException));

virtual CORBA::Boolean target_is_a (
    const char * id
    ACE_ENV_ARG_DECL_WITH_DEFAULTS
  )
  ACE_THROW_SPEC ((CORBA::SystemException));

private:
  TAO_ServerRequestInfo_ImplementationRepository_Locator_server_is_shutting_down_in_location (
      const TAO_ServerRequestInfo_ImplementationRepository_Locator_server_is_shutting_down_in_location &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_ImplementationRepository_Locator_server_is_shutting_down_in_location &
    );
  
private:
  POA_ImplementationRepository::Locator *_tao_impl;
  const char * server_;
  const char * location_;
  
};

TAO_ServerRequestInfo_ImplementationRepository_Locator_server_is_shutting_down_in_location::TAO_ServerRequestInfo_ImplementationRepository_Locator_server_is_shutting_down_in_location (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_ImplementationRepository::Locator *tao_impl,
    const char * server,
    const char * location ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl),
    server_ (server),
    location_ (location)
{}

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

Dynamic::ExceptionList *
TAO_ServerRequestInfo_ImplementationRepository_Locator_server_is_shutting_down_in_location::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_Locator_server_is_shutting_down_in_location_exceptiondata[] = 
  {
    ImplementationRepository::_tc_NotFound
  };
  
  exception_list->length (1);
  for (CORBA::ULong i = 0; i < 1; ++i)
    {
      CORBA::TypeCode_ptr tcp = _tao_ImplementationRepository_Locator_server_is_shutting_down_in_location_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_ServerRequestInfo_ImplementationRepository_Locator_server_is_shutting_down_in_location::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;
}

char *
TAO_ServerRequestInfo_ImplementationRepository_Locator_server_is_shutting_down_in_location::target_most_derived_interface (
    ACE_ENV_SINGLE_ARG_DECL_NOT_USED
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  return
    CORBA::string_dup (this->_tao_impl->_interface_repository_id ());
}

CORBA::Boolean
TAO_ServerRequestInfo_ImplementationRepository_Locator_server_is_shutting_down_in_location::target_is_a (
    const char * id
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  return this->_tao_impl->_is_a (id ACE_ENV_ARG_PARAMETER);
}

class TAO_ServerRequestInfo_ImplementationRepository_Locator_register_activator : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_ImplementationRepository_Locator_register_activator (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_ImplementationRepository::Locator *tao_impl,
      const char * location,
      CORBA::Object_ptr object_ref ACE_ENV_ARG_DECL_WITH_DEFAULTS
    
  );

virtual Dynamic::ParameterList * arguments (
    ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
  )
  ACE_THROW_SPEC ((CORBA::SystemException));

virtual Dynamic::ExceptionList * exceptions (
    ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
  )
  ACE_THROW_SPEC ((CORBA::SystemException));

virtual CORBA::Any * result (
    ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
  )
  ACE_THROW_SPEC ((CORBA::SystemException));

virtual char * target_most_derived_interface (
    ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
  )
  ACE_THROW_SPEC ((CORBA::SystemException));

virtual CORBA::Boolean target_is_a (
    const char * id
    ACE_ENV_ARG_DECL_WITH_DEFAULTS
  )
  ACE_THROW_SPEC ((CORBA::SystemException));

void result (CORBA::ULong result);

private:
  TAO_ServerRequestInfo_ImplementationRepository_Locator_register_activator (
      const TAO_ServerRequestInfo_ImplementationRepository_Locator_register_activator &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_ImplementationRepository_Locator_register_activator &
    );
  
private:
  POA_ImplementationRepository::Locator *_tao_impl;
  const char * location_;
  CORBA::Object_ptr object_ref_;
  CORBA::ULong _result;
};

TAO_ServerRequestInfo_ImplementationRepository_Locator_register_activator::TAO_ServerRequestInfo_ImplementationRepository_Locator_register_activator (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_ImplementationRepository::Locator *tao_impl,
    const char * location,
    CORBA::Object_ptr object_ref ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl),
    location_ (location),
    object_ref_ (object_ref)
{}

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

Dynamic::ExceptionList *
TAO_ServerRequestInfo_ImplementationRepository_Locator_register_activator::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_Locator_register_activator_exceptiondata[] = 
  {
    ImplementationRepository::_tc_AlreadyRegistered
  };
  
  exception_list->length (1);
  for (CORBA::ULong i = 0; i < 1; ++i)
    {
      CORBA::TypeCode_ptr tcp = _tao_ImplementationRepository_Locator_register_activator_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_ServerRequestInfo_ImplementationRepository_Locator_register_activator::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 ();
}

char *
TAO_ServerRequestInfo_ImplementationRepository_Locator_register_activator::target_most_derived_interface (
    ACE_ENV_SINGLE_ARG_DECL_NOT_USED
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  return
    CORBA::string_dup (this->_tao_impl->_interface_repository_id ());
}

CORBA::Boolean
TAO_ServerRequestInfo_ImplementationRepository_Locator_register_activator::target_is_a (
    const char * id
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  return this->_tao_impl->_is_a (id ACE_ENV_ARG_PARAMETER);
}

void 
TAO_ServerRequestInfo_ImplementationRepository_Locator_register_activator::result (CORBA::ULong result)
{
  // Update the result.
   this->_result = result;
}

class TAO_ServerRequestInfo_ImplementationRepository_Locator_unregister_activator : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_ImplementationRepository_Locator_unregister_activator (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_ImplementationRepository::Locator *tao_impl,
      const char * location,
      CORBA::Object_ptr object_ref ACE_ENV_ARG_DECL_WITH_DEFAULTS
    
  );

virtual Dynamic::ParameterList * arguments (
    ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
  )
  ACE_THROW_SPEC ((CORBA::SystemException));

virtual Dynamic::ExceptionList * exceptions (
    ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
  )
  ACE_THROW_SPEC ((CORBA::SystemException));

virtual CORBA::Any * result (
    ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
  )
  ACE_THROW_SPEC ((CORBA::SystemException));

virtual char * target_most_derived_interface (
    ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
  )
  ACE_THROW_SPEC ((CORBA::SystemException));

virtual CORBA::Boolean target_is_a (
    const char * id
    ACE_ENV_ARG_DECL_WITH_DEFAULTS
  )
  ACE_THROW_SPEC ((CORBA::SystemException));

void result (CORBA::ULong result);

private:
  TAO_ServerRequestInfo_ImplementationRepository_Locator_unregister_activator (
      const TAO_ServerRequestInfo_ImplementationRepository_Locator_unregister_activator &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_ImplementationRepository_Locator_unregister_activator &
    );
  
private:
  POA_ImplementationRepository::Locator *_tao_impl;
  const char * location_;
  CORBA::Object_ptr object_ref_;
  CORBA::ULong _result;
};

TAO_ServerRequestInfo_ImplementationRepository_Locator_unregister_activator::TAO_ServerRequestInfo_ImplementationRepository_Locator_unregister_activator (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_ImplementationRepository::Locator *tao_impl,
    const char * location,
    CORBA::Object_ptr object_ref ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl),
    location_ (location),
    object_ref_ (object_ref)
{}

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

Dynamic::ExceptionList *
TAO_ServerRequestInfo_ImplementationRepository_Locator_unregister_activator::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_Locator_unregister_activator_exceptiondata[] = 
  {
    ImplementationRepository::_tc_NotFound
  };
  
  exception_list->length (1);
  for (CORBA::ULong i = 0; i < 1; ++i)
    {
      CORBA::TypeCode_ptr tcp = _tao_ImplementationRepository_Locator_unregister_activator_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_ServerRequestInfo_ImplementationRepository_Locator_unregister_activator::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 ();
}

char *
TAO_ServerRequestInfo_ImplementationRepository_Locator_unregister_activator::target_most_derived_interface (
    ACE_ENV_SINGLE_ARG_DECL_NOT_USED
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  return
    CORBA::string_dup (this->_tao_impl->_interface_repository_id ());
}

CORBA::Boolean
TAO_ServerRequestInfo_ImplementationRepository_Locator_unregister_activator::target_is_a (
    const char * id
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  return this->_tao_impl->_is_a (id ACE_ENV_ARG_PARAMETER);
}

void 
TAO_ServerRequestInfo_ImplementationRepository_Locator_unregister_activator::result (CORBA::ULong result)
{
  // Update the result.
   this->_result = result;
}

#endif /* TAO_HAS_INTERCEPTORS */

///////////////////////////////////////////////////////////////////////
//            Strategized Proxy Broker Implementation
//

// TAO_IDL - Generated from
// be/be_visitor_interface/strategized_proxy_broker_ss.cpp:40

// Factory function Implementation.
POA_ImplementationRepository::_TAO_Locator_Strategized_Proxy_Broker *POA_ImplementationRepository::_TAO_Locator_Strategized_Proxy_Broker::the_TAO_Locator_Strategized_Proxy_Broker (void)
{
  static POA_ImplementationRepository::_TAO_Locator_Strategized_Proxy_Broker strategized_proxy_broker;
  return &strategized_proxy_broker;
}

POA_ImplementationRepository::_TAO_Locator_Strategized_Proxy_Broker::_TAO_Locator_Strategized_Proxy_Broker (void)
{
  for (int i = 0; i < TAO_Collocation_Strategies::CS_LAST; ++i)
    this->proxy_cache_[i] = 0;
  
}

POA_ImplementationRepository::_TAO_Locator_Strategized_Proxy_Broker::~_TAO_Locator_Strategized_Proxy_Broker (void)
{
  for (int i = 0; i < TAO_Collocation_Strategies::CS_LAST; ++i)
    {
      delete this->proxy_cache_[i];
      
      // Hack to prevent bug mentioned in 1204. Refer to 1204
      // for details..
      this->proxy_cache_[i] = 0;
    }
  
}

ImplementationRepository::_TAO_Locator_Proxy_Impl&
POA_ImplementationRepository::_TAO_Locator_Strategized_Proxy_Broker::select_proxy (
    ::ImplementationRepository::Locator *object
    ACE_ENV_ARG_DECL
  )
{
  int strategy =
    TAO_ORB_Core::collocation_strategy (object ACE_ENV_ARG_PARAMETER);
    ACE_CHECK_RETURN (*this->proxy_cache_[strategy]);
  
  if (this->proxy_cache_[strategy] != 0)
    return *this->proxy_cache_[strategy];
  
  this->create_proxy (strategy ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (*this->proxy_cache_[strategy]);
  
  return *this->proxy_cache_[strategy];
  
}

void 
POA_ImplementationRepository::_TAO_Locator_Strategized_Proxy_Broker::create_proxy (
    int strategy
    ACE_ENV_ARG_DECL
  )
{
  ACE_GUARD (TAO_SYNCH_MUTEX, guard, this->mutex_);
  
  if (this->proxy_cache_[strategy] == 0)
    {
      switch (strategy)
        {
        case TAO_Collocation_Strategies::CS_THRU_POA_STRATEGY:
          ACE_NEW_THROW_EX (
              this->proxy_cache_[strategy],
              POA_ImplementationRepository::_TAO_Locator_ThruPOA_Proxy_Impl,
              CORBA::NO_MEMORY ()
          );
          ACE_CHECK;
          break;
          
        case TAO_Collocation_Strategies::CS_DIRECT_STRATEGY:
          ACE_NEW_THROW_EX (
              this->proxy_cache_[strategy],
              POA_ImplementationRepository::_TAO_Locator_Direct_Proxy_Impl,
              CORBA::NO_MEMORY ()
          );
          ACE_CHECK;
          break;
          
        case TAO_Collocation_Strategies::CS_REMOTE_STRATEGY:
        default:
          ACE_NEW_THROW_EX (
              this->proxy_cache_[strategy],
              ::ImplementationRepository::_TAO_Locator_Remote_Proxy_Impl,
              CORBA::NO_MEMORY ()
          );
          ACE_CHECK;
          break;
        
      }
    
  }
}


//
//        End Strategized Proxy Broker Implementation
///////////////////////////////////////////////////////////////////////


// TAO_IDL - Generated from
// be/be_visitor_interface/interface_ss.cpp:599

ImplementationRepository::_TAO_Locator_Proxy_Broker *
ImplementationRepository__TAO_Locator_Proxy_Broker_Factory_function (CORBA::Object_ptr obj)
{
  ACE_UNUSED_ARG (obj);
  return ::POA_ImplementationRepository::_TAO_Locator_Strategized_Proxy_Broker::the_TAO_Locator_Strategized_Proxy_Broker();
}

int
ImplementationRepository__TAO_Locator_Proxy_Broker_Factory_Initializer (long)
{
  ImplementationRepository__TAO_Locator_Proxy_Broker_Factory_function_pointer = 
    ImplementationRepository__TAO_Locator_Proxy_Broker_Factory_function;
  
  return 0;
}

static int ImplementationRepository__TAO_Locator_Proxy_Broker_Stub_Factory_Initializer_Scarecrow = 
  ImplementationRepository__TAO_Locator_Proxy_Broker_Factory_Initializer (ACE_reinterpret_cast (long, ImplementationRepository__TAO_Locator_Proxy_Broker_Factory_Initializer));


///////////////////////////////////////////////////////////////////////
//                 ThruPOA Proxy  Implementation
//

// TAO_IDL - Generated from
// be/be_visitor_interface/thru_poa_proxy_impl_ss.cpp:37

POA_ImplementationRepository::_TAO_Locator_ThruPOA_Proxy_Impl::_TAO_Locator_ThruPOA_Proxy_Impl (void)
{}

// ThruPOA Implementation of the IDL interface methods

void POA_ImplementationRepository::_TAO_Locator_ThruPOA_Proxy_Impl::activate_server_in_location (
    CORBA_Object *_collocated_tao_target_,
    const char * server,
    const char * location
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
    , ImplementationRepository::NotFound
    , ImplementationRepository::CannotActivate
  ))
{
  TAO_Object_Adapter::Servant_Upcall servant_upcall (
      _collocated_tao_target_->_stubobj ()->servant_orb_var ()->orb_core ()
    );
  CORBA::Object_var forward_to;
  servant_upcall.prepare_for_upcall (
      _collocated_tao_target_->_object_key (),
      "activate_server_in_location",
      forward_to.out ()
      ACE_ENV_ARG_PARAMETER
    );
  ACE_CHECK;
  
  servant_upcall.pre_invoke_collocated_request (
      ACE_ENV_SINGLE_ARG_PARAMETER
    );
  ACE_CHECK;
  
  ACE_reinterpret_cast (
      POA_ImplementationRepository::Locator_ptr,
      servant_upcall.servant ()->_downcast (
          "IDL:ImplementationRepository/Locator:1.0"
        )
    )->activate_server_in_location (
        server,
        location ACE_ENV_ARG_PARAMETER
      );
}

void POA_ImplementationRepository::_TAO_Locator_ThruPOA_Proxy_Impl::remove_server_in_location (
    CORBA_Object *_collocated_tao_target_,
    const char * server,
    const char * location
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
    , ImplementationRepository::NotFound
  ))
{
  TAO_Object_Adapter::Servant_Upcall servant_upcall (
      _collocated_tao_target_->_stubobj ()->servant_orb_var ()->orb_core ()
    );
  CORBA::Object_var forward_to;
  servant_upcall.prepare_for_upcall (
      _collocated_tao_target_->_object_key (),
      "remove_server_in_location",
      forward_to.out ()
      ACE_ENV_ARG_PARAMETER
    );
  ACE_CHECK;
  
  servant_upcall.pre_invoke_collocated_request (
      ACE_ENV_SINGLE_ARG_PARAMETER
    );
  ACE_CHECK;
  
  ACE_reinterpret_cast (
      POA_ImplementationRepository::Locator_ptr,
      servant_upcall.servant ()->_downcast (
          "IDL:ImplementationRepository/Locator:1.0"
        )
    )->remove_server_in_location (
        server,
        location ACE_ENV_ARG_PARAMETER
      );
}

void POA_ImplementationRepository::_TAO_Locator_ThruPOA_Proxy_Impl::shutdown_server_in_location (
    CORBA_Object *_collocated_tao_target_,
    const char * server,
    const char * location
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
    , ImplementationRepository::NotFound
  ))
{
  TAO_Object_Adapter::Servant_Upcall servant_upcall (
      _collocated_tao_target_->_stubobj ()->servant_orb_var ()->orb_core ()
    );
  CORBA::Object_var forward_to;
  servant_upcall.prepare_for_upcall (
      _collocated_tao_target_->_object_key (),
      "shutdown_server_in_location",
      forward_to.out ()
      ACE_ENV_ARG_PARAMETER
    );
  ACE_CHECK;
  
  servant_upcall.pre_invoke_collocated_request (
      ACE_ENV_SINGLE_ARG_PARAMETER
    );
  ACE_CHECK;
  
  ACE_reinterpret_cast (
      POA_ImplementationRepository::Locator_ptr,
      servant_upcall.servant ()->_downcast (
          "IDL:ImplementationRepository/Locator:1.0"
        )
    )->shutdown_server_in_location (
        server,
        location ACE_ENV_ARG_PARAMETER
      );
}

void POA_ImplementationRepository::_TAO_Locator_ThruPOA_Proxy_Impl::server_is_shutting_down_in_location (
    CORBA_Object *_collocated_tao_target_,
    const char * server,
    const char * location
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
    , ImplementationRepository::NotFound
  ))
{
  TAO_Object_Adapter::Servant_Upcall servant_upcall (
      _collocated_tao_target_->_stubobj ()->servant_orb_var ()->orb_core ()
    );
  CORBA::Object_var forward_to;
  servant_upcall.prepare_for_upcall (
      _collocated_tao_target_->_object_key (),
      "server_is_shutting_down_in_location",
      forward_to.out ()
      ACE_ENV_ARG_PARAMETER
    );
  ACE_CHECK;
  
  servant_upcall.pre_invoke_collocated_request (
      ACE_ENV_SINGLE_ARG_PARAMETER
    );
  ACE_CHECK;
  
  ACE_reinterpret_cast (
      POA_ImplementationRepository::Locator_ptr,
      servant_upcall.servant ()->_downcast (
          "IDL:ImplementationRepository/Locator:1.0"
        )
    )->server_is_shutting_down_in_location (
        server,
        location ACE_ENV_ARG_PARAMETER
      );
}

CORBA::ULong POA_ImplementationRepository::_TAO_Locator_ThruPOA_Proxy_Impl::register_activator (
    CORBA_Object *_collocated_tao_target_,
    const char * location,
    CORBA::Object_ptr object_ref
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
    , ImplementationRepository::AlreadyRegistered
  ))
{
  CORBA::ULong _tao_retval = 0;
  ACE_UNUSED_ARG (_tao_retval);
  TAO_Object_Adapter::Servant_Upcall servant_upcall (
      _collocated_tao_target_->_stubobj ()->servant_orb_var ()->orb_core ()
    );
  CORBA::Object_var forward_to;
  servant_upcall.prepare_for_upcall (
      _collocated_tao_target_->_object_key (),
      "register_activator",
      forward_to.out ()
      ACE_ENV_ARG_PARAMETER
    );
  ACE_CHECK_RETURN (_tao_retval);
  
  servant_upcall.pre_invoke_collocated_request (
      ACE_ENV_SINGLE_ARG_PARAMETER
    );
  ACE_CHECK_RETURN (_tao_retval);
  
  return ACE_reinterpret_cast (
      POA_ImplementationRepository::Locator_ptr,
      servant_upcall.servant ()->_downcast (
          "IDL:ImplementationRepository/Locator:1.0"
        )
    )->register_activator (
        location,
        object_ref ACE_ENV_ARG_PARAMETER
      );
}

CORBA::ULong POA_ImplementationRepository::_TAO_Locator_ThruPOA_Proxy_Impl::unregister_activator (
    CORBA_Object *_collocated_tao_target_,
    const char * location,
    CORBA::Object_ptr object_ref
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
    , ImplementationRepository::NotFound
  ))
{
  CORBA::ULong _tao_retval = 0;
  ACE_UNUSED_ARG (_tao_retval);
  TAO_Object_Adapter::Servant_Upcall servant_upcall (
      _collocated_tao_target_->_stubobj ()->servant_orb_var ()->orb_core ()
    );
  CORBA::Object_var forward_to;
  servant_upcall.prepare_for_upcall (
      _collocated_tao_target_->_object_key (),
      "unregister_activator",
      forward_to.out ()
      ACE_ENV_ARG_PARAMETER
    );
  ACE_CHECK_RETURN (_tao_retval);
  
  servant_upcall.pre_invoke_collocated_request (
      ACE_ENV_SINGLE_ARG_PARAMETER
    );
  ACE_CHECK_RETURN (_tao_retval);
  
  return ACE_reinterpret_cast (
      POA_ImplementationRepository::Locator_ptr,
      servant_upcall.servant ()->_downcast (
          "IDL:ImplementationRepository/Locator:1.0"
        )
    )->unregister_activator (
        location,
        object_ref ACE_ENV_ARG_PARAMETER
      );
}

//
//           End ThruPOA Proxy Implementation
///////////////////////////////////////////////////////////////////////


///////////////////////////////////////////////////////////////////////
//                 Direct Proxy  Implementation
//

POA_ImplementationRepository::_TAO_Locator_Direct_Proxy_Impl::_TAO_Locator_Direct_Proxy_Impl (void)
{}

void POA_ImplementationRepository::_TAO_Locator_Direct_Proxy_Impl::activate_server_in_location  (
    CORBA_Object *_collocated_tao_target_,
    const char * server,
    const char * location
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
    , ImplementationRepository::NotFound
    , ImplementationRepository::CannotActivate
  ))
{
  ACE_reinterpret_cast (
      POA_ImplementationRepository::Locator_ptr,
      _collocated_tao_target_->_servant ()->_downcast ("IDL:ImplementationRepository/Locator:1.0")
    )->activate_server_in_location (
          server,
          location ACE_ENV_ARG_PARAMETER
        );
  
}

void POA_ImplementationRepository::_TAO_Locator_Direct_Proxy_Impl::remove_server_in_location  (
    CORBA_Object *_collocated_tao_target_,
    const char * server,
    const char * location
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
    , ImplementationRepository::NotFound
  ))
{
  ACE_reinterpret_cast (
      POA_ImplementationRepository::Locator_ptr,
      _collocated_tao_target_->_servant ()->_downcast ("IDL:ImplementationRepository/Locator:1.0")
    )->remove_server_in_location (
          server,
          location ACE_ENV_ARG_PARAMETER
        );
  
}

void POA_ImplementationRepository::_TAO_Locator_Direct_Proxy_Impl::shutdown_server_in_location  (
    CORBA_Object *_collocated_tao_target_,
    const char * server,
    const char * location
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
    , ImplementationRepository::NotFound
  ))
{
  ACE_reinterpret_cast (
      POA_ImplementationRepository::Locator_ptr,
      _collocated_tao_target_->_servant ()->_downcast ("IDL:ImplementationRepository/Locator:1.0")
    )->shutdown_server_in_location (
          server,
          location ACE_ENV_ARG_PARAMETER
        );
  
}

void POA_ImplementationRepository::_TAO_Locator_Direct_Proxy_Impl::server_is_shutting_down_in_location  (
    CORBA_Object *_collocated_tao_target_,
    const char * server,
    const char * location
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
    , ImplementationRepository::NotFound
  ))
{
  ACE_reinterpret_cast (
      POA_ImplementationRepository::Locator_ptr,
      _collocated_tao_target_->_servant ()->_downcast ("IDL:ImplementationRepository/Locator:1.0")
    )->server_is_shutting_down_in_location (
          server,
          location ACE_ENV_ARG_PARAMETER
        );
  
}

CORBA::ULong POA_ImplementationRepository::_TAO_Locator_Direct_Proxy_Impl::register_activator  (
    CORBA_Object *_collocated_tao_target_,
    const char * location,
    CORBA::Object_ptr object_ref
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
    , ImplementationRepository::AlreadyRegistered
  ))
{
  return ACE_reinterpret_cast (
      POA_ImplementationRepository::Locator_ptr,
      _collocated_tao_target_->_servant ()->_downcast ("IDL:ImplementationRepository/Locator:1.0")
    )->register_activator (
          location,
          object_ref ACE_ENV_ARG_PARAMETER
        );
  
}

CORBA::ULong POA_ImplementationRepository::_TAO_Locator_Direct_Proxy_Impl::unregister_activator  (
    CORBA_Object *_collocated_tao_target_,
    const char * location,
    CORBA::Object_ptr object_ref
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
    , ImplementationRepository::NotFound
  ))
{
  return ACE_reinterpret_cast (
      POA_ImplementationRepository::Locator_ptr,
      _collocated_tao_target_->_servant ()->_downcast ("IDL:ImplementationRepository/Locator:1.0")
    )->unregister_activator (
          location,
          object_ref ACE_ENV_ARG_PARAMETER
        );
  
}


//
//           End Direct Proxy Implementation
///////////////////////////////////////////////////////////////////////

// TAO_IDL - Generated from 
// be/be_visitor_interface/interface_ss.cpp:98

POA_ImplementationRepository::Locator::Locator (void)
{
  this->optable_ = &tao_ImplementationRepository_Locator_optable;
}

POA_ImplementationRepository::Locator::Locator (const Locator& rhs)
  :  ACE_NESTED_CLASS (POA_ImplementationRepository,Administration) (rhs),
    TAO_ServantBase (rhs)
{}

POA_ImplementationRepository::Locator::~Locator (void)
{
}

// TAO_IDL - Generated from 
// be/be_visitor_operation/operation_ss.cpp:103

void POA_ImplementationRepository::Locator::activate_server_in_location_skel (
    TAO_ServerRequest &_tao_server_request,
    void *_tao_servant,
    void *_tao_servant_upcall
    ACE_ENV_ARG_DECL
  )
{
  TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
  POA_ImplementationRepository::Locator *_tao_impl =
    ACE_static_cast (
        POA_ImplementationRepository::Locator *,
        _tao_servant
      );
  _tao_server_request.argument_flag (0);
    CORBA::String_var server;
  CORBA::String_var location;
  if (!(
    (_tao_in >> server.out ()) &&
    (_tao_in >> location.out ())
  ))
ACE_THROW (CORBA::MARSHAL ());


#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_Object_Adapter::Servant_Upcall *_tao_upcall =
    ACE_static_cast (TAO_Object_Adapter::Servant_Upcall *, _tao_servant_upcall);
  
  TAO_ServerRequestInterceptor_Adapter _tao_vfr (
      _tao_server_request.orb_core ()->server_request_interceptors (),
      _tao_server_request.interceptor_count ()
    );
  
  TAO_ServerRequestInfo_ImplementationRepository_Locator_activate_server_in_location _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl,
      server.in (),
      location.in () ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO_PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                           1  /* Copy TSC to RSC */);
        
        _tao_vfr.receive_request (&_tao_ri ACE_ENV_ARG_PARAMETER);
        ACE_TRY_CHECK;
        
        if (!_tao_vfr.location_forwarded ())
          {
            
#endif /* TAO_HAS_INTERCEPTORS */
            
            _tao_impl->activate_server_in_location (
                server.in (),
                location.in () ACE_ENV_ARG_PARAMETER
              );
            TAO_INTERCEPTOR_CHECK;
            
#if (TAO_HAS_INTERCEPTORS == 1)
            
          }
      }
      
      if (!_tao_vfr.location_forwarded ())
        {
          _tao_ri.reply_status (PortableInterceptor::SUCCESSFUL);
          _tao_vfr.send_reply (&_tao_ri ACE_ENV_ARG_PARAMETER);
          ACE_TRY_CHECK;
        }
    }
  ACE_CATCHANY
    {
      _tao_ri.exception (&ACE_ANY_EXCEPTION);
      _tao_vfr.send_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.send_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;
#endif /* TAO_HAS_INTERCEPTORS */
  
  _tao_server_request.init_reply ();
  
  // In case _tao_servant_upcall is not used in this function
  ACE_UNUSED_ARG (_tao_servant_upcall);
}

// TAO_IDL - Generated from 
// be/be_visitor_operation/operation_ss.cpp:103

void POA_ImplementationRepository::Locator::remove_server_in_location_skel (
    TAO_ServerRequest &_tao_server_request,
    void *_tao_servant,
    void *_tao_servant_upcall
    ACE_ENV_ARG_DECL
  )
{
  TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
  POA_ImplementationRepository::Locator *_tao_impl =
    ACE_static_cast (
        POA_ImplementationRepository::Locator *,
        _tao_servant
      );
  _tao_server_request.argument_flag (0);
    CORBA::String_var server;
  CORBA::String_var location;
  if (!(
    (_tao_in >> server.out ()) &&
    (_tao_in >> location.out ())
  ))
ACE_THROW (CORBA::MARSHAL ());


#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_Object_Adapter::Servant_Upcall *_tao_upcall =
    ACE_static_cast (TAO_Object_Adapter::Servant_Upcall *, _tao_servant_upcall);
  
  TAO_ServerRequestInterceptor_Adapter _tao_vfr (
      _tao_server_request.orb_core ()->server_request_interceptors (),
      _tao_server_request.interceptor_count ()
    );
  
  TAO_ServerRequestInfo_ImplementationRepository_Locator_remove_server_in_location _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl,
      server.in (),
      location.in () ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO_PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                           1  /* Copy TSC to RSC */);
        
        _tao_vfr.receive_request (&_tao_ri ACE_ENV_ARG_PARAMETER);
        ACE_TRY_CHECK;
        
        if (!_tao_vfr.location_forwarded ())
          {
            
#endif /* TAO_HAS_INTERCEPTORS */
            
            _tao_impl->remove_server_in_location (
                server.in (),
                location.in () ACE_ENV_ARG_PARAMETER
              );
            TAO_INTERCEPTOR_CHECK;
            
#if (TAO_HAS_INTERCEPTORS == 1)
            
          }
      }
      
      if (!_tao_vfr.location_forwarded ())
        {
          _tao_ri.reply_status (PortableInterceptor::SUCCESSFUL);
          _tao_vfr.send_reply (&_tao_ri ACE_ENV_ARG_PARAMETER);
          ACE_TRY_CHECK;
        }
    }
  ACE_CATCHANY
    {
      _tao_ri.exception (&ACE_ANY_EXCEPTION);
      _tao_vfr.send_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.send_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;
#endif /* TAO_HAS_INTERCEPTORS */
  
  _tao_server_request.init_reply ();
  
  // In case _tao_servant_upcall is not used in this function
  ACE_UNUSED_ARG (_tao_servant_upcall);
}

// TAO_IDL - Generated from 
// be/be_visitor_operation/operation_ss.cpp:103

void POA_ImplementationRepository::Locator::shutdown_server_in_location_skel (
    TAO_ServerRequest &_tao_server_request,
    void *_tao_servant,
    void *_tao_servant_upcall
    ACE_ENV_ARG_DECL
  )
{
  TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
  POA_ImplementationRepository::Locator *_tao_impl =
    ACE_static_cast (
        POA_ImplementationRepository::Locator *,
        _tao_servant
      );
  _tao_server_request.argument_flag (0);
    CORBA::String_var server;
  CORBA::String_var location;
  if (!(
    (_tao_in >> server.out ()) &&
    (_tao_in >> location.out ())
  ))
ACE_THROW (CORBA::MARSHAL ());


#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_Object_Adapter::Servant_Upcall *_tao_upcall =
    ACE_static_cast (TAO_Object_Adapter::Servant_Upcall *, _tao_servant_upcall);
  
  TAO_ServerRequestInterceptor_Adapter _tao_vfr (
      _tao_server_request.orb_core ()->server_request_interceptors (),
      _tao_server_request.interceptor_count ()
    );
  
  TAO_ServerRequestInfo_ImplementationRepository_Locator_shutdown_server_in_location _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl,
      server.in (),
      location.in () ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO_PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                           1  /* Copy TSC to RSC */);
        
        _tao_vfr.receive_request (&_tao_ri ACE_ENV_ARG_PARAMETER);
        ACE_TRY_CHECK;
        
        if (!_tao_vfr.location_forwarded ())
          {
            
#endif /* TAO_HAS_INTERCEPTORS */
            
            _tao_impl->shutdown_server_in_location (
                server.in (),
                location.in () ACE_ENV_ARG_PARAMETER
              );
            TAO_INTERCEPTOR_CHECK;
            
#if (TAO_HAS_INTERCEPTORS == 1)
            
          }
      }
      
      if (!_tao_vfr.location_forwarded ())
        {
          _tao_ri.reply_status (PortableInterceptor::SUCCESSFUL);
          _tao_vfr.send_reply (&_tao_ri ACE_ENV_ARG_PARAMETER);
          ACE_TRY_CHECK;
        }
    }
  ACE_CATCHANY
    {
      _tao_ri.exception (&ACE_ANY_EXCEPTION);
      _tao_vfr.send_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.send_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;
#endif /* TAO_HAS_INTERCEPTORS */
  
  _tao_server_request.init_reply ();
  
  // In case _tao_servant_upcall is not used in this function
  ACE_UNUSED_ARG (_tao_servant_upcall);
}

// TAO_IDL - Generated from 
// be/be_visitor_operation/operation_ss.cpp:103

void POA_ImplementationRepository::Locator::server_is_shutting_down_in_location_skel (
    TAO_ServerRequest &_tao_server_request,
    void *_tao_servant,
    void *_tao_servant_upcall
    ACE_ENV_ARG_DECL
  )
{
  TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
  POA_ImplementationRepository::Locator *_tao_impl =
    ACE_static_cast (
        POA_ImplementationRepository::Locator *,
        _tao_servant
      );
  _tao_server_request.argument_flag (0);
    CORBA::String_var server;
  CORBA::String_var location;
  if (!(
    (_tao_in >> server.out ()) &&
    (_tao_in >> location.out ())
  ))
ACE_THROW (CORBA::MARSHAL ());


#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_Object_Adapter::Servant_Upcall *_tao_upcall =
    ACE_static_cast (TAO_Object_Adapter::Servant_Upcall *, _tao_servant_upcall);
  
  TAO_ServerRequestInterceptor_Adapter _tao_vfr (
      _tao_server_request.orb_core ()->server_request_interceptors (),
      _tao_server_request.interceptor_count ()
    );
  
  TAO_ServerRequestInfo_ImplementationRepository_Locator_server_is_shutting_down_in_location _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl,
      server.in (),
      location.in () ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO_PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                           1  /* Copy TSC to RSC */);
        
        _tao_vfr.receive_request (&_tao_ri ACE_ENV_ARG_PARAMETER);
        ACE_TRY_CHECK;
        
        if (!_tao_vfr.location_forwarded ())
          {
            
#endif /* TAO_HAS_INTERCEPTORS */
            
            _tao_impl->server_is_shutting_down_in_location (
                server.in (),
                location.in () ACE_ENV_ARG_PARAMETER
              );
            TAO_INTERCEPTOR_CHECK;
            
#if (TAO_HAS_INTERCEPTORS == 1)
            
          }
      }
      
      if (!_tao_vfr.location_forwarded ())
        {
          _tao_ri.reply_status (PortableInterceptor::SUCCESSFUL);
          _tao_vfr.send_reply (&_tao_ri ACE_ENV_ARG_PARAMETER);
          ACE_TRY_CHECK;
        }
    }
  ACE_CATCHANY
    {
      _tao_ri.exception (&ACE_ANY_EXCEPTION);
      _tao_vfr.send_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.send_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;
#endif /* TAO_HAS_INTERCEPTORS */
  
  _tao_server_request.init_reply ();
  
  // In case _tao_servant_upcall is not used in this function
  ACE_UNUSED_ARG (_tao_servant_upcall);
}

// TAO_IDL - Generated from 
// be/be_visitor_operation/operation_ss.cpp:103

void POA_ImplementationRepository::Locator::register_activator_skel (
    TAO_ServerRequest &_tao_server_request,
    void *_tao_servant,
    void *_tao_servant_upcall
    ACE_ENV_ARG_DECL
  )
{
  TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
  POA_ImplementationRepository::Locator *_tao_impl =
    ACE_static_cast (
        POA_ImplementationRepository::Locator *,
        _tao_servant
      );
  CORBA::ULong _tao_retval = 0;
  CORBA::String_var location;
  CORBA::Object_var object_ref;
  if (!(
    (_tao_in >> location.out ()) &&
    (_tao_in >> object_ref.out ())
  ))
ACE_THROW (CORBA::MARSHAL ());


#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_Object_Adapter::Servant_Upcall *_tao_upcall =
    ACE_static_cast (TAO_Object_Adapter::Servant_Upcall *, _tao_servant_upcall);
  
  TAO_ServerRequestInterceptor_Adapter _tao_vfr (
      _tao_server_request.orb_core ()->server_request_interceptors (),
      _tao_server_request.interceptor_count ()
    );
  
  TAO_ServerRequestInfo_ImplementationRepository_Locator_register_activator _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl,
      location.in (),
      object_ref.in () ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO_PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                           1  /* Copy TSC to RSC */);
        
        _tao_vfr.receive_request (&_tao_ri ACE_ENV_ARG_PARAMETER);
        ACE_TRY_CHECK;
        
        if (!_tao_vfr.location_forwarded ())
          {
            
#endif /* TAO_HAS_INTERCEPTORS */
            _tao_retval = 
            _tao_impl->register_activator (
                location.in (),
                object_ref.in () ACE_ENV_ARG_PARAMETER
              );
            TAO_INTERCEPTOR_CHECK;
            
#if (TAO_HAS_INTERCEPTORS == 1)
            
          }
      }
      
      if (!_tao_vfr.location_forwarded ())
        {
          CORBA::ULong _tao_retval_info = _tao_retval;
          _tao_ri.result (_tao_retval_info);
          _tao_ri.reply_status (PortableInterceptor::SUCCESSFUL);
          _tao_vfr.send_reply (&_tao_ri ACE_ENV_ARG_PARAMETER);
          ACE_TRY_CHECK;
        }
    }
  ACE_CATCHANY
    {
      _tao_ri.exception (&ACE_ANY_EXCEPTION);
      _tao_vfr.send_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.send_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;
#endif /* TAO_HAS_INTERCEPTORS */
  
  _tao_server_request.init_reply ();
  
  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
  
  if (!(
(_tao_out << _tao_retval)
    ))
ACE_THROW (CORBA::MARSHAL ());

  // In case _tao_servant_upcall is not used in this function
  ACE_UNUSED_ARG (_tao_servant_upcall);
}

// TAO_IDL - Generated from 
// be/be_visitor_operation/operation_ss.cpp:103

void POA_ImplementationRepository::Locator::unregister_activator_skel (
    TAO_ServerRequest &_tao_server_request,
    void *_tao_servant,
    void *_tao_servant_upcall
    ACE_ENV_ARG_DECL
  )
{
  TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
  POA_ImplementationRepository::Locator *_tao_impl =
    ACE_static_cast (
        POA_ImplementationRepository::Locator *,
        _tao_servant
      );
  CORBA::ULong _tao_retval = 0;
  CORBA::String_var location;
  CORBA::Object_var object_ref;
  if (!(
    (_tao_in >> location.out ()) &&
    (_tao_in >> object_ref.out ())
  ))
ACE_THROW (CORBA::MARSHAL ());


#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_Object_Adapter::Servant_Upcall *_tao_upcall =
    ACE_static_cast (TAO_Object_Adapter::Servant_Upcall *, _tao_servant_upcall);
  
  TAO_ServerRequestInterceptor_Adapter _tao_vfr (
      _tao_server_request.orb_core ()->server_request_interceptors (),
      _tao_server_request.interceptor_count ()
    );
  
  TAO_ServerRequestInfo_ImplementationRepository_Locator_unregister_activator _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl,
      location.in (),
      object_ref.in () ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO_PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                           1  /* Copy TSC to RSC */);
        
        _tao_vfr.receive_request (&_tao_ri ACE_ENV_ARG_PARAMETER);
        ACE_TRY_CHECK;
        
        if (!_tao_vfr.location_forwarded ())
          {
            
#endif /* TAO_HAS_INTERCEPTORS */
            _tao_retval = 
            _tao_impl->unregister_activator (
                location.in (),
                object_ref.in () ACE_ENV_ARG_PARAMETER
              );
            TAO_INTERCEPTOR_CHECK;
            
#if (TAO_HAS_INTERCEPTORS == 1)
            
          }
      }
      
      if (!_tao_vfr.location_forwarded ())
        {
          CORBA::ULong _tao_retval_info = _tao_retval;
          _tao_ri.result (_tao_retval_info);
          _tao_ri.reply_status (PortableInterceptor::SUCCESSFUL);
          _tao_vfr.send_reply (&_tao_ri ACE_ENV_ARG_PARAMETER);
          ACE_TRY_CHECK;
        }
    }
  ACE_CATCHANY
    {
      _tao_ri.exception (&ACE_ANY_EXCEPTION);
      _tao_vfr.send_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.send_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;
#endif /* TAO_HAS_INTERCEPTORS */
  
  _tao_server_request.init_reply ();
  
  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
  
  if (!(
(_tao_out << _tao_retval)
    ))
ACE_THROW (CORBA::MARSHAL ());

  // In case _tao_servant_upcall is not used in this function
  ACE_UNUSED_ARG (_tao_servant_upcall);
}

// TAO_IDL - Generated from 
// be/be_visitor_interface/interface_ss.cpp:163

void POA_ImplementationRepository::Locator::_is_a_skel (
    TAO_ServerRequest &_tao_server_request, 
    void * _tao_servant,
    void * /* Servant_Upcall */
    ACE_ENV_ARG_DECL
  )
{
  TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
  POA_ImplementationRepository::Locator *_tao_impl = (POA_ImplementationRepository::Locator *) _tao_servant;
  CORBA::Boolean _tao_retval = 0;
  CORBA::String_var value;
  if (!(_tao_in >> value.out ()))
    ACE_THROW (CORBA::MARSHAL ());
  
  _tao_retval = _tao_impl->_is_a (value.in () ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
  
  _tao_server_request.init_reply ();
  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
  if (!(_tao_out << CORBA::Any::from_boolean (_tao_retval)))
    ACE_THROW (CORBA::MARSHAL ());
}

void POA_ImplementationRepository::Locator::_non_existent_skel (
    TAO_ServerRequest &_tao_server_request, 
    void * _tao_servant,
    void * /* Servant_Upcall */
    ACE_ENV_ARG_DECL
  )
{
  POA_ImplementationRepository::Locator *_tao_impl = (POA_ImplementationRepository::Locator *) _tao_servant;
  CORBA::Boolean _tao_retval =
    _tao_impl->_non_existent (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK;
  
  _tao_server_request.init_reply ();
  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
  if (!(_tao_out << CORBA::Any::from_boolean (_tao_retval)))
    ACE_THROW (CORBA::MARSHAL ());
}

void POA_ImplementationRepository::Locator::_interface_skel (
    TAO_ServerRequest &_tao_server_request, 
    void * _tao_servant,
    void * /* Servant_Upcall */
    ACE_ENV_ARG_DECL
  )
{
  POA_ImplementationRepository::Locator *_tao_impl = (POA_ImplementationRepository::Locator *) _tao_servant;
  CORBA_InterfaceDef_ptr _tao_retval = 0;
  CORBA::Boolean _tao_result = 0;
  
  TAO_IFR_Client_Adapter *_tao_adapter =
    ACE_Dynamic_Service<TAO_IFR_Client_Adapter>::instance (
        TAO_ORB_Core::ifr_client_adapter_name ()
      );
    
  if (_tao_adapter == 0)
    {
      ACE_THROW (CORBA::INTF_REPOS ());
    }
  
  ACE_TRY
    {
      _tao_retval = 
        _tao_impl->_get_interface (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_TRY_CHECK;
      
      _tao_server_request.init_reply ();
      
      TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
      
      _tao_result =
        _tao_adapter->interfacedef_cdr_insert (
            _tao_out,
            _tao_retval
          );
    }
  ACE_CATCHALL
    {
      _tao_adapter->dispose (_tao_retval);
    }
  ACE_ENDTRY;
  
  if (_tao_result == 0)
    {
      ACE_THROW (CORBA::MARSHAL ());
    }
}

void POA_ImplementationRepository::Locator::_component_skel (
    TAO_ServerRequest &_tao_server_request, 
    void * _tao_object_reference,
    void * /* Servant_Upcall */
    ACE_ENV_ARG_DECL
  )
{
  POA_ImplementationRepository::Locator *_tao_impl = (POA_ImplementationRepository::Locator *) _tao_object_reference;
  CORBA::Object_var _tao_retval =
    _tao_impl->_get_component (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK;
  
  _tao_server_request.init_reply ();
  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
  if (!(_tao_out << _tao_retval._retn ()))
    ACE_THROW (CORBA::MARSHAL ());
}

CORBA::Boolean POA_ImplementationRepository::Locator::_is_a (
    const char* value
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  if (
      !ACE_OS::strcmp (
          (char *)value,
          "IDL:ImplementationRepository/Locator:1.0"
        ) ||
      !ACE_OS::strcmp (
          (char *)value,
          "IDL:ImplementationRepository/Administration:1.0"
        ) ||
      !ACE_OS::strcmp (
          (char *)value,
          "IDL:org.omg/CORBA/Object:1.0"
        )
     )
    {
      return 1;
    }
  else
    {
      return 0;
    }
}

void* POA_ImplementationRepository::Locator::_downcast (
    const char* logical_type_id
  )
{
  if (ACE_OS::strcmp (logical_type_id,
                      "IDL:ImplementationRepository/Locator:1.0") == 0)
    {
      return ACE_static_cast (POA_ImplementationRepository::Locator_ptr, this);
    }
  
  if (ACE_OS::strcmp (logical_type_id,
                      "IDL:ImplementationRepository/Administration:1.0") == 0)
    {
      return ACE_static_cast (POA_ImplementationRepository::Administration_ptr, this);
    }
  
  if (ACE_OS::strcmp (logical_type_id,
                      "IDL:omg.org/CORBA/Object:1.0") == 0)
    {
      return ACE_static_cast(PortableServer::Servant, this);
    }
  
  return 0;
}

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

// TAO_IDL - Generated from
// be/be_visitor_interface/interface_ss.cpp:533

void POA_ImplementationRepository::Locator::_dispatch (
    TAO_ServerRequest &req,
    void *servant_upcall
    ACE_ENV_ARG_DECL
  )
{
  this->synchronous_upcall_dispatch (req,
                                     servant_upcall,
                                     this
                                     ACE_ENV_ARG_PARAMETER);
}

// TAO_IDL - Generated from
// be/be_visitor_interface/interface_ss.cpp:479

ImplementationRepository::Locator *
POA_ImplementationRepository::Locator::_this (ACE_ENV_SINGLE_ARG_DECL)
{
  TAO_Stub *stub = this->_create_stub (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  TAO_Stub_Auto_Ptr safe_stub (stub);
  CORBA::Object_ptr tmp = CORBA::Object::_nil ();
  
  if (stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects ())
    {
      ACE_NEW_RETURN (
          tmp,
          CORBA::Object (
              stub,
              1,
              this
            ),
          0
        );
    }
  else
    {
      ACE_NEW_RETURN (
          tmp,
          CORBA::Object (
              stub,
              0,
              this
            ),
          0
        );
    }
  
  CORBA::Object_var obj = tmp;
  (void) safe_stub.release ();
  return ::ImplementationRepository::Locator::_unchecked_narrow (obj.in ());
}



#endif /* ifndef */
