// -*- C++ -*-
//
// $Id$

// ****  Code generated by the The ACE ORB (TAO) IDL Compiler ****
// TAO and the TAO IDL Compiler have been developed by:
//       Center for Distributed Object Computing
//       Washington University
//       St. Louis, MO
//       USA
//       http://www.cs.wustl.edu/~schmidt/doc-center.html
// and
//       Distributed Object Computing Laboratory
//       University of California at Irvine
//       Irvine, CA
//       USA
//       http://doc.ece.uci.edu/
// and
//       Institute for Software Integrated Systems
//       Vanderbilt University
//       Nashville, TN
//       USA
//       http://www.isis.vanderbilt.edu/
//
// Information about TAO is available at:
//     http://www.cs.wustl.edu/~schmidt/TAO.html


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

#ifndef _TAO_IDL_COSLOADBALANCINGS_CPP_
#define _TAO_IDL_COSLOADBALANCINGS_CPP_


#include "CosLoadBalancingS.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/Profile.h"
#include "tao/Stub.h"
#include "tao/IFR_Client_Adapter.h"
#include "tao/Object_T.h"
#include "tao/Typecode.h"
#include "tao/DynamicC.h"
#include "tao/CDR.h"
#include "tao/Basic_Arguments.h"
#include "tao/Object_Argument_T.h"
#include "tao/Special_Basic_Arguments.h"
#include "tao/UB_String_Arguments.h"
#include "tao/Var_Size_Argument_T.h"
#include "tao/PortableInterceptor.h"
#if TAO_HAS_INTERCEPTORS == 1
#include "tao/PortableServer/PICurrent_Guard.h"
#include "tao/PortableServer/ServerRequestInfo.h"
#include "tao/PortableServer/ServerInterceptorAdapter.h"
#include "tao/RequestInfo_Util.h"
#endif  /* TAO_HAS_INTERCEPTORS == 1 */

#include "ace/Dynamic_Service.h"
#include "ace/Malloc_Allocator.h"
#include "ace/config-all.h"

#if defined (__BORLANDC__)
#pragma option -w-rvl -w-rch -w-ccc -w-aus
#endif /* __BORLANDC__ */

#if !defined (__ACE_INLINE__)
#include "CosLoadBalancingS.inl"
#endif /* !defined __ACE_INLINE__ */

// TAO_IDL - Generated from
// be/be_visitor_arg_traits.cpp:64

// Arg traits specializations.
namespace TAO
{
  
  // TAO_IDL - Generated from
  // be/be_visitor_arg_traits.cpp:582

#if !defined (_CORBA_ANY__ARG_TRAITS_SS_)
#define _CORBA_ANY__ARG_TRAITS_SS_
  
  ACE_TEMPLATE_SPECIALIZATION
  class TAO_LoadBalancing_Export Arg_Traits<CORBA::Any>
    : public
        Var_Size_Arg_Traits_T<
            CORBA::Any,
            CORBA::Any_var,
            CORBA::Any_out
          >
  {
  };

#endif /* end #if !defined */
  
  // TAO_IDL - Generated from
  // be/be_visitor_arg_traits.cpp:379

#if !defined (_COSNAMING_NAME__ARG_TRAITS_SS_)
#define _COSNAMING_NAME__ARG_TRAITS_SS_
  
  ACE_TEMPLATE_SPECIALIZATION
  class TAO_LoadBalancing_Export Arg_Traits<CosNaming::Name>
    : public
        Var_Size_Arg_Traits_T<
            CosNaming::Name,
            CosNaming::Name_var,
            CosNaming::Name_out
          >
  {
  };

#endif /* end #if !defined */
  
  // TAO_IDL - Generated from
  // be/be_visitor_arg_traits.cpp:618

#if !defined (_COSNAMING_BINDING__ARG_TRAITS_SS_)
#define _COSNAMING_BINDING__ARG_TRAITS_SS_
  
  ACE_TEMPLATE_SPECIALIZATION
  class TAO_LoadBalancing_Export Arg_Traits<CosNaming::Binding>
    : public
        Var_Size_Arg_Traits_T<
            CosNaming::Binding,
            CosNaming::Binding_var,
            CosNaming::Binding_out
          >
  {
  };

#endif /* end #if !defined */
  
  // TAO_IDL - Generated from
  // be/be_visitor_arg_traits.cpp:379

#if !defined (_COSNAMING_BINDINGLIST__ARG_TRAITS_SS_)
#define _COSNAMING_BINDINGLIST__ARG_TRAITS_SS_
  
  ACE_TEMPLATE_SPECIALIZATION
  class TAO_LoadBalancing_Export Arg_Traits<CosNaming::BindingList>
    : public
        Var_Size_Arg_Traits_T<
            CosNaming::BindingList,
            CosNaming::BindingList_var,
            CosNaming::BindingList_out
          >
  {
  };

#endif /* end #if !defined */

#if !defined (_COSNAMING_BINDINGITERATOR__ARG_TRAITS_SS_)
#define _COSNAMING_BINDINGITERATOR__ARG_TRAITS_SS_
  
  ACE_TEMPLATE_SPECIALIZATION
  class TAO_LoadBalancing_Export Arg_Traits<CosNaming::BindingIterator>
    : public
        Object_Arg_Traits_T<
            CosNaming::BindingIterator_ptr,
            CosNaming::BindingIterator_var,
            CosNaming::BindingIterator_out,
            TAO::Objref_Traits<CosNaming::BindingIterator>
          >
  {
  };

#endif /* end #if !defined */

#if !defined (_COSNAMING_NAMINGCONTEXT__ARG_TRAITS_SS_)
#define _COSNAMING_NAMINGCONTEXT__ARG_TRAITS_SS_
  
  ACE_TEMPLATE_SPECIALIZATION
  class TAO_LoadBalancing_Export Arg_Traits<CosNaming::NamingContext>
    : public
        Object_Arg_Traits_T<
            CosNaming::NamingContext_ptr,
            CosNaming::NamingContext_var,
            CosNaming::NamingContext_out,
            TAO::Objref_Traits<CosNaming::NamingContext>
          >
  {
  };

#endif /* end #if !defined */
  
  // TAO_IDL - Generated from
  // be/be_visitor_arg_traits.cpp:379

#if !defined (_PORTABLEGROUP_PROPERTIES__ARG_TRAITS_SS_)
#define _PORTABLEGROUP_PROPERTIES__ARG_TRAITS_SS_
  
  ACE_TEMPLATE_SPECIALIZATION
  class TAO_LoadBalancing_Export Arg_Traits<PortableGroup::Properties>
    : public
        Var_Size_Arg_Traits_T<
            PortableGroup::Properties,
            PortableGroup::Properties_var,
            PortableGroup::Properties_out
          >
  {
  };

#endif /* end #if !defined */
  
  // TAO_IDL - Generated from
  // be/be_visitor_arg_traits.cpp:618

#if !defined (_PORTABLEGROUP_FACTORYINFO__ARG_TRAITS_SS_)
#define _PORTABLEGROUP_FACTORYINFO__ARG_TRAITS_SS_
  
  ACE_TEMPLATE_SPECIALIZATION
  class TAO_LoadBalancing_Export Arg_Traits<PortableGroup::FactoryInfo>
    : public
        Var_Size_Arg_Traits_T<
            PortableGroup::FactoryInfo,
            PortableGroup::FactoryInfo_var,
            PortableGroup::FactoryInfo_out
          >
  {
  };

#endif /* end #if !defined */
  
  // TAO_IDL - Generated from
  // be/be_visitor_arg_traits.cpp:379

#if !defined (_COSLOADBALANCING_LOADLIST__ARG_TRAITS_SS_)
#define _COSLOADBALANCING_LOADLIST__ARG_TRAITS_SS_
  
  ACE_TEMPLATE_SPECIALIZATION
  class TAO_LoadBalancing_Export Arg_Traits<CosLoadBalancing::LoadList>
    : public
        Var_Size_Arg_Traits_T<
            CosLoadBalancing::LoadList,
            CosLoadBalancing::LoadList_var,
            CosLoadBalancing::LoadList_out
          >
  {
  };

#endif /* end #if !defined */

#if !defined (_COSLOADBALANCING_LOADMANAGER__ARG_TRAITS_SS_)
#define _COSLOADBALANCING_LOADMANAGER__ARG_TRAITS_SS_
  
  ACE_TEMPLATE_SPECIALIZATION
  class TAO_LoadBalancing_Export Arg_Traits<CosLoadBalancing::LoadManager>
    : public
        Object_Arg_Traits_T<
            CosLoadBalancing::LoadManager_ptr,
            CosLoadBalancing::LoadManager_var,
            CosLoadBalancing::LoadManager_out,
            TAO::Objref_Traits<CosLoadBalancing::LoadManager>
          >
  {
  };

#endif /* end #if !defined */

#if !defined (_COSLOADBALANCING_AMI_STRATEGYEXCEPTIONHOLDER__ARG_TRAITS_SS_)
#define _COSLOADBALANCING_AMI_STRATEGYEXCEPTIONHOLDER__ARG_TRAITS_SS_
  
  ACE_TEMPLATE_SPECIALIZATION
  class TAO_LoadBalancing_Export Arg_Traits<CosLoadBalancing::AMI_StrategyExceptionHolder>
    : public
        Object_Arg_Traits_T<
            CosLoadBalancing::AMI_StrategyExceptionHolder *,
            CosLoadBalancing::AMI_StrategyExceptionHolder_var,
            CosLoadBalancing::AMI_StrategyExceptionHolder_out,
            TAO::Value_Traits<CosLoadBalancing::AMI_StrategyExceptionHolder>
          >
  {
  };

#endif /* end #if !defined */

#if !defined (_COSLOADBALANCING_LOADALERT__ARG_TRAITS_SS_)
#define _COSLOADBALANCING_LOADALERT__ARG_TRAITS_SS_
  
  ACE_TEMPLATE_SPECIALIZATION
  class TAO_LoadBalancing_Export Arg_Traits<CosLoadBalancing::LoadAlert>
    : public
        Object_Arg_Traits_T<
            CosLoadBalancing::LoadAlert_ptr,
            CosLoadBalancing::LoadAlert_var,
            CosLoadBalancing::LoadAlert_out,
            TAO::Objref_Traits<CosLoadBalancing::LoadAlert>
          >
  {
  };

#endif /* end #if !defined */

#if !defined (_COSLOADBALANCING_AMI_LOADALERTEXCEPTIONHOLDER__ARG_TRAITS_SS_)
#define _COSLOADBALANCING_AMI_LOADALERTEXCEPTIONHOLDER__ARG_TRAITS_SS_
  
  ACE_TEMPLATE_SPECIALIZATION
  class TAO_LoadBalancing_Export Arg_Traits<CosLoadBalancing::AMI_LoadAlertExceptionHolder>
    : public
        Object_Arg_Traits_T<
            CosLoadBalancing::AMI_LoadAlertExceptionHolder *,
            CosLoadBalancing::AMI_LoadAlertExceptionHolder_var,
            CosLoadBalancing::AMI_LoadAlertExceptionHolder_out,
            TAO::Value_Traits<CosLoadBalancing::AMI_LoadAlertExceptionHolder>
          >
  {
  };

#endif /* end #if !defined */

#if !defined (_COSLOADBALANCING_LOADMONITOR__ARG_TRAITS_SS_)
#define _COSLOADBALANCING_LOADMONITOR__ARG_TRAITS_SS_
  
  ACE_TEMPLATE_SPECIALIZATION
  class TAO_LoadBalancing_Export Arg_Traits<CosLoadBalancing::LoadMonitor>
    : public
        Object_Arg_Traits_T<
            CosLoadBalancing::LoadMonitor_ptr,
            CosLoadBalancing::LoadMonitor_var,
            CosLoadBalancing::LoadMonitor_out,
            TAO::Objref_Traits<CosLoadBalancing::LoadMonitor>
          >
  {
  };

#endif /* end #if !defined */

#if !defined (_COSLOADBALANCING_AMI_LOADMONITOREXCEPTIONHOLDER__ARG_TRAITS_SS_)
#define _COSLOADBALANCING_AMI_LOADMONITOREXCEPTIONHOLDER__ARG_TRAITS_SS_
  
  ACE_TEMPLATE_SPECIALIZATION
  class TAO_LoadBalancing_Export Arg_Traits<CosLoadBalancing::AMI_LoadMonitorExceptionHolder>
    : public
        Object_Arg_Traits_T<
            CosLoadBalancing::AMI_LoadMonitorExceptionHolder *,
            CosLoadBalancing::AMI_LoadMonitorExceptionHolder_var,
            CosLoadBalancing::AMI_LoadMonitorExceptionHolder_out,
            TAO::Value_Traits<CosLoadBalancing::AMI_LoadMonitorExceptionHolder>
          >
  {
  };

#endif /* end #if !defined */

#if !defined (_COSLOADBALANCING_AMI_LOADMANAGEREXCEPTIONHOLDER__ARG_TRAITS_SS_)
#define _COSLOADBALANCING_AMI_LOADMANAGEREXCEPTIONHOLDER__ARG_TRAITS_SS_
  
  ACE_TEMPLATE_SPECIALIZATION
  class TAO_LoadBalancing_Export Arg_Traits<CosLoadBalancing::AMI_LoadManagerExceptionHolder>
    : public
        Object_Arg_Traits_T<
            CosLoadBalancing::AMI_LoadManagerExceptionHolder *,
            CosLoadBalancing::AMI_LoadManagerExceptionHolder_var,
            CosLoadBalancing::AMI_LoadManagerExceptionHolder_out,
            TAO::Value_Traits<CosLoadBalancing::AMI_LoadManagerExceptionHolder>
          >
  {
  };

#endif /* end #if !defined */
}


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

class TAO_CosLoadBalancing_Strategy_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: /work/a/ports/devel/ace+tao/work/ACE_wrappers/bin/gperf -m -M -J -c -C -D -E -T -f 0 -F 0,0,0 -a -o -t -p -K opname_ -L C++ -Z TAO_CosLoadBalancing_Strategy_Perfect_Hash_OpTable -N lookup  */
unsigned int
TAO_CosLoadBalancing_Strategy_Perfect_Hash_OpTable::hash (const char *str, unsigned int len)
{
  static const unsigned char asso_values[] =
    {
#if defined (ACE_MVS)
     29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
     29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
     29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
     29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
     29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
     29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
     29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
     29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
     29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
     29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
     29, 29, 29, 29, 29, 29, 29, 29, 29,  0,
     29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
     29, 29, 29, 29, 29, 29, 29, 29, 29, 15,
     29, 29, 29, 15, 29,  0, 29, 29, 29, 29,
     29, 29, 29, 29, 29, 29, 29, 29, 29,  0,
     29,  5, 29,  0, 29, 29, 29, 29, 29, 29,
     29, 29,  0,  0, 29, 29, 29, 29, 29, 29,
     29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
     29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
     29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
     29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
     29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
     29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
     29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
     29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
     29, 29, 29, 29, 29, 29,
#else
     29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
     29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
     29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
     29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
     29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
     29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
     29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
     29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
     29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
     29, 29, 29, 29, 29,  0, 29, 15, 29, 29,
     29, 15, 29,  0, 29, 29, 29, 29, 29, 29,
      0, 29,  5, 29,  0,  0,  0, 29, 29, 29,
     29, 29, 29, 29, 29, 29, 29, 29,
#endif /* ACE_MVS */
    };
  return len + asso_values[(int) str[len - 1]] + asso_values[(int) str[0]];
}

const class TAO_operation_db_entry *
TAO_CosLoadBalancing_Strategy_Perfect_Hash_OpTable::lookup (const char *str, unsigned int len)
{
  enum
    {
      TOTAL_KEYWORDS = 10,
      MIN_WORD_LENGTH = 5,
      MAX_WORD_LENGTH = 14,
      MIN_HASH_VALUE = 9,
      MAX_HASH_VALUE = 28,
      HASH_VALUE_RANGE = 20,
      DUPLICATES = 0,
      WORDLIST_SIZE = 19
    };

  static const class TAO_operation_db_entry  wordlist[] =
    {
      {"",0,0,0},{"",0,0,0},{"",0,0,0},{"",0,0,0},{"",0,0,0},{"",0,0,0},{"",0,0,0},{"",0,0,0},{"",0,0,0},
            {"get_loads", &POA_CosLoadBalancing::Strategy::get_loads_skel, &POA_CosLoadBalancing::_TAO_Strategy_ThruPOA_Proxy_Impl::get_loads, 0},
      {"_component", &POA_CosLoadBalancing::Strategy::_component_skel, 0, 0},
      {"next_member", &POA_CosLoadBalancing::Strategy::next_member_skel, &POA_CosLoadBalancing::_TAO_Strategy_ThruPOA_Proxy_Impl::next_member, 0},
      {"",0,0,0},
      {"_non_existent", &POA_CosLoadBalancing::Strategy::_non_existent_skel, 0, 0},
      {"get_properties", &POA_CosLoadBalancing::Strategy::get_properties_skel, &POA_CosLoadBalancing::_TAO_Strategy_ThruPOA_Proxy_Impl::get_properties, 0},
      {"push_loads", &POA_CosLoadBalancing::Strategy::push_loads_skel, &POA_CosLoadBalancing::_TAO_Strategy_ThruPOA_Proxy_Impl::push_loads, 0},
      {"",0,0,0},{"",0,0,0},{"",0,0,0},{"",0,0,0},
      {"_is_a", &POA_CosLoadBalancing::Strategy::_is_a_skel, 0, 0},
      {"",0,0,0},{"",0,0,0},{"",0,0,0},
      {"_get_name", &POA_CosLoadBalancing::Strategy::_get_name_skel, &POA_CosLoadBalancing::_TAO_Strategy_ThruPOA_Proxy_Impl::_get_name, 0},
      {"_interface", &POA_CosLoadBalancing::Strategy::_interface_skel, 0, 0},
      {"",0,0,0},{"",0,0,0},
      {"analyze_loads", &POA_CosLoadBalancing::Strategy::analyze_loads_skel, &POA_CosLoadBalancing::_TAO_Strategy_ThruPOA_Proxy_Impl::analyze_loads, 0},
    };

  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_CosLoadBalancing_Strategy_Perfect_Hash_OpTable tao_CosLoadBalancing_Strategy_optable;

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

#if (TAO_HAS_INTERCEPTORS == 1)

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:74

class TAO_ServerRequestInfo_CosLoadBalancing_Strategy_name_get : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_CosLoadBalancing_Strategy_name_get (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_CosLoadBalancing::Strategy *tao_impl
      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 (char * result);

private:
  TAO_ServerRequestInfo_CosLoadBalancing_Strategy_name_get (
      const TAO_ServerRequestInfo_CosLoadBalancing_Strategy_name_get &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_CosLoadBalancing_Strategy_name_get &
    );
  
private:
  POA_CosLoadBalancing::Strategy *_tao_impl;
  
  char * _result;
};

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:438

TAO_ServerRequestInfo_CosLoadBalancing_Strategy_name_get::TAO_ServerRequestInfo_CosLoadBalancing_Strategy_name_get (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_CosLoadBalancing::Strategy *tao_impl
    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl)
{}

Dynamic::ParameterList *
TAO_ServerRequestInfo_CosLoadBalancing_Strategy_name_get::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_ServerRequestInfo_CosLoadBalancing_Strategy_name_get::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_ServerRequestInfo_CosLoadBalancing_Strategy_name_get::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_CosLoadBalancing_Strategy_name_get::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_CosLoadBalancing_Strategy_name_get::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_CosLoadBalancing_Strategy_name_get::result (char * result)
{
  // Update the result.
   this->_result = result;
}

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:74

class TAO_ServerRequestInfo_CosLoadBalancing_Strategy_get_properties : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_CosLoadBalancing_Strategy_get_properties (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_CosLoadBalancing::Strategy *tao_impl
      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 (::CosLoadBalancing::Properties * result);

private:
  TAO_ServerRequestInfo_CosLoadBalancing_Strategy_get_properties (
      const TAO_ServerRequestInfo_CosLoadBalancing_Strategy_get_properties &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_CosLoadBalancing_Strategy_get_properties &
    );
  
private:
  POA_CosLoadBalancing::Strategy *_tao_impl;
  
  ::CosLoadBalancing::Properties * _result;
};

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:438

TAO_ServerRequestInfo_CosLoadBalancing_Strategy_get_properties::TAO_ServerRequestInfo_CosLoadBalancing_Strategy_get_properties (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_CosLoadBalancing::Strategy *tao_impl
    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl)
{}

Dynamic::ParameterList *
TAO_ServerRequestInfo_CosLoadBalancing_Strategy_get_properties::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_ServerRequestInfo_CosLoadBalancing_Strategy_get_properties::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_ServerRequestInfo_CosLoadBalancing_Strategy_get_properties::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_CosLoadBalancing_Strategy_get_properties::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_CosLoadBalancing_Strategy_get_properties::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_CosLoadBalancing_Strategy_get_properties::result (::CosLoadBalancing::Properties * result)
{
  // Update the result.
   this->_result = result;
}

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:74

class TAO_ServerRequestInfo_CosLoadBalancing_Strategy_push_loads : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_CosLoadBalancing_Strategy_push_loads (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_CosLoadBalancing::Strategy *tao_impl,
      const ::PortableGroup::Location & the_location,
      const ::CosLoadBalancing::LoadList & loads
      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_CosLoadBalancing_Strategy_push_loads (
      const TAO_ServerRequestInfo_CosLoadBalancing_Strategy_push_loads &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_CosLoadBalancing_Strategy_push_loads &
    );
  
private:
  POA_CosLoadBalancing::Strategy *_tao_impl;
  
  const ::PortableGroup::Location & the_location_;
  const ::CosLoadBalancing::LoadList & loads_;
};

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:438

TAO_ServerRequestInfo_CosLoadBalancing_Strategy_push_loads::TAO_ServerRequestInfo_CosLoadBalancing_Strategy_push_loads (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_CosLoadBalancing::Strategy *tao_impl,
    const ::PortableGroup::Location & the_location,
    const ::CosLoadBalancing::LoadList & loads
    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl),
    the_location_ (the_location),
    loads_ (loads)
{}

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

Dynamic::ExceptionList *
TAO_ServerRequestInfo_CosLoadBalancing_Strategy_push_loads::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_CosLoadBalancing_Strategy_push_loads_exceptiondata[] = 
  {
    CosLoadBalancing::_tc_StrategyNotAdaptive
  };
  
  exception_list->length (1);
  for (CORBA::ULong i = 0; i < 1; ++i)
    {
      CORBA::TypeCode_ptr tcp = _tao_CosLoadBalancing_Strategy_push_loads_exceptiondata[i];
      TAO_Pseudo_Object_Manager<CORBA::TypeCode> tcp_object (&tcp, 1);
      (*exception_list)[i] = tcp_object;
    }

  return safe_exception_list._retn ();
}

CORBA::Any * 
TAO_ServerRequestInfo_CosLoadBalancing_Strategy_push_loads::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_CosLoadBalancing_Strategy_push_loads::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_CosLoadBalancing_Strategy_push_loads::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);
}

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:74

class TAO_ServerRequestInfo_CosLoadBalancing_Strategy_get_loads : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_CosLoadBalancing_Strategy_get_loads (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_CosLoadBalancing::Strategy *tao_impl,
      ::CosLoadBalancing::LoadManager_ptr load_manager,
      const ::PortableGroup::Location & the_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));
  
  void result (::CosLoadBalancing::LoadList * result);

private:
  TAO_ServerRequestInfo_CosLoadBalancing_Strategy_get_loads (
      const TAO_ServerRequestInfo_CosLoadBalancing_Strategy_get_loads &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_CosLoadBalancing_Strategy_get_loads &
    );
  
private:
  POA_CosLoadBalancing::Strategy *_tao_impl;
  
  ::CosLoadBalancing::LoadManager_ptr load_manager_;
  const ::PortableGroup::Location & the_location_;
  ::CosLoadBalancing::LoadList * _result;
};

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:438

TAO_ServerRequestInfo_CosLoadBalancing_Strategy_get_loads::TAO_ServerRequestInfo_CosLoadBalancing_Strategy_get_loads (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_CosLoadBalancing::Strategy *tao_impl,
    ::CosLoadBalancing::LoadManager_ptr load_manager,
    const ::PortableGroup::Location & the_location
    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl),
    load_manager_ (load_manager),
    the_location_ (the_location)
{}

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

Dynamic::ExceptionList *
TAO_ServerRequestInfo_CosLoadBalancing_Strategy_get_loads::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_CosLoadBalancing_Strategy_get_loads_exceptiondata[] = 
  {
    CosLoadBalancing::_tc_LocationNotFound
  };
  
  exception_list->length (1);
  for (CORBA::ULong i = 0; i < 1; ++i)
    {
      CORBA::TypeCode_ptr tcp = _tao_CosLoadBalancing_Strategy_get_loads_exceptiondata[i];
      TAO_Pseudo_Object_Manager<CORBA::TypeCode> tcp_object (&tcp, 1);
      (*exception_list)[i] = tcp_object;
    }

  return safe_exception_list._retn ();
}

CORBA::Any * 
TAO_ServerRequestInfo_CosLoadBalancing_Strategy_get_loads::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_CosLoadBalancing_Strategy_get_loads::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_CosLoadBalancing_Strategy_get_loads::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_CosLoadBalancing_Strategy_get_loads::result (::CosLoadBalancing::LoadList * result)
{
  // Update the result.
   this->_result = result;
}

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:74

class TAO_ServerRequestInfo_CosLoadBalancing_Strategy_next_member : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_CosLoadBalancing_Strategy_next_member (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_CosLoadBalancing::Strategy *tao_impl,
      ::PortableGroup::ObjectGroup_ptr object_group,
      ::CosLoadBalancing::LoadManager_ptr load_manager
      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::Object_ptr result);

private:
  TAO_ServerRequestInfo_CosLoadBalancing_Strategy_next_member (
      const TAO_ServerRequestInfo_CosLoadBalancing_Strategy_next_member &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_CosLoadBalancing_Strategy_next_member &
    );
  
private:
  POA_CosLoadBalancing::Strategy *_tao_impl;
  
  ::PortableGroup::ObjectGroup_ptr object_group_;
  ::CosLoadBalancing::LoadManager_ptr load_manager_;
  CORBA::Object_ptr _result;
};

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:438

TAO_ServerRequestInfo_CosLoadBalancing_Strategy_next_member::TAO_ServerRequestInfo_CosLoadBalancing_Strategy_next_member (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_CosLoadBalancing::Strategy *tao_impl,
    ::PortableGroup::ObjectGroup_ptr object_group,
    ::CosLoadBalancing::LoadManager_ptr load_manager
    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl),
    object_group_ (object_group),
    load_manager_ (load_manager)
{}

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

Dynamic::ExceptionList *
TAO_ServerRequestInfo_CosLoadBalancing_Strategy_next_member::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_CosLoadBalancing_Strategy_next_member_exceptiondata[] = 
  {
    PortableGroup::_tc_ObjectGroupNotFound,
    PortableGroup::_tc_MemberNotFound
  };
  
  exception_list->length (2);
  for (CORBA::ULong i = 0; i < 2; ++i)
    {
      CORBA::TypeCode_ptr tcp = _tao_CosLoadBalancing_Strategy_next_member_exceptiondata[i];
      TAO_Pseudo_Object_Manager<CORBA::TypeCode> tcp_object (&tcp, 1);
      (*exception_list)[i] = tcp_object;
    }

  return safe_exception_list._retn ();
}

CORBA::Any * 
TAO_ServerRequestInfo_CosLoadBalancing_Strategy_next_member::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_CosLoadBalancing_Strategy_next_member::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_CosLoadBalancing_Strategy_next_member::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_CosLoadBalancing_Strategy_next_member::result (CORBA::Object_ptr result)
{
  // Update the result.
   this->_result = result;
}

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:74

class TAO_ServerRequestInfo_CosLoadBalancing_Strategy_analyze_loads : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_CosLoadBalancing_Strategy_analyze_loads (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_CosLoadBalancing::Strategy *tao_impl,
      ::PortableGroup::ObjectGroup_ptr object_group,
      ::CosLoadBalancing::LoadManager_ptr load_manager
      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_CosLoadBalancing_Strategy_analyze_loads (
      const TAO_ServerRequestInfo_CosLoadBalancing_Strategy_analyze_loads &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_CosLoadBalancing_Strategy_analyze_loads &
    );
  
private:
  POA_CosLoadBalancing::Strategy *_tao_impl;
  
  ::PortableGroup::ObjectGroup_ptr object_group_;
  ::CosLoadBalancing::LoadManager_ptr load_manager_;
};

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:438

TAO_ServerRequestInfo_CosLoadBalancing_Strategy_analyze_loads::TAO_ServerRequestInfo_CosLoadBalancing_Strategy_analyze_loads (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_CosLoadBalancing::Strategy *tao_impl,
    ::PortableGroup::ObjectGroup_ptr object_group,
    ::CosLoadBalancing::LoadManager_ptr load_manager
    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl),
    object_group_ (object_group),
    load_manager_ (load_manager)
{}

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

Dynamic::ExceptionList *
TAO_ServerRequestInfo_CosLoadBalancing_Strategy_analyze_loads::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_ServerRequestInfo_CosLoadBalancing_Strategy_analyze_loads::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_CosLoadBalancing_Strategy_analyze_loads::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_CosLoadBalancing_Strategy_analyze_loads::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);
}

#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_CosLoadBalancing::_TAO_Strategy_Strategized_Proxy_Broker *
POA_CosLoadBalancing::_TAO_Strategy_Strategized_Proxy_Broker::the_TAO_Strategy_Strategized_Proxy_Broker (void)
{
  static POA_CosLoadBalancing::_TAO_Strategy_Strategized_Proxy_Broker
  strategized_proxy_broker;
  
  return &strategized_proxy_broker;
}

POA_CosLoadBalancing::_TAO_Strategy_Strategized_Proxy_Broker::_TAO_Strategy_Strategized_Proxy_Broker (void)
{
}

POA_CosLoadBalancing::_TAO_Strategy_Strategized_Proxy_Broker::~_TAO_Strategy_Strategized_Proxy_Broker (void)
{
}

TAO::Collocation_Strategy
POA_CosLoadBalancing::_TAO_Strategy_Strategized_Proxy_Broker::get_strategy (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  TAO::Collocation_Strategy strategy =
    TAO_ORB_Core::collocation_strategy (obj ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (TAO::TAO_CS_REMOTE_STRATEGY);
  
  return strategy;
}

void
POA_CosLoadBalancing::_TAO_Strategy_Strategized_Proxy_Broker::dispatch (
    CORBA::Object_ptr obj,
    CORBA::Object_out forward_obj,
    TAO::Argument ** args,
    int num_args,
    const char * op,
    size_t op_len,
    TAO::Collocation_Strategy strategy
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::Exception))
{
  TAO_Object_Adapter::Servant_Upcall servant_upcall (
      obj->_stubobj ()->servant_orb_var ()->orb_core ()
    );
  
  TAO_Collocated_Skeleton collocated_skel;
  TAO_Abstract_ServantBase *servant = 0;
  
  if (strategy == TAO::TAO_CS_THRU_POA_STRATEGY)
    {
      servant_upcall.prepare_for_upcall (
          obj->_stubobj ()->object_key (),
          op,
          forward_obj
          ACE_ENV_ARG_PARAMETER
        );
      ACE_CHECK;
      
      servant_upcall.pre_invoke_collocated_request (
          ACE_ENV_SINGLE_ARG_PARAMETER
        );
      ACE_CHECK;
      
      servant = servant_upcall.servant ();
    }
  else
    {
      servant = obj->_servant ();
    }
  
  int status = servant->_find (op,
                               collocated_skel,
                               strategy,
                               op_len);
  
  if (status == -1)
    {
      ACE_THROW (CORBA::BAD_OPERATION ());
    }
  
  ACE_TRY
    {
      collocated_skel (servant,
                       args,
                       num_args
                       ACE_ENV_ARG_PARAMETER);
      ACE_TRY_CHECK;
    }
#if (TAO_HAS_MINIMUM_CORBA == 0)
  ACE_CATCH (PortableServer::ForwardRequest, forward_request)
    {
      forward_obj =
        CORBA::Object::_duplicate (forward_request.forward_reference.in ());
      return;
    }
#else
  ACE_CATCHANY
    {
      ACE_UNUSED_ARG (forward_obj);
      ACE_RE_THROW;
    }
#endif /* TAO_HAS_MINIMUM_CORBA */
  ACE_ENDTRY;
  ACE_CHECK;
}

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

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

TAO::Collocation_Proxy_Broker *
CosLoadBalancing__TAO_Strategy_Proxy_Broker_Factory_function (CORBA::Object_ptr)
{
  return
    ::POA_CosLoadBalancing::_TAO_Strategy_Strategized_Proxy_Broker::the_TAO_Strategy_Strategized_Proxy_Broker ();
}

int
CosLoadBalancing__TAO_Strategy_Proxy_Broker_Factory_Initializer (size_t)
{
  CosLoadBalancing__TAO_Strategy_Proxy_Broker_Factory_function_pointer = 
    CosLoadBalancing__TAO_Strategy_Proxy_Broker_Factory_function;
  
  return 0;
}

static int
CosLoadBalancing__TAO_Strategy_Proxy_Broker_Stub_Factory_Initializer_Scarecrow =
  CosLoadBalancing__TAO_Strategy_Proxy_Broker_Factory_Initializer (
      reinterpret_cast<
          size_t> (
          CosLoadBalancing__TAO_Strategy_Proxy_Broker_Factory_Initializer
        )
    );


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

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

POA_CosLoadBalancing::_TAO_Strategy_ThruPOA_Proxy_Impl::_TAO_Strategy_ThruPOA_Proxy_Impl (void)
{}

// ThruPOA Implementation of the IDL interface methods

// TAO_IDL - Generated from 
// be/be_visitor_operation/thru_poa_proxy_impl_ss.cpp:52

void
POA_CosLoadBalancing::_TAO_Strategy_ThruPOA_Proxy_Impl::_get_name (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument ** args,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  ((TAO::Arg_Traits< ::CORBA::Char *>::ret_val *) args[0])->arg () =
    reinterpret_cast<
        POA_CosLoadBalancing::Strategy_ptr> (
        servant->_downcast (
            "IDL:omg.org/CosLoadBalancing/Strategy:1.0"
          )
      )->name (
          ACE_ENV_SINGLE_ARG_PARAMETER
        );
  ACE_CHECK;
}

// TAO_IDL - Generated from 
// be/be_visitor_operation/thru_poa_proxy_impl_ss.cpp:52

void
POA_CosLoadBalancing::_TAO_Strategy_ThruPOA_Proxy_Impl::get_properties (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument ** args,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  ((TAO::Arg_Traits< ::CosLoadBalancing::Properties>::ret_val *) args[0])->arg () =
    reinterpret_cast<
        POA_CosLoadBalancing::Strategy_ptr> (
        servant->_downcast (
            "IDL:omg.org/CosLoadBalancing/Strategy:1.0"
          )
      )->get_properties (
          ACE_ENV_SINGLE_ARG_PARAMETER
        );
  ACE_CHECK;
}

// TAO_IDL - Generated from 
// be/be_visitor_operation/thru_poa_proxy_impl_ss.cpp:52

void
POA_CosLoadBalancing::_TAO_Strategy_ThruPOA_Proxy_Impl::push_loads (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument ** args,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException,
    ::CosLoadBalancing::StrategyNotAdaptive
  ))
{
  reinterpret_cast<
      POA_CosLoadBalancing::Strategy_ptr> (
      servant->_downcast (
          "IDL:omg.org/CosLoadBalancing/Strategy:1.0"
        )
    )->push_loads (
        ((TAO::Arg_Traits< ::PortableGroup::Location>::in_arg_val *) args[1])->arg (),
        ((TAO::Arg_Traits< ::CosLoadBalancing::LoadList>::in_arg_val *) args[2])->arg ()
        ACE_ENV_ARG_PARAMETER
      );
  ACE_CHECK;
}

// TAO_IDL - Generated from 
// be/be_visitor_operation/thru_poa_proxy_impl_ss.cpp:52

void
POA_CosLoadBalancing::_TAO_Strategy_ThruPOA_Proxy_Impl::get_loads (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument ** args,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException,
    ::CosLoadBalancing::LocationNotFound
  ))
{
  ((TAO::Arg_Traits< ::CosLoadBalancing::LoadList>::ret_val *) args[0])->arg () =
    reinterpret_cast<
        POA_CosLoadBalancing::Strategy_ptr> (
        servant->_downcast (
            "IDL:omg.org/CosLoadBalancing/Strategy:1.0"
          )
      )->get_loads (
          ((TAO::Arg_Traits< ::CosLoadBalancing::LoadManager>::in_arg_val *) args[1])->arg (),
          ((TAO::Arg_Traits< ::PortableGroup::Location>::in_arg_val *) args[2])->arg ()
          ACE_ENV_ARG_PARAMETER
        );
  ACE_CHECK;
}

// TAO_IDL - Generated from 
// be/be_visitor_operation/thru_poa_proxy_impl_ss.cpp:52

void
POA_CosLoadBalancing::_TAO_Strategy_ThruPOA_Proxy_Impl::next_member (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument ** args,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException,
    ::PortableGroup::ObjectGroupNotFound,
    ::PortableGroup::MemberNotFound
  ))
{
  ((TAO::Arg_Traits< CORBA::Object>::ret_val *) args[0])->arg () =
    reinterpret_cast<
        POA_CosLoadBalancing::Strategy_ptr> (
        servant->_downcast (
            "IDL:omg.org/CosLoadBalancing/Strategy:1.0"
          )
      )->next_member (
          ((TAO::Arg_Traits< PortableGroup::ObjectGroup>::in_arg_val *) args[1])->arg (),
          ((TAO::Arg_Traits< ::CosLoadBalancing::LoadManager>::in_arg_val *) args[2])->arg ()
          ACE_ENV_ARG_PARAMETER
        );
  ACE_CHECK;
}

// TAO_IDL - Generated from 
// be/be_visitor_operation/thru_poa_proxy_impl_ss.cpp:52

void
POA_CosLoadBalancing::_TAO_Strategy_ThruPOA_Proxy_Impl::analyze_loads (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument ** args,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  reinterpret_cast<
      POA_CosLoadBalancing::Strategy_ptr> (
      servant->_downcast (
          "IDL:omg.org/CosLoadBalancing/Strategy:1.0"
        )
    )->analyze_loads (
        ((TAO::Arg_Traits< PortableGroup::ObjectGroup>::in_arg_val *) args[1])->arg (),
        ((TAO::Arg_Traits< ::CosLoadBalancing::LoadManager>::in_arg_val *) args[2])->arg ()
        ACE_ENV_ARG_PARAMETER
      );
  ACE_CHECK;
}

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

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

POA_CosLoadBalancing::Strategy::Strategy (void)
{
  this->optable_ = &tao_CosLoadBalancing_Strategy_optable;
}

POA_CosLoadBalancing::Strategy::Strategy (const Strategy& rhs)
  : TAO_Abstract_ServantBase (rhs),
    TAO_ServantBase (rhs)
{
}

POA_CosLoadBalancing::Strategy::~Strategy (void)
{
}

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

void POA_CosLoadBalancing::Strategy::_get_name_skel (
    TAO_ServerRequest &_tao_server_request,
    void *_tao_servant,
    void *_tao_servant_upcall
    ACE_ENV_ARG_DECL
  )
{
  POA_CosLoadBalancing::Strategy *_tao_impl =
    static_cast<
        POA_CosLoadBalancing::Strategy *> (
        _tao_servant
      );
  CORBA::String_var _tao_retval;
  
#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_Object_Adapter::Servant_Upcall *_tao_upcall =
    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_CosLoadBalancing_Strategy_name_get _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl
      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* 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->name (
                  ACE_ENV_SINGLE_ARG_PARAMETER
                );
            TAO_INTERCEPTOR_CHECK;
#if (TAO_HAS_INTERCEPTORS == 1)
          }
      }
      
      if (!_tao_vfr.location_forwarded ())
        {
          char * _tao_retval_info = _tao_retval._retn ();
          _tao_ri.result (_tao_retval_info);
          _tao_retval = _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 ();
#if (TAO_HAS_INTERCEPTORS == 1)
  if (!_tao_vfr.location_forwarded ())
    {
#endif /* TAO_HAS_INTERCEPTORS */
      TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
      
      if (!(
          (_tao_out << _tao_retval.in ())
          ))
        {
          TAO_OutputCDR::throw_skel_exception (errno ACE_ENV_ARG_PARAMETER);
          ACE_CHECK;
        }
#if (TAO_HAS_INTERCEPTORS == 1)
    }
#endif /* TAO_HAS_INTERCEPTORS */
  
  
  // 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:98

void POA_CosLoadBalancing::Strategy::get_properties_skel (
    TAO_ServerRequest &_tao_server_request,
    void *_tao_servant,
    void *_tao_servant_upcall
    ACE_ENV_ARG_DECL
  )
{
  POA_CosLoadBalancing::Strategy *_tao_impl =
    static_cast<
        POA_CosLoadBalancing::Strategy *> (
        _tao_servant
      );
  ::CosLoadBalancing::Properties_var _tao_retval;
  
#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_Object_Adapter::Servant_Upcall *_tao_upcall =
    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_CosLoadBalancing_Strategy_get_properties _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl
      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* 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->get_properties (
                  ACE_ENV_SINGLE_ARG_PARAMETER
                );
            TAO_INTERCEPTOR_CHECK;
#if (TAO_HAS_INTERCEPTORS == 1)
          }
      }
      
      if (!_tao_vfr.location_forwarded ())
        {
          ::CosLoadBalancing::Properties * _tao_retval_info = _tao_retval._retn ();
          _tao_ri.result (_tao_retval_info);
          _tao_retval = _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 ();
#if (TAO_HAS_INTERCEPTORS == 1)
  if (!_tao_vfr.location_forwarded ())
    {
#endif /* TAO_HAS_INTERCEPTORS */
      TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
      
      if (!(
          (_tao_out << _tao_retval.in ())
          ))
        {
          TAO_OutputCDR::throw_skel_exception (errno ACE_ENV_ARG_PARAMETER);
          ACE_CHECK;
        }
#if (TAO_HAS_INTERCEPTORS == 1)
    }
#endif /* TAO_HAS_INTERCEPTORS */
  
  
  // 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:98

void POA_CosLoadBalancing::Strategy::push_loads_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_CosLoadBalancing::Strategy *_tao_impl =
    static_cast<
        POA_CosLoadBalancing::Strategy *> (
        _tao_servant
      );
  _tao_server_request.argument_flag (0);
  
  ::PortableGroup::Location the_location;
  ::CosLoadBalancing::LoadList loads;
  
  if (!(
      (_tao_in >> the_location) &&
      (_tao_in >> loads)
      ))
    {
      TAO_InputCDR::throw_skel_exception (errno ACE_ENV_ARG_PARAMETER);
      ACE_CHECK;
    }
  
#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_Object_Adapter::Servant_Upcall *_tao_upcall =
    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_CosLoadBalancing_Strategy_push_loads _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl,
      
      the_location,
      
      loads
      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* 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->push_loads (
                  the_location,
                  
                  loads
                  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:98

void POA_CosLoadBalancing::Strategy::get_loads_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_CosLoadBalancing::Strategy *_tao_impl =
    static_cast<
        POA_CosLoadBalancing::Strategy *> (
        _tao_servant
      );
  ::CosLoadBalancing::LoadList_var _tao_retval;
  ::CosLoadBalancing::LoadManager_var load_manager;
  ::PortableGroup::Location the_location;
  
  if (!(
      (_tao_in >> load_manager.out ()) &&
      (_tao_in >> the_location)
      ))
    {
      TAO_InputCDR::throw_skel_exception (errno ACE_ENV_ARG_PARAMETER);
      ACE_CHECK;
    }
  
#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_Object_Adapter::Servant_Upcall *_tao_upcall =
    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_CosLoadBalancing_Strategy_get_loads _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl,
      
      load_manager.in (),
      
      the_location
      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* 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->get_loads (
                  load_manager.in (),
                  
                  the_location
                  ACE_ENV_ARG_PARAMETER
                );
            TAO_INTERCEPTOR_CHECK;
#if (TAO_HAS_INTERCEPTORS == 1)
          }
      }
      
      if (!_tao_vfr.location_forwarded ())
        {
          ::CosLoadBalancing::LoadList * _tao_retval_info = _tao_retval._retn ();
          _tao_ri.result (_tao_retval_info);
          _tao_retval = _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 ();
#if (TAO_HAS_INTERCEPTORS == 1)
  if (!_tao_vfr.location_forwarded ())
    {
#endif /* TAO_HAS_INTERCEPTORS */
      TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
      
      if (!(
          (_tao_out << _tao_retval.in ())
          ))
        {
          TAO_OutputCDR::throw_skel_exception (errno ACE_ENV_ARG_PARAMETER);
          ACE_CHECK;
        }
#if (TAO_HAS_INTERCEPTORS == 1)
    }
#endif /* TAO_HAS_INTERCEPTORS */
  
  
  // 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:98

void POA_CosLoadBalancing::Strategy::next_member_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_CosLoadBalancing::Strategy *_tao_impl =
    static_cast<
        POA_CosLoadBalancing::Strategy *> (
        _tao_servant
      );
  CORBA::Object_var _tao_retval;
  ::PortableGroup::ObjectGroup_var object_group;
  ::CosLoadBalancing::LoadManager_var load_manager;
  
  if (!(
      (_tao_in >> object_group.out ()) &&
      (_tao_in >> load_manager.out ())
      ))
    {
      TAO_InputCDR::throw_skel_exception (errno ACE_ENV_ARG_PARAMETER);
      ACE_CHECK;
    }
  
#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_Object_Adapter::Servant_Upcall *_tao_upcall =
    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_CosLoadBalancing_Strategy_next_member _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl,
      
      object_group.in (),
      
      load_manager.in ()
      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* 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->next_member (
                  object_group.in (),
                  
                  load_manager.in ()
                  ACE_ENV_ARG_PARAMETER
                );
            TAO_INTERCEPTOR_CHECK;
#if (TAO_HAS_INTERCEPTORS == 1)
          }
      }
      
      if (!_tao_vfr.location_forwarded ())
        {
          CORBA::Object_ptr _tao_retval_info = _tao_retval._retn ();
          _tao_ri.result (_tao_retval_info);
          _tao_retval = _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 ();
#if (TAO_HAS_INTERCEPTORS == 1)
  if (!_tao_vfr.location_forwarded ())
    {
#endif /* TAO_HAS_INTERCEPTORS */
      TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
      
      if (!(
          (_tao_out << _tao_retval.in ())
          ))
        {
          TAO_OutputCDR::throw_skel_exception (errno ACE_ENV_ARG_PARAMETER);
          ACE_CHECK;
        }
#if (TAO_HAS_INTERCEPTORS == 1)
    }
#endif /* TAO_HAS_INTERCEPTORS */
  
  
  // 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:98

void POA_CosLoadBalancing::Strategy::analyze_loads_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_CosLoadBalancing::Strategy *_tao_impl =
    static_cast<
        POA_CosLoadBalancing::Strategy *> (
        _tao_servant
      );
  _tao_server_request.argument_flag (0);
  
  ::PortableGroup::ObjectGroup_var object_group;
  ::CosLoadBalancing::LoadManager_var load_manager;
  
  if (!(
      (_tao_in >> object_group.out ()) &&
      (_tao_in >> load_manager.out ())
      ))
    {
      TAO_InputCDR::throw_skel_exception (errno ACE_ENV_ARG_PARAMETER);
      ACE_CHECK;
    }
  
#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_Object_Adapter::Servant_Upcall *_tao_upcall =
    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_CosLoadBalancing_Strategy_analyze_loads _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl,
      
      object_group.in (),
      
      load_manager.in ()
      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* 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->analyze_loads (
                  object_group.in (),
                  
                  load_manager.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 */
  
  if (_tao_server_request.response_expected ()
      && !_tao_server_request.sync_with_server ())
    {
      _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_interface/interface_ss.cpp:162

void POA_CosLoadBalancing::Strategy::_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_CosLoadBalancing::Strategy *_tao_impl =
    (POA_CosLoadBalancing::Strategy *) _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_CosLoadBalancing::Strategy::_non_existent_skel (
    TAO_ServerRequest &_tao_server_request, 
    void * _tao_servant,
    void * /* Servant_Upcall */
    ACE_ENV_ARG_DECL
  )
{
  POA_CosLoadBalancing::Strategy *_tao_impl =
    (POA_CosLoadBalancing::Strategy *) _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_CosLoadBalancing::Strategy::_interface_skel (
    TAO_ServerRequest &_tao_server_request, 
    void * _tao_servant,
    void * /* Servant_Upcall */
    ACE_ENV_ARG_DECL
  )
{
  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 ());
    }
  
  POA_CosLoadBalancing::Strategy *_tao_impl =
    (POA_CosLoadBalancing::Strategy *) _tao_servant;
  
  CORBA::InterfaceDef_ptr _tao_retval = 
    _tao_impl->_get_interface (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK;
  
  _tao_server_request.init_reply ();
  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
  
  CORBA::Boolean _tao_result =
    _tao_adapter->interfacedef_cdr_insert (
        _tao_out,
        _tao_retval
      );
  
  _tao_adapter->dispose (_tao_retval);
  
  if (_tao_result == 0)
    {
      ACE_THROW (CORBA::MARSHAL ());
    }
}

void POA_CosLoadBalancing::Strategy::_component_skel (
    TAO_ServerRequest &_tao_server_request, 
    void * _tao_object_reference,
    void * /* Servant_Upcall */
    ACE_ENV_ARG_DECL
  )
{
  POA_CosLoadBalancing::Strategy *_tao_impl =
    (POA_CosLoadBalancing::Strategy *) _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.in ()))
    {
      ACE_THROW (CORBA::MARSHAL ());
    }
}

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

void* POA_CosLoadBalancing::Strategy::_downcast (
    const char* logical_type_id
  )
{
  if (ACE_OS::strcmp (logical_type_id,
                      "IDL:omg.org/CosLoadBalancing/Strategy:1.0") == 0)
    {
      return static_cast<POA_CosLoadBalancing::Strategy_ptr> (this);
    }
  
  if (ACE_OS::strcmp (logical_type_id,
                      "IDL:omg.org/CORBA/Object:1.0") == 0)
    {
      return static_cast<PortableServer::Servant> (this);
    }
  
  return 0;
}

const char* POA_CosLoadBalancing::Strategy::_interface_repository_id (void) const
{
  return "IDL:omg.org/CosLoadBalancing/Strategy:1.0";
}

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

void POA_CosLoadBalancing::Strategy::_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:526

CosLoadBalancing::Strategy *
POA_CosLoadBalancing::Strategy::_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 ();
  
  typedef ::CosLoadBalancing::Strategy STUB_SCOPED_NAME;
  return
    TAO::Narrow_Utils<STUB_SCOPED_NAME>::unchecked_narrow (
        obj.in (),
        CosLoadBalancing__TAO_Strategy_Proxy_Broker_Factory_function_pointer
      );
}

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

class TAO_CosLoadBalancing_AMI_StrategyHandler_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: /work/a/ports/devel/ace+tao/work/ACE_wrappers/bin/gperf -m -M -J -c -C -D -E -T -f 0 -F 0,0,0 -a -o -t -p -K opname_ -L C++ -Z TAO_CosLoadBalancing_AMI_StrategyHandler_Perfect_Hash_OpTable -N lookup  */
unsigned int
TAO_CosLoadBalancing_AMI_StrategyHandler_Perfect_Hash_OpTable::hash (const char *str, unsigned int len)
{
  static const unsigned char asso_values[] =
    {
#if defined (ACE_MVS)
     30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30, 30,  0,
     30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30, 30,  0,
     30, 30, 30, 13, 30,  0, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30, 30,  0,
     30,  0, 30,  0, 30, 30, 30, 30, 30, 30,
     30, 30, 15,  0, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30,
#else
     30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
     30, 30, 30, 30, 30,  0, 30,  0, 30, 30,
     30, 13, 30,  0, 30, 30, 30, 30, 30, 30,
      0, 30,  0, 30,  0, 15,  0, 30, 30, 30,
     30, 30, 30, 30, 30, 30, 30, 30,
#endif /* ACE_MVS */
    };
  return len + asso_values[(int) str[len - 1]] + asso_values[(int) str[0]];
}

const class TAO_operation_db_entry *
TAO_CosLoadBalancing_AMI_StrategyHandler_Perfect_Hash_OpTable::lookup (const char *str, unsigned int len)
{
  enum
    {
      TOTAL_KEYWORDS = 14,
      MIN_WORD_LENGTH = 5,
      MAX_WORD_LENGTH = 20,
      MIN_HASH_VALUE = 5,
      MAX_HASH_VALUE = 29,
      HASH_VALUE_RANGE = 25,
      DUPLICATES = 0,
      WORDLIST_SIZE = 19
    };

  static const class TAO_operation_db_entry  wordlist[] =
    {
      {"",0,0,0},{"",0,0,0},{"",0,0,0},{"",0,0,0},{"",0,0,0},
      {"_is_a", &POA_CosLoadBalancing::AMI_StrategyHandler::_is_a_skel, 0, 0},
      {"",0,0,0},{"",0,0,0},{"",0,0,0},{"",0,0,0},
      {"_component", &POA_CosLoadBalancing::AMI_StrategyHandler::_component_skel, 0, 0},
      {"next_member", &POA_CosLoadBalancing::AMI_StrategyHandler::next_member_skel, &POA_CosLoadBalancing::_TAO_AMI_StrategyHandler_ThruPOA_Proxy_Impl::next_member, 0},
      {"",0,0,0},
      {"_non_existent", &POA_CosLoadBalancing::AMI_StrategyHandler::_non_existent_skel, 0, 0},
      {"get_name_excep", &POA_CosLoadBalancing::AMI_StrategyHandler::get_name_excep_skel, &POA_CosLoadBalancing::_TAO_AMI_StrategyHandler_ThruPOA_Proxy_Impl::get_name_excep, 0},
      {"get_loads_excep", &POA_CosLoadBalancing::AMI_StrategyHandler::get_loads_excep_skel, &POA_CosLoadBalancing::_TAO_AMI_StrategyHandler_ThruPOA_Proxy_Impl::get_loads_excep, 0},
      {"push_loads_excep", &POA_CosLoadBalancing::AMI_StrategyHandler::push_loads_excep_skel, &POA_CosLoadBalancing::_TAO_AMI_StrategyHandler_ThruPOA_Proxy_Impl::push_loads_excep, 0},
      {"next_member_excep", &POA_CosLoadBalancing::AMI_StrategyHandler::next_member_excep_skel, &POA_CosLoadBalancing::_TAO_AMI_StrategyHandler_ThruPOA_Proxy_Impl::next_member_excep, 0},
      {"",0,0,0},{"",0,0,0},
      {"get_properties_excep", &POA_CosLoadBalancing::AMI_StrategyHandler::get_properties_excep_skel, &POA_CosLoadBalancing::_TAO_AMI_StrategyHandler_ThruPOA_Proxy_Impl::get_properties_excep, 0},
      {"get_name", &POA_CosLoadBalancing::AMI_StrategyHandler::get_name_skel, &POA_CosLoadBalancing::_TAO_AMI_StrategyHandler_ThruPOA_Proxy_Impl::get_name, 0},
      {"",0,0,0},
      {"_interface", &POA_CosLoadBalancing::AMI_StrategyHandler::_interface_skel, 0, 0},
      {"get_loads", &POA_CosLoadBalancing::AMI_StrategyHandler::get_loads_skel, &POA_CosLoadBalancing::_TAO_AMI_StrategyHandler_ThruPOA_Proxy_Impl::get_loads, 0},
      {"push_loads", &POA_CosLoadBalancing::AMI_StrategyHandler::push_loads_skel, &POA_CosLoadBalancing::_TAO_AMI_StrategyHandler_ThruPOA_Proxy_Impl::push_loads, 0},
      {"",0,0,0},{"",0,0,0},{"",0,0,0},
      {"get_properties", &POA_CosLoadBalancing::AMI_StrategyHandler::get_properties_skel, &POA_CosLoadBalancing::_TAO_AMI_StrategyHandler_ThruPOA_Proxy_Impl::get_properties, 0},
    };

  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_CosLoadBalancing_AMI_StrategyHandler_Perfect_Hash_OpTable tao_CosLoadBalancing_AMI_StrategyHandler_optable;

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

#if (TAO_HAS_INTERCEPTORS == 1)

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:74

class TAO_ServerRequestInfo_CosLoadBalancing_AMI_StrategyHandler_get_name : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_CosLoadBalancing_AMI_StrategyHandler_get_name (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_CosLoadBalancing::AMI_StrategyHandler *tao_impl,
      const char * ami_return_val
      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_CosLoadBalancing_AMI_StrategyHandler_get_name (
      const TAO_ServerRequestInfo_CosLoadBalancing_AMI_StrategyHandler_get_name &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_CosLoadBalancing_AMI_StrategyHandler_get_name &
    );
  
private:
  POA_CosLoadBalancing::AMI_StrategyHandler *_tao_impl;
  
  const char * ami_return_val_;
};

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:438

TAO_ServerRequestInfo_CosLoadBalancing_AMI_StrategyHandler_get_name::TAO_ServerRequestInfo_CosLoadBalancing_AMI_StrategyHandler_get_name (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_CosLoadBalancing::AMI_StrategyHandler *tao_impl,
    const char * ami_return_val
    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl),
    ami_return_val_ (ami_return_val)
{}

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

Dynamic::ExceptionList *
TAO_ServerRequestInfo_CosLoadBalancing_AMI_StrategyHandler_get_name::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_ServerRequestInfo_CosLoadBalancing_AMI_StrategyHandler_get_name::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_CosLoadBalancing_AMI_StrategyHandler_get_name::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_CosLoadBalancing_AMI_StrategyHandler_get_name::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);
}

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:74

class TAO_ServerRequestInfo_CosLoadBalancing_AMI_StrategyHandler_get_name_excep : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_CosLoadBalancing_AMI_StrategyHandler_get_name_excep (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_CosLoadBalancing::AMI_StrategyHandler *tao_impl,
      ::CosLoadBalancing::AMI_StrategyExceptionHolder * excep_holder
      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_CosLoadBalancing_AMI_StrategyHandler_get_name_excep (
      const TAO_ServerRequestInfo_CosLoadBalancing_AMI_StrategyHandler_get_name_excep &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_CosLoadBalancing_AMI_StrategyHandler_get_name_excep &
    );
  
private:
  POA_CosLoadBalancing::AMI_StrategyHandler *_tao_impl;
  
  ::CosLoadBalancing::AMI_StrategyExceptionHolder * excep_holder_;
};

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:438

TAO_ServerRequestInfo_CosLoadBalancing_AMI_StrategyHandler_get_name_excep::TAO_ServerRequestInfo_CosLoadBalancing_AMI_StrategyHandler_get_name_excep (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_CosLoadBalancing::AMI_StrategyHandler *tao_impl,
    ::CosLoadBalancing::AMI_StrategyExceptionHolder * excep_holder
    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl),
    excep_holder_ (excep_holder)
{}

Dynamic::ParameterList *
TAO_ServerRequestInfo_CosLoadBalancing_AMI_StrategyHandler_get_name_excep::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_ServerRequestInfo_CosLoadBalancing_AMI_StrategyHandler_get_name_excep::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_ServerRequestInfo_CosLoadBalancing_AMI_StrategyHandler_get_name_excep::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_CosLoadBalancing_AMI_StrategyHandler_get_name_excep::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_CosLoadBalancing_AMI_StrategyHandler_get_name_excep::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);
}

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:74

class TAO_ServerRequestInfo_CosLoadBalancing_AMI_StrategyHandler_get_properties : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_CosLoadBalancing_AMI_StrategyHandler_get_properties (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_CosLoadBalancing::AMI_StrategyHandler *tao_impl,
      const ::CosLoadBalancing::Properties & ami_return_val
      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_CosLoadBalancing_AMI_StrategyHandler_get_properties (
      const TAO_ServerRequestInfo_CosLoadBalancing_AMI_StrategyHandler_get_properties &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_CosLoadBalancing_AMI_StrategyHandler_get_properties &
    );
  
private:
  POA_CosLoadBalancing::AMI_StrategyHandler *_tao_impl;
  
  const ::CosLoadBalancing::Properties & ami_return_val_;
};

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:438

TAO_ServerRequestInfo_CosLoadBalancing_AMI_StrategyHandler_get_properties::TAO_ServerRequestInfo_CosLoadBalancing_AMI_StrategyHandler_get_properties (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_CosLoadBalancing::AMI_StrategyHandler *tao_impl,
    const ::CosLoadBalancing::Properties & ami_return_val
    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl),
    ami_return_val_ (ami_return_val)
{}

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

Dynamic::ExceptionList *
TAO_ServerRequestInfo_CosLoadBalancing_AMI_StrategyHandler_get_properties::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_ServerRequestInfo_CosLoadBalancing_AMI_StrategyHandler_get_properties::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_CosLoadBalancing_AMI_StrategyHandler_get_properties::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_CosLoadBalancing_AMI_StrategyHandler_get_properties::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);
}

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:74

class TAO_ServerRequestInfo_CosLoadBalancing_AMI_StrategyHandler_get_properties_excep : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_CosLoadBalancing_AMI_StrategyHandler_get_properties_excep (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_CosLoadBalancing::AMI_StrategyHandler *tao_impl,
      ::CosLoadBalancing::AMI_StrategyExceptionHolder * excep_holder
      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_CosLoadBalancing_AMI_StrategyHandler_get_properties_excep (
      const TAO_ServerRequestInfo_CosLoadBalancing_AMI_StrategyHandler_get_properties_excep &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_CosLoadBalancing_AMI_StrategyHandler_get_properties_excep &
    );
  
private:
  POA_CosLoadBalancing::AMI_StrategyHandler *_tao_impl;
  
  ::CosLoadBalancing::AMI_StrategyExceptionHolder * excep_holder_;
};

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:438

TAO_ServerRequestInfo_CosLoadBalancing_AMI_StrategyHandler_get_properties_excep::TAO_ServerRequestInfo_CosLoadBalancing_AMI_StrategyHandler_get_properties_excep (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_CosLoadBalancing::AMI_StrategyHandler *tao_impl,
    ::CosLoadBalancing::AMI_StrategyExceptionHolder * excep_holder
    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl),
    excep_holder_ (excep_holder)
{}

Dynamic::ParameterList *
TAO_ServerRequestInfo_CosLoadBalancing_AMI_StrategyHandler_get_properties_excep::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_ServerRequestInfo_CosLoadBalancing_AMI_StrategyHandler_get_properties_excep::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_ServerRequestInfo_CosLoadBalancing_AMI_StrategyHandler_get_properties_excep::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_CosLoadBalancing_AMI_StrategyHandler_get_properties_excep::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_CosLoadBalancing_AMI_StrategyHandler_get_properties_excep::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);
}

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:74

class TAO_ServerRequestInfo_CosLoadBalancing_AMI_StrategyHandler_push_loads : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_CosLoadBalancing_AMI_StrategyHandler_push_loads (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_CosLoadBalancing::AMI_StrategyHandler *tao_impl
      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_CosLoadBalancing_AMI_StrategyHandler_push_loads (
      const TAO_ServerRequestInfo_CosLoadBalancing_AMI_StrategyHandler_push_loads &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_CosLoadBalancing_AMI_StrategyHandler_push_loads &
    );
  
private:
  POA_CosLoadBalancing::AMI_StrategyHandler *_tao_impl;
  
};

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:438

TAO_ServerRequestInfo_CosLoadBalancing_AMI_StrategyHandler_push_loads::TAO_ServerRequestInfo_CosLoadBalancing_AMI_StrategyHandler_push_loads (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_CosLoadBalancing::AMI_StrategyHandler *tao_impl
    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl)
{}

Dynamic::ParameterList *
TAO_ServerRequestInfo_CosLoadBalancing_AMI_StrategyHandler_push_loads::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_ServerRequestInfo_CosLoadBalancing_AMI_StrategyHandler_push_loads::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_ServerRequestInfo_CosLoadBalancing_AMI_StrategyHandler_push_loads::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_CosLoadBalancing_AMI_StrategyHandler_push_loads::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_CosLoadBalancing_AMI_StrategyHandler_push_loads::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);
}

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:74

class TAO_ServerRequestInfo_CosLoadBalancing_AMI_StrategyHandler_push_loads_excep : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_CosLoadBalancing_AMI_StrategyHandler_push_loads_excep (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_CosLoadBalancing::AMI_StrategyHandler *tao_impl,
      ::CosLoadBalancing::AMI_StrategyExceptionHolder * excep_holder
      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_CosLoadBalancing_AMI_StrategyHandler_push_loads_excep (
      const TAO_ServerRequestInfo_CosLoadBalancing_AMI_StrategyHandler_push_loads_excep &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_CosLoadBalancing_AMI_StrategyHandler_push_loads_excep &
    );
  
private:
  POA_CosLoadBalancing::AMI_StrategyHandler *_tao_impl;
  
  ::CosLoadBalancing::AMI_StrategyExceptionHolder * excep_holder_;
};

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:438

TAO_ServerRequestInfo_CosLoadBalancing_AMI_StrategyHandler_push_loads_excep::TAO_ServerRequestInfo_CosLoadBalancing_AMI_StrategyHandler_push_loads_excep (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_CosLoadBalancing::AMI_StrategyHandler *tao_impl,
    ::CosLoadBalancing::AMI_StrategyExceptionHolder * excep_holder
    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl),
    excep_holder_ (excep_holder)
{}

Dynamic::ParameterList *
TAO_ServerRequestInfo_CosLoadBalancing_AMI_StrategyHandler_push_loads_excep::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_ServerRequestInfo_CosLoadBalancing_AMI_StrategyHandler_push_loads_excep::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_ServerRequestInfo_CosLoadBalancing_AMI_StrategyHandler_push_loads_excep::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_CosLoadBalancing_AMI_StrategyHandler_push_loads_excep::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_CosLoadBalancing_AMI_StrategyHandler_push_loads_excep::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);
}

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:74

class TAO_ServerRequestInfo_CosLoadBalancing_AMI_StrategyHandler_get_loads : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_CosLoadBalancing_AMI_StrategyHandler_get_loads (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_CosLoadBalancing::AMI_StrategyHandler *tao_impl,
      const ::CosLoadBalancing::LoadList & ami_return_val
      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_CosLoadBalancing_AMI_StrategyHandler_get_loads (
      const TAO_ServerRequestInfo_CosLoadBalancing_AMI_StrategyHandler_get_loads &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_CosLoadBalancing_AMI_StrategyHandler_get_loads &
    );
  
private:
  POA_CosLoadBalancing::AMI_StrategyHandler *_tao_impl;
  
  const ::CosLoadBalancing::LoadList & ami_return_val_;
};

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:438

TAO_ServerRequestInfo_CosLoadBalancing_AMI_StrategyHandler_get_loads::TAO_ServerRequestInfo_CosLoadBalancing_AMI_StrategyHandler_get_loads (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_CosLoadBalancing::AMI_StrategyHandler *tao_impl,
    const ::CosLoadBalancing::LoadList & ami_return_val
    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl),
    ami_return_val_ (ami_return_val)
{}

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

Dynamic::ExceptionList *
TAO_ServerRequestInfo_CosLoadBalancing_AMI_StrategyHandler_get_loads::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_ServerRequestInfo_CosLoadBalancing_AMI_StrategyHandler_get_loads::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_CosLoadBalancing_AMI_StrategyHandler_get_loads::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_CosLoadBalancing_AMI_StrategyHandler_get_loads::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);
}

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:74

class TAO_ServerRequestInfo_CosLoadBalancing_AMI_StrategyHandler_get_loads_excep : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_CosLoadBalancing_AMI_StrategyHandler_get_loads_excep (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_CosLoadBalancing::AMI_StrategyHandler *tao_impl,
      ::CosLoadBalancing::AMI_StrategyExceptionHolder * excep_holder
      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_CosLoadBalancing_AMI_StrategyHandler_get_loads_excep (
      const TAO_ServerRequestInfo_CosLoadBalancing_AMI_StrategyHandler_get_loads_excep &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_CosLoadBalancing_AMI_StrategyHandler_get_loads_excep &
    );
  
private:
  POA_CosLoadBalancing::AMI_StrategyHandler *_tao_impl;
  
  ::CosLoadBalancing::AMI_StrategyExceptionHolder * excep_holder_;
};

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:438

TAO_ServerRequestInfo_CosLoadBalancing_AMI_StrategyHandler_get_loads_excep::TAO_ServerRequestInfo_CosLoadBalancing_AMI_StrategyHandler_get_loads_excep (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_CosLoadBalancing::AMI_StrategyHandler *tao_impl,
    ::CosLoadBalancing::AMI_StrategyExceptionHolder * excep_holder
    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl),
    excep_holder_ (excep_holder)
{}

Dynamic::ParameterList *
TAO_ServerRequestInfo_CosLoadBalancing_AMI_StrategyHandler_get_loads_excep::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_ServerRequestInfo_CosLoadBalancing_AMI_StrategyHandler_get_loads_excep::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_ServerRequestInfo_CosLoadBalancing_AMI_StrategyHandler_get_loads_excep::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_CosLoadBalancing_AMI_StrategyHandler_get_loads_excep::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_CosLoadBalancing_AMI_StrategyHandler_get_loads_excep::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);
}

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:74

class TAO_ServerRequestInfo_CosLoadBalancing_AMI_StrategyHandler_next_member : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_CosLoadBalancing_AMI_StrategyHandler_next_member (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_CosLoadBalancing::AMI_StrategyHandler *tao_impl,
      ::CORBA::Object_ptr ami_return_val
      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_CosLoadBalancing_AMI_StrategyHandler_next_member (
      const TAO_ServerRequestInfo_CosLoadBalancing_AMI_StrategyHandler_next_member &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_CosLoadBalancing_AMI_StrategyHandler_next_member &
    );
  
private:
  POA_CosLoadBalancing::AMI_StrategyHandler *_tao_impl;
  
  ::CORBA::Object_ptr ami_return_val_;
};

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:438

TAO_ServerRequestInfo_CosLoadBalancing_AMI_StrategyHandler_next_member::TAO_ServerRequestInfo_CosLoadBalancing_AMI_StrategyHandler_next_member (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_CosLoadBalancing::AMI_StrategyHandler *tao_impl,
    ::CORBA::Object_ptr ami_return_val
    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl),
    ami_return_val_ (ami_return_val)
{}

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

Dynamic::ExceptionList *
TAO_ServerRequestInfo_CosLoadBalancing_AMI_StrategyHandler_next_member::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_ServerRequestInfo_CosLoadBalancing_AMI_StrategyHandler_next_member::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_CosLoadBalancing_AMI_StrategyHandler_next_member::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_CosLoadBalancing_AMI_StrategyHandler_next_member::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);
}

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:74

class TAO_ServerRequestInfo_CosLoadBalancing_AMI_StrategyHandler_next_member_excep : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_CosLoadBalancing_AMI_StrategyHandler_next_member_excep (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_CosLoadBalancing::AMI_StrategyHandler *tao_impl,
      ::CosLoadBalancing::AMI_StrategyExceptionHolder * excep_holder
      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_CosLoadBalancing_AMI_StrategyHandler_next_member_excep (
      const TAO_ServerRequestInfo_CosLoadBalancing_AMI_StrategyHandler_next_member_excep &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_CosLoadBalancing_AMI_StrategyHandler_next_member_excep &
    );
  
private:
  POA_CosLoadBalancing::AMI_StrategyHandler *_tao_impl;
  
  ::CosLoadBalancing::AMI_StrategyExceptionHolder * excep_holder_;
};

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:438

TAO_ServerRequestInfo_CosLoadBalancing_AMI_StrategyHandler_next_member_excep::TAO_ServerRequestInfo_CosLoadBalancing_AMI_StrategyHandler_next_member_excep (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_CosLoadBalancing::AMI_StrategyHandler *tao_impl,
    ::CosLoadBalancing::AMI_StrategyExceptionHolder * excep_holder
    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl),
    excep_holder_ (excep_holder)
{}

Dynamic::ParameterList *
TAO_ServerRequestInfo_CosLoadBalancing_AMI_StrategyHandler_next_member_excep::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_ServerRequestInfo_CosLoadBalancing_AMI_StrategyHandler_next_member_excep::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_ServerRequestInfo_CosLoadBalancing_AMI_StrategyHandler_next_member_excep::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_CosLoadBalancing_AMI_StrategyHandler_next_member_excep::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_CosLoadBalancing_AMI_StrategyHandler_next_member_excep::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);
}

#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_CosLoadBalancing::_TAO_AMI_StrategyHandler_Strategized_Proxy_Broker *
POA_CosLoadBalancing::_TAO_AMI_StrategyHandler_Strategized_Proxy_Broker::the_TAO_AMI_StrategyHandler_Strategized_Proxy_Broker (void)
{
  static POA_CosLoadBalancing::_TAO_AMI_StrategyHandler_Strategized_Proxy_Broker
  strategized_proxy_broker;
  
  return &strategized_proxy_broker;
}

POA_CosLoadBalancing::_TAO_AMI_StrategyHandler_Strategized_Proxy_Broker::_TAO_AMI_StrategyHandler_Strategized_Proxy_Broker (void)
{
}

POA_CosLoadBalancing::_TAO_AMI_StrategyHandler_Strategized_Proxy_Broker::~_TAO_AMI_StrategyHandler_Strategized_Proxy_Broker (void)
{
}

TAO::Collocation_Strategy
POA_CosLoadBalancing::_TAO_AMI_StrategyHandler_Strategized_Proxy_Broker::get_strategy (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  TAO::Collocation_Strategy strategy =
    TAO_ORB_Core::collocation_strategy (obj ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (TAO::TAO_CS_REMOTE_STRATEGY);
  
  return strategy;
}

void
POA_CosLoadBalancing::_TAO_AMI_StrategyHandler_Strategized_Proxy_Broker::dispatch (
    CORBA::Object_ptr obj,
    CORBA::Object_out forward_obj,
    TAO::Argument ** args,
    int num_args,
    const char * op,
    size_t op_len,
    TAO::Collocation_Strategy strategy
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::Exception))
{
  TAO_Object_Adapter::Servant_Upcall servant_upcall (
      obj->_stubobj ()->servant_orb_var ()->orb_core ()
    );
  
  TAO_Collocated_Skeleton collocated_skel;
  TAO_Abstract_ServantBase *servant = 0;
  
  if (strategy == TAO::TAO_CS_THRU_POA_STRATEGY)
    {
      servant_upcall.prepare_for_upcall (
          obj->_stubobj ()->object_key (),
          op,
          forward_obj
          ACE_ENV_ARG_PARAMETER
        );
      ACE_CHECK;
      
      servant_upcall.pre_invoke_collocated_request (
          ACE_ENV_SINGLE_ARG_PARAMETER
        );
      ACE_CHECK;
      
      servant = servant_upcall.servant ();
    }
  else
    {
      servant = obj->_servant ();
    }
  
  int status = servant->_find (op,
                               collocated_skel,
                               strategy,
                               op_len);
  
  if (status == -1)
    {
      ACE_THROW (CORBA::BAD_OPERATION ());
    }
  
  ACE_TRY
    {
      collocated_skel (servant,
                       args,
                       num_args
                       ACE_ENV_ARG_PARAMETER);
      ACE_TRY_CHECK;
    }
#if (TAO_HAS_MINIMUM_CORBA == 0)
  ACE_CATCH (PortableServer::ForwardRequest, forward_request)
    {
      forward_obj =
        CORBA::Object::_duplicate (forward_request.forward_reference.in ());
      return;
    }
#else
  ACE_CATCHANY
    {
      ACE_UNUSED_ARG (forward_obj);
      ACE_RE_THROW;
    }
#endif /* TAO_HAS_MINIMUM_CORBA */
  ACE_ENDTRY;
  ACE_CHECK;
}

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

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

TAO::Collocation_Proxy_Broker *
CosLoadBalancing__TAO_AMI_StrategyHandler_Proxy_Broker_Factory_function (CORBA::Object_ptr)
{
  return
    ::POA_CosLoadBalancing::_TAO_AMI_StrategyHandler_Strategized_Proxy_Broker::the_TAO_AMI_StrategyHandler_Strategized_Proxy_Broker ();
}

int
CosLoadBalancing__TAO_AMI_StrategyHandler_Proxy_Broker_Factory_Initializer (size_t)
{
  CosLoadBalancing__TAO_AMI_StrategyHandler_Proxy_Broker_Factory_function_pointer = 
    CosLoadBalancing__TAO_AMI_StrategyHandler_Proxy_Broker_Factory_function;
  
  return 0;
}

static int
CosLoadBalancing__TAO_AMI_StrategyHandler_Proxy_Broker_Stub_Factory_Initializer_Scarecrow =
  CosLoadBalancing__TAO_AMI_StrategyHandler_Proxy_Broker_Factory_Initializer (
      reinterpret_cast<
          size_t> (
          CosLoadBalancing__TAO_AMI_StrategyHandler_Proxy_Broker_Factory_Initializer
        )
    );


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

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

POA_CosLoadBalancing::_TAO_AMI_StrategyHandler_ThruPOA_Proxy_Impl::_TAO_AMI_StrategyHandler_ThruPOA_Proxy_Impl (void)
{}

// ThruPOA Implementation of the IDL interface methods

// TAO_IDL - Generated from 
// be/be_visitor_operation/thru_poa_proxy_impl_ss.cpp:52

void
POA_CosLoadBalancing::_TAO_AMI_StrategyHandler_ThruPOA_Proxy_Impl::get_name (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument ** args,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  reinterpret_cast<
      POA_CosLoadBalancing::AMI_StrategyHandler_ptr> (
      servant->_downcast (
          "IDL:AMI_StrategyHandler:1.0"
        )
    )->get_name (
        ((TAO::Arg_Traits< ::CORBA::Char *>::in_arg_val *) args[1])->arg ()
        ACE_ENV_ARG_PARAMETER
      );
  ACE_CHECK;
}

// TAO_IDL - Generated from 
// be/be_visitor_operation/thru_poa_proxy_impl_ss.cpp:52

void
POA_CosLoadBalancing::_TAO_AMI_StrategyHandler_ThruPOA_Proxy_Impl::get_name_excep (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument ** args,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  reinterpret_cast<
      POA_CosLoadBalancing::AMI_StrategyHandler_ptr> (
      servant->_downcast (
          "IDL:AMI_StrategyHandler:1.0"
        )
    )->get_name_excep (
        ((TAO::Arg_Traits< ::CosLoadBalancing::AMI_StrategyExceptionHolder>::in_arg_val *) args[1])->arg ()
        ACE_ENV_ARG_PARAMETER
      );
  ACE_CHECK;
}

// TAO_IDL - Generated from 
// be/be_visitor_operation/thru_poa_proxy_impl_ss.cpp:52

void
POA_CosLoadBalancing::_TAO_AMI_StrategyHandler_ThruPOA_Proxy_Impl::get_properties (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument ** args,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  reinterpret_cast<
      POA_CosLoadBalancing::AMI_StrategyHandler_ptr> (
      servant->_downcast (
          "IDL:AMI_StrategyHandler:1.0"
        )
    )->get_properties (
        ((TAO::Arg_Traits< ::CosLoadBalancing::Properties>::in_arg_val *) args[1])->arg ()
        ACE_ENV_ARG_PARAMETER
      );
  ACE_CHECK;
}

// TAO_IDL - Generated from 
// be/be_visitor_operation/thru_poa_proxy_impl_ss.cpp:52

void
POA_CosLoadBalancing::_TAO_AMI_StrategyHandler_ThruPOA_Proxy_Impl::get_properties_excep (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument ** args,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  reinterpret_cast<
      POA_CosLoadBalancing::AMI_StrategyHandler_ptr> (
      servant->_downcast (
          "IDL:AMI_StrategyHandler:1.0"
        )
    )->get_properties_excep (
        ((TAO::Arg_Traits< ::CosLoadBalancing::AMI_StrategyExceptionHolder>::in_arg_val *) args[1])->arg ()
        ACE_ENV_ARG_PARAMETER
      );
  ACE_CHECK;
}

// TAO_IDL - Generated from 
// be/be_visitor_operation/thru_poa_proxy_impl_ss.cpp:52

void
POA_CosLoadBalancing::_TAO_AMI_StrategyHandler_ThruPOA_Proxy_Impl::push_loads (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument **,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  reinterpret_cast<
      POA_CosLoadBalancing::AMI_StrategyHandler_ptr> (
      servant->_downcast (
          "IDL:AMI_StrategyHandler:1.0"
        )
    )->push_loads (
        ACE_ENV_SINGLE_ARG_PARAMETER
      );
  ACE_CHECK;
}

// TAO_IDL - Generated from 
// be/be_visitor_operation/thru_poa_proxy_impl_ss.cpp:52

void
POA_CosLoadBalancing::_TAO_AMI_StrategyHandler_ThruPOA_Proxy_Impl::push_loads_excep (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument ** args,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  reinterpret_cast<
      POA_CosLoadBalancing::AMI_StrategyHandler_ptr> (
      servant->_downcast (
          "IDL:AMI_StrategyHandler:1.0"
        )
    )->push_loads_excep (
        ((TAO::Arg_Traits< ::CosLoadBalancing::AMI_StrategyExceptionHolder>::in_arg_val *) args[1])->arg ()
        ACE_ENV_ARG_PARAMETER
      );
  ACE_CHECK;
}

// TAO_IDL - Generated from 
// be/be_visitor_operation/thru_poa_proxy_impl_ss.cpp:52

void
POA_CosLoadBalancing::_TAO_AMI_StrategyHandler_ThruPOA_Proxy_Impl::get_loads (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument ** args,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  reinterpret_cast<
      POA_CosLoadBalancing::AMI_StrategyHandler_ptr> (
      servant->_downcast (
          "IDL:AMI_StrategyHandler:1.0"
        )
    )->get_loads (
        ((TAO::Arg_Traits< ::CosLoadBalancing::LoadList>::in_arg_val *) args[1])->arg ()
        ACE_ENV_ARG_PARAMETER
      );
  ACE_CHECK;
}

// TAO_IDL - Generated from 
// be/be_visitor_operation/thru_poa_proxy_impl_ss.cpp:52

void
POA_CosLoadBalancing::_TAO_AMI_StrategyHandler_ThruPOA_Proxy_Impl::get_loads_excep (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument ** args,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  reinterpret_cast<
      POA_CosLoadBalancing::AMI_StrategyHandler_ptr> (
      servant->_downcast (
          "IDL:AMI_StrategyHandler:1.0"
        )
    )->get_loads_excep (
        ((TAO::Arg_Traits< ::CosLoadBalancing::AMI_StrategyExceptionHolder>::in_arg_val *) args[1])->arg ()
        ACE_ENV_ARG_PARAMETER
      );
  ACE_CHECK;
}

// TAO_IDL - Generated from 
// be/be_visitor_operation/thru_poa_proxy_impl_ss.cpp:52

void
POA_CosLoadBalancing::_TAO_AMI_StrategyHandler_ThruPOA_Proxy_Impl::next_member (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument ** args,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  reinterpret_cast<
      POA_CosLoadBalancing::AMI_StrategyHandler_ptr> (
      servant->_downcast (
          "IDL:AMI_StrategyHandler:1.0"
        )
    )->next_member (
        ((TAO::Arg_Traits< CORBA::Object>::in_arg_val *) args[1])->arg ()
        ACE_ENV_ARG_PARAMETER
      );
  ACE_CHECK;
}

// TAO_IDL - Generated from 
// be/be_visitor_operation/thru_poa_proxy_impl_ss.cpp:52

void
POA_CosLoadBalancing::_TAO_AMI_StrategyHandler_ThruPOA_Proxy_Impl::next_member_excep (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument ** args,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  reinterpret_cast<
      POA_CosLoadBalancing::AMI_StrategyHandler_ptr> (
      servant->_downcast (
          "IDL:AMI_StrategyHandler:1.0"
        )
    )->next_member_excep (
        ((TAO::Arg_Traits< ::CosLoadBalancing::AMI_StrategyExceptionHolder>::in_arg_val *) args[1])->arg ()
        ACE_ENV_ARG_PARAMETER
      );
  ACE_CHECK;
}

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

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

POA_CosLoadBalancing::AMI_StrategyHandler::AMI_StrategyHandler (void)
{
  this->optable_ = &tao_CosLoadBalancing_AMI_StrategyHandler_optable;
}

POA_CosLoadBalancing::AMI_StrategyHandler::AMI_StrategyHandler (const AMI_StrategyHandler& rhs)
  : TAO_Abstract_ServantBase (rhs),
    TAO_ServantBase (rhs),
    ACE_NESTED_CLASS (POA_Messaging, ReplyHandler) (rhs)
{
}

POA_CosLoadBalancing::AMI_StrategyHandler::~AMI_StrategyHandler (void)
{
}

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

void POA_CosLoadBalancing::AMI_StrategyHandler::get_name_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_CosLoadBalancing::AMI_StrategyHandler *_tao_impl =
    static_cast<
        POA_CosLoadBalancing::AMI_StrategyHandler *> (
        _tao_servant
      );
  _tao_server_request.argument_flag (0);
  
  ::CORBA::String_var ami_return_val;
  
  if (!(
      (_tao_in >> ami_return_val.out ())
      ))
    {
      TAO_InputCDR::throw_skel_exception (errno ACE_ENV_ARG_PARAMETER);
      ACE_CHECK;
    }
  
#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_Object_Adapter::Servant_Upcall *_tao_upcall =
    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_CosLoadBalancing_AMI_StrategyHandler_get_name _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl,
      
      ami_return_val.in ()
      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* 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->get_name (
                  ami_return_val.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:98

void POA_CosLoadBalancing::AMI_StrategyHandler::get_name_excep_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_CosLoadBalancing::AMI_StrategyHandler *_tao_impl =
    static_cast<
        POA_CosLoadBalancing::AMI_StrategyHandler *> (
        _tao_servant
      );
  _tao_server_request.argument_flag (0);
  
  ::CosLoadBalancing::AMI_StrategyExceptionHolder_var excep_holder;
  
  if (!(
      (_tao_in >> excep_holder.out ())
      ))
    {
      TAO_InputCDR::throw_skel_exception (errno ACE_ENV_ARG_PARAMETER);
      ACE_CHECK;
    }
  
#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_Object_Adapter::Servant_Upcall *_tao_upcall =
    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_CosLoadBalancing_AMI_StrategyHandler_get_name_excep _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl,
      
      excep_holder.in ()
      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* 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->get_name_excep (
                  excep_holder.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:98

void POA_CosLoadBalancing::AMI_StrategyHandler::get_properties_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_CosLoadBalancing::AMI_StrategyHandler *_tao_impl =
    static_cast<
        POA_CosLoadBalancing::AMI_StrategyHandler *> (
        _tao_servant
      );
  _tao_server_request.argument_flag (0);
  
  ::CosLoadBalancing::Properties ami_return_val;
  
  if (!(
      (_tao_in >> ami_return_val)
      ))
    {
      TAO_InputCDR::throw_skel_exception (errno ACE_ENV_ARG_PARAMETER);
      ACE_CHECK;
    }
  
#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_Object_Adapter::Servant_Upcall *_tao_upcall =
    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_CosLoadBalancing_AMI_StrategyHandler_get_properties _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl,
      
      ami_return_val
      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* 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->get_properties (
                  ami_return_val
                  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:98

void POA_CosLoadBalancing::AMI_StrategyHandler::get_properties_excep_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_CosLoadBalancing::AMI_StrategyHandler *_tao_impl =
    static_cast<
        POA_CosLoadBalancing::AMI_StrategyHandler *> (
        _tao_servant
      );
  _tao_server_request.argument_flag (0);
  
  ::CosLoadBalancing::AMI_StrategyExceptionHolder_var excep_holder;
  
  if (!(
      (_tao_in >> excep_holder.out ())
      ))
    {
      TAO_InputCDR::throw_skel_exception (errno ACE_ENV_ARG_PARAMETER);
      ACE_CHECK;
    }
  
#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_Object_Adapter::Servant_Upcall *_tao_upcall =
    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_CosLoadBalancing_AMI_StrategyHandler_get_properties_excep _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl,
      
      excep_holder.in ()
      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* 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->get_properties_excep (
                  excep_holder.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:98

void POA_CosLoadBalancing::AMI_StrategyHandler::push_loads_skel (
    TAO_ServerRequest &_tao_server_request,
    void *_tao_servant,
    void *_tao_servant_upcall
    ACE_ENV_ARG_DECL
  )
{
  POA_CosLoadBalancing::AMI_StrategyHandler *_tao_impl =
    static_cast<
        POA_CosLoadBalancing::AMI_StrategyHandler *> (
        _tao_servant
      );
  _tao_server_request.argument_flag (0);
  
  
#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_Object_Adapter::Servant_Upcall *_tao_upcall =
    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_CosLoadBalancing_AMI_StrategyHandler_push_loads _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl
      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* 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->push_loads (
                  ACE_ENV_SINGLE_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:98

void POA_CosLoadBalancing::AMI_StrategyHandler::push_loads_excep_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_CosLoadBalancing::AMI_StrategyHandler *_tao_impl =
    static_cast<
        POA_CosLoadBalancing::AMI_StrategyHandler *> (
        _tao_servant
      );
  _tao_server_request.argument_flag (0);
  
  ::CosLoadBalancing::AMI_StrategyExceptionHolder_var excep_holder;
  
  if (!(
      (_tao_in >> excep_holder.out ())
      ))
    {
      TAO_InputCDR::throw_skel_exception (errno ACE_ENV_ARG_PARAMETER);
      ACE_CHECK;
    }
  
#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_Object_Adapter::Servant_Upcall *_tao_upcall =
    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_CosLoadBalancing_AMI_StrategyHandler_push_loads_excep _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl,
      
      excep_holder.in ()
      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* 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->push_loads_excep (
                  excep_holder.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:98

void POA_CosLoadBalancing::AMI_StrategyHandler::get_loads_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_CosLoadBalancing::AMI_StrategyHandler *_tao_impl =
    static_cast<
        POA_CosLoadBalancing::AMI_StrategyHandler *> (
        _tao_servant
      );
  _tao_server_request.argument_flag (0);
  
  ::CosLoadBalancing::LoadList ami_return_val;
  
  if (!(
      (_tao_in >> ami_return_val)
      ))
    {
      TAO_InputCDR::throw_skel_exception (errno ACE_ENV_ARG_PARAMETER);
      ACE_CHECK;
    }
  
#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_Object_Adapter::Servant_Upcall *_tao_upcall =
    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_CosLoadBalancing_AMI_StrategyHandler_get_loads _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl,
      
      ami_return_val
      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* 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->get_loads (
                  ami_return_val
                  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:98

void POA_CosLoadBalancing::AMI_StrategyHandler::get_loads_excep_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_CosLoadBalancing::AMI_StrategyHandler *_tao_impl =
    static_cast<
        POA_CosLoadBalancing::AMI_StrategyHandler *> (
        _tao_servant
      );
  _tao_server_request.argument_flag (0);
  
  ::CosLoadBalancing::AMI_StrategyExceptionHolder_var excep_holder;
  
  if (!(
      (_tao_in >> excep_holder.out ())
      ))
    {
      TAO_InputCDR::throw_skel_exception (errno ACE_ENV_ARG_PARAMETER);
      ACE_CHECK;
    }
  
#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_Object_Adapter::Servant_Upcall *_tao_upcall =
    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_CosLoadBalancing_AMI_StrategyHandler_get_loads_excep _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl,
      
      excep_holder.in ()
      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* 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->get_loads_excep (
                  excep_holder.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:98

void POA_CosLoadBalancing::AMI_StrategyHandler::next_member_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_CosLoadBalancing::AMI_StrategyHandler *_tao_impl =
    static_cast<
        POA_CosLoadBalancing::AMI_StrategyHandler *> (
        _tao_servant
      );
  _tao_server_request.argument_flag (0);
  
  ::CORBA::Object_var ami_return_val;
  
  if (!(
      (_tao_in >> ami_return_val.out ())
      ))
    {
      TAO_InputCDR::throw_skel_exception (errno ACE_ENV_ARG_PARAMETER);
      ACE_CHECK;
    }
  
#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_Object_Adapter::Servant_Upcall *_tao_upcall =
    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_CosLoadBalancing_AMI_StrategyHandler_next_member _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl,
      
      ami_return_val.in ()
      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* 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->next_member (
                  ami_return_val.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:98

void POA_CosLoadBalancing::AMI_StrategyHandler::next_member_excep_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_CosLoadBalancing::AMI_StrategyHandler *_tao_impl =
    static_cast<
        POA_CosLoadBalancing::AMI_StrategyHandler *> (
        _tao_servant
      );
  _tao_server_request.argument_flag (0);
  
  ::CosLoadBalancing::AMI_StrategyExceptionHolder_var excep_holder;
  
  if (!(
      (_tao_in >> excep_holder.out ())
      ))
    {
      TAO_InputCDR::throw_skel_exception (errno ACE_ENV_ARG_PARAMETER);
      ACE_CHECK;
    }
  
#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_Object_Adapter::Servant_Upcall *_tao_upcall =
    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_CosLoadBalancing_AMI_StrategyHandler_next_member_excep _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl,
      
      excep_holder.in ()
      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* 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->next_member_excep (
                  excep_holder.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_interface/interface_ss.cpp:162

void POA_CosLoadBalancing::AMI_StrategyHandler::_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_CosLoadBalancing::AMI_StrategyHandler *_tao_impl =
    (POA_CosLoadBalancing::AMI_StrategyHandler *) _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_CosLoadBalancing::AMI_StrategyHandler::_non_existent_skel (
    TAO_ServerRequest &_tao_server_request, 
    void * _tao_servant,
    void * /* Servant_Upcall */
    ACE_ENV_ARG_DECL
  )
{
  POA_CosLoadBalancing::AMI_StrategyHandler *_tao_impl =
    (POA_CosLoadBalancing::AMI_StrategyHandler *) _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_CosLoadBalancing::AMI_StrategyHandler::_interface_skel (
    TAO_ServerRequest &_tao_server_request, 
    void * _tao_servant,
    void * /* Servant_Upcall */
    ACE_ENV_ARG_DECL
  )
{
  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 ());
    }
  
  POA_CosLoadBalancing::AMI_StrategyHandler *_tao_impl =
    (POA_CosLoadBalancing::AMI_StrategyHandler *) _tao_servant;
  
  CORBA::InterfaceDef_ptr _tao_retval = 
    _tao_impl->_get_interface (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK;
  
  _tao_server_request.init_reply ();
  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
  
  CORBA::Boolean _tao_result =
    _tao_adapter->interfacedef_cdr_insert (
        _tao_out,
        _tao_retval
      );
  
  _tao_adapter->dispose (_tao_retval);
  
  if (_tao_result == 0)
    {
      ACE_THROW (CORBA::MARSHAL ());
    }
}

void POA_CosLoadBalancing::AMI_StrategyHandler::_component_skel (
    TAO_ServerRequest &_tao_server_request, 
    void * _tao_object_reference,
    void * /* Servant_Upcall */
    ACE_ENV_ARG_DECL
  )
{
  POA_CosLoadBalancing::AMI_StrategyHandler *_tao_impl =
    (POA_CosLoadBalancing::AMI_StrategyHandler *) _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.in ()))
    {
      ACE_THROW (CORBA::MARSHAL ());
    }
}

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

void* POA_CosLoadBalancing::AMI_StrategyHandler::_downcast (
    const char* logical_type_id
  )
{
  if (ACE_OS::strcmp (logical_type_id,
                      "IDL:ReplyHandler:1.0") == 0)
    {
      return static_cast<POA_Messaging::ReplyHandler_ptr> (this);
    }
  
  if (ACE_OS::strcmp (logical_type_id,
                      "IDL:AMI_StrategyHandler:1.0") == 0)
    {
      return static_cast<POA_CosLoadBalancing::AMI_StrategyHandler_ptr> (this);
    }
  
  if (ACE_OS::strcmp (logical_type_id,
                      "IDL:omg.org/CORBA/Object:1.0") == 0)
    {
      return static_cast<PortableServer::Servant> (this);
    }
  
  return 0;
}

const char* POA_CosLoadBalancing::AMI_StrategyHandler::_interface_repository_id (void) const
{
  return "IDL:AMI_StrategyHandler:1.0";
}

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

void POA_CosLoadBalancing::AMI_StrategyHandler::_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:526

CosLoadBalancing::AMI_StrategyHandler *
POA_CosLoadBalancing::AMI_StrategyHandler::_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 ();
  
  typedef ::CosLoadBalancing::AMI_StrategyHandler STUB_SCOPED_NAME;
  return
    TAO::Narrow_Utils<STUB_SCOPED_NAME>::unchecked_narrow (
        obj.in (),
        CosLoadBalancing__TAO_AMI_StrategyHandler_Proxy_Broker_Factory_function_pointer
      );
}

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

class TAO_CosLoadBalancing_LoadAlert_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: /work/a/ports/devel/ace+tao/work/ACE_wrappers/bin/gperf -m -M -J -c -C -D -E -T -f 0 -F 0,0,0 -a -o -t -p -K opname_ -L C++ -Z TAO_CosLoadBalancing_LoadAlert_Perfect_Hash_OpTable -N lookup  */
unsigned int
TAO_CosLoadBalancing_LoadAlert_Perfect_Hash_OpTable::hash (const char *str, unsigned int len)
{
  static const unsigned char asso_values[] =
    {
#if defined (ACE_MVS)
     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19, 19,  0,
     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19, 19,  0,
     19, 19,  5,  5, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19,  0, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19,
#else
     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19,  0, 19,  0, 19, 19,
      5,  5, 19, 19, 19, 19, 19, 19, 19, 19,
     19, 19, 19, 19, 19, 19,  0, 19, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
#endif /* ACE_MVS */
    };
  return len + asso_values[(int) str[len - 1]] + asso_values[(int) str[0]];
}

const class TAO_operation_db_entry *
TAO_CosLoadBalancing_LoadAlert_Perfect_Hash_OpTable::lookup (const char *str, unsigned int len)
{
  enum
    {
      TOTAL_KEYWORDS = 6,
      MIN_WORD_LENGTH = 5,
      MAX_WORD_LENGTH = 13,
      MIN_HASH_VALUE = 5,
      MAX_HASH_VALUE = 18,
      HASH_VALUE_RANGE = 14,
      DUPLICATES = 0,
      WORDLIST_SIZE = 11
    };

  static const class TAO_operation_db_entry  wordlist[] =
    {
      {"",0,0,0},{"",0,0,0},{"",0,0,0},{"",0,0,0},{"",0,0,0},
      {"_is_a", &POA_CosLoadBalancing::LoadAlert::_is_a_skel, 0, 0},
      {"",0,0,0},{"",0,0,0},{"",0,0,0},{"",0,0,0},
      {"_component", &POA_CosLoadBalancing::LoadAlert::_component_skel, 0, 0},
      {"",0,0,0},{"",0,0,0},
      {"_non_existent", &POA_CosLoadBalancing::LoadAlert::_non_existent_skel, 0, 0},
      {"",0,0,0},
      {"_interface", &POA_CosLoadBalancing::LoadAlert::_interface_skel, 0, 0},
      {"",0,0,0},
      {"enable_alert", &POA_CosLoadBalancing::LoadAlert::enable_alert_skel, &POA_CosLoadBalancing::_TAO_LoadAlert_ThruPOA_Proxy_Impl::enable_alert, 0},
      {"disable_alert", &POA_CosLoadBalancing::LoadAlert::disable_alert_skel, &POA_CosLoadBalancing::_TAO_LoadAlert_ThruPOA_Proxy_Impl::disable_alert, 0},
    };

  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_CosLoadBalancing_LoadAlert_Perfect_Hash_OpTable tao_CosLoadBalancing_LoadAlert_optable;

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

#if (TAO_HAS_INTERCEPTORS == 1)

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:74

class TAO_ServerRequestInfo_CosLoadBalancing_LoadAlert_enable_alert : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_CosLoadBalancing_LoadAlert_enable_alert (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_CosLoadBalancing::LoadAlert *tao_impl
      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_CosLoadBalancing_LoadAlert_enable_alert (
      const TAO_ServerRequestInfo_CosLoadBalancing_LoadAlert_enable_alert &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_CosLoadBalancing_LoadAlert_enable_alert &
    );
  
private:
  POA_CosLoadBalancing::LoadAlert *_tao_impl;
  
};

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:438

TAO_ServerRequestInfo_CosLoadBalancing_LoadAlert_enable_alert::TAO_ServerRequestInfo_CosLoadBalancing_LoadAlert_enable_alert (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_CosLoadBalancing::LoadAlert *tao_impl
    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl)
{}

Dynamic::ParameterList *
TAO_ServerRequestInfo_CosLoadBalancing_LoadAlert_enable_alert::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_ServerRequestInfo_CosLoadBalancing_LoadAlert_enable_alert::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_ServerRequestInfo_CosLoadBalancing_LoadAlert_enable_alert::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_CosLoadBalancing_LoadAlert_enable_alert::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_CosLoadBalancing_LoadAlert_enable_alert::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);
}

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:74

class TAO_ServerRequestInfo_CosLoadBalancing_LoadAlert_disable_alert : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_CosLoadBalancing_LoadAlert_disable_alert (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_CosLoadBalancing::LoadAlert *tao_impl
      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_CosLoadBalancing_LoadAlert_disable_alert (
      const TAO_ServerRequestInfo_CosLoadBalancing_LoadAlert_disable_alert &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_CosLoadBalancing_LoadAlert_disable_alert &
    );
  
private:
  POA_CosLoadBalancing::LoadAlert *_tao_impl;
  
};

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:438

TAO_ServerRequestInfo_CosLoadBalancing_LoadAlert_disable_alert::TAO_ServerRequestInfo_CosLoadBalancing_LoadAlert_disable_alert (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_CosLoadBalancing::LoadAlert *tao_impl
    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl)
{}

Dynamic::ParameterList *
TAO_ServerRequestInfo_CosLoadBalancing_LoadAlert_disable_alert::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_ServerRequestInfo_CosLoadBalancing_LoadAlert_disable_alert::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_ServerRequestInfo_CosLoadBalancing_LoadAlert_disable_alert::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_CosLoadBalancing_LoadAlert_disable_alert::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_CosLoadBalancing_LoadAlert_disable_alert::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);
}

#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_CosLoadBalancing::_TAO_LoadAlert_Strategized_Proxy_Broker *
POA_CosLoadBalancing::_TAO_LoadAlert_Strategized_Proxy_Broker::the_TAO_LoadAlert_Strategized_Proxy_Broker (void)
{
  static POA_CosLoadBalancing::_TAO_LoadAlert_Strategized_Proxy_Broker
  strategized_proxy_broker;
  
  return &strategized_proxy_broker;
}

POA_CosLoadBalancing::_TAO_LoadAlert_Strategized_Proxy_Broker::_TAO_LoadAlert_Strategized_Proxy_Broker (void)
{
}

POA_CosLoadBalancing::_TAO_LoadAlert_Strategized_Proxy_Broker::~_TAO_LoadAlert_Strategized_Proxy_Broker (void)
{
}

TAO::Collocation_Strategy
POA_CosLoadBalancing::_TAO_LoadAlert_Strategized_Proxy_Broker::get_strategy (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  TAO::Collocation_Strategy strategy =
    TAO_ORB_Core::collocation_strategy (obj ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (TAO::TAO_CS_REMOTE_STRATEGY);
  
  return strategy;
}

void
POA_CosLoadBalancing::_TAO_LoadAlert_Strategized_Proxy_Broker::dispatch (
    CORBA::Object_ptr obj,
    CORBA::Object_out forward_obj,
    TAO::Argument ** args,
    int num_args,
    const char * op,
    size_t op_len,
    TAO::Collocation_Strategy strategy
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::Exception))
{
  TAO_Object_Adapter::Servant_Upcall servant_upcall (
      obj->_stubobj ()->servant_orb_var ()->orb_core ()
    );
  
  TAO_Collocated_Skeleton collocated_skel;
  TAO_Abstract_ServantBase *servant = 0;
  
  if (strategy == TAO::TAO_CS_THRU_POA_STRATEGY)
    {
      servant_upcall.prepare_for_upcall (
          obj->_stubobj ()->object_key (),
          op,
          forward_obj
          ACE_ENV_ARG_PARAMETER
        );
      ACE_CHECK;
      
      servant_upcall.pre_invoke_collocated_request (
          ACE_ENV_SINGLE_ARG_PARAMETER
        );
      ACE_CHECK;
      
      servant = servant_upcall.servant ();
    }
  else
    {
      servant = obj->_servant ();
    }
  
  int status = servant->_find (op,
                               collocated_skel,
                               strategy,
                               op_len);
  
  if (status == -1)
    {
      ACE_THROW (CORBA::BAD_OPERATION ());
    }
  
  ACE_TRY
    {
      collocated_skel (servant,
                       args,
                       num_args
                       ACE_ENV_ARG_PARAMETER);
      ACE_TRY_CHECK;
    }
#if (TAO_HAS_MINIMUM_CORBA == 0)
  ACE_CATCH (PortableServer::ForwardRequest, forward_request)
    {
      forward_obj =
        CORBA::Object::_duplicate (forward_request.forward_reference.in ());
      return;
    }
#else
  ACE_CATCHANY
    {
      ACE_UNUSED_ARG (forward_obj);
      ACE_RE_THROW;
    }
#endif /* TAO_HAS_MINIMUM_CORBA */
  ACE_ENDTRY;
  ACE_CHECK;
}

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

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

TAO::Collocation_Proxy_Broker *
CosLoadBalancing__TAO_LoadAlert_Proxy_Broker_Factory_function (CORBA::Object_ptr)
{
  return
    ::POA_CosLoadBalancing::_TAO_LoadAlert_Strategized_Proxy_Broker::the_TAO_LoadAlert_Strategized_Proxy_Broker ();
}

int
CosLoadBalancing__TAO_LoadAlert_Proxy_Broker_Factory_Initializer (size_t)
{
  CosLoadBalancing__TAO_LoadAlert_Proxy_Broker_Factory_function_pointer = 
    CosLoadBalancing__TAO_LoadAlert_Proxy_Broker_Factory_function;
  
  return 0;
}

static int
CosLoadBalancing__TAO_LoadAlert_Proxy_Broker_Stub_Factory_Initializer_Scarecrow =
  CosLoadBalancing__TAO_LoadAlert_Proxy_Broker_Factory_Initializer (
      reinterpret_cast<
          size_t> (
          CosLoadBalancing__TAO_LoadAlert_Proxy_Broker_Factory_Initializer
        )
    );


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

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

POA_CosLoadBalancing::_TAO_LoadAlert_ThruPOA_Proxy_Impl::_TAO_LoadAlert_ThruPOA_Proxy_Impl (void)
{}

// ThruPOA Implementation of the IDL interface methods

// TAO_IDL - Generated from 
// be/be_visitor_operation/thru_poa_proxy_impl_ss.cpp:52

void
POA_CosLoadBalancing::_TAO_LoadAlert_ThruPOA_Proxy_Impl::enable_alert (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument **,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  reinterpret_cast<
      POA_CosLoadBalancing::LoadAlert_ptr> (
      servant->_downcast (
          "IDL:omg.org/CosLoadBalancing/LoadAlert:1.0"
        )
    )->enable_alert (
        ACE_ENV_SINGLE_ARG_PARAMETER
      );
  ACE_CHECK;
}

// TAO_IDL - Generated from 
// be/be_visitor_operation/thru_poa_proxy_impl_ss.cpp:52

void
POA_CosLoadBalancing::_TAO_LoadAlert_ThruPOA_Proxy_Impl::disable_alert (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument **,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  reinterpret_cast<
      POA_CosLoadBalancing::LoadAlert_ptr> (
      servant->_downcast (
          "IDL:omg.org/CosLoadBalancing/LoadAlert:1.0"
        )
    )->disable_alert (
        ACE_ENV_SINGLE_ARG_PARAMETER
      );
  ACE_CHECK;
}

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

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

POA_CosLoadBalancing::LoadAlert::LoadAlert (void)
{
  this->optable_ = &tao_CosLoadBalancing_LoadAlert_optable;
}

POA_CosLoadBalancing::LoadAlert::LoadAlert (const LoadAlert& rhs)
  : TAO_Abstract_ServantBase (rhs),
    TAO_ServantBase (rhs)
{
}

POA_CosLoadBalancing::LoadAlert::~LoadAlert (void)
{
}

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

void POA_CosLoadBalancing::LoadAlert::enable_alert_skel (
    TAO_ServerRequest &_tao_server_request,
    void *_tao_servant,
    void *_tao_servant_upcall
    ACE_ENV_ARG_DECL
  )
{
  POA_CosLoadBalancing::LoadAlert *_tao_impl =
    static_cast<
        POA_CosLoadBalancing::LoadAlert *> (
        _tao_servant
      );
  _tao_server_request.argument_flag (0);
  
  
#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_Object_Adapter::Servant_Upcall *_tao_upcall =
    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_CosLoadBalancing_LoadAlert_enable_alert _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl
      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* 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->enable_alert (
                  ACE_ENV_SINGLE_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:98

void POA_CosLoadBalancing::LoadAlert::disable_alert_skel (
    TAO_ServerRequest &_tao_server_request,
    void *_tao_servant,
    void *_tao_servant_upcall
    ACE_ENV_ARG_DECL
  )
{
  POA_CosLoadBalancing::LoadAlert *_tao_impl =
    static_cast<
        POA_CosLoadBalancing::LoadAlert *> (
        _tao_servant
      );
  _tao_server_request.argument_flag (0);
  
  
#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_Object_Adapter::Servant_Upcall *_tao_upcall =
    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_CosLoadBalancing_LoadAlert_disable_alert _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl
      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* 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->disable_alert (
                  ACE_ENV_SINGLE_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_interface/interface_ss.cpp:162

void POA_CosLoadBalancing::LoadAlert::_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_CosLoadBalancing::LoadAlert *_tao_impl =
    (POA_CosLoadBalancing::LoadAlert *) _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_CosLoadBalancing::LoadAlert::_non_existent_skel (
    TAO_ServerRequest &_tao_server_request, 
    void * _tao_servant,
    void * /* Servant_Upcall */
    ACE_ENV_ARG_DECL
  )
{
  POA_CosLoadBalancing::LoadAlert *_tao_impl =
    (POA_CosLoadBalancing::LoadAlert *) _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_CosLoadBalancing::LoadAlert::_interface_skel (
    TAO_ServerRequest &_tao_server_request, 
    void * _tao_servant,
    void * /* Servant_Upcall */
    ACE_ENV_ARG_DECL
  )
{
  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 ());
    }
  
  POA_CosLoadBalancing::LoadAlert *_tao_impl =
    (POA_CosLoadBalancing::LoadAlert *) _tao_servant;
  
  CORBA::InterfaceDef_ptr _tao_retval = 
    _tao_impl->_get_interface (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK;
  
  _tao_server_request.init_reply ();
  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
  
  CORBA::Boolean _tao_result =
    _tao_adapter->interfacedef_cdr_insert (
        _tao_out,
        _tao_retval
      );
  
  _tao_adapter->dispose (_tao_retval);
  
  if (_tao_result == 0)
    {
      ACE_THROW (CORBA::MARSHAL ());
    }
}

void POA_CosLoadBalancing::LoadAlert::_component_skel (
    TAO_ServerRequest &_tao_server_request, 
    void * _tao_object_reference,
    void * /* Servant_Upcall */
    ACE_ENV_ARG_DECL
  )
{
  POA_CosLoadBalancing::LoadAlert *_tao_impl =
    (POA_CosLoadBalancing::LoadAlert *) _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.in ()))
    {
      ACE_THROW (CORBA::MARSHAL ());
    }
}

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

void* POA_CosLoadBalancing::LoadAlert::_downcast (
    const char* logical_type_id
  )
{
  if (ACE_OS::strcmp (logical_type_id,
                      "IDL:omg.org/CosLoadBalancing/LoadAlert:1.0") == 0)
    {
      return static_cast<POA_CosLoadBalancing::LoadAlert_ptr> (this);
    }
  
  if (ACE_OS::strcmp (logical_type_id,
                      "IDL:omg.org/CORBA/Object:1.0") == 0)
    {
      return static_cast<PortableServer::Servant> (this);
    }
  
  return 0;
}

const char* POA_CosLoadBalancing::LoadAlert::_interface_repository_id (void) const
{
  return "IDL:omg.org/CosLoadBalancing/LoadAlert:1.0";
}

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

void POA_CosLoadBalancing::LoadAlert::_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:526

CosLoadBalancing::LoadAlert *
POA_CosLoadBalancing::LoadAlert::_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 ();
  
  typedef ::CosLoadBalancing::LoadAlert STUB_SCOPED_NAME;
  return
    TAO::Narrow_Utils<STUB_SCOPED_NAME>::unchecked_narrow (
        obj.in (),
        CosLoadBalancing__TAO_LoadAlert_Proxy_Broker_Factory_function_pointer
      );
}

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

class TAO_CosLoadBalancing_AMI_LoadAlertHandler_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: /work/a/ports/devel/ace+tao/work/ACE_wrappers/bin/gperf -m -M -J -c -C -D -E -T -f 0 -F 0,0,0 -a -o -t -p -K opname_ -L C++ -Z TAO_CosLoadBalancing_AMI_LoadAlertHandler_Perfect_Hash_OpTable -N lookup  */
unsigned int
TAO_CosLoadBalancing_AMI_LoadAlertHandler_Perfect_Hash_OpTable::hash (const char *str, unsigned int len)
{
  static const unsigned char asso_values[] =
    {
#if defined (ACE_MVS)
     25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
     25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
     25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
     25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
     25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
     25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
     25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
     25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
     25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
     25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
     25, 25, 25, 25, 25, 25, 25, 25, 25,  0,
     25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
     25, 25, 25, 25, 25, 25, 25, 25, 25,  0,
     25, 25,  5,  5, 25, 25, 25, 25, 25, 25,
     25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
     25,  0, 25, 25, 25, 25, 25, 25, 25, 25,
     25, 25, 25,  0, 25, 25, 25, 25, 25, 25,
     25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
     25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
     25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
     25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
     25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
     25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
     25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
     25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
     25, 25, 25, 25, 25, 25,
#else
     25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
     25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
     25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
     25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
     25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
     25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
     25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
     25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
     25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
     25, 25, 25, 25, 25,  0, 25,  0, 25, 25,
      5,  5, 25, 25, 25, 25, 25, 25, 25, 25,
     25, 25,  0, 25, 25, 25,  0, 25, 25, 25,
     25, 25, 25, 25, 25, 25, 25, 25,
#endif /* ACE_MVS */
    };
  return len + asso_values[(int) str[len - 1]] + asso_values[(int) str[0]];
}

const class TAO_operation_db_entry *
TAO_CosLoadBalancing_AMI_LoadAlertHandler_Perfect_Hash_OpTable::lookup (const char *str, unsigned int len)
{
  enum
    {
      TOTAL_KEYWORDS = 8,
      MIN_WORD_LENGTH = 5,
      MAX_WORD_LENGTH = 19,
      MIN_HASH_VALUE = 5,
      MAX_HASH_VALUE = 24,
      HASH_VALUE_RANGE = 20,
      DUPLICATES = 0,
      WORDLIST_SIZE = 13
    };

  static const class TAO_operation_db_entry  wordlist[] =
    {
      {"",0,0,0},{"",0,0,0},{"",0,0,0},{"",0,0,0},{"",0,0,0},
      {"_is_a", &POA_CosLoadBalancing::AMI_LoadAlertHandler::_is_a_skel, 0, 0},
      {"",0,0,0},{"",0,0,0},{"",0,0,0},{"",0,0,0},
      {"_component", &POA_CosLoadBalancing::AMI_LoadAlertHandler::_component_skel, 0, 0},
      {"",0,0,0},{"",0,0,0},
      {"_non_existent", &POA_CosLoadBalancing::AMI_LoadAlertHandler::_non_existent_skel, 0, 0},
      {"",0,0,0},
      {"_interface", &POA_CosLoadBalancing::AMI_LoadAlertHandler::_interface_skel, 0, 0},
      {"",0,0,0},
      {"enable_alert", &POA_CosLoadBalancing::AMI_LoadAlertHandler::enable_alert_skel, &POA_CosLoadBalancing::_TAO_AMI_LoadAlertHandler_ThruPOA_Proxy_Impl::enable_alert, 0},
      {"disable_alert", &POA_CosLoadBalancing::AMI_LoadAlertHandler::disable_alert_skel, &POA_CosLoadBalancing::_TAO_AMI_LoadAlertHandler_ThruPOA_Proxy_Impl::disable_alert, 0},
      {"",0,0,0},{"",0,0,0},{"",0,0,0},{"",0,0,0},
      {"enable_alert_excep", &POA_CosLoadBalancing::AMI_LoadAlertHandler::enable_alert_excep_skel, &POA_CosLoadBalancing::_TAO_AMI_LoadAlertHandler_ThruPOA_Proxy_Impl::enable_alert_excep, 0},
      {"disable_alert_excep", &POA_CosLoadBalancing::AMI_LoadAlertHandler::disable_alert_excep_skel, &POA_CosLoadBalancing::_TAO_AMI_LoadAlertHandler_ThruPOA_Proxy_Impl::disable_alert_excep, 0},
    };

  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_CosLoadBalancing_AMI_LoadAlertHandler_Perfect_Hash_OpTable tao_CosLoadBalancing_AMI_LoadAlertHandler_optable;

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

#if (TAO_HAS_INTERCEPTORS == 1)

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:74

class TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadAlertHandler_enable_alert : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadAlertHandler_enable_alert (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_CosLoadBalancing::AMI_LoadAlertHandler *tao_impl
      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_CosLoadBalancing_AMI_LoadAlertHandler_enable_alert (
      const TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadAlertHandler_enable_alert &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadAlertHandler_enable_alert &
    );
  
private:
  POA_CosLoadBalancing::AMI_LoadAlertHandler *_tao_impl;
  
};

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:438

TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadAlertHandler_enable_alert::TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadAlertHandler_enable_alert (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_CosLoadBalancing::AMI_LoadAlertHandler *tao_impl
    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl)
{}

Dynamic::ParameterList *
TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadAlertHandler_enable_alert::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_ServerRequestInfo_CosLoadBalancing_AMI_LoadAlertHandler_enable_alert::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_ServerRequestInfo_CosLoadBalancing_AMI_LoadAlertHandler_enable_alert::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_CosLoadBalancing_AMI_LoadAlertHandler_enable_alert::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_CosLoadBalancing_AMI_LoadAlertHandler_enable_alert::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);
}

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:74

class TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadAlertHandler_enable_alert_excep : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadAlertHandler_enable_alert_excep (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_CosLoadBalancing::AMI_LoadAlertHandler *tao_impl,
      ::CosLoadBalancing::AMI_LoadAlertExceptionHolder * excep_holder
      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_CosLoadBalancing_AMI_LoadAlertHandler_enable_alert_excep (
      const TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadAlertHandler_enable_alert_excep &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadAlertHandler_enable_alert_excep &
    );
  
private:
  POA_CosLoadBalancing::AMI_LoadAlertHandler *_tao_impl;
  
  ::CosLoadBalancing::AMI_LoadAlertExceptionHolder * excep_holder_;
};

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:438

TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadAlertHandler_enable_alert_excep::TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadAlertHandler_enable_alert_excep (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_CosLoadBalancing::AMI_LoadAlertHandler *tao_impl,
    ::CosLoadBalancing::AMI_LoadAlertExceptionHolder * excep_holder
    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl),
    excep_holder_ (excep_holder)
{}

Dynamic::ParameterList *
TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadAlertHandler_enable_alert_excep::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_ServerRequestInfo_CosLoadBalancing_AMI_LoadAlertHandler_enable_alert_excep::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_ServerRequestInfo_CosLoadBalancing_AMI_LoadAlertHandler_enable_alert_excep::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_CosLoadBalancing_AMI_LoadAlertHandler_enable_alert_excep::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_CosLoadBalancing_AMI_LoadAlertHandler_enable_alert_excep::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);
}

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:74

class TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadAlertHandler_disable_alert : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadAlertHandler_disable_alert (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_CosLoadBalancing::AMI_LoadAlertHandler *tao_impl
      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_CosLoadBalancing_AMI_LoadAlertHandler_disable_alert (
      const TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadAlertHandler_disable_alert &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadAlertHandler_disable_alert &
    );
  
private:
  POA_CosLoadBalancing::AMI_LoadAlertHandler *_tao_impl;
  
};

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:438

TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadAlertHandler_disable_alert::TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadAlertHandler_disable_alert (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_CosLoadBalancing::AMI_LoadAlertHandler *tao_impl
    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl)
{}

Dynamic::ParameterList *
TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadAlertHandler_disable_alert::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_ServerRequestInfo_CosLoadBalancing_AMI_LoadAlertHandler_disable_alert::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_ServerRequestInfo_CosLoadBalancing_AMI_LoadAlertHandler_disable_alert::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_CosLoadBalancing_AMI_LoadAlertHandler_disable_alert::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_CosLoadBalancing_AMI_LoadAlertHandler_disable_alert::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);
}

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:74

class TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadAlertHandler_disable_alert_excep : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadAlertHandler_disable_alert_excep (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_CosLoadBalancing::AMI_LoadAlertHandler *tao_impl,
      ::CosLoadBalancing::AMI_LoadAlertExceptionHolder * excep_holder
      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_CosLoadBalancing_AMI_LoadAlertHandler_disable_alert_excep (
      const TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadAlertHandler_disable_alert_excep &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadAlertHandler_disable_alert_excep &
    );
  
private:
  POA_CosLoadBalancing::AMI_LoadAlertHandler *_tao_impl;
  
  ::CosLoadBalancing::AMI_LoadAlertExceptionHolder * excep_holder_;
};

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:438

TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadAlertHandler_disable_alert_excep::TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadAlertHandler_disable_alert_excep (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_CosLoadBalancing::AMI_LoadAlertHandler *tao_impl,
    ::CosLoadBalancing::AMI_LoadAlertExceptionHolder * excep_holder
    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl),
    excep_holder_ (excep_holder)
{}

Dynamic::ParameterList *
TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadAlertHandler_disable_alert_excep::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_ServerRequestInfo_CosLoadBalancing_AMI_LoadAlertHandler_disable_alert_excep::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_ServerRequestInfo_CosLoadBalancing_AMI_LoadAlertHandler_disable_alert_excep::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_CosLoadBalancing_AMI_LoadAlertHandler_disable_alert_excep::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_CosLoadBalancing_AMI_LoadAlertHandler_disable_alert_excep::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);
}

#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_CosLoadBalancing::_TAO_AMI_LoadAlertHandler_Strategized_Proxy_Broker *
POA_CosLoadBalancing::_TAO_AMI_LoadAlertHandler_Strategized_Proxy_Broker::the_TAO_AMI_LoadAlertHandler_Strategized_Proxy_Broker (void)
{
  static POA_CosLoadBalancing::_TAO_AMI_LoadAlertHandler_Strategized_Proxy_Broker
  strategized_proxy_broker;
  
  return &strategized_proxy_broker;
}

POA_CosLoadBalancing::_TAO_AMI_LoadAlertHandler_Strategized_Proxy_Broker::_TAO_AMI_LoadAlertHandler_Strategized_Proxy_Broker (void)
{
}

POA_CosLoadBalancing::_TAO_AMI_LoadAlertHandler_Strategized_Proxy_Broker::~_TAO_AMI_LoadAlertHandler_Strategized_Proxy_Broker (void)
{
}

TAO::Collocation_Strategy
POA_CosLoadBalancing::_TAO_AMI_LoadAlertHandler_Strategized_Proxy_Broker::get_strategy (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  TAO::Collocation_Strategy strategy =
    TAO_ORB_Core::collocation_strategy (obj ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (TAO::TAO_CS_REMOTE_STRATEGY);
  
  return strategy;
}

void
POA_CosLoadBalancing::_TAO_AMI_LoadAlertHandler_Strategized_Proxy_Broker::dispatch (
    CORBA::Object_ptr obj,
    CORBA::Object_out forward_obj,
    TAO::Argument ** args,
    int num_args,
    const char * op,
    size_t op_len,
    TAO::Collocation_Strategy strategy
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::Exception))
{
  TAO_Object_Adapter::Servant_Upcall servant_upcall (
      obj->_stubobj ()->servant_orb_var ()->orb_core ()
    );
  
  TAO_Collocated_Skeleton collocated_skel;
  TAO_Abstract_ServantBase *servant = 0;
  
  if (strategy == TAO::TAO_CS_THRU_POA_STRATEGY)
    {
      servant_upcall.prepare_for_upcall (
          obj->_stubobj ()->object_key (),
          op,
          forward_obj
          ACE_ENV_ARG_PARAMETER
        );
      ACE_CHECK;
      
      servant_upcall.pre_invoke_collocated_request (
          ACE_ENV_SINGLE_ARG_PARAMETER
        );
      ACE_CHECK;
      
      servant = servant_upcall.servant ();
    }
  else
    {
      servant = obj->_servant ();
    }
  
  int status = servant->_find (op,
                               collocated_skel,
                               strategy,
                               op_len);
  
  if (status == -1)
    {
      ACE_THROW (CORBA::BAD_OPERATION ());
    }
  
  ACE_TRY
    {
      collocated_skel (servant,
                       args,
                       num_args
                       ACE_ENV_ARG_PARAMETER);
      ACE_TRY_CHECK;
    }
#if (TAO_HAS_MINIMUM_CORBA == 0)
  ACE_CATCH (PortableServer::ForwardRequest, forward_request)
    {
      forward_obj =
        CORBA::Object::_duplicate (forward_request.forward_reference.in ());
      return;
    }
#else
  ACE_CATCHANY
    {
      ACE_UNUSED_ARG (forward_obj);
      ACE_RE_THROW;
    }
#endif /* TAO_HAS_MINIMUM_CORBA */
  ACE_ENDTRY;
  ACE_CHECK;
}

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

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

TAO::Collocation_Proxy_Broker *
CosLoadBalancing__TAO_AMI_LoadAlertHandler_Proxy_Broker_Factory_function (CORBA::Object_ptr)
{
  return
    ::POA_CosLoadBalancing::_TAO_AMI_LoadAlertHandler_Strategized_Proxy_Broker::the_TAO_AMI_LoadAlertHandler_Strategized_Proxy_Broker ();
}

int
CosLoadBalancing__TAO_AMI_LoadAlertHandler_Proxy_Broker_Factory_Initializer (size_t)
{
  CosLoadBalancing__TAO_AMI_LoadAlertHandler_Proxy_Broker_Factory_function_pointer = 
    CosLoadBalancing__TAO_AMI_LoadAlertHandler_Proxy_Broker_Factory_function;
  
  return 0;
}

static int
CosLoadBalancing__TAO_AMI_LoadAlertHandler_Proxy_Broker_Stub_Factory_Initializer_Scarecrow =
  CosLoadBalancing__TAO_AMI_LoadAlertHandler_Proxy_Broker_Factory_Initializer (
      reinterpret_cast<
          size_t> (
          CosLoadBalancing__TAO_AMI_LoadAlertHandler_Proxy_Broker_Factory_Initializer
        )
    );


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

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

POA_CosLoadBalancing::_TAO_AMI_LoadAlertHandler_ThruPOA_Proxy_Impl::_TAO_AMI_LoadAlertHandler_ThruPOA_Proxy_Impl (void)
{}

// ThruPOA Implementation of the IDL interface methods

// TAO_IDL - Generated from 
// be/be_visitor_operation/thru_poa_proxy_impl_ss.cpp:52

void
POA_CosLoadBalancing::_TAO_AMI_LoadAlertHandler_ThruPOA_Proxy_Impl::enable_alert (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument **,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  reinterpret_cast<
      POA_CosLoadBalancing::AMI_LoadAlertHandler_ptr> (
      servant->_downcast (
          "IDL:AMI_LoadAlertHandler:1.0"
        )
    )->enable_alert (
        ACE_ENV_SINGLE_ARG_PARAMETER
      );
  ACE_CHECK;
}

// TAO_IDL - Generated from 
// be/be_visitor_operation/thru_poa_proxy_impl_ss.cpp:52

void
POA_CosLoadBalancing::_TAO_AMI_LoadAlertHandler_ThruPOA_Proxy_Impl::enable_alert_excep (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument ** args,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  reinterpret_cast<
      POA_CosLoadBalancing::AMI_LoadAlertHandler_ptr> (
      servant->_downcast (
          "IDL:AMI_LoadAlertHandler:1.0"
        )
    )->enable_alert_excep (
        ((TAO::Arg_Traits< ::CosLoadBalancing::AMI_LoadAlertExceptionHolder>::in_arg_val *) args[1])->arg ()
        ACE_ENV_ARG_PARAMETER
      );
  ACE_CHECK;
}

// TAO_IDL - Generated from 
// be/be_visitor_operation/thru_poa_proxy_impl_ss.cpp:52

void
POA_CosLoadBalancing::_TAO_AMI_LoadAlertHandler_ThruPOA_Proxy_Impl::disable_alert (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument **,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  reinterpret_cast<
      POA_CosLoadBalancing::AMI_LoadAlertHandler_ptr> (
      servant->_downcast (
          "IDL:AMI_LoadAlertHandler:1.0"
        )
    )->disable_alert (
        ACE_ENV_SINGLE_ARG_PARAMETER
      );
  ACE_CHECK;
}

// TAO_IDL - Generated from 
// be/be_visitor_operation/thru_poa_proxy_impl_ss.cpp:52

void
POA_CosLoadBalancing::_TAO_AMI_LoadAlertHandler_ThruPOA_Proxy_Impl::disable_alert_excep (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument ** args,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  reinterpret_cast<
      POA_CosLoadBalancing::AMI_LoadAlertHandler_ptr> (
      servant->_downcast (
          "IDL:AMI_LoadAlertHandler:1.0"
        )
    )->disable_alert_excep (
        ((TAO::Arg_Traits< ::CosLoadBalancing::AMI_LoadAlertExceptionHolder>::in_arg_val *) args[1])->arg ()
        ACE_ENV_ARG_PARAMETER
      );
  ACE_CHECK;
}

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

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

POA_CosLoadBalancing::AMI_LoadAlertHandler::AMI_LoadAlertHandler (void)
{
  this->optable_ = &tao_CosLoadBalancing_AMI_LoadAlertHandler_optable;
}

POA_CosLoadBalancing::AMI_LoadAlertHandler::AMI_LoadAlertHandler (const AMI_LoadAlertHandler& rhs)
  : TAO_Abstract_ServantBase (rhs),
    TAO_ServantBase (rhs),
    ACE_NESTED_CLASS (POA_Messaging, ReplyHandler) (rhs)
{
}

POA_CosLoadBalancing::AMI_LoadAlertHandler::~AMI_LoadAlertHandler (void)
{
}

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

void POA_CosLoadBalancing::AMI_LoadAlertHandler::enable_alert_skel (
    TAO_ServerRequest &_tao_server_request,
    void *_tao_servant,
    void *_tao_servant_upcall
    ACE_ENV_ARG_DECL
  )
{
  POA_CosLoadBalancing::AMI_LoadAlertHandler *_tao_impl =
    static_cast<
        POA_CosLoadBalancing::AMI_LoadAlertHandler *> (
        _tao_servant
      );
  _tao_server_request.argument_flag (0);
  
  
#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_Object_Adapter::Servant_Upcall *_tao_upcall =
    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_CosLoadBalancing_AMI_LoadAlertHandler_enable_alert _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl
      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* 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->enable_alert (
                  ACE_ENV_SINGLE_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:98

void POA_CosLoadBalancing::AMI_LoadAlertHandler::enable_alert_excep_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_CosLoadBalancing::AMI_LoadAlertHandler *_tao_impl =
    static_cast<
        POA_CosLoadBalancing::AMI_LoadAlertHandler *> (
        _tao_servant
      );
  _tao_server_request.argument_flag (0);
  
  ::CosLoadBalancing::AMI_LoadAlertExceptionHolder_var excep_holder;
  
  if (!(
      (_tao_in >> excep_holder.out ())
      ))
    {
      TAO_InputCDR::throw_skel_exception (errno ACE_ENV_ARG_PARAMETER);
      ACE_CHECK;
    }
  
#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_Object_Adapter::Servant_Upcall *_tao_upcall =
    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_CosLoadBalancing_AMI_LoadAlertHandler_enable_alert_excep _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl,
      
      excep_holder.in ()
      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* 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->enable_alert_excep (
                  excep_holder.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:98

void POA_CosLoadBalancing::AMI_LoadAlertHandler::disable_alert_skel (
    TAO_ServerRequest &_tao_server_request,
    void *_tao_servant,
    void *_tao_servant_upcall
    ACE_ENV_ARG_DECL
  )
{
  POA_CosLoadBalancing::AMI_LoadAlertHandler *_tao_impl =
    static_cast<
        POA_CosLoadBalancing::AMI_LoadAlertHandler *> (
        _tao_servant
      );
  _tao_server_request.argument_flag (0);
  
  
#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_Object_Adapter::Servant_Upcall *_tao_upcall =
    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_CosLoadBalancing_AMI_LoadAlertHandler_disable_alert _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl
      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* 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->disable_alert (
                  ACE_ENV_SINGLE_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:98

void POA_CosLoadBalancing::AMI_LoadAlertHandler::disable_alert_excep_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_CosLoadBalancing::AMI_LoadAlertHandler *_tao_impl =
    static_cast<
        POA_CosLoadBalancing::AMI_LoadAlertHandler *> (
        _tao_servant
      );
  _tao_server_request.argument_flag (0);
  
  ::CosLoadBalancing::AMI_LoadAlertExceptionHolder_var excep_holder;
  
  if (!(
      (_tao_in >> excep_holder.out ())
      ))
    {
      TAO_InputCDR::throw_skel_exception (errno ACE_ENV_ARG_PARAMETER);
      ACE_CHECK;
    }
  
#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_Object_Adapter::Servant_Upcall *_tao_upcall =
    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_CosLoadBalancing_AMI_LoadAlertHandler_disable_alert_excep _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl,
      
      excep_holder.in ()
      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* 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->disable_alert_excep (
                  excep_holder.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_interface/interface_ss.cpp:162

void POA_CosLoadBalancing::AMI_LoadAlertHandler::_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_CosLoadBalancing::AMI_LoadAlertHandler *_tao_impl =
    (POA_CosLoadBalancing::AMI_LoadAlertHandler *) _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_CosLoadBalancing::AMI_LoadAlertHandler::_non_existent_skel (
    TAO_ServerRequest &_tao_server_request, 
    void * _tao_servant,
    void * /* Servant_Upcall */
    ACE_ENV_ARG_DECL
  )
{
  POA_CosLoadBalancing::AMI_LoadAlertHandler *_tao_impl =
    (POA_CosLoadBalancing::AMI_LoadAlertHandler *) _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_CosLoadBalancing::AMI_LoadAlertHandler::_interface_skel (
    TAO_ServerRequest &_tao_server_request, 
    void * _tao_servant,
    void * /* Servant_Upcall */
    ACE_ENV_ARG_DECL
  )
{
  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 ());
    }
  
  POA_CosLoadBalancing::AMI_LoadAlertHandler *_tao_impl =
    (POA_CosLoadBalancing::AMI_LoadAlertHandler *) _tao_servant;
  
  CORBA::InterfaceDef_ptr _tao_retval = 
    _tao_impl->_get_interface (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK;
  
  _tao_server_request.init_reply ();
  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
  
  CORBA::Boolean _tao_result =
    _tao_adapter->interfacedef_cdr_insert (
        _tao_out,
        _tao_retval
      );
  
  _tao_adapter->dispose (_tao_retval);
  
  if (_tao_result == 0)
    {
      ACE_THROW (CORBA::MARSHAL ());
    }
}

void POA_CosLoadBalancing::AMI_LoadAlertHandler::_component_skel (
    TAO_ServerRequest &_tao_server_request, 
    void * _tao_object_reference,
    void * /* Servant_Upcall */
    ACE_ENV_ARG_DECL
  )
{
  POA_CosLoadBalancing::AMI_LoadAlertHandler *_tao_impl =
    (POA_CosLoadBalancing::AMI_LoadAlertHandler *) _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.in ()))
    {
      ACE_THROW (CORBA::MARSHAL ());
    }
}

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

void* POA_CosLoadBalancing::AMI_LoadAlertHandler::_downcast (
    const char* logical_type_id
  )
{
  if (ACE_OS::strcmp (logical_type_id,
                      "IDL:ReplyHandler:1.0") == 0)
    {
      return static_cast<POA_Messaging::ReplyHandler_ptr> (this);
    }
  
  if (ACE_OS::strcmp (logical_type_id,
                      "IDL:AMI_LoadAlertHandler:1.0") == 0)
    {
      return static_cast<POA_CosLoadBalancing::AMI_LoadAlertHandler_ptr> (this);
    }
  
  if (ACE_OS::strcmp (logical_type_id,
                      "IDL:omg.org/CORBA/Object:1.0") == 0)
    {
      return static_cast<PortableServer::Servant> (this);
    }
  
  return 0;
}

const char* POA_CosLoadBalancing::AMI_LoadAlertHandler::_interface_repository_id (void) const
{
  return "IDL:AMI_LoadAlertHandler:1.0";
}

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

void POA_CosLoadBalancing::AMI_LoadAlertHandler::_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:526

CosLoadBalancing::AMI_LoadAlertHandler *
POA_CosLoadBalancing::AMI_LoadAlertHandler::_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 ();
  
  typedef ::CosLoadBalancing::AMI_LoadAlertHandler STUB_SCOPED_NAME;
  return
    TAO::Narrow_Utils<STUB_SCOPED_NAME>::unchecked_narrow (
        obj.in (),
        CosLoadBalancing__TAO_AMI_LoadAlertHandler_Proxy_Broker_Factory_function_pointer
      );
}

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

class TAO_CosLoadBalancing_LoadMonitor_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: /work/a/ports/devel/ace+tao/work/ACE_wrappers/bin/gperf -m -M -J -c -C -D -E -T -f 0 -F 0,0,0 -a -o -t -p -K opname_ -L C++ -Z TAO_CosLoadBalancing_LoadMonitor_Perfect_Hash_OpTable -N lookup  */
unsigned int
TAO_CosLoadBalancing_LoadMonitor_Perfect_Hash_OpTable::hash (const char *str, unsigned int len)
{
  static const unsigned char asso_values[] =
    {
#if defined (ACE_MVS)
     18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
     18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
     18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
     18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
     18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
     18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
     18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
     18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
     18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
     18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
     18, 18, 18, 18, 18, 18, 18, 18, 18,  0,
     18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
     18, 18, 18, 18, 18, 18, 18, 18, 18,  0,
     18, 18, 18,  5, 18, 18, 18, 18, 18, 18,
     18, 18, 18, 18, 18, 18, 18, 18, 18,  0,
     18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
     18, 18,  2,  0, 18, 18, 18, 18, 18, 18,
     18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
     18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
     18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
     18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
     18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
     18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
     18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
     18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
     18, 18, 18, 18, 18, 18,
#else
     18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
     18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
     18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
     18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
     18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
     18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
     18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
     18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
     18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
     18, 18, 18, 18, 18,  0, 18,  0, 18, 18,
     18,  5, 18, 18, 18, 18, 18, 18, 18, 18,
      0, 18, 18, 18, 18,  2,  0, 18, 18, 18,
     18, 18, 18, 18, 18, 18, 18, 18,
#endif /* ACE_MVS */
    };
  return len + asso_values[(int) str[len - 1]] + asso_values[(int) str[0]];
}

const class TAO_operation_db_entry *
TAO_CosLoadBalancing_LoadMonitor_Perfect_Hash_OpTable::lookup (const char *str, unsigned int len)
{
  enum
    {
      TOTAL_KEYWORDS = 6,
      MIN_WORD_LENGTH = 5,
      MAX_WORD_LENGTH = 17,
      MIN_HASH_VALUE = 5,
      MAX_HASH_VALUE = 17,
      HASH_VALUE_RANGE = 13,
      DUPLICATES = 0,
      WORDLIST_SIZE = 11
    };

  static const class TAO_operation_db_entry  wordlist[] =
    {
      {"",0,0,0},{"",0,0,0},{"",0,0,0},{"",0,0,0},{"",0,0,0},
      {"_is_a", &POA_CosLoadBalancing::LoadMonitor::_is_a_skel, 0, 0},
      {"",0,0,0},{"",0,0,0},{"",0,0,0},{"",0,0,0},
      {"_component", &POA_CosLoadBalancing::LoadMonitor::_component_skel, 0, 0},
      {"",0,0,0},
      {"_get_loads", &POA_CosLoadBalancing::LoadMonitor::_get_loads_skel, &POA_CosLoadBalancing::_TAO_LoadMonitor_ThruPOA_Proxy_Impl::_get_loads, 0},
      {"_non_existent", &POA_CosLoadBalancing::LoadMonitor::_non_existent_skel, 0, 0},
      {"",0,0,0},
      {"_interface", &POA_CosLoadBalancing::LoadMonitor::_interface_skel, 0, 0},
      {"",0,0,0},
      {"_get_the_location", &POA_CosLoadBalancing::LoadMonitor::_get_the_location_skel, &POA_CosLoadBalancing::_TAO_LoadMonitor_ThruPOA_Proxy_Impl::_get_the_location, 0},
    };

  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_CosLoadBalancing_LoadMonitor_Perfect_Hash_OpTable tao_CosLoadBalancing_LoadMonitor_optable;

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

#if (TAO_HAS_INTERCEPTORS == 1)

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:74

class TAO_ServerRequestInfo_CosLoadBalancing_LoadMonitor_the_location_get : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_CosLoadBalancing_LoadMonitor_the_location_get (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_CosLoadBalancing::LoadMonitor *tao_impl
      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 (::CosLoadBalancing::Location * result);

private:
  TAO_ServerRequestInfo_CosLoadBalancing_LoadMonitor_the_location_get (
      const TAO_ServerRequestInfo_CosLoadBalancing_LoadMonitor_the_location_get &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_CosLoadBalancing_LoadMonitor_the_location_get &
    );
  
private:
  POA_CosLoadBalancing::LoadMonitor *_tao_impl;
  
  ::CosLoadBalancing::Location * _result;
};

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:438

TAO_ServerRequestInfo_CosLoadBalancing_LoadMonitor_the_location_get::TAO_ServerRequestInfo_CosLoadBalancing_LoadMonitor_the_location_get (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_CosLoadBalancing::LoadMonitor *tao_impl
    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl)
{}

Dynamic::ParameterList *
TAO_ServerRequestInfo_CosLoadBalancing_LoadMonitor_the_location_get::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_ServerRequestInfo_CosLoadBalancing_LoadMonitor_the_location_get::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_ServerRequestInfo_CosLoadBalancing_LoadMonitor_the_location_get::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_CosLoadBalancing_LoadMonitor_the_location_get::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_CosLoadBalancing_LoadMonitor_the_location_get::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_CosLoadBalancing_LoadMonitor_the_location_get::result (::CosLoadBalancing::Location * result)
{
  // Update the result.
   this->_result = result;
}

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:74

class TAO_ServerRequestInfo_CosLoadBalancing_LoadMonitor_loads_get : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_CosLoadBalancing_LoadMonitor_loads_get (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_CosLoadBalancing::LoadMonitor *tao_impl
      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 (::CosLoadBalancing::LoadList * result);

private:
  TAO_ServerRequestInfo_CosLoadBalancing_LoadMonitor_loads_get (
      const TAO_ServerRequestInfo_CosLoadBalancing_LoadMonitor_loads_get &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_CosLoadBalancing_LoadMonitor_loads_get &
    );
  
private:
  POA_CosLoadBalancing::LoadMonitor *_tao_impl;
  
  ::CosLoadBalancing::LoadList * _result;
};

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:438

TAO_ServerRequestInfo_CosLoadBalancing_LoadMonitor_loads_get::TAO_ServerRequestInfo_CosLoadBalancing_LoadMonitor_loads_get (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_CosLoadBalancing::LoadMonitor *tao_impl
    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl)
{}

Dynamic::ParameterList *
TAO_ServerRequestInfo_CosLoadBalancing_LoadMonitor_loads_get::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_ServerRequestInfo_CosLoadBalancing_LoadMonitor_loads_get::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_ServerRequestInfo_CosLoadBalancing_LoadMonitor_loads_get::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_CosLoadBalancing_LoadMonitor_loads_get::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_CosLoadBalancing_LoadMonitor_loads_get::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_CosLoadBalancing_LoadMonitor_loads_get::result (::CosLoadBalancing::LoadList * 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_CosLoadBalancing::_TAO_LoadMonitor_Strategized_Proxy_Broker *
POA_CosLoadBalancing::_TAO_LoadMonitor_Strategized_Proxy_Broker::the_TAO_LoadMonitor_Strategized_Proxy_Broker (void)
{
  static POA_CosLoadBalancing::_TAO_LoadMonitor_Strategized_Proxy_Broker
  strategized_proxy_broker;
  
  return &strategized_proxy_broker;
}

POA_CosLoadBalancing::_TAO_LoadMonitor_Strategized_Proxy_Broker::_TAO_LoadMonitor_Strategized_Proxy_Broker (void)
{
}

POA_CosLoadBalancing::_TAO_LoadMonitor_Strategized_Proxy_Broker::~_TAO_LoadMonitor_Strategized_Proxy_Broker (void)
{
}

TAO::Collocation_Strategy
POA_CosLoadBalancing::_TAO_LoadMonitor_Strategized_Proxy_Broker::get_strategy (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  TAO::Collocation_Strategy strategy =
    TAO_ORB_Core::collocation_strategy (obj ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (TAO::TAO_CS_REMOTE_STRATEGY);
  
  return strategy;
}

void
POA_CosLoadBalancing::_TAO_LoadMonitor_Strategized_Proxy_Broker::dispatch (
    CORBA::Object_ptr obj,
    CORBA::Object_out forward_obj,
    TAO::Argument ** args,
    int num_args,
    const char * op,
    size_t op_len,
    TAO::Collocation_Strategy strategy
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::Exception))
{
  TAO_Object_Adapter::Servant_Upcall servant_upcall (
      obj->_stubobj ()->servant_orb_var ()->orb_core ()
    );
  
  TAO_Collocated_Skeleton collocated_skel;
  TAO_Abstract_ServantBase *servant = 0;
  
  if (strategy == TAO::TAO_CS_THRU_POA_STRATEGY)
    {
      servant_upcall.prepare_for_upcall (
          obj->_stubobj ()->object_key (),
          op,
          forward_obj
          ACE_ENV_ARG_PARAMETER
        );
      ACE_CHECK;
      
      servant_upcall.pre_invoke_collocated_request (
          ACE_ENV_SINGLE_ARG_PARAMETER
        );
      ACE_CHECK;
      
      servant = servant_upcall.servant ();
    }
  else
    {
      servant = obj->_servant ();
    }
  
  int status = servant->_find (op,
                               collocated_skel,
                               strategy,
                               op_len);
  
  if (status == -1)
    {
      ACE_THROW (CORBA::BAD_OPERATION ());
    }
  
  ACE_TRY
    {
      collocated_skel (servant,
                       args,
                       num_args
                       ACE_ENV_ARG_PARAMETER);
      ACE_TRY_CHECK;
    }
#if (TAO_HAS_MINIMUM_CORBA == 0)
  ACE_CATCH (PortableServer::ForwardRequest, forward_request)
    {
      forward_obj =
        CORBA::Object::_duplicate (forward_request.forward_reference.in ());
      return;
    }
#else
  ACE_CATCHANY
    {
      ACE_UNUSED_ARG (forward_obj);
      ACE_RE_THROW;
    }
#endif /* TAO_HAS_MINIMUM_CORBA */
  ACE_ENDTRY;
  ACE_CHECK;
}

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

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

TAO::Collocation_Proxy_Broker *
CosLoadBalancing__TAO_LoadMonitor_Proxy_Broker_Factory_function (CORBA::Object_ptr)
{
  return
    ::POA_CosLoadBalancing::_TAO_LoadMonitor_Strategized_Proxy_Broker::the_TAO_LoadMonitor_Strategized_Proxy_Broker ();
}

int
CosLoadBalancing__TAO_LoadMonitor_Proxy_Broker_Factory_Initializer (size_t)
{
  CosLoadBalancing__TAO_LoadMonitor_Proxy_Broker_Factory_function_pointer = 
    CosLoadBalancing__TAO_LoadMonitor_Proxy_Broker_Factory_function;
  
  return 0;
}

static int
CosLoadBalancing__TAO_LoadMonitor_Proxy_Broker_Stub_Factory_Initializer_Scarecrow =
  CosLoadBalancing__TAO_LoadMonitor_Proxy_Broker_Factory_Initializer (
      reinterpret_cast<
          size_t> (
          CosLoadBalancing__TAO_LoadMonitor_Proxy_Broker_Factory_Initializer
        )
    );


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

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

POA_CosLoadBalancing::_TAO_LoadMonitor_ThruPOA_Proxy_Impl::_TAO_LoadMonitor_ThruPOA_Proxy_Impl (void)
{}

// ThruPOA Implementation of the IDL interface methods

// TAO_IDL - Generated from 
// be/be_visitor_operation/thru_poa_proxy_impl_ss.cpp:52

void
POA_CosLoadBalancing::_TAO_LoadMonitor_ThruPOA_Proxy_Impl::_get_the_location (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument ** args,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  ((TAO::Arg_Traits< ::CosLoadBalancing::Location>::ret_val *) args[0])->arg () =
    reinterpret_cast<
        POA_CosLoadBalancing::LoadMonitor_ptr> (
        servant->_downcast (
            "IDL:omg.org/CosLoadBalancing/LoadMonitor:1.0"
          )
      )->the_location (
          ACE_ENV_SINGLE_ARG_PARAMETER
        );
  ACE_CHECK;
}

// TAO_IDL - Generated from 
// be/be_visitor_operation/thru_poa_proxy_impl_ss.cpp:52

void
POA_CosLoadBalancing::_TAO_LoadMonitor_ThruPOA_Proxy_Impl::_get_loads (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument ** args,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  ((TAO::Arg_Traits< ::CosLoadBalancing::LoadList>::ret_val *) args[0])->arg () =
    reinterpret_cast<
        POA_CosLoadBalancing::LoadMonitor_ptr> (
        servant->_downcast (
            "IDL:omg.org/CosLoadBalancing/LoadMonitor:1.0"
          )
      )->loads (
          ACE_ENV_SINGLE_ARG_PARAMETER
        );
  ACE_CHECK;
}

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

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

POA_CosLoadBalancing::LoadMonitor::LoadMonitor (void)
{
  this->optable_ = &tao_CosLoadBalancing_LoadMonitor_optable;
}

POA_CosLoadBalancing::LoadMonitor::LoadMonitor (const LoadMonitor& rhs)
  : TAO_Abstract_ServantBase (rhs),
    TAO_ServantBase (rhs)
{
}

POA_CosLoadBalancing::LoadMonitor::~LoadMonitor (void)
{
}

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

void POA_CosLoadBalancing::LoadMonitor::_get_the_location_skel (
    TAO_ServerRequest &_tao_server_request,
    void *_tao_servant,
    void *_tao_servant_upcall
    ACE_ENV_ARG_DECL
  )
{
  POA_CosLoadBalancing::LoadMonitor *_tao_impl =
    static_cast<
        POA_CosLoadBalancing::LoadMonitor *> (
        _tao_servant
      );
  ::CosLoadBalancing::Location_var _tao_retval;
  
#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_Object_Adapter::Servant_Upcall *_tao_upcall =
    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_CosLoadBalancing_LoadMonitor_the_location_get _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl
      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* 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->the_location (
                  ACE_ENV_SINGLE_ARG_PARAMETER
                );
            TAO_INTERCEPTOR_CHECK;
#if (TAO_HAS_INTERCEPTORS == 1)
          }
      }
      
      if (!_tao_vfr.location_forwarded ())
        {
          ::CosLoadBalancing::Location * _tao_retval_info = _tao_retval._retn ();
          _tao_ri.result (_tao_retval_info);
          _tao_retval = _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 ();
#if (TAO_HAS_INTERCEPTORS == 1)
  if (!_tao_vfr.location_forwarded ())
    {
#endif /* TAO_HAS_INTERCEPTORS */
      TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
      
      if (!(
          (_tao_out << _tao_retval.in ())
          ))
        {
          TAO_OutputCDR::throw_skel_exception (errno ACE_ENV_ARG_PARAMETER);
          ACE_CHECK;
        }
#if (TAO_HAS_INTERCEPTORS == 1)
    }
#endif /* TAO_HAS_INTERCEPTORS */
  
  
  // 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:98

void POA_CosLoadBalancing::LoadMonitor::_get_loads_skel (
    TAO_ServerRequest &_tao_server_request,
    void *_tao_servant,
    void *_tao_servant_upcall
    ACE_ENV_ARG_DECL
  )
{
  POA_CosLoadBalancing::LoadMonitor *_tao_impl =
    static_cast<
        POA_CosLoadBalancing::LoadMonitor *> (
        _tao_servant
      );
  ::CosLoadBalancing::LoadList_var _tao_retval;
  
#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_Object_Adapter::Servant_Upcall *_tao_upcall =
    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_CosLoadBalancing_LoadMonitor_loads_get _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl
      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* 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->loads (
                  ACE_ENV_SINGLE_ARG_PARAMETER
                );
            TAO_INTERCEPTOR_CHECK;
#if (TAO_HAS_INTERCEPTORS == 1)
          }
      }
      
      if (!_tao_vfr.location_forwarded ())
        {
          ::CosLoadBalancing::LoadList * _tao_retval_info = _tao_retval._retn ();
          _tao_ri.result (_tao_retval_info);
          _tao_retval = _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 ();
#if (TAO_HAS_INTERCEPTORS == 1)
  if (!_tao_vfr.location_forwarded ())
    {
#endif /* TAO_HAS_INTERCEPTORS */
      TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
      
      if (!(
          (_tao_out << _tao_retval.in ())
          ))
        {
          TAO_OutputCDR::throw_skel_exception (errno ACE_ENV_ARG_PARAMETER);
          ACE_CHECK;
        }
#if (TAO_HAS_INTERCEPTORS == 1)
    }
#endif /* TAO_HAS_INTERCEPTORS */
  
  
  // 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:162

void POA_CosLoadBalancing::LoadMonitor::_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_CosLoadBalancing::LoadMonitor *_tao_impl =
    (POA_CosLoadBalancing::LoadMonitor *) _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_CosLoadBalancing::LoadMonitor::_non_existent_skel (
    TAO_ServerRequest &_tao_server_request, 
    void * _tao_servant,
    void * /* Servant_Upcall */
    ACE_ENV_ARG_DECL
  )
{
  POA_CosLoadBalancing::LoadMonitor *_tao_impl =
    (POA_CosLoadBalancing::LoadMonitor *) _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_CosLoadBalancing::LoadMonitor::_interface_skel (
    TAO_ServerRequest &_tao_server_request, 
    void * _tao_servant,
    void * /* Servant_Upcall */
    ACE_ENV_ARG_DECL
  )
{
  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 ());
    }
  
  POA_CosLoadBalancing::LoadMonitor *_tao_impl =
    (POA_CosLoadBalancing::LoadMonitor *) _tao_servant;
  
  CORBA::InterfaceDef_ptr _tao_retval = 
    _tao_impl->_get_interface (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK;
  
  _tao_server_request.init_reply ();
  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
  
  CORBA::Boolean _tao_result =
    _tao_adapter->interfacedef_cdr_insert (
        _tao_out,
        _tao_retval
      );
  
  _tao_adapter->dispose (_tao_retval);
  
  if (_tao_result == 0)
    {
      ACE_THROW (CORBA::MARSHAL ());
    }
}

void POA_CosLoadBalancing::LoadMonitor::_component_skel (
    TAO_ServerRequest &_tao_server_request, 
    void * _tao_object_reference,
    void * /* Servant_Upcall */
    ACE_ENV_ARG_DECL
  )
{
  POA_CosLoadBalancing::LoadMonitor *_tao_impl =
    (POA_CosLoadBalancing::LoadMonitor *) _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.in ()))
    {
      ACE_THROW (CORBA::MARSHAL ());
    }
}

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

void* POA_CosLoadBalancing::LoadMonitor::_downcast (
    const char* logical_type_id
  )
{
  if (ACE_OS::strcmp (logical_type_id,
                      "IDL:omg.org/CosLoadBalancing/LoadMonitor:1.0") == 0)
    {
      return static_cast<POA_CosLoadBalancing::LoadMonitor_ptr> (this);
    }
  
  if (ACE_OS::strcmp (logical_type_id,
                      "IDL:omg.org/CORBA/Object:1.0") == 0)
    {
      return static_cast<PortableServer::Servant> (this);
    }
  
  return 0;
}

const char* POA_CosLoadBalancing::LoadMonitor::_interface_repository_id (void) const
{
  return "IDL:omg.org/CosLoadBalancing/LoadMonitor:1.0";
}

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

void POA_CosLoadBalancing::LoadMonitor::_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:526

CosLoadBalancing::LoadMonitor *
POA_CosLoadBalancing::LoadMonitor::_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 ();
  
  typedef ::CosLoadBalancing::LoadMonitor STUB_SCOPED_NAME;
  return
    TAO::Narrow_Utils<STUB_SCOPED_NAME>::unchecked_narrow (
        obj.in (),
        CosLoadBalancing__TAO_LoadMonitor_Proxy_Broker_Factory_function_pointer
      );
}

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

class TAO_CosLoadBalancing_AMI_LoadMonitorHandler_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: /work/a/ports/devel/ace+tao/work/ACE_wrappers/bin/gperf -m -M -J -c -C -D -E -T -f 0 -F 0,0,0 -a -o -t -p -K opname_ -L C++ -Z TAO_CosLoadBalancing_AMI_LoadMonitorHandler_Perfect_Hash_OpTable -N lookup  */
unsigned int
TAO_CosLoadBalancing_AMI_LoadMonitorHandler_Perfect_Hash_OpTable::hash (const char *str, unsigned int len)
{
  static const unsigned char asso_values[] =
    {
#if defined (ACE_MVS)
     23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
     23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
     23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
     23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
     23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
     23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
     23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
     23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
     23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
     23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
     23, 23, 23, 23, 23, 23, 23, 23, 23,  0,
     23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
     23, 23, 23, 23, 23, 23, 23, 23, 23,  0,
     23, 23, 23,  2, 23,  0, 23, 23, 23, 23,
     23, 23, 23, 23, 23, 23, 23, 23, 23,  0,
     23,  0, 23, 23, 23, 23, 23, 23, 23, 23,
     23, 23,  0,  0, 23, 23, 23, 23, 23, 23,
     23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
     23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
     23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
     23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
     23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
     23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
     23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
     23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
     23, 23, 23, 23, 23, 23,
#else
     23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
     23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
     23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
     23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
     23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
     23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
     23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
     23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
     23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
     23, 23, 23, 23, 23,  0, 23,  0, 23, 23,
     23,  2, 23,  0, 23, 23, 23, 23, 23, 23,
      0, 23,  0, 23, 23,  0,  0, 23, 23, 23,
     23, 23, 23, 23, 23, 23, 23, 23,
#endif /* ACE_MVS */
    };
  return len + asso_values[(int) str[len - 1]] + asso_values[(int) str[0]];
}

const class TAO_operation_db_entry *
TAO_CosLoadBalancing_AMI_LoadMonitorHandler_Perfect_Hash_OpTable::lookup (const char *str, unsigned int len)
{
  enum
    {
      TOTAL_KEYWORDS = 8,
      MIN_WORD_LENGTH = 5,
      MAX_WORD_LENGTH = 22,
      MIN_HASH_VALUE = 5,
      MAX_HASH_VALUE = 22,
      HASH_VALUE_RANGE = 18,
      DUPLICATES = 0,
      WORDLIST_SIZE = 13
    };

  static const class TAO_operation_db_entry  wordlist[] =
    {
      {"",0,0,0},{"",0,0,0},{"",0,0,0},{"",0,0,0},{"",0,0,0},
      {"_is_a", &POA_CosLoadBalancing::AMI_LoadMonitorHandler::_is_a_skel, 0, 0},
      {"",0,0,0},{"",0,0,0},{"",0,0,0},
      {"get_loads", &POA_CosLoadBalancing::AMI_LoadMonitorHandler::get_loads_skel, &POA_CosLoadBalancing::_TAO_AMI_LoadMonitorHandler_ThruPOA_Proxy_Impl::get_loads, 0},
      {"_component", &POA_CosLoadBalancing::AMI_LoadMonitorHandler::_component_skel, 0, 0},
      {"",0,0,0},
      {"_interface", &POA_CosLoadBalancing::AMI_LoadMonitorHandler::_interface_skel, 0, 0},
      {"_non_existent", &POA_CosLoadBalancing::AMI_LoadMonitorHandler::_non_existent_skel, 0, 0},
      {"",0,0,0},
      {"get_loads_excep", &POA_CosLoadBalancing::AMI_LoadMonitorHandler::get_loads_excep_skel, &POA_CosLoadBalancing::_TAO_AMI_LoadMonitorHandler_ThruPOA_Proxy_Impl::get_loads_excep, 0},
      {"get_the_location", &POA_CosLoadBalancing::AMI_LoadMonitorHandler::get_the_location_skel, &POA_CosLoadBalancing::_TAO_AMI_LoadMonitorHandler_ThruPOA_Proxy_Impl::get_the_location, 0},
      {"",0,0,0},{"",0,0,0},{"",0,0,0},{"",0,0,0},{"",0,0,0},
      {"get_the_location_excep", &POA_CosLoadBalancing::AMI_LoadMonitorHandler::get_the_location_excep_skel, &POA_CosLoadBalancing::_TAO_AMI_LoadMonitorHandler_ThruPOA_Proxy_Impl::get_the_location_excep, 0},
    };

  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_CosLoadBalancing_AMI_LoadMonitorHandler_Perfect_Hash_OpTable tao_CosLoadBalancing_AMI_LoadMonitorHandler_optable;

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

#if (TAO_HAS_INTERCEPTORS == 1)

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:74

class TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadMonitorHandler_get_the_location : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadMonitorHandler_get_the_location (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_CosLoadBalancing::AMI_LoadMonitorHandler *tao_impl,
      const ::CosLoadBalancing::Location & ami_return_val
      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_CosLoadBalancing_AMI_LoadMonitorHandler_get_the_location (
      const TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadMonitorHandler_get_the_location &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadMonitorHandler_get_the_location &
    );
  
private:
  POA_CosLoadBalancing::AMI_LoadMonitorHandler *_tao_impl;
  
  const ::CosLoadBalancing::Location & ami_return_val_;
};

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:438

TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadMonitorHandler_get_the_location::TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadMonitorHandler_get_the_location (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_CosLoadBalancing::AMI_LoadMonitorHandler *tao_impl,
    const ::CosLoadBalancing::Location & ami_return_val
    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl),
    ami_return_val_ (ami_return_val)
{}

Dynamic::ParameterList *
TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadMonitorHandler_get_the_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 (1);
  CORBA::ULong len = 0;
  
  (*parameter_list)[len].argument <<=  this->ami_return_val_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
  
  return safe_parameter_list._retn ();
}

Dynamic::ExceptionList *
TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadMonitorHandler_get_the_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);
  
  return exception_list;
}

CORBA::Any * 
TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadMonitorHandler_get_the_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_CosLoadBalancing_AMI_LoadMonitorHandler_get_the_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_CosLoadBalancing_AMI_LoadMonitorHandler_get_the_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);
}

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:74

class TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadMonitorHandler_get_the_location_excep : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadMonitorHandler_get_the_location_excep (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_CosLoadBalancing::AMI_LoadMonitorHandler *tao_impl,
      ::CosLoadBalancing::AMI_LoadMonitorExceptionHolder * excep_holder
      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_CosLoadBalancing_AMI_LoadMonitorHandler_get_the_location_excep (
      const TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadMonitorHandler_get_the_location_excep &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadMonitorHandler_get_the_location_excep &
    );
  
private:
  POA_CosLoadBalancing::AMI_LoadMonitorHandler *_tao_impl;
  
  ::CosLoadBalancing::AMI_LoadMonitorExceptionHolder * excep_holder_;
};

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:438

TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadMonitorHandler_get_the_location_excep::TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadMonitorHandler_get_the_location_excep (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_CosLoadBalancing::AMI_LoadMonitorHandler *tao_impl,
    ::CosLoadBalancing::AMI_LoadMonitorExceptionHolder * excep_holder
    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl),
    excep_holder_ (excep_holder)
{}

Dynamic::ParameterList *
TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadMonitorHandler_get_the_location_excep::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_ServerRequestInfo_CosLoadBalancing_AMI_LoadMonitorHandler_get_the_location_excep::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_ServerRequestInfo_CosLoadBalancing_AMI_LoadMonitorHandler_get_the_location_excep::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_CosLoadBalancing_AMI_LoadMonitorHandler_get_the_location_excep::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_CosLoadBalancing_AMI_LoadMonitorHandler_get_the_location_excep::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);
}

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:74

class TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadMonitorHandler_get_loads : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadMonitorHandler_get_loads (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_CosLoadBalancing::AMI_LoadMonitorHandler *tao_impl,
      const ::CosLoadBalancing::LoadList & ami_return_val
      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_CosLoadBalancing_AMI_LoadMonitorHandler_get_loads (
      const TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadMonitorHandler_get_loads &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadMonitorHandler_get_loads &
    );
  
private:
  POA_CosLoadBalancing::AMI_LoadMonitorHandler *_tao_impl;
  
  const ::CosLoadBalancing::LoadList & ami_return_val_;
};

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:438

TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadMonitorHandler_get_loads::TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadMonitorHandler_get_loads (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_CosLoadBalancing::AMI_LoadMonitorHandler *tao_impl,
    const ::CosLoadBalancing::LoadList & ami_return_val
    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl),
    ami_return_val_ (ami_return_val)
{}

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

Dynamic::ExceptionList *
TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadMonitorHandler_get_loads::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_ServerRequestInfo_CosLoadBalancing_AMI_LoadMonitorHandler_get_loads::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_CosLoadBalancing_AMI_LoadMonitorHandler_get_loads::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_CosLoadBalancing_AMI_LoadMonitorHandler_get_loads::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);
}

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:74

class TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadMonitorHandler_get_loads_excep : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadMonitorHandler_get_loads_excep (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_CosLoadBalancing::AMI_LoadMonitorHandler *tao_impl,
      ::CosLoadBalancing::AMI_LoadMonitorExceptionHolder * excep_holder
      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_CosLoadBalancing_AMI_LoadMonitorHandler_get_loads_excep (
      const TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadMonitorHandler_get_loads_excep &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadMonitorHandler_get_loads_excep &
    );
  
private:
  POA_CosLoadBalancing::AMI_LoadMonitorHandler *_tao_impl;
  
  ::CosLoadBalancing::AMI_LoadMonitorExceptionHolder * excep_holder_;
};

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:438

TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadMonitorHandler_get_loads_excep::TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadMonitorHandler_get_loads_excep (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_CosLoadBalancing::AMI_LoadMonitorHandler *tao_impl,
    ::CosLoadBalancing::AMI_LoadMonitorExceptionHolder * excep_holder
    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl),
    excep_holder_ (excep_holder)
{}

Dynamic::ParameterList *
TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadMonitorHandler_get_loads_excep::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_ServerRequestInfo_CosLoadBalancing_AMI_LoadMonitorHandler_get_loads_excep::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_ServerRequestInfo_CosLoadBalancing_AMI_LoadMonitorHandler_get_loads_excep::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_CosLoadBalancing_AMI_LoadMonitorHandler_get_loads_excep::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_CosLoadBalancing_AMI_LoadMonitorHandler_get_loads_excep::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);
}

#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_CosLoadBalancing::_TAO_AMI_LoadMonitorHandler_Strategized_Proxy_Broker *
POA_CosLoadBalancing::_TAO_AMI_LoadMonitorHandler_Strategized_Proxy_Broker::the_TAO_AMI_LoadMonitorHandler_Strategized_Proxy_Broker (void)
{
  static POA_CosLoadBalancing::_TAO_AMI_LoadMonitorHandler_Strategized_Proxy_Broker
  strategized_proxy_broker;
  
  return &strategized_proxy_broker;
}

POA_CosLoadBalancing::_TAO_AMI_LoadMonitorHandler_Strategized_Proxy_Broker::_TAO_AMI_LoadMonitorHandler_Strategized_Proxy_Broker (void)
{
}

POA_CosLoadBalancing::_TAO_AMI_LoadMonitorHandler_Strategized_Proxy_Broker::~_TAO_AMI_LoadMonitorHandler_Strategized_Proxy_Broker (void)
{
}

TAO::Collocation_Strategy
POA_CosLoadBalancing::_TAO_AMI_LoadMonitorHandler_Strategized_Proxy_Broker::get_strategy (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  TAO::Collocation_Strategy strategy =
    TAO_ORB_Core::collocation_strategy (obj ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (TAO::TAO_CS_REMOTE_STRATEGY);
  
  return strategy;
}

void
POA_CosLoadBalancing::_TAO_AMI_LoadMonitorHandler_Strategized_Proxy_Broker::dispatch (
    CORBA::Object_ptr obj,
    CORBA::Object_out forward_obj,
    TAO::Argument ** args,
    int num_args,
    const char * op,
    size_t op_len,
    TAO::Collocation_Strategy strategy
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::Exception))
{
  TAO_Object_Adapter::Servant_Upcall servant_upcall (
      obj->_stubobj ()->servant_orb_var ()->orb_core ()
    );
  
  TAO_Collocated_Skeleton collocated_skel;
  TAO_Abstract_ServantBase *servant = 0;
  
  if (strategy == TAO::TAO_CS_THRU_POA_STRATEGY)
    {
      servant_upcall.prepare_for_upcall (
          obj->_stubobj ()->object_key (),
          op,
          forward_obj
          ACE_ENV_ARG_PARAMETER
        );
      ACE_CHECK;
      
      servant_upcall.pre_invoke_collocated_request (
          ACE_ENV_SINGLE_ARG_PARAMETER
        );
      ACE_CHECK;
      
      servant = servant_upcall.servant ();
    }
  else
    {
      servant = obj->_servant ();
    }
  
  int status = servant->_find (op,
                               collocated_skel,
                               strategy,
                               op_len);
  
  if (status == -1)
    {
      ACE_THROW (CORBA::BAD_OPERATION ());
    }
  
  ACE_TRY
    {
      collocated_skel (servant,
                       args,
                       num_args
                       ACE_ENV_ARG_PARAMETER);
      ACE_TRY_CHECK;
    }
#if (TAO_HAS_MINIMUM_CORBA == 0)
  ACE_CATCH (PortableServer::ForwardRequest, forward_request)
    {
      forward_obj =
        CORBA::Object::_duplicate (forward_request.forward_reference.in ());
      return;
    }
#else
  ACE_CATCHANY
    {
      ACE_UNUSED_ARG (forward_obj);
      ACE_RE_THROW;
    }
#endif /* TAO_HAS_MINIMUM_CORBA */
  ACE_ENDTRY;
  ACE_CHECK;
}

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

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

TAO::Collocation_Proxy_Broker *
CosLoadBalancing__TAO_AMI_LoadMonitorHandler_Proxy_Broker_Factory_function (CORBA::Object_ptr)
{
  return
    ::POA_CosLoadBalancing::_TAO_AMI_LoadMonitorHandler_Strategized_Proxy_Broker::the_TAO_AMI_LoadMonitorHandler_Strategized_Proxy_Broker ();
}

int
CosLoadBalancing__TAO_AMI_LoadMonitorHandler_Proxy_Broker_Factory_Initializer (size_t)
{
  CosLoadBalancing__TAO_AMI_LoadMonitorHandler_Proxy_Broker_Factory_function_pointer = 
    CosLoadBalancing__TAO_AMI_LoadMonitorHandler_Proxy_Broker_Factory_function;
  
  return 0;
}

static int
CosLoadBalancing__TAO_AMI_LoadMonitorHandler_Proxy_Broker_Stub_Factory_Initializer_Scarecrow =
  CosLoadBalancing__TAO_AMI_LoadMonitorHandler_Proxy_Broker_Factory_Initializer (
      reinterpret_cast<
          size_t> (
          CosLoadBalancing__TAO_AMI_LoadMonitorHandler_Proxy_Broker_Factory_Initializer
        )
    );


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

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

POA_CosLoadBalancing::_TAO_AMI_LoadMonitorHandler_ThruPOA_Proxy_Impl::_TAO_AMI_LoadMonitorHandler_ThruPOA_Proxy_Impl (void)
{}

// ThruPOA Implementation of the IDL interface methods

// TAO_IDL - Generated from 
// be/be_visitor_operation/thru_poa_proxy_impl_ss.cpp:52

void
POA_CosLoadBalancing::_TAO_AMI_LoadMonitorHandler_ThruPOA_Proxy_Impl::get_the_location (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument ** args,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  reinterpret_cast<
      POA_CosLoadBalancing::AMI_LoadMonitorHandler_ptr> (
      servant->_downcast (
          "IDL:AMI_LoadMonitorHandler:1.0"
        )
    )->get_the_location (
        ((TAO::Arg_Traits< ::CosLoadBalancing::Location>::in_arg_val *) args[1])->arg ()
        ACE_ENV_ARG_PARAMETER
      );
  ACE_CHECK;
}

// TAO_IDL - Generated from 
// be/be_visitor_operation/thru_poa_proxy_impl_ss.cpp:52

void
POA_CosLoadBalancing::_TAO_AMI_LoadMonitorHandler_ThruPOA_Proxy_Impl::get_the_location_excep (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument ** args,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  reinterpret_cast<
      POA_CosLoadBalancing::AMI_LoadMonitorHandler_ptr> (
      servant->_downcast (
          "IDL:AMI_LoadMonitorHandler:1.0"
        )
    )->get_the_location_excep (
        ((TAO::Arg_Traits< ::CosLoadBalancing::AMI_LoadMonitorExceptionHolder>::in_arg_val *) args[1])->arg ()
        ACE_ENV_ARG_PARAMETER
      );
  ACE_CHECK;
}

// TAO_IDL - Generated from 
// be/be_visitor_operation/thru_poa_proxy_impl_ss.cpp:52

void
POA_CosLoadBalancing::_TAO_AMI_LoadMonitorHandler_ThruPOA_Proxy_Impl::get_loads (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument ** args,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  reinterpret_cast<
      POA_CosLoadBalancing::AMI_LoadMonitorHandler_ptr> (
      servant->_downcast (
          "IDL:AMI_LoadMonitorHandler:1.0"
        )
    )->get_loads (
        ((TAO::Arg_Traits< ::CosLoadBalancing::LoadList>::in_arg_val *) args[1])->arg ()
        ACE_ENV_ARG_PARAMETER
      );
  ACE_CHECK;
}

// TAO_IDL - Generated from 
// be/be_visitor_operation/thru_poa_proxy_impl_ss.cpp:52

void
POA_CosLoadBalancing::_TAO_AMI_LoadMonitorHandler_ThruPOA_Proxy_Impl::get_loads_excep (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument ** args,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  reinterpret_cast<
      POA_CosLoadBalancing::AMI_LoadMonitorHandler_ptr> (
      servant->_downcast (
          "IDL:AMI_LoadMonitorHandler:1.0"
        )
    )->get_loads_excep (
        ((TAO::Arg_Traits< ::CosLoadBalancing::AMI_LoadMonitorExceptionHolder>::in_arg_val *) args[1])->arg ()
        ACE_ENV_ARG_PARAMETER
      );
  ACE_CHECK;
}

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

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

POA_CosLoadBalancing::AMI_LoadMonitorHandler::AMI_LoadMonitorHandler (void)
{
  this->optable_ = &tao_CosLoadBalancing_AMI_LoadMonitorHandler_optable;
}

POA_CosLoadBalancing::AMI_LoadMonitorHandler::AMI_LoadMonitorHandler (const AMI_LoadMonitorHandler& rhs)
  : TAO_Abstract_ServantBase (rhs),
    TAO_ServantBase (rhs),
    ACE_NESTED_CLASS (POA_Messaging, ReplyHandler) (rhs)
{
}

POA_CosLoadBalancing::AMI_LoadMonitorHandler::~AMI_LoadMonitorHandler (void)
{
}

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

void POA_CosLoadBalancing::AMI_LoadMonitorHandler::get_the_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_CosLoadBalancing::AMI_LoadMonitorHandler *_tao_impl =
    static_cast<
        POA_CosLoadBalancing::AMI_LoadMonitorHandler *> (
        _tao_servant
      );
  _tao_server_request.argument_flag (0);
  
  ::CosLoadBalancing::Location ami_return_val;
  
  if (!(
      (_tao_in >> ami_return_val)
      ))
    {
      TAO_InputCDR::throw_skel_exception (errno ACE_ENV_ARG_PARAMETER);
      ACE_CHECK;
    }
  
#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_Object_Adapter::Servant_Upcall *_tao_upcall =
    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_CosLoadBalancing_AMI_LoadMonitorHandler_get_the_location _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl,
      
      ami_return_val
      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* 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->get_the_location (
                  ami_return_val
                  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:98

void POA_CosLoadBalancing::AMI_LoadMonitorHandler::get_the_location_excep_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_CosLoadBalancing::AMI_LoadMonitorHandler *_tao_impl =
    static_cast<
        POA_CosLoadBalancing::AMI_LoadMonitorHandler *> (
        _tao_servant
      );
  _tao_server_request.argument_flag (0);
  
  ::CosLoadBalancing::AMI_LoadMonitorExceptionHolder_var excep_holder;
  
  if (!(
      (_tao_in >> excep_holder.out ())
      ))
    {
      TAO_InputCDR::throw_skel_exception (errno ACE_ENV_ARG_PARAMETER);
      ACE_CHECK;
    }
  
#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_Object_Adapter::Servant_Upcall *_tao_upcall =
    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_CosLoadBalancing_AMI_LoadMonitorHandler_get_the_location_excep _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl,
      
      excep_holder.in ()
      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* 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->get_the_location_excep (
                  excep_holder.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:98

void POA_CosLoadBalancing::AMI_LoadMonitorHandler::get_loads_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_CosLoadBalancing::AMI_LoadMonitorHandler *_tao_impl =
    static_cast<
        POA_CosLoadBalancing::AMI_LoadMonitorHandler *> (
        _tao_servant
      );
  _tao_server_request.argument_flag (0);
  
  ::CosLoadBalancing::LoadList ami_return_val;
  
  if (!(
      (_tao_in >> ami_return_val)
      ))
    {
      TAO_InputCDR::throw_skel_exception (errno ACE_ENV_ARG_PARAMETER);
      ACE_CHECK;
    }
  
#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_Object_Adapter::Servant_Upcall *_tao_upcall =
    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_CosLoadBalancing_AMI_LoadMonitorHandler_get_loads _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl,
      
      ami_return_val
      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* 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->get_loads (
                  ami_return_val
                  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:98

void POA_CosLoadBalancing::AMI_LoadMonitorHandler::get_loads_excep_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_CosLoadBalancing::AMI_LoadMonitorHandler *_tao_impl =
    static_cast<
        POA_CosLoadBalancing::AMI_LoadMonitorHandler *> (
        _tao_servant
      );
  _tao_server_request.argument_flag (0);
  
  ::CosLoadBalancing::AMI_LoadMonitorExceptionHolder_var excep_holder;
  
  if (!(
      (_tao_in >> excep_holder.out ())
      ))
    {
      TAO_InputCDR::throw_skel_exception (errno ACE_ENV_ARG_PARAMETER);
      ACE_CHECK;
    }
  
#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_Object_Adapter::Servant_Upcall *_tao_upcall =
    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_CosLoadBalancing_AMI_LoadMonitorHandler_get_loads_excep _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl,
      
      excep_holder.in ()
      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* 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->get_loads_excep (
                  excep_holder.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_interface/interface_ss.cpp:162

void POA_CosLoadBalancing::AMI_LoadMonitorHandler::_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_CosLoadBalancing::AMI_LoadMonitorHandler *_tao_impl =
    (POA_CosLoadBalancing::AMI_LoadMonitorHandler *) _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_CosLoadBalancing::AMI_LoadMonitorHandler::_non_existent_skel (
    TAO_ServerRequest &_tao_server_request, 
    void * _tao_servant,
    void * /* Servant_Upcall */
    ACE_ENV_ARG_DECL
  )
{
  POA_CosLoadBalancing::AMI_LoadMonitorHandler *_tao_impl =
    (POA_CosLoadBalancing::AMI_LoadMonitorHandler *) _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_CosLoadBalancing::AMI_LoadMonitorHandler::_interface_skel (
    TAO_ServerRequest &_tao_server_request, 
    void * _tao_servant,
    void * /* Servant_Upcall */
    ACE_ENV_ARG_DECL
  )
{
  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 ());
    }
  
  POA_CosLoadBalancing::AMI_LoadMonitorHandler *_tao_impl =
    (POA_CosLoadBalancing::AMI_LoadMonitorHandler *) _tao_servant;
  
  CORBA::InterfaceDef_ptr _tao_retval = 
    _tao_impl->_get_interface (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK;
  
  _tao_server_request.init_reply ();
  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
  
  CORBA::Boolean _tao_result =
    _tao_adapter->interfacedef_cdr_insert (
        _tao_out,
        _tao_retval
      );
  
  _tao_adapter->dispose (_tao_retval);
  
  if (_tao_result == 0)
    {
      ACE_THROW (CORBA::MARSHAL ());
    }
}

void POA_CosLoadBalancing::AMI_LoadMonitorHandler::_component_skel (
    TAO_ServerRequest &_tao_server_request, 
    void * _tao_object_reference,
    void * /* Servant_Upcall */
    ACE_ENV_ARG_DECL
  )
{
  POA_CosLoadBalancing::AMI_LoadMonitorHandler *_tao_impl =
    (POA_CosLoadBalancing::AMI_LoadMonitorHandler *) _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.in ()))
    {
      ACE_THROW (CORBA::MARSHAL ());
    }
}

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

void* POA_CosLoadBalancing::AMI_LoadMonitorHandler::_downcast (
    const char* logical_type_id
  )
{
  if (ACE_OS::strcmp (logical_type_id,
                      "IDL:ReplyHandler:1.0") == 0)
    {
      return static_cast<POA_Messaging::ReplyHandler_ptr> (this);
    }
  
  if (ACE_OS::strcmp (logical_type_id,
                      "IDL:AMI_LoadMonitorHandler:1.0") == 0)
    {
      return static_cast<POA_CosLoadBalancing::AMI_LoadMonitorHandler_ptr> (this);
    }
  
  if (ACE_OS::strcmp (logical_type_id,
                      "IDL:omg.org/CORBA/Object:1.0") == 0)
    {
      return static_cast<PortableServer::Servant> (this);
    }
  
  return 0;
}

const char* POA_CosLoadBalancing::AMI_LoadMonitorHandler::_interface_repository_id (void) const
{
  return "IDL:AMI_LoadMonitorHandler:1.0";
}

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

void POA_CosLoadBalancing::AMI_LoadMonitorHandler::_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:526

CosLoadBalancing::AMI_LoadMonitorHandler *
POA_CosLoadBalancing::AMI_LoadMonitorHandler::_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 ();
  
  typedef ::CosLoadBalancing::AMI_LoadMonitorHandler STUB_SCOPED_NAME;
  return
    TAO::Narrow_Utils<STUB_SCOPED_NAME>::unchecked_narrow (
        obj.in (),
        CosLoadBalancing__TAO_AMI_LoadMonitorHandler_Proxy_Broker_Factory_function_pointer
      );
}

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

class TAO_CosLoadBalancing_LoadManager_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: /work/a/ports/devel/ace+tao/work/ACE_wrappers/bin/gperf -m -M -J -c -C -D -E -T -f 0 -F 0,0,0 -a -o -t -p -K opname_ -L C++ -Z TAO_CosLoadBalancing_LoadManager_Perfect_Hash_OpTable -N lookup  */
unsigned int
TAO_CosLoadBalancing_LoadManager_Perfect_Hash_OpTable::hash (const char *str, unsigned int len)
{
  static const unsigned char asso_values[] =
    {
#if defined (ACE_MVS)
     70, 70, 70, 70, 70, 70, 70, 70, 70, 70,
     70, 70, 70, 70, 70, 70, 70, 70, 70, 70,
     70, 70, 70, 70, 70, 70, 70, 70, 70, 70,
     70, 70, 70, 70, 70, 70, 70, 70, 70, 70,
     70, 70, 70, 70, 70, 70, 70, 70, 70, 70,
     70, 70, 70, 70, 70, 70, 70, 70, 70, 70,
     70, 70, 70, 70, 70, 70, 70, 70, 70, 70,
     70, 70, 70, 70, 70, 70, 70, 70, 70, 70,
     70, 70, 70, 70, 70, 70, 70, 70, 70, 70,
     70, 70, 70, 70, 70, 70, 70, 70, 70, 70,
     70, 70, 70, 70, 70, 70, 70, 70, 70,  0,
     70, 70, 70, 70, 70, 70, 70, 70, 70, 70,
     70, 70, 70, 70, 70, 70, 70, 70, 70,  0,
     70, 10,  5,  0, 20, 25, 70, 70, 70, 70,
     70, 70, 70, 70, 70, 70, 70,  0, 70, 20,
     70, 15, 70,  5, 70, 70, 70, 70, 70, 70,
     70, 70,  0, 30, 70, 70, 70, 70,  0, 70,
     70, 70, 70, 70, 70, 70, 70, 70, 70, 70,
     70, 70, 70, 70, 70, 70, 70, 70, 70, 70,
     70, 70, 70, 70, 70, 70, 70, 70, 70, 70,
     70, 70, 70, 70, 70, 70, 70, 70, 70, 70,
     70, 70, 70, 70, 70, 70, 70, 70, 70, 70,
     70, 70, 70, 70, 70, 70, 70, 70, 70, 70,
     70, 70, 70, 70, 70, 70, 70, 70, 70, 70,
     70, 70, 70, 70, 70, 70, 70, 70, 70, 70,
     70, 70, 70, 70, 70, 70,
#else
     70, 70, 70, 70, 70, 70, 70, 70, 70, 70,
     70, 70, 70, 70, 70, 70, 70, 70, 70, 70,
     70, 70, 70, 70, 70, 70, 70, 70, 70, 70,
     70, 70, 70, 70, 70, 70, 70, 70, 70, 70,
     70, 70, 70, 70, 70, 70, 70, 70, 70, 70,
     70, 70, 70, 70, 70, 70, 70, 70, 70, 70,
     70, 70, 70, 70, 70, 70, 70, 70, 70, 70,
     70, 70, 70, 70, 70, 70, 70, 70, 70, 70,
     70, 70, 70, 70, 70, 70, 70, 70, 70, 70,
     70, 70, 70, 70, 70,  0, 70,  0, 70, 10,
      5,  0, 20, 25, 70, 70, 70, 70,  0, 70,
     20, 70, 15, 70,  5,  0, 30, 70, 70, 70,
     70,  0, 70, 70, 70, 70, 70, 70,
#endif /* ACE_MVS */
    };
  return len + asso_values[(int) str[len - 1]] + asso_values[(int) str[0]];
}

const class TAO_operation_db_entry *
TAO_CosLoadBalancing_LoadManager_Perfect_Hash_OpTable::lookup (const char *str, unsigned int len)
{
  enum
    {
      TOTAL_KEYWORDS = 33,
      MIN_WORD_LENGTH = 5,
      MAX_WORD_LENGTH = 28,
      MIN_HASH_VALUE = 5,
      MAX_HASH_VALUE = 69,
      HASH_VALUE_RANGE = 65,
      DUPLICATES = 2,
      WORDLIST_SIZE = 38
    };

  static const class TAO_operation_db_entry  wordlist[] =
    {
      {"",0,0,0},{"",0,0,0},{"",0,0,0},{"",0,0,0},{"",0,0,0},
      {"_is_a", &POA_CosLoadBalancing::LoadManager::_is_a_skel, 0, 0},
      {"_interface", &POA_CosLoadBalancing::LoadManager::_interface_skel, 0, 0},
      {"add_member", &POA_CosLoadBalancing::LoadManager::add_member_skel, &POA_CosLoadBalancing::_TAO_LoadManager_ThruPOA_Proxy_Impl::add_member, 0},
      {"set_type_properties", &POA_CosLoadBalancing::LoadManager::set_type_properties_skel, &POA_CosLoadBalancing::_TAO_LoadManager_ThruPOA_Proxy_Impl::set_type_properties, 0},
      {"locations_of_members", &POA_CosLoadBalancing::LoadManager::locations_of_members_skel, &POA_CosLoadBalancing::_TAO_LoadManager_ThruPOA_Proxy_Impl::locations_of_members, 0},
      {"set_default_properties", &POA_CosLoadBalancing::LoadManager::set_default_properties_skel, &POA_CosLoadBalancing::_TAO_LoadManager_ThruPOA_Proxy_Impl::set_default_properties, 0},
      {"remove_member", &POA_CosLoadBalancing::LoadManager::remove_member_skel, &POA_CosLoadBalancing::_TAO_LoadManager_ThruPOA_Proxy_Impl::remove_member, 0},
      {"push_loads", &POA_CosLoadBalancing::LoadManager::push_loads_skel, &POA_CosLoadBalancing::_TAO_LoadManager_ThruPOA_Proxy_Impl::push_loads, 0},
      {"set_properties_dynamically", &POA_CosLoadBalancing::LoadManager::set_properties_dynamically_skel, &POA_CosLoadBalancing::_TAO_LoadManager_ThruPOA_Proxy_Impl::set_properties_dynamically, 0},
      {"remove_type_properties", &POA_CosLoadBalancing::LoadManager::remove_type_properties_skel, &POA_CosLoadBalancing::_TAO_LoadManager_ThruPOA_Proxy_Impl::remove_type_properties, 0},
      {"create_member", &POA_CosLoadBalancing::LoadManager::create_member_skel, &POA_CosLoadBalancing::_TAO_LoadManager_ThruPOA_Proxy_Impl::create_member, 0},
      {"remove_load_monitor", &POA_CosLoadBalancing::LoadManager::remove_load_monitor_skel, &POA_CosLoadBalancing::_TAO_LoadManager_ThruPOA_Proxy_Impl::remove_load_monitor, 0},
      {"remove_default_properties", &POA_CosLoadBalancing::LoadManager::remove_default_properties_skel, &POA_CosLoadBalancing::_TAO_LoadManager_ThruPOA_Proxy_Impl::remove_default_properties, 0},
      {"register_load_monitor", &POA_CosLoadBalancing::LoadManager::register_load_monitor_skel, &POA_CosLoadBalancing::_TAO_LoadManager_ThruPOA_Proxy_Impl::register_load_monitor, 0},
      {"get_loads", &POA_CosLoadBalancing::LoadManager::get_loads_skel, &POA_CosLoadBalancing::_TAO_LoadManager_ThruPOA_Proxy_Impl::get_loads, 0},
      {"get_properties", &POA_CosLoadBalancing::LoadManager::get_properties_skel, &POA_CosLoadBalancing::_TAO_LoadManager_ThruPOA_Proxy_Impl::get_properties, 0},
      {"_component", &POA_CosLoadBalancing::LoadManager::_component_skel, 0, 0},
      {"enable_alert", &POA_CosLoadBalancing::LoadManager::enable_alert_skel, &POA_CosLoadBalancing::_TAO_LoadManager_ThruPOA_Proxy_Impl::enable_alert, 0},
      {"_non_existent", &POA_CosLoadBalancing::LoadManager::_non_existent_skel, 0, 0},
      {"get_type_properties", &POA_CosLoadBalancing::LoadManager::get_type_properties_skel, &POA_CosLoadBalancing::_TAO_LoadManager_ThruPOA_Proxy_Impl::get_type_properties, 0},
      {"get_load_monitor", &POA_CosLoadBalancing::LoadManager::get_load_monitor_skel, &POA_CosLoadBalancing::_TAO_LoadManager_ThruPOA_Proxy_Impl::get_load_monitor, 0},
      {"get_default_properties", &POA_CosLoadBalancing::LoadManager::get_default_properties_skel, &POA_CosLoadBalancing::_TAO_LoadManager_ThruPOA_Proxy_Impl::get_default_properties, 0},
      {"delete_object", &POA_CosLoadBalancing::LoadManager::delete_object_skel, &POA_CosLoadBalancing::_TAO_LoadManager_ThruPOA_Proxy_Impl::delete_object, 0},
      {"disable_alert", &POA_CosLoadBalancing::LoadManager::disable_alert_skel, &POA_CosLoadBalancing::_TAO_LoadManager_ThruPOA_Proxy_Impl::disable_alert, 0},
      {"get_object_group_id", &POA_CosLoadBalancing::LoadManager::get_object_group_id_skel, &POA_CosLoadBalancing::_TAO_LoadManager_ThruPOA_Proxy_Impl::get_object_group_id, 0},
      {"remove_load_alert", &POA_CosLoadBalancing::LoadManager::remove_load_alert_skel, &POA_CosLoadBalancing::_TAO_LoadManager_ThruPOA_Proxy_Impl::remove_load_alert, 0},
      {"create_object", &POA_CosLoadBalancing::LoadManager::create_object_skel, &POA_CosLoadBalancing::_TAO_LoadManager_ThruPOA_Proxy_Impl::create_object, 0},
      {"register_load_alert", &POA_CosLoadBalancing::LoadManager::register_load_alert_skel, &POA_CosLoadBalancing::_TAO_LoadManager_ThruPOA_Proxy_Impl::register_load_alert, 0},
      {"get_object_group_ref_from_id", &POA_CosLoadBalancing::LoadManager::get_object_group_ref_from_id_skel, &POA_CosLoadBalancing::_TAO_LoadManager_ThruPOA_Proxy_Impl::get_object_group_ref_from_id, 0},
      {"get_member_ref", &POA_CosLoadBalancing::LoadManager::get_member_ref_skel, &POA_CosLoadBalancing::_TAO_LoadManager_ThruPOA_Proxy_Impl::get_member_ref, 0},
      {"groups_at_location", &POA_CosLoadBalancing::LoadManager::groups_at_location_skel, &POA_CosLoadBalancing::_TAO_LoadManager_ThruPOA_Proxy_Impl::groups_at_location, 0},
      {"get_object_group_ref", &POA_CosLoadBalancing::LoadManager::get_object_group_ref_skel, &POA_CosLoadBalancing::_TAO_LoadManager_ThruPOA_Proxy_Impl::get_object_group_ref, 0},
      {"get_load_alert", &POA_CosLoadBalancing::LoadManager::get_load_alert_skel, &POA_CosLoadBalancing::_TAO_LoadManager_ThruPOA_Proxy_Impl::get_load_alert, 0},
    };

  static const signed char lookup[] =
    {
       -1,  -1,  -1,  -1,  -1,   5,  -1,  -1,  -1,  -1,   6,  -1,  -1,  -1, 
       -1,   7,  -1,  -1,  -1,   8,   9,  -1,  10,  11,  -1,  12,  13,  14, 
       15,  16,  17,  18,  -1,  -1,  19,  -1,  -1, -27,  -2,  20,  21,  -1, 
       22,  23,  24,  -1,  25,  26, -80,  29,  -1,  -1,  30,  31,  32,  -1, 
       -1,  -1,  33,  34,  -1,  -1,  -1,  35,  -1,  36,  -1,  -1,  -1,  37, 
      
    };

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

      if (key <= MAX_HASH_VALUE && key >= MIN_HASH_VALUE)
        {
          int slot = lookup[key];

          if (slot >= 0 && slot < WORDLIST_SIZE)
            {
              const char *s = wordlist[slot].opname_;

              if (*str == *s && !strncmp (str + 1, s + 1, len - 1))
                return &wordlist[slot];
            }
          else if (slot < 0 && slot >= -MAX_HASH_VALUE)
            return 0;
          else
            {
              unsigned int offset = key + slot + (slot > 0 ? -MAX_HASH_VALUE : MAX_HASH_VALUE);
              const class TAO_operation_db_entry  *base = &wordlist[-lookup[offset]];
              const class TAO_operation_db_entry  *ptr = base + -lookup[offset + 1];

              while (--ptr >= base)
                if (*str == *ptr->opname_ && !strncmp (str + 1, ptr->opname_ + 1, len - 1))
                  return ptr;
            }
        }
    }
  return 0;
}

static TAO_CosLoadBalancing_LoadManager_Perfect_Hash_OpTable tao_CosLoadBalancing_LoadManager_optable;

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

#if (TAO_HAS_INTERCEPTORS == 1)

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:74

class TAO_ServerRequestInfo_CosLoadBalancing_LoadManager_push_loads : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_CosLoadBalancing_LoadManager_push_loads (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_CosLoadBalancing::LoadManager *tao_impl,
      const ::PortableGroup::Location & the_location,
      const ::CosLoadBalancing::LoadList & loads
      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_CosLoadBalancing_LoadManager_push_loads (
      const TAO_ServerRequestInfo_CosLoadBalancing_LoadManager_push_loads &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_CosLoadBalancing_LoadManager_push_loads &
    );
  
private:
  POA_CosLoadBalancing::LoadManager *_tao_impl;
  
  const ::PortableGroup::Location & the_location_;
  const ::CosLoadBalancing::LoadList & loads_;
};

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:438

TAO_ServerRequestInfo_CosLoadBalancing_LoadManager_push_loads::TAO_ServerRequestInfo_CosLoadBalancing_LoadManager_push_loads (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_CosLoadBalancing::LoadManager *tao_impl,
    const ::PortableGroup::Location & the_location,
    const ::CosLoadBalancing::LoadList & loads
    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl),
    the_location_ (the_location),
    loads_ (loads)
{}

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

Dynamic::ExceptionList *
TAO_ServerRequestInfo_CosLoadBalancing_LoadManager_push_loads::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_ServerRequestInfo_CosLoadBalancing_LoadManager_push_loads::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_CosLoadBalancing_LoadManager_push_loads::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_CosLoadBalancing_LoadManager_push_loads::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);
}

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:74

class TAO_ServerRequestInfo_CosLoadBalancing_LoadManager_get_loads : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_CosLoadBalancing_LoadManager_get_loads (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_CosLoadBalancing::LoadManager *tao_impl,
      const ::PortableGroup::Location & the_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));
  
  void result (::CosLoadBalancing::LoadList * result);

private:
  TAO_ServerRequestInfo_CosLoadBalancing_LoadManager_get_loads (
      const TAO_ServerRequestInfo_CosLoadBalancing_LoadManager_get_loads &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_CosLoadBalancing_LoadManager_get_loads &
    );
  
private:
  POA_CosLoadBalancing::LoadManager *_tao_impl;
  
  const ::PortableGroup::Location & the_location_;
  ::CosLoadBalancing::LoadList * _result;
};

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:438

TAO_ServerRequestInfo_CosLoadBalancing_LoadManager_get_loads::TAO_ServerRequestInfo_CosLoadBalancing_LoadManager_get_loads (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_CosLoadBalancing::LoadManager *tao_impl,
    const ::PortableGroup::Location & the_location
    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl),
    the_location_ (the_location)
{}

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

Dynamic::ExceptionList *
TAO_ServerRequestInfo_CosLoadBalancing_LoadManager_get_loads::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_CosLoadBalancing_LoadManager_get_loads_exceptiondata[] = 
  {
    CosLoadBalancing::_tc_LocationNotFound
  };
  
  exception_list->length (1);
  for (CORBA::ULong i = 0; i < 1; ++i)
    {
      CORBA::TypeCode_ptr tcp = _tao_CosLoadBalancing_LoadManager_get_loads_exceptiondata[i];
      TAO_Pseudo_Object_Manager<CORBA::TypeCode> tcp_object (&tcp, 1);
      (*exception_list)[i] = tcp_object;
    }

  return safe_exception_list._retn ();
}

CORBA::Any * 
TAO_ServerRequestInfo_CosLoadBalancing_LoadManager_get_loads::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_CosLoadBalancing_LoadManager_get_loads::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_CosLoadBalancing_LoadManager_get_loads::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_CosLoadBalancing_LoadManager_get_loads::result (::CosLoadBalancing::LoadList * result)
{
  // Update the result.
   this->_result = result;
}

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:74

class TAO_ServerRequestInfo_CosLoadBalancing_LoadManager_enable_alert : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_CosLoadBalancing_LoadManager_enable_alert (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_CosLoadBalancing::LoadManager *tao_impl,
      const ::PortableGroup::Location & the_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_CosLoadBalancing_LoadManager_enable_alert (
      const TAO_ServerRequestInfo_CosLoadBalancing_LoadManager_enable_alert &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_CosLoadBalancing_LoadManager_enable_alert &
    );
  
private:
  POA_CosLoadBalancing::LoadManager *_tao_impl;
  
  const ::PortableGroup::Location & the_location_;
};

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:438

TAO_ServerRequestInfo_CosLoadBalancing_LoadManager_enable_alert::TAO_ServerRequestInfo_CosLoadBalancing_LoadManager_enable_alert (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_CosLoadBalancing::LoadManager *tao_impl,
    const ::PortableGroup::Location & the_location
    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl),
    the_location_ (the_location)
{}

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

Dynamic::ExceptionList *
TAO_ServerRequestInfo_CosLoadBalancing_LoadManager_enable_alert::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_CosLoadBalancing_LoadManager_enable_alert_exceptiondata[] = 
  {
    CosLoadBalancing::_tc_LoadAlertNotFound
  };
  
  exception_list->length (1);
  for (CORBA::ULong i = 0; i < 1; ++i)
    {
      CORBA::TypeCode_ptr tcp = _tao_CosLoadBalancing_LoadManager_enable_alert_exceptiondata[i];
      TAO_Pseudo_Object_Manager<CORBA::TypeCode> tcp_object (&tcp, 1);
      (*exception_list)[i] = tcp_object;
    }

  return safe_exception_list._retn ();
}

CORBA::Any * 
TAO_ServerRequestInfo_CosLoadBalancing_LoadManager_enable_alert::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_CosLoadBalancing_LoadManager_enable_alert::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_CosLoadBalancing_LoadManager_enable_alert::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);
}

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:74

class TAO_ServerRequestInfo_CosLoadBalancing_LoadManager_disable_alert : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_CosLoadBalancing_LoadManager_disable_alert (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_CosLoadBalancing::LoadManager *tao_impl,
      const ::PortableGroup::Location & the_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_CosLoadBalancing_LoadManager_disable_alert (
      const TAO_ServerRequestInfo_CosLoadBalancing_LoadManager_disable_alert &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_CosLoadBalancing_LoadManager_disable_alert &
    );
  
private:
  POA_CosLoadBalancing::LoadManager *_tao_impl;
  
  const ::PortableGroup::Location & the_location_;
};

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:438

TAO_ServerRequestInfo_CosLoadBalancing_LoadManager_disable_alert::TAO_ServerRequestInfo_CosLoadBalancing_LoadManager_disable_alert (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_CosLoadBalancing::LoadManager *tao_impl,
    const ::PortableGroup::Location & the_location
    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl),
    the_location_ (the_location)
{}

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

Dynamic::ExceptionList *
TAO_ServerRequestInfo_CosLoadBalancing_LoadManager_disable_alert::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_CosLoadBalancing_LoadManager_disable_alert_exceptiondata[] = 
  {
    CosLoadBalancing::_tc_LoadAlertNotFound
  };
  
  exception_list->length (1);
  for (CORBA::ULong i = 0; i < 1; ++i)
    {
      CORBA::TypeCode_ptr tcp = _tao_CosLoadBalancing_LoadManager_disable_alert_exceptiondata[i];
      TAO_Pseudo_Object_Manager<CORBA::TypeCode> tcp_object (&tcp, 1);
      (*exception_list)[i] = tcp_object;
    }

  return safe_exception_list._retn ();
}

CORBA::Any * 
TAO_ServerRequestInfo_CosLoadBalancing_LoadManager_disable_alert::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_CosLoadBalancing_LoadManager_disable_alert::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_CosLoadBalancing_LoadManager_disable_alert::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);
}

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:74

class TAO_ServerRequestInfo_CosLoadBalancing_LoadManager_register_load_alert : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_CosLoadBalancing_LoadManager_register_load_alert (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_CosLoadBalancing::LoadManager *tao_impl,
      const ::PortableGroup::Location & the_location,
      ::CosLoadBalancing::LoadAlert_ptr load_alert
      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_CosLoadBalancing_LoadManager_register_load_alert (
      const TAO_ServerRequestInfo_CosLoadBalancing_LoadManager_register_load_alert &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_CosLoadBalancing_LoadManager_register_load_alert &
    );
  
private:
  POA_CosLoadBalancing::LoadManager *_tao_impl;
  
  const ::PortableGroup::Location & the_location_;
  ::CosLoadBalancing::LoadAlert_ptr load_alert_;
};

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:438

TAO_ServerRequestInfo_CosLoadBalancing_LoadManager_register_load_alert::TAO_ServerRequestInfo_CosLoadBalancing_LoadManager_register_load_alert (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_CosLoadBalancing::LoadManager *tao_impl,
    const ::PortableGroup::Location & the_location,
    ::CosLoadBalancing::LoadAlert_ptr load_alert
    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl),
    the_location_ (the_location),
    load_alert_ (load_alert)
{}

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

Dynamic::ExceptionList *
TAO_ServerRequestInfo_CosLoadBalancing_LoadManager_register_load_alert::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_CosLoadBalancing_LoadManager_register_load_alert_exceptiondata[] = 
  {
    CosLoadBalancing::_tc_LoadAlertAlreadyPresent,
    CosLoadBalancing::_tc_LoadAlertNotAdded
  };
  
  exception_list->length (2);
  for (CORBA::ULong i = 0; i < 2; ++i)
    {
      CORBA::TypeCode_ptr tcp = _tao_CosLoadBalancing_LoadManager_register_load_alert_exceptiondata[i];
      TAO_Pseudo_Object_Manager<CORBA::TypeCode> tcp_object (&tcp, 1);
      (*exception_list)[i] = tcp_object;
    }

  return safe_exception_list._retn ();
}

CORBA::Any * 
TAO_ServerRequestInfo_CosLoadBalancing_LoadManager_register_load_alert::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_CosLoadBalancing_LoadManager_register_load_alert::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_CosLoadBalancing_LoadManager_register_load_alert::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);
}

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:74

class TAO_ServerRequestInfo_CosLoadBalancing_LoadManager_get_load_alert : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_CosLoadBalancing_LoadManager_get_load_alert (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_CosLoadBalancing::LoadManager *tao_impl,
      const ::PortableGroup::Location & the_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));
  
  void result (::CosLoadBalancing::LoadAlert_ptr result);

private:
  TAO_ServerRequestInfo_CosLoadBalancing_LoadManager_get_load_alert (
      const TAO_ServerRequestInfo_CosLoadBalancing_LoadManager_get_load_alert &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_CosLoadBalancing_LoadManager_get_load_alert &
    );
  
private:
  POA_CosLoadBalancing::LoadManager *_tao_impl;
  
  const ::PortableGroup::Location & the_location_;
  ::CosLoadBalancing::LoadAlert_ptr _result;
};

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:438

TAO_ServerRequestInfo_CosLoadBalancing_LoadManager_get_load_alert::TAO_ServerRequestInfo_CosLoadBalancing_LoadManager_get_load_alert (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_CosLoadBalancing::LoadManager *tao_impl,
    const ::PortableGroup::Location & the_location
    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl),
    the_location_ (the_location)
{}

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

Dynamic::ExceptionList *
TAO_ServerRequestInfo_CosLoadBalancing_LoadManager_get_load_alert::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_CosLoadBalancing_LoadManager_get_load_alert_exceptiondata[] = 
  {
    CosLoadBalancing::_tc_LoadAlertNotFound
  };
  
  exception_list->length (1);
  for (CORBA::ULong i = 0; i < 1; ++i)
    {
      CORBA::TypeCode_ptr tcp = _tao_CosLoadBalancing_LoadManager_get_load_alert_exceptiondata[i];
      TAO_Pseudo_Object_Manager<CORBA::TypeCode> tcp_object (&tcp, 1);
      (*exception_list)[i] = tcp_object;
    }

  return safe_exception_list._retn ();
}

CORBA::Any * 
TAO_ServerRequestInfo_CosLoadBalancing_LoadManager_get_load_alert::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_CosLoadBalancing_LoadManager_get_load_alert::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_CosLoadBalancing_LoadManager_get_load_alert::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_CosLoadBalancing_LoadManager_get_load_alert::result (::CosLoadBalancing::LoadAlert_ptr result)
{
  // Update the result.
   this->_result = result;
}

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:74

class TAO_ServerRequestInfo_CosLoadBalancing_LoadManager_remove_load_alert : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_CosLoadBalancing_LoadManager_remove_load_alert (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_CosLoadBalancing::LoadManager *tao_impl,
      const ::PortableGroup::Location & the_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_CosLoadBalancing_LoadManager_remove_load_alert (
      const TAO_ServerRequestInfo_CosLoadBalancing_LoadManager_remove_load_alert &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_CosLoadBalancing_LoadManager_remove_load_alert &
    );
  
private:
  POA_CosLoadBalancing::LoadManager *_tao_impl;
  
  const ::PortableGroup::Location & the_location_;
};

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:438

TAO_ServerRequestInfo_CosLoadBalancing_LoadManager_remove_load_alert::TAO_ServerRequestInfo_CosLoadBalancing_LoadManager_remove_load_alert (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_CosLoadBalancing::LoadManager *tao_impl,
    const ::PortableGroup::Location & the_location
    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl),
    the_location_ (the_location)
{}

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

Dynamic::ExceptionList *
TAO_ServerRequestInfo_CosLoadBalancing_LoadManager_remove_load_alert::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_CosLoadBalancing_LoadManager_remove_load_alert_exceptiondata[] = 
  {
    CosLoadBalancing::_tc_LoadAlertNotFound
  };
  
  exception_list->length (1);
  for (CORBA::ULong i = 0; i < 1; ++i)
    {
      CORBA::TypeCode_ptr tcp = _tao_CosLoadBalancing_LoadManager_remove_load_alert_exceptiondata[i];
      TAO_Pseudo_Object_Manager<CORBA::TypeCode> tcp_object (&tcp, 1);
      (*exception_list)[i] = tcp_object;
    }

  return safe_exception_list._retn ();
}

CORBA::Any * 
TAO_ServerRequestInfo_CosLoadBalancing_LoadManager_remove_load_alert::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_CosLoadBalancing_LoadManager_remove_load_alert::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_CosLoadBalancing_LoadManager_remove_load_alert::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);
}

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:74

class TAO_ServerRequestInfo_CosLoadBalancing_LoadManager_register_load_monitor : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_CosLoadBalancing_LoadManager_register_load_monitor (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_CosLoadBalancing::LoadManager *tao_impl,
      const ::PortableGroup::Location & the_location,
      ::CosLoadBalancing::LoadMonitor_ptr load_monitor
      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_CosLoadBalancing_LoadManager_register_load_monitor (
      const TAO_ServerRequestInfo_CosLoadBalancing_LoadManager_register_load_monitor &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_CosLoadBalancing_LoadManager_register_load_monitor &
    );
  
private:
  POA_CosLoadBalancing::LoadManager *_tao_impl;
  
  const ::PortableGroup::Location & the_location_;
  ::CosLoadBalancing::LoadMonitor_ptr load_monitor_;
};

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:438

TAO_ServerRequestInfo_CosLoadBalancing_LoadManager_register_load_monitor::TAO_ServerRequestInfo_CosLoadBalancing_LoadManager_register_load_monitor (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_CosLoadBalancing::LoadManager *tao_impl,
    const ::PortableGroup::Location & the_location,
    ::CosLoadBalancing::LoadMonitor_ptr load_monitor
    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl),
    the_location_ (the_location),
    load_monitor_ (load_monitor)
{}

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

Dynamic::ExceptionList *
TAO_ServerRequestInfo_CosLoadBalancing_LoadManager_register_load_monitor::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_CosLoadBalancing_LoadManager_register_load_monitor_exceptiondata[] = 
  {
    CosLoadBalancing::_tc_MonitorAlreadyPresent
  };
  
  exception_list->length (1);
  for (CORBA::ULong i = 0; i < 1; ++i)
    {
      CORBA::TypeCode_ptr tcp = _tao_CosLoadBalancing_LoadManager_register_load_monitor_exceptiondata[i];
      TAO_Pseudo_Object_Manager<CORBA::TypeCode> tcp_object (&tcp, 1);
      (*exception_list)[i] = tcp_object;
    }

  return safe_exception_list._retn ();
}

CORBA::Any * 
TAO_ServerRequestInfo_CosLoadBalancing_LoadManager_register_load_monitor::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_CosLoadBalancing_LoadManager_register_load_monitor::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_CosLoadBalancing_LoadManager_register_load_monitor::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);
}

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:74

class TAO_ServerRequestInfo_CosLoadBalancing_LoadManager_get_load_monitor : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_CosLoadBalancing_LoadManager_get_load_monitor (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_CosLoadBalancing::LoadManager *tao_impl,
      const ::PortableGroup::Location & the_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));
  
  void result (::CosLoadBalancing::LoadMonitor_ptr result);

private:
  TAO_ServerRequestInfo_CosLoadBalancing_LoadManager_get_load_monitor (
      const TAO_ServerRequestInfo_CosLoadBalancing_LoadManager_get_load_monitor &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_CosLoadBalancing_LoadManager_get_load_monitor &
    );
  
private:
  POA_CosLoadBalancing::LoadManager *_tao_impl;
  
  const ::PortableGroup::Location & the_location_;
  ::CosLoadBalancing::LoadMonitor_ptr _result;
};

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:438

TAO_ServerRequestInfo_CosLoadBalancing_LoadManager_get_load_monitor::TAO_ServerRequestInfo_CosLoadBalancing_LoadManager_get_load_monitor (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_CosLoadBalancing::LoadManager *tao_impl,
    const ::PortableGroup::Location & the_location
    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl),
    the_location_ (the_location)
{}

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

Dynamic::ExceptionList *
TAO_ServerRequestInfo_CosLoadBalancing_LoadManager_get_load_monitor::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_CosLoadBalancing_LoadManager_get_load_monitor_exceptiondata[] = 
  {
    CosLoadBalancing::_tc_LocationNotFound
  };
  
  exception_list->length (1);
  for (CORBA::ULong i = 0; i < 1; ++i)
    {
      CORBA::TypeCode_ptr tcp = _tao_CosLoadBalancing_LoadManager_get_load_monitor_exceptiondata[i];
      TAO_Pseudo_Object_Manager<CORBA::TypeCode> tcp_object (&tcp, 1);
      (*exception_list)[i] = tcp_object;
    }

  return safe_exception_list._retn ();
}

CORBA::Any * 
TAO_ServerRequestInfo_CosLoadBalancing_LoadManager_get_load_monitor::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_CosLoadBalancing_LoadManager_get_load_monitor::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_CosLoadBalancing_LoadManager_get_load_monitor::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_CosLoadBalancing_LoadManager_get_load_monitor::result (::CosLoadBalancing::LoadMonitor_ptr result)
{
  // Update the result.
   this->_result = result;
}

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:74

class TAO_ServerRequestInfo_CosLoadBalancing_LoadManager_remove_load_monitor : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_CosLoadBalancing_LoadManager_remove_load_monitor (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_CosLoadBalancing::LoadManager *tao_impl,
      const ::PortableGroup::Location & the_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_CosLoadBalancing_LoadManager_remove_load_monitor (
      const TAO_ServerRequestInfo_CosLoadBalancing_LoadManager_remove_load_monitor &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_CosLoadBalancing_LoadManager_remove_load_monitor &
    );
  
private:
  POA_CosLoadBalancing::LoadManager *_tao_impl;
  
  const ::PortableGroup::Location & the_location_;
};

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:438

TAO_ServerRequestInfo_CosLoadBalancing_LoadManager_remove_load_monitor::TAO_ServerRequestInfo_CosLoadBalancing_LoadManager_remove_load_monitor (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_CosLoadBalancing::LoadManager *tao_impl,
    const ::PortableGroup::Location & the_location
    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl),
    the_location_ (the_location)
{}

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

Dynamic::ExceptionList *
TAO_ServerRequestInfo_CosLoadBalancing_LoadManager_remove_load_monitor::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_CosLoadBalancing_LoadManager_remove_load_monitor_exceptiondata[] = 
  {
    CosLoadBalancing::_tc_LocationNotFound
  };
  
  exception_list->length (1);
  for (CORBA::ULong i = 0; i < 1; ++i)
    {
      CORBA::TypeCode_ptr tcp = _tao_CosLoadBalancing_LoadManager_remove_load_monitor_exceptiondata[i];
      TAO_Pseudo_Object_Manager<CORBA::TypeCode> tcp_object (&tcp, 1);
      (*exception_list)[i] = tcp_object;
    }

  return safe_exception_list._retn ();
}

CORBA::Any * 
TAO_ServerRequestInfo_CosLoadBalancing_LoadManager_remove_load_monitor::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_CosLoadBalancing_LoadManager_remove_load_monitor::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_CosLoadBalancing_LoadManager_remove_load_monitor::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);
}

#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_CosLoadBalancing::_TAO_LoadManager_Strategized_Proxy_Broker *
POA_CosLoadBalancing::_TAO_LoadManager_Strategized_Proxy_Broker::the_TAO_LoadManager_Strategized_Proxy_Broker (void)
{
  static POA_CosLoadBalancing::_TAO_LoadManager_Strategized_Proxy_Broker
  strategized_proxy_broker;
  
  return &strategized_proxy_broker;
}

POA_CosLoadBalancing::_TAO_LoadManager_Strategized_Proxy_Broker::_TAO_LoadManager_Strategized_Proxy_Broker (void)
{
}

POA_CosLoadBalancing::_TAO_LoadManager_Strategized_Proxy_Broker::~_TAO_LoadManager_Strategized_Proxy_Broker (void)
{
}

TAO::Collocation_Strategy
POA_CosLoadBalancing::_TAO_LoadManager_Strategized_Proxy_Broker::get_strategy (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  TAO::Collocation_Strategy strategy =
    TAO_ORB_Core::collocation_strategy (obj ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (TAO::TAO_CS_REMOTE_STRATEGY);
  
  return strategy;
}

void
POA_CosLoadBalancing::_TAO_LoadManager_Strategized_Proxy_Broker::dispatch (
    CORBA::Object_ptr obj,
    CORBA::Object_out forward_obj,
    TAO::Argument ** args,
    int num_args,
    const char * op,
    size_t op_len,
    TAO::Collocation_Strategy strategy
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::Exception))
{
  TAO_Object_Adapter::Servant_Upcall servant_upcall (
      obj->_stubobj ()->servant_orb_var ()->orb_core ()
    );
  
  TAO_Collocated_Skeleton collocated_skel;
  TAO_Abstract_ServantBase *servant = 0;
  
  if (strategy == TAO::TAO_CS_THRU_POA_STRATEGY)
    {
      servant_upcall.prepare_for_upcall (
          obj->_stubobj ()->object_key (),
          op,
          forward_obj
          ACE_ENV_ARG_PARAMETER
        );
      ACE_CHECK;
      
      servant_upcall.pre_invoke_collocated_request (
          ACE_ENV_SINGLE_ARG_PARAMETER
        );
      ACE_CHECK;
      
      servant = servant_upcall.servant ();
    }
  else
    {
      servant = obj->_servant ();
    }
  
  int status = servant->_find (op,
                               collocated_skel,
                               strategy,
                               op_len);
  
  if (status == -1)
    {
      ACE_THROW (CORBA::BAD_OPERATION ());
    }
  
  ACE_TRY
    {
      collocated_skel (servant,
                       args,
                       num_args
                       ACE_ENV_ARG_PARAMETER);
      ACE_TRY_CHECK;
    }
#if (TAO_HAS_MINIMUM_CORBA == 0)
  ACE_CATCH (PortableServer::ForwardRequest, forward_request)
    {
      forward_obj =
        CORBA::Object::_duplicate (forward_request.forward_reference.in ());
      return;
    }
#else
  ACE_CATCHANY
    {
      ACE_UNUSED_ARG (forward_obj);
      ACE_RE_THROW;
    }
#endif /* TAO_HAS_MINIMUM_CORBA */
  ACE_ENDTRY;
  ACE_CHECK;
}

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

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

TAO::Collocation_Proxy_Broker *
CosLoadBalancing__TAO_LoadManager_Proxy_Broker_Factory_function (CORBA::Object_ptr)
{
  return
    ::POA_CosLoadBalancing::_TAO_LoadManager_Strategized_Proxy_Broker::the_TAO_LoadManager_Strategized_Proxy_Broker ();
}

int
CosLoadBalancing__TAO_LoadManager_Proxy_Broker_Factory_Initializer (size_t)
{
  CosLoadBalancing__TAO_LoadManager_Proxy_Broker_Factory_function_pointer = 
    CosLoadBalancing__TAO_LoadManager_Proxy_Broker_Factory_function;
  
  return 0;
}

static int
CosLoadBalancing__TAO_LoadManager_Proxy_Broker_Stub_Factory_Initializer_Scarecrow =
  CosLoadBalancing__TAO_LoadManager_Proxy_Broker_Factory_Initializer (
      reinterpret_cast<
          size_t> (
          CosLoadBalancing__TAO_LoadManager_Proxy_Broker_Factory_Initializer
        )
    );


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

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

POA_CosLoadBalancing::_TAO_LoadManager_ThruPOA_Proxy_Impl::_TAO_LoadManager_ThruPOA_Proxy_Impl (void)
{}

// ThruPOA Implementation of the IDL interface methods

// TAO_IDL - Generated from 
// be/be_visitor_operation/thru_poa_proxy_impl_ss.cpp:52

void
POA_CosLoadBalancing::_TAO_LoadManager_ThruPOA_Proxy_Impl::push_loads (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument ** args,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  reinterpret_cast<
      POA_CosLoadBalancing::LoadManager_ptr> (
      servant->_downcast (
          "IDL:omg.org/CosLoadBalancing/LoadManager:1.0"
        )
    )->push_loads (
        ((TAO::Arg_Traits< ::PortableGroup::Location>::in_arg_val *) args[1])->arg (),
        ((TAO::Arg_Traits< ::CosLoadBalancing::LoadList>::in_arg_val *) args[2])->arg ()
        ACE_ENV_ARG_PARAMETER
      );
  ACE_CHECK;
}

// TAO_IDL - Generated from 
// be/be_visitor_operation/thru_poa_proxy_impl_ss.cpp:52

void
POA_CosLoadBalancing::_TAO_LoadManager_ThruPOA_Proxy_Impl::get_loads (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument ** args,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException,
    ::CosLoadBalancing::LocationNotFound
  ))
{
  ((TAO::Arg_Traits< ::CosLoadBalancing::LoadList>::ret_val *) args[0])->arg () =
    reinterpret_cast<
        POA_CosLoadBalancing::LoadManager_ptr> (
        servant->_downcast (
            "IDL:omg.org/CosLoadBalancing/LoadManager:1.0"
          )
      )->get_loads (
          ((TAO::Arg_Traits< ::PortableGroup::Location>::in_arg_val *) args[1])->arg ()
          ACE_ENV_ARG_PARAMETER
        );
  ACE_CHECK;
}

// TAO_IDL - Generated from 
// be/be_visitor_operation/thru_poa_proxy_impl_ss.cpp:52

void
POA_CosLoadBalancing::_TAO_LoadManager_ThruPOA_Proxy_Impl::enable_alert (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument ** args,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException,
    ::CosLoadBalancing::LoadAlertNotFound
  ))
{
  reinterpret_cast<
      POA_CosLoadBalancing::LoadManager_ptr> (
      servant->_downcast (
          "IDL:omg.org/CosLoadBalancing/LoadManager:1.0"
        )
    )->enable_alert (
        ((TAO::Arg_Traits< ::PortableGroup::Location>::in_arg_val *) args[1])->arg ()
        ACE_ENV_ARG_PARAMETER
      );
  ACE_CHECK;
}

// TAO_IDL - Generated from 
// be/be_visitor_operation/thru_poa_proxy_impl_ss.cpp:52

void
POA_CosLoadBalancing::_TAO_LoadManager_ThruPOA_Proxy_Impl::disable_alert (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument ** args,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException,
    ::CosLoadBalancing::LoadAlertNotFound
  ))
{
  reinterpret_cast<
      POA_CosLoadBalancing::LoadManager_ptr> (
      servant->_downcast (
          "IDL:omg.org/CosLoadBalancing/LoadManager:1.0"
        )
    )->disable_alert (
        ((TAO::Arg_Traits< ::PortableGroup::Location>::in_arg_val *) args[1])->arg ()
        ACE_ENV_ARG_PARAMETER
      );
  ACE_CHECK;
}

// TAO_IDL - Generated from 
// be/be_visitor_operation/thru_poa_proxy_impl_ss.cpp:52

void
POA_CosLoadBalancing::_TAO_LoadManager_ThruPOA_Proxy_Impl::register_load_alert (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument ** args,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException,
    ::CosLoadBalancing::LoadAlertAlreadyPresent,
    ::CosLoadBalancing::LoadAlertNotAdded
  ))
{
  reinterpret_cast<
      POA_CosLoadBalancing::LoadManager_ptr> (
      servant->_downcast (
          "IDL:omg.org/CosLoadBalancing/LoadManager:1.0"
        )
    )->register_load_alert (
        ((TAO::Arg_Traits< ::PortableGroup::Location>::in_arg_val *) args[1])->arg (),
        ((TAO::Arg_Traits< ::CosLoadBalancing::LoadAlert>::in_arg_val *) args[2])->arg ()
        ACE_ENV_ARG_PARAMETER
      );
  ACE_CHECK;
}

// TAO_IDL - Generated from 
// be/be_visitor_operation/thru_poa_proxy_impl_ss.cpp:52

void
POA_CosLoadBalancing::_TAO_LoadManager_ThruPOA_Proxy_Impl::get_load_alert (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument ** args,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException,
    ::CosLoadBalancing::LoadAlertNotFound
  ))
{
  ((TAO::Arg_Traits< ::CosLoadBalancing::LoadAlert>::ret_val *) args[0])->arg () =
    reinterpret_cast<
        POA_CosLoadBalancing::LoadManager_ptr> (
        servant->_downcast (
            "IDL:omg.org/CosLoadBalancing/LoadManager:1.0"
          )
      )->get_load_alert (
          ((TAO::Arg_Traits< ::PortableGroup::Location>::in_arg_val *) args[1])->arg ()
          ACE_ENV_ARG_PARAMETER
        );
  ACE_CHECK;
}

// TAO_IDL - Generated from 
// be/be_visitor_operation/thru_poa_proxy_impl_ss.cpp:52

void
POA_CosLoadBalancing::_TAO_LoadManager_ThruPOA_Proxy_Impl::remove_load_alert (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument ** args,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException,
    ::CosLoadBalancing::LoadAlertNotFound
  ))
{
  reinterpret_cast<
      POA_CosLoadBalancing::LoadManager_ptr> (
      servant->_downcast (
          "IDL:omg.org/CosLoadBalancing/LoadManager:1.0"
        )
    )->remove_load_alert (
        ((TAO::Arg_Traits< ::PortableGroup::Location>::in_arg_val *) args[1])->arg ()
        ACE_ENV_ARG_PARAMETER
      );
  ACE_CHECK;
}

// TAO_IDL - Generated from 
// be/be_visitor_operation/thru_poa_proxy_impl_ss.cpp:52

void
POA_CosLoadBalancing::_TAO_LoadManager_ThruPOA_Proxy_Impl::register_load_monitor (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument ** args,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException,
    ::CosLoadBalancing::MonitorAlreadyPresent
  ))
{
  reinterpret_cast<
      POA_CosLoadBalancing::LoadManager_ptr> (
      servant->_downcast (
          "IDL:omg.org/CosLoadBalancing/LoadManager:1.0"
        )
    )->register_load_monitor (
        ((TAO::Arg_Traits< ::PortableGroup::Location>::in_arg_val *) args[1])->arg (),
        ((TAO::Arg_Traits< ::CosLoadBalancing::LoadMonitor>::in_arg_val *) args[2])->arg ()
        ACE_ENV_ARG_PARAMETER
      );
  ACE_CHECK;
}

// TAO_IDL - Generated from 
// be/be_visitor_operation/thru_poa_proxy_impl_ss.cpp:52

void
POA_CosLoadBalancing::_TAO_LoadManager_ThruPOA_Proxy_Impl::get_load_monitor (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument ** args,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException,
    ::CosLoadBalancing::LocationNotFound
  ))
{
  ((TAO::Arg_Traits< ::CosLoadBalancing::LoadMonitor>::ret_val *) args[0])->arg () =
    reinterpret_cast<
        POA_CosLoadBalancing::LoadManager_ptr> (
        servant->_downcast (
            "IDL:omg.org/CosLoadBalancing/LoadManager:1.0"
          )
      )->get_load_monitor (
          ((TAO::Arg_Traits< ::PortableGroup::Location>::in_arg_val *) args[1])->arg ()
          ACE_ENV_ARG_PARAMETER
        );
  ACE_CHECK;
}

// TAO_IDL - Generated from 
// be/be_visitor_operation/thru_poa_proxy_impl_ss.cpp:52

void
POA_CosLoadBalancing::_TAO_LoadManager_ThruPOA_Proxy_Impl::remove_load_monitor (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument ** args,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException,
    ::CosLoadBalancing::LocationNotFound
  ))
{
  reinterpret_cast<
      POA_CosLoadBalancing::LoadManager_ptr> (
      servant->_downcast (
          "IDL:omg.org/CosLoadBalancing/LoadManager:1.0"
        )
    )->remove_load_monitor (
        ((TAO::Arg_Traits< ::PortableGroup::Location>::in_arg_val *) args[1])->arg ()
        ACE_ENV_ARG_PARAMETER
      );
  ACE_CHECK;
}

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

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

POA_CosLoadBalancing::LoadManager::LoadManager (void)
{
  this->optable_ = &tao_CosLoadBalancing_LoadManager_optable;
}

POA_CosLoadBalancing::LoadManager::LoadManager (const LoadManager& rhs)
  : TAO_Abstract_ServantBase (rhs),
    TAO_ServantBase (rhs),
    ACE_NESTED_CLASS (POA_PortableGroup, PropertyManager) (rhs),
    ACE_NESTED_CLASS (POA_PortableGroup, ObjectGroupManager) (rhs),
    ACE_NESTED_CLASS (POA_PortableGroup, GenericFactory) (rhs)
{
}

POA_CosLoadBalancing::LoadManager::~LoadManager (void)
{
}

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

void POA_CosLoadBalancing::LoadManager::push_loads_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_CosLoadBalancing::LoadManager *_tao_impl =
    static_cast<
        POA_CosLoadBalancing::LoadManager *> (
        _tao_servant
      );
  _tao_server_request.argument_flag (0);
  
  ::PortableGroup::Location the_location;
  ::CosLoadBalancing::LoadList loads;
  
  if (!(
      (_tao_in >> the_location) &&
      (_tao_in >> loads)
      ))
    {
      TAO_InputCDR::throw_skel_exception (errno ACE_ENV_ARG_PARAMETER);
      ACE_CHECK;
    }
  
#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_Object_Adapter::Servant_Upcall *_tao_upcall =
    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_CosLoadBalancing_LoadManager_push_loads _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl,
      
      the_location,
      
      loads
      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* 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->push_loads (
                  the_location,
                  
                  loads
                  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:98

void POA_CosLoadBalancing::LoadManager::get_loads_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_CosLoadBalancing::LoadManager *_tao_impl =
    static_cast<
        POA_CosLoadBalancing::LoadManager *> (
        _tao_servant
      );
  ::CosLoadBalancing::LoadList_var _tao_retval;
  ::PortableGroup::Location the_location;
  
  if (!(
      (_tao_in >> the_location)
      ))
    {
      TAO_InputCDR::throw_skel_exception (errno ACE_ENV_ARG_PARAMETER);
      ACE_CHECK;
    }
  
#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_Object_Adapter::Servant_Upcall *_tao_upcall =
    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_CosLoadBalancing_LoadManager_get_loads _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl,
      
      the_location
      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* 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->get_loads (
                  the_location
                  ACE_ENV_ARG_PARAMETER
                );
            TAO_INTERCEPTOR_CHECK;
#if (TAO_HAS_INTERCEPTORS == 1)
          }
      }
      
      if (!_tao_vfr.location_forwarded ())
        {
          ::CosLoadBalancing::LoadList * _tao_retval_info = _tao_retval._retn ();
          _tao_ri.result (_tao_retval_info);
          _tao_retval = _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 ();
#if (TAO_HAS_INTERCEPTORS == 1)
  if (!_tao_vfr.location_forwarded ())
    {
#endif /* TAO_HAS_INTERCEPTORS */
      TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
      
      if (!(
          (_tao_out << _tao_retval.in ())
          ))
        {
          TAO_OutputCDR::throw_skel_exception (errno ACE_ENV_ARG_PARAMETER);
          ACE_CHECK;
        }
#if (TAO_HAS_INTERCEPTORS == 1)
    }
#endif /* TAO_HAS_INTERCEPTORS */
  
  
  // 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:98

void POA_CosLoadBalancing::LoadManager::enable_alert_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_CosLoadBalancing::LoadManager *_tao_impl =
    static_cast<
        POA_CosLoadBalancing::LoadManager *> (
        _tao_servant
      );
  _tao_server_request.argument_flag (0);
  
  ::PortableGroup::Location the_location;
  
  if (!(
      (_tao_in >> the_location)
      ))
    {
      TAO_InputCDR::throw_skel_exception (errno ACE_ENV_ARG_PARAMETER);
      ACE_CHECK;
    }
  
#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_Object_Adapter::Servant_Upcall *_tao_upcall =
    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_CosLoadBalancing_LoadManager_enable_alert _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl,
      
      the_location
      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* 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->enable_alert (
                  the_location
                  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:98

void POA_CosLoadBalancing::LoadManager::disable_alert_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_CosLoadBalancing::LoadManager *_tao_impl =
    static_cast<
        POA_CosLoadBalancing::LoadManager *> (
        _tao_servant
      );
  _tao_server_request.argument_flag (0);
  
  ::PortableGroup::Location the_location;
  
  if (!(
      (_tao_in >> the_location)
      ))
    {
      TAO_InputCDR::throw_skel_exception (errno ACE_ENV_ARG_PARAMETER);
      ACE_CHECK;
    }
  
#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_Object_Adapter::Servant_Upcall *_tao_upcall =
    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_CosLoadBalancing_LoadManager_disable_alert _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl,
      
      the_location
      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* 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->disable_alert (
                  the_location
                  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:98

void POA_CosLoadBalancing::LoadManager::register_load_alert_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_CosLoadBalancing::LoadManager *_tao_impl =
    static_cast<
        POA_CosLoadBalancing::LoadManager *> (
        _tao_servant
      );
  _tao_server_request.argument_flag (0);
  
  ::PortableGroup::Location the_location;
  ::CosLoadBalancing::LoadAlert_var load_alert;
  
  if (!(
      (_tao_in >> the_location) &&
      (_tao_in >> load_alert.out ())
      ))
    {
      TAO_InputCDR::throw_skel_exception (errno ACE_ENV_ARG_PARAMETER);
      ACE_CHECK;
    }
  
#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_Object_Adapter::Servant_Upcall *_tao_upcall =
    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_CosLoadBalancing_LoadManager_register_load_alert _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl,
      
      the_location,
      
      load_alert.in ()
      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* 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->register_load_alert (
                  the_location,
                  
                  load_alert.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:98

void POA_CosLoadBalancing::LoadManager::get_load_alert_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_CosLoadBalancing::LoadManager *_tao_impl =
    static_cast<
        POA_CosLoadBalancing::LoadManager *> (
        _tao_servant
      );
  ::CosLoadBalancing::LoadAlert_var _tao_retval;
  ::PortableGroup::Location the_location;
  
  if (!(
      (_tao_in >> the_location)
      ))
    {
      TAO_InputCDR::throw_skel_exception (errno ACE_ENV_ARG_PARAMETER);
      ACE_CHECK;
    }
  
#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_Object_Adapter::Servant_Upcall *_tao_upcall =
    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_CosLoadBalancing_LoadManager_get_load_alert _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl,
      
      the_location
      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* 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->get_load_alert (
                  the_location
                  ACE_ENV_ARG_PARAMETER
                );
            TAO_INTERCEPTOR_CHECK;
#if (TAO_HAS_INTERCEPTORS == 1)
          }
      }
      
      if (!_tao_vfr.location_forwarded ())
        {
          ::CosLoadBalancing::LoadAlert_ptr _tao_retval_info = _tao_retval._retn ();
          _tao_ri.result (_tao_retval_info);
          _tao_retval = _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 ();
#if (TAO_HAS_INTERCEPTORS == 1)
  if (!_tao_vfr.location_forwarded ())
    {
#endif /* TAO_HAS_INTERCEPTORS */
      TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
      
      if (!(
          (_tao_out << _tao_retval.in ())
          ))
        {
          TAO_OutputCDR::throw_skel_exception (errno ACE_ENV_ARG_PARAMETER);
          ACE_CHECK;
        }
#if (TAO_HAS_INTERCEPTORS == 1)
    }
#endif /* TAO_HAS_INTERCEPTORS */
  
  
  // 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:98

void POA_CosLoadBalancing::LoadManager::remove_load_alert_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_CosLoadBalancing::LoadManager *_tao_impl =
    static_cast<
        POA_CosLoadBalancing::LoadManager *> (
        _tao_servant
      );
  _tao_server_request.argument_flag (0);
  
  ::PortableGroup::Location the_location;
  
  if (!(
      (_tao_in >> the_location)
      ))
    {
      TAO_InputCDR::throw_skel_exception (errno ACE_ENV_ARG_PARAMETER);
      ACE_CHECK;
    }
  
#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_Object_Adapter::Servant_Upcall *_tao_upcall =
    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_CosLoadBalancing_LoadManager_remove_load_alert _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl,
      
      the_location
      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* 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_load_alert (
                  the_location
                  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:98

void POA_CosLoadBalancing::LoadManager::register_load_monitor_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_CosLoadBalancing::LoadManager *_tao_impl =
    static_cast<
        POA_CosLoadBalancing::LoadManager *> (
        _tao_servant
      );
  _tao_server_request.argument_flag (0);
  
  ::PortableGroup::Location the_location;
  ::CosLoadBalancing::LoadMonitor_var load_monitor;
  
  if (!(
      (_tao_in >> the_location) &&
      (_tao_in >> load_monitor.out ())
      ))
    {
      TAO_InputCDR::throw_skel_exception (errno ACE_ENV_ARG_PARAMETER);
      ACE_CHECK;
    }
  
#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_Object_Adapter::Servant_Upcall *_tao_upcall =
    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_CosLoadBalancing_LoadManager_register_load_monitor _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl,
      
      the_location,
      
      load_monitor.in ()
      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* 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->register_load_monitor (
                  the_location,
                  
                  load_monitor.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:98

void POA_CosLoadBalancing::LoadManager::get_load_monitor_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_CosLoadBalancing::LoadManager *_tao_impl =
    static_cast<
        POA_CosLoadBalancing::LoadManager *> (
        _tao_servant
      );
  ::CosLoadBalancing::LoadMonitor_var _tao_retval;
  ::PortableGroup::Location the_location;
  
  if (!(
      (_tao_in >> the_location)
      ))
    {
      TAO_InputCDR::throw_skel_exception (errno ACE_ENV_ARG_PARAMETER);
      ACE_CHECK;
    }
  
#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_Object_Adapter::Servant_Upcall *_tao_upcall =
    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_CosLoadBalancing_LoadManager_get_load_monitor _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl,
      
      the_location
      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* 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->get_load_monitor (
                  the_location
                  ACE_ENV_ARG_PARAMETER
                );
            TAO_INTERCEPTOR_CHECK;
#if (TAO_HAS_INTERCEPTORS == 1)
          }
      }
      
      if (!_tao_vfr.location_forwarded ())
        {
          ::CosLoadBalancing::LoadMonitor_ptr _tao_retval_info = _tao_retval._retn ();
          _tao_ri.result (_tao_retval_info);
          _tao_retval = _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 ();
#if (TAO_HAS_INTERCEPTORS == 1)
  if (!_tao_vfr.location_forwarded ())
    {
#endif /* TAO_HAS_INTERCEPTORS */
      TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
      
      if (!(
          (_tao_out << _tao_retval.in ())
          ))
        {
          TAO_OutputCDR::throw_skel_exception (errno ACE_ENV_ARG_PARAMETER);
          ACE_CHECK;
        }
#if (TAO_HAS_INTERCEPTORS == 1)
    }
#endif /* TAO_HAS_INTERCEPTORS */
  
  
  // 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:98

void POA_CosLoadBalancing::LoadManager::remove_load_monitor_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_CosLoadBalancing::LoadManager *_tao_impl =
    static_cast<
        POA_CosLoadBalancing::LoadManager *> (
        _tao_servant
      );
  _tao_server_request.argument_flag (0);
  
  ::PortableGroup::Location the_location;
  
  if (!(
      (_tao_in >> the_location)
      ))
    {
      TAO_InputCDR::throw_skel_exception (errno ACE_ENV_ARG_PARAMETER);
      ACE_CHECK;
    }
  
#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_Object_Adapter::Servant_Upcall *_tao_upcall =
    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_CosLoadBalancing_LoadManager_remove_load_monitor _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl,
      
      the_location
      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* 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_load_monitor (
                  the_location
                  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_interface/interface_ss.cpp:162

void POA_CosLoadBalancing::LoadManager::_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_CosLoadBalancing::LoadManager *_tao_impl =
    (POA_CosLoadBalancing::LoadManager *) _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_CosLoadBalancing::LoadManager::_non_existent_skel (
    TAO_ServerRequest &_tao_server_request, 
    void * _tao_servant,
    void * /* Servant_Upcall */
    ACE_ENV_ARG_DECL
  )
{
  POA_CosLoadBalancing::LoadManager *_tao_impl =
    (POA_CosLoadBalancing::LoadManager *) _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_CosLoadBalancing::LoadManager::_interface_skel (
    TAO_ServerRequest &_tao_server_request, 
    void * _tao_servant,
    void * /* Servant_Upcall */
    ACE_ENV_ARG_DECL
  )
{
  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 ());
    }
  
  POA_CosLoadBalancing::LoadManager *_tao_impl =
    (POA_CosLoadBalancing::LoadManager *) _tao_servant;
  
  CORBA::InterfaceDef_ptr _tao_retval = 
    _tao_impl->_get_interface (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK;
  
  _tao_server_request.init_reply ();
  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
  
  CORBA::Boolean _tao_result =
    _tao_adapter->interfacedef_cdr_insert (
        _tao_out,
        _tao_retval
      );
  
  _tao_adapter->dispose (_tao_retval);
  
  if (_tao_result == 0)
    {
      ACE_THROW (CORBA::MARSHAL ());
    }
}

void POA_CosLoadBalancing::LoadManager::_component_skel (
    TAO_ServerRequest &_tao_server_request, 
    void * _tao_object_reference,
    void * /* Servant_Upcall */
    ACE_ENV_ARG_DECL
  )
{
  POA_CosLoadBalancing::LoadManager *_tao_impl =
    (POA_CosLoadBalancing::LoadManager *) _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.in ()))
    {
      ACE_THROW (CORBA::MARSHAL ());
    }
}

CORBA::Boolean POA_CosLoadBalancing::LoadManager::_is_a (
    const char* value
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  if (
      !ACE_OS::strcmp (
          (char *)value,
          "IDL:omg.org/PortableGroup/PropertyManager:1.0"
        ) ||
      !ACE_OS::strcmp (
          (char *)value,
          "IDL:omg.org/PortableGroup/ObjectGroupManager:1.0"
        ) ||
      !ACE_OS::strcmp (
          (char *)value,
          "IDL:omg.org/PortableGroup/GenericFactory:1.0"
        ) ||
      !ACE_OS::strcmp (
          (char *)value,
          "IDL:omg.org/CosLoadBalancing/LoadManager:1.0"
        ) ||
      !ACE_OS::strcmp (
          (char *)value,
          "IDL:omg.org/CORBA/Object:1.0"
        )
     )
    {
      return 1;
    }
  else
    {
      return 0;
    }
}

void* POA_CosLoadBalancing::LoadManager::_downcast (
    const char* logical_type_id
  )
{
  if (ACE_OS::strcmp (logical_type_id,
                      "IDL:omg.org/PortableGroup/PropertyManager:1.0") == 0)
    {
      return static_cast<POA_PortableGroup::PropertyManager_ptr> (this);
    }
  
  if (ACE_OS::strcmp (logical_type_id,
                      "IDL:omg.org/PortableGroup/ObjectGroupManager:1.0") == 0)
    {
      return static_cast<POA_PortableGroup::ObjectGroupManager_ptr> (this);
    }
  
  if (ACE_OS::strcmp (logical_type_id,
                      "IDL:omg.org/PortableGroup/GenericFactory:1.0") == 0)
    {
      return static_cast<POA_PortableGroup::GenericFactory_ptr> (this);
    }
  
  if (ACE_OS::strcmp (logical_type_id,
                      "IDL:omg.org/CosLoadBalancing/LoadManager:1.0") == 0)
    {
      return static_cast<POA_CosLoadBalancing::LoadManager_ptr> (this);
    }
  
  if (ACE_OS::strcmp (logical_type_id,
                      "IDL:omg.org/CORBA/Object:1.0") == 0)
    {
      return static_cast<PortableServer::Servant> (this);
    }
  
  return 0;
}

const char* POA_CosLoadBalancing::LoadManager::_interface_repository_id (void) const
{
  return "IDL:omg.org/CosLoadBalancing/LoadManager:1.0";
}

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

void POA_CosLoadBalancing::LoadManager::_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:526

CosLoadBalancing::LoadManager *
POA_CosLoadBalancing::LoadManager::_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 ();
  
  typedef ::CosLoadBalancing::LoadManager STUB_SCOPED_NAME;
  return
    TAO::Narrow_Utils<STUB_SCOPED_NAME>::unchecked_narrow (
        obj.in (),
        CosLoadBalancing__TAO_LoadManager_Proxy_Broker_Factory_function_pointer
      );
}

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

class TAO_CosLoadBalancing_AMI_LoadManagerHandler_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: /work/a/ports/devel/ace+tao/work/ACE_wrappers/bin/gperf -m -M -J -c -C -D -E -T -f 0 -F 0,0,0 -a -o -t -p -K opname_ -L C++ -Z TAO_CosLoadBalancing_AMI_LoadManagerHandler_Perfect_Hash_OpTable -N lookup  */
unsigned int
TAO_CosLoadBalancing_AMI_LoadManagerHandler_Perfect_Hash_OpTable::hash (const char *str, unsigned int len)
{
  static const unsigned char asso_values[] =
    {
#if defined (ACE_MVS)
     55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
     55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
     55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
     55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
     55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
     55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
     55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
     55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
     55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
     55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
     55, 55, 55, 55, 55, 55, 55, 55, 55,  0,
     55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
     55, 55, 55, 55, 55, 55, 55, 55, 55,  0,
     55, 55, 20, 26, 55, 15, 55, 55, 55, 55,
     55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
     55,  0, 55,  0, 55, 55, 55, 55, 55, 55,
     55, 55, 30,  5, 55, 55, 55, 55, 55, 55,
     55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
     55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
     55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
     55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
     55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
     55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
     55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
     55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
     55, 55, 55, 55, 55, 55,
#else
     55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
     55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
     55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
     55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
     55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
     55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
     55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
     55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
     55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
     55, 55, 55, 55, 55,  0, 55,  0, 55, 55,
     20, 26, 55, 15, 55, 55, 55, 55, 55, 55,
     55, 55,  0, 55,  0, 30,  5, 55, 55, 55,
     55, 55, 55, 55, 55, 55, 55, 55,
#endif /* ACE_MVS */
    };
  return len + asso_values[(int) str[len - 1]] + asso_values[(int) str[0]];
}

const class TAO_operation_db_entry *
TAO_CosLoadBalancing_AMI_LoadManagerHandler_Perfect_Hash_OpTable::lookup (const char *str, unsigned int len)
{
  enum
    {
      TOTAL_KEYWORDS = 24,
      MIN_WORD_LENGTH = 5,
      MAX_WORD_LENGTH = 27,
      MIN_HASH_VALUE = 5,
      MAX_HASH_VALUE = 54,
      HASH_VALUE_RANGE = 50,
      DUPLICATES = 2,
      WORDLIST_SIZE = 29
    };

  static const class TAO_operation_db_entry  wordlist[] =
    {
      {"",0,0,0},{"",0,0,0},{"",0,0,0},{"",0,0,0},{"",0,0,0},
      {"_is_a", &POA_CosLoadBalancing::AMI_LoadManagerHandler::_is_a_skel, 0, 0},
      {"_component", &POA_CosLoadBalancing::AMI_LoadManagerHandler::_component_skel, 0, 0},
      {"push_loads_excep", &POA_CosLoadBalancing::AMI_LoadManagerHandler::push_loads_excep_skel, &POA_CosLoadBalancing::_TAO_AMI_LoadManagerHandler_ThruPOA_Proxy_Impl::push_loads_excep, 0},
      {"_non_existent", &POA_CosLoadBalancing::AMI_LoadManagerHandler::_non_existent_skel, 0, 0},
      {"remove_load_monitor", &POA_CosLoadBalancing::AMI_LoadManagerHandler::remove_load_monitor_skel, &POA_CosLoadBalancing::_TAO_AMI_LoadManagerHandler_ThruPOA_Proxy_Impl::remove_load_monitor, 0},
      {"register_load_monitor", &POA_CosLoadBalancing::AMI_LoadManagerHandler::register_load_monitor_skel, &POA_CosLoadBalancing::_TAO_AMI_LoadManagerHandler_ThruPOA_Proxy_Impl::register_load_monitor, 0},
      {"remove_load_alert", &POA_CosLoadBalancing::AMI_LoadManagerHandler::remove_load_alert_skel, &POA_CosLoadBalancing::_TAO_AMI_LoadManagerHandler_ThruPOA_Proxy_Impl::remove_load_alert, 0},
      {"remove_load_alert_excep", &POA_CosLoadBalancing::AMI_LoadManagerHandler::remove_load_alert_excep_skel, &POA_CosLoadBalancing::_TAO_AMI_LoadManagerHandler_ThruPOA_Proxy_Impl::remove_load_alert_excep, 0},
      {"register_load_alert", &POA_CosLoadBalancing::AMI_LoadManagerHandler::register_load_alert_skel, &POA_CosLoadBalancing::_TAO_AMI_LoadManagerHandler_ThruPOA_Proxy_Impl::register_load_alert, 0},
      {"register_load_alert_excep", &POA_CosLoadBalancing::AMI_LoadManagerHandler::register_load_alert_excep_skel, &POA_CosLoadBalancing::_TAO_AMI_LoadManagerHandler_ThruPOA_Proxy_Impl::register_load_alert_excep, 0},
      {"remove_load_monitor_excep", &POA_CosLoadBalancing::AMI_LoadManagerHandler::remove_load_monitor_excep_skel, &POA_CosLoadBalancing::_TAO_AMI_LoadManagerHandler_ThruPOA_Proxy_Impl::remove_load_monitor_excep, 0},
      {"register_load_monitor_excep", &POA_CosLoadBalancing::AMI_LoadManagerHandler::register_load_monitor_excep_skel, &POA_CosLoadBalancing::_TAO_AMI_LoadManagerHandler_ThruPOA_Proxy_Impl::register_load_monitor_excep, 0},
      {"get_loads_excep", &POA_CosLoadBalancing::AMI_LoadManagerHandler::get_loads_excep_skel, &POA_CosLoadBalancing::_TAO_AMI_LoadManagerHandler_ThruPOA_Proxy_Impl::get_loads_excep, 0},
      {"get_load_monitor", &POA_CosLoadBalancing::AMI_LoadManagerHandler::get_load_monitor_skel, &POA_CosLoadBalancing::_TAO_AMI_LoadManagerHandler_ThruPOA_Proxy_Impl::get_load_monitor, 0},
      {"get_load_alert", &POA_CosLoadBalancing::AMI_LoadManagerHandler::get_load_alert_skel, &POA_CosLoadBalancing::_TAO_AMI_LoadManagerHandler_ThruPOA_Proxy_Impl::get_load_alert, 0},
      {"get_load_alert_excep", &POA_CosLoadBalancing::AMI_LoadManagerHandler::get_load_alert_excep_skel, &POA_CosLoadBalancing::_TAO_AMI_LoadManagerHandler_ThruPOA_Proxy_Impl::get_load_alert_excep, 0},
      {"_interface", &POA_CosLoadBalancing::AMI_LoadManagerHandler::_interface_skel, 0, 0},
      {"get_load_monitor_excep", &POA_CosLoadBalancing::AMI_LoadManagerHandler::get_load_monitor_excep_skel, &POA_CosLoadBalancing::_TAO_AMI_LoadManagerHandler_ThruPOA_Proxy_Impl::get_load_monitor_excep, 0},
      {"disable_alert", &POA_CosLoadBalancing::AMI_LoadManagerHandler::disable_alert_skel, &POA_CosLoadBalancing::_TAO_AMI_LoadManagerHandler_ThruPOA_Proxy_Impl::disable_alert, 0},
      {"disable_alert_excep", &POA_CosLoadBalancing::AMI_LoadManagerHandler::disable_alert_excep_skel, &POA_CosLoadBalancing::_TAO_AMI_LoadManagerHandler_ThruPOA_Proxy_Impl::disable_alert_excep, 0},
      {"push_loads", &POA_CosLoadBalancing::AMI_LoadManagerHandler::push_loads_skel, &POA_CosLoadBalancing::_TAO_AMI_LoadManagerHandler_ThruPOA_Proxy_Impl::push_loads, 0},
      {"enable_alert", &POA_CosLoadBalancing::AMI_LoadManagerHandler::enable_alert_skel, &POA_CosLoadBalancing::_TAO_AMI_LoadManagerHandler_ThruPOA_Proxy_Impl::enable_alert, 0},
      {"enable_alert_excep", &POA_CosLoadBalancing::AMI_LoadManagerHandler::enable_alert_excep_skel, &POA_CosLoadBalancing::_TAO_AMI_LoadManagerHandler_ThruPOA_Proxy_Impl::enable_alert_excep, 0},
      {"get_loads", &POA_CosLoadBalancing::AMI_LoadManagerHandler::get_loads_skel, &POA_CosLoadBalancing::_TAO_AMI_LoadManagerHandler_ThruPOA_Proxy_Impl::get_loads, 0},
    };

  static const signed char lookup[] =
    {
       -1,  -1,  -1,  -1,  -1,   5,  -1,  -1,  -1,  -1,  -1,  -1,  -1, -14, 
       -2,   6,   7,  -1,   8,   9,  -1,  10,  11,  12,  13, -66,  -1,  16, 
       -1,  -1,  17,  18,  -1,  -1,  19,  20,  21,  22,  23,  24,  25,  -1, 
       -1,  26,  27,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  28, 
    };

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

      if (key <= MAX_HASH_VALUE && key >= MIN_HASH_VALUE)
        {
          int slot = lookup[key];

          if (slot >= 0 && slot < WORDLIST_SIZE)
            {
              const char *s = wordlist[slot].opname_;

              if (*str == *s && !strncmp (str + 1, s + 1, len - 1))
                return &wordlist[slot];
            }
          else if (slot < 0 && slot >= -MAX_HASH_VALUE)
            return 0;
          else
            {
              unsigned int offset = key + slot + (slot > 0 ? -MAX_HASH_VALUE : MAX_HASH_VALUE);
              const class TAO_operation_db_entry  *base = &wordlist[-lookup[offset]];
              const class TAO_operation_db_entry  *ptr = base + -lookup[offset + 1];

              while (--ptr >= base)
                if (*str == *ptr->opname_ && !strncmp (str + 1, ptr->opname_ + 1, len - 1))
                  return ptr;
            }
        }
    }
  return 0;
}

static TAO_CosLoadBalancing_AMI_LoadManagerHandler_Perfect_Hash_OpTable tao_CosLoadBalancing_AMI_LoadManagerHandler_optable;

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

#if (TAO_HAS_INTERCEPTORS == 1)

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:74

class TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_push_loads : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_push_loads (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_CosLoadBalancing::AMI_LoadManagerHandler *tao_impl
      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_CosLoadBalancing_AMI_LoadManagerHandler_push_loads (
      const TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_push_loads &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_push_loads &
    );
  
private:
  POA_CosLoadBalancing::AMI_LoadManagerHandler *_tao_impl;
  
};

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:438

TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_push_loads::TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_push_loads (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_CosLoadBalancing::AMI_LoadManagerHandler *tao_impl
    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl)
{}

Dynamic::ParameterList *
TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_push_loads::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_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_push_loads::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_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_push_loads::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_CosLoadBalancing_AMI_LoadManagerHandler_push_loads::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_CosLoadBalancing_AMI_LoadManagerHandler_push_loads::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);
}

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:74

class TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_push_loads_excep : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_push_loads_excep (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_CosLoadBalancing::AMI_LoadManagerHandler *tao_impl,
      ::CosLoadBalancing::AMI_LoadManagerExceptionHolder * excep_holder
      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_CosLoadBalancing_AMI_LoadManagerHandler_push_loads_excep (
      const TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_push_loads_excep &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_push_loads_excep &
    );
  
private:
  POA_CosLoadBalancing::AMI_LoadManagerHandler *_tao_impl;
  
  ::CosLoadBalancing::AMI_LoadManagerExceptionHolder * excep_holder_;
};

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:438

TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_push_loads_excep::TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_push_loads_excep (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_CosLoadBalancing::AMI_LoadManagerHandler *tao_impl,
    ::CosLoadBalancing::AMI_LoadManagerExceptionHolder * excep_holder
    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl),
    excep_holder_ (excep_holder)
{}

Dynamic::ParameterList *
TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_push_loads_excep::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_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_push_loads_excep::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_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_push_loads_excep::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_CosLoadBalancing_AMI_LoadManagerHandler_push_loads_excep::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_CosLoadBalancing_AMI_LoadManagerHandler_push_loads_excep::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);
}

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:74

class TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_get_loads : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_get_loads (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_CosLoadBalancing::AMI_LoadManagerHandler *tao_impl,
      const ::CosLoadBalancing::LoadList & ami_return_val
      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_CosLoadBalancing_AMI_LoadManagerHandler_get_loads (
      const TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_get_loads &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_get_loads &
    );
  
private:
  POA_CosLoadBalancing::AMI_LoadManagerHandler *_tao_impl;
  
  const ::CosLoadBalancing::LoadList & ami_return_val_;
};

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:438

TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_get_loads::TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_get_loads (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_CosLoadBalancing::AMI_LoadManagerHandler *tao_impl,
    const ::CosLoadBalancing::LoadList & ami_return_val
    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl),
    ami_return_val_ (ami_return_val)
{}

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

Dynamic::ExceptionList *
TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_get_loads::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_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_get_loads::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_CosLoadBalancing_AMI_LoadManagerHandler_get_loads::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_CosLoadBalancing_AMI_LoadManagerHandler_get_loads::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);
}

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:74

class TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_get_loads_excep : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_get_loads_excep (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_CosLoadBalancing::AMI_LoadManagerHandler *tao_impl,
      ::CosLoadBalancing::AMI_LoadManagerExceptionHolder * excep_holder
      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_CosLoadBalancing_AMI_LoadManagerHandler_get_loads_excep (
      const TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_get_loads_excep &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_get_loads_excep &
    );
  
private:
  POA_CosLoadBalancing::AMI_LoadManagerHandler *_tao_impl;
  
  ::CosLoadBalancing::AMI_LoadManagerExceptionHolder * excep_holder_;
};

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:438

TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_get_loads_excep::TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_get_loads_excep (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_CosLoadBalancing::AMI_LoadManagerHandler *tao_impl,
    ::CosLoadBalancing::AMI_LoadManagerExceptionHolder * excep_holder
    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl),
    excep_holder_ (excep_holder)
{}

Dynamic::ParameterList *
TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_get_loads_excep::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_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_get_loads_excep::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_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_get_loads_excep::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_CosLoadBalancing_AMI_LoadManagerHandler_get_loads_excep::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_CosLoadBalancing_AMI_LoadManagerHandler_get_loads_excep::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);
}

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:74

class TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_enable_alert : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_enable_alert (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_CosLoadBalancing::AMI_LoadManagerHandler *tao_impl
      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_CosLoadBalancing_AMI_LoadManagerHandler_enable_alert (
      const TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_enable_alert &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_enable_alert &
    );
  
private:
  POA_CosLoadBalancing::AMI_LoadManagerHandler *_tao_impl;
  
};

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:438

TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_enable_alert::TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_enable_alert (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_CosLoadBalancing::AMI_LoadManagerHandler *tao_impl
    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl)
{}

Dynamic::ParameterList *
TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_enable_alert::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_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_enable_alert::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_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_enable_alert::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_CosLoadBalancing_AMI_LoadManagerHandler_enable_alert::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_CosLoadBalancing_AMI_LoadManagerHandler_enable_alert::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);
}

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:74

class TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_enable_alert_excep : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_enable_alert_excep (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_CosLoadBalancing::AMI_LoadManagerHandler *tao_impl,
      ::CosLoadBalancing::AMI_LoadManagerExceptionHolder * excep_holder
      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_CosLoadBalancing_AMI_LoadManagerHandler_enable_alert_excep (
      const TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_enable_alert_excep &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_enable_alert_excep &
    );
  
private:
  POA_CosLoadBalancing::AMI_LoadManagerHandler *_tao_impl;
  
  ::CosLoadBalancing::AMI_LoadManagerExceptionHolder * excep_holder_;
};

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:438

TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_enable_alert_excep::TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_enable_alert_excep (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_CosLoadBalancing::AMI_LoadManagerHandler *tao_impl,
    ::CosLoadBalancing::AMI_LoadManagerExceptionHolder * excep_holder
    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl),
    excep_holder_ (excep_holder)
{}

Dynamic::ParameterList *
TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_enable_alert_excep::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_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_enable_alert_excep::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_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_enable_alert_excep::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_CosLoadBalancing_AMI_LoadManagerHandler_enable_alert_excep::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_CosLoadBalancing_AMI_LoadManagerHandler_enable_alert_excep::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);
}

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:74

class TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_disable_alert : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_disable_alert (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_CosLoadBalancing::AMI_LoadManagerHandler *tao_impl
      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_CosLoadBalancing_AMI_LoadManagerHandler_disable_alert (
      const TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_disable_alert &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_disable_alert &
    );
  
private:
  POA_CosLoadBalancing::AMI_LoadManagerHandler *_tao_impl;
  
};

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:438

TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_disable_alert::TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_disable_alert (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_CosLoadBalancing::AMI_LoadManagerHandler *tao_impl
    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl)
{}

Dynamic::ParameterList *
TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_disable_alert::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_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_disable_alert::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_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_disable_alert::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_CosLoadBalancing_AMI_LoadManagerHandler_disable_alert::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_CosLoadBalancing_AMI_LoadManagerHandler_disable_alert::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);
}

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:74

class TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_disable_alert_excep : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_disable_alert_excep (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_CosLoadBalancing::AMI_LoadManagerHandler *tao_impl,
      ::CosLoadBalancing::AMI_LoadManagerExceptionHolder * excep_holder
      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_CosLoadBalancing_AMI_LoadManagerHandler_disable_alert_excep (
      const TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_disable_alert_excep &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_disable_alert_excep &
    );
  
private:
  POA_CosLoadBalancing::AMI_LoadManagerHandler *_tao_impl;
  
  ::CosLoadBalancing::AMI_LoadManagerExceptionHolder * excep_holder_;
};

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:438

TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_disable_alert_excep::TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_disable_alert_excep (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_CosLoadBalancing::AMI_LoadManagerHandler *tao_impl,
    ::CosLoadBalancing::AMI_LoadManagerExceptionHolder * excep_holder
    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl),
    excep_holder_ (excep_holder)
{}

Dynamic::ParameterList *
TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_disable_alert_excep::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_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_disable_alert_excep::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_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_disable_alert_excep::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_CosLoadBalancing_AMI_LoadManagerHandler_disable_alert_excep::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_CosLoadBalancing_AMI_LoadManagerHandler_disable_alert_excep::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);
}

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:74

class TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_register_load_alert : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_register_load_alert (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_CosLoadBalancing::AMI_LoadManagerHandler *tao_impl
      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_CosLoadBalancing_AMI_LoadManagerHandler_register_load_alert (
      const TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_register_load_alert &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_register_load_alert &
    );
  
private:
  POA_CosLoadBalancing::AMI_LoadManagerHandler *_tao_impl;
  
};

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:438

TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_register_load_alert::TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_register_load_alert (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_CosLoadBalancing::AMI_LoadManagerHandler *tao_impl
    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl)
{}

Dynamic::ParameterList *
TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_register_load_alert::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_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_register_load_alert::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_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_register_load_alert::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_CosLoadBalancing_AMI_LoadManagerHandler_register_load_alert::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_CosLoadBalancing_AMI_LoadManagerHandler_register_load_alert::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);
}

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:74

class TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_register_load_alert_excep : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_register_load_alert_excep (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_CosLoadBalancing::AMI_LoadManagerHandler *tao_impl,
      ::CosLoadBalancing::AMI_LoadManagerExceptionHolder * excep_holder
      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_CosLoadBalancing_AMI_LoadManagerHandler_register_load_alert_excep (
      const TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_register_load_alert_excep &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_register_load_alert_excep &
    );
  
private:
  POA_CosLoadBalancing::AMI_LoadManagerHandler *_tao_impl;
  
  ::CosLoadBalancing::AMI_LoadManagerExceptionHolder * excep_holder_;
};

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:438

TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_register_load_alert_excep::TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_register_load_alert_excep (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_CosLoadBalancing::AMI_LoadManagerHandler *tao_impl,
    ::CosLoadBalancing::AMI_LoadManagerExceptionHolder * excep_holder
    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl),
    excep_holder_ (excep_holder)
{}

Dynamic::ParameterList *
TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_register_load_alert_excep::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_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_register_load_alert_excep::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_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_register_load_alert_excep::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_CosLoadBalancing_AMI_LoadManagerHandler_register_load_alert_excep::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_CosLoadBalancing_AMI_LoadManagerHandler_register_load_alert_excep::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);
}

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:74

class TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_get_load_alert : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_get_load_alert (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_CosLoadBalancing::AMI_LoadManagerHandler *tao_impl,
      ::CosLoadBalancing::LoadAlert_ptr ami_return_val
      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_CosLoadBalancing_AMI_LoadManagerHandler_get_load_alert (
      const TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_get_load_alert &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_get_load_alert &
    );
  
private:
  POA_CosLoadBalancing::AMI_LoadManagerHandler *_tao_impl;
  
  ::CosLoadBalancing::LoadAlert_ptr ami_return_val_;
};

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:438

TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_get_load_alert::TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_get_load_alert (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_CosLoadBalancing::AMI_LoadManagerHandler *tao_impl,
    ::CosLoadBalancing::LoadAlert_ptr ami_return_val
    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl),
    ami_return_val_ (ami_return_val)
{}

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

Dynamic::ExceptionList *
TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_get_load_alert::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_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_get_load_alert::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_CosLoadBalancing_AMI_LoadManagerHandler_get_load_alert::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_CosLoadBalancing_AMI_LoadManagerHandler_get_load_alert::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);
}

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:74

class TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_get_load_alert_excep : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_get_load_alert_excep (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_CosLoadBalancing::AMI_LoadManagerHandler *tao_impl,
      ::CosLoadBalancing::AMI_LoadManagerExceptionHolder * excep_holder
      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_CosLoadBalancing_AMI_LoadManagerHandler_get_load_alert_excep (
      const TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_get_load_alert_excep &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_get_load_alert_excep &
    );
  
private:
  POA_CosLoadBalancing::AMI_LoadManagerHandler *_tao_impl;
  
  ::CosLoadBalancing::AMI_LoadManagerExceptionHolder * excep_holder_;
};

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:438

TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_get_load_alert_excep::TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_get_load_alert_excep (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_CosLoadBalancing::AMI_LoadManagerHandler *tao_impl,
    ::CosLoadBalancing::AMI_LoadManagerExceptionHolder * excep_holder
    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl),
    excep_holder_ (excep_holder)
{}

Dynamic::ParameterList *
TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_get_load_alert_excep::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_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_get_load_alert_excep::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_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_get_load_alert_excep::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_CosLoadBalancing_AMI_LoadManagerHandler_get_load_alert_excep::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_CosLoadBalancing_AMI_LoadManagerHandler_get_load_alert_excep::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);
}

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:74

class TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_remove_load_alert : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_remove_load_alert (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_CosLoadBalancing::AMI_LoadManagerHandler *tao_impl
      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_CosLoadBalancing_AMI_LoadManagerHandler_remove_load_alert (
      const TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_remove_load_alert &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_remove_load_alert &
    );
  
private:
  POA_CosLoadBalancing::AMI_LoadManagerHandler *_tao_impl;
  
};

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:438

TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_remove_load_alert::TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_remove_load_alert (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_CosLoadBalancing::AMI_LoadManagerHandler *tao_impl
    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl)
{}

Dynamic::ParameterList *
TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_remove_load_alert::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_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_remove_load_alert::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_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_remove_load_alert::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_CosLoadBalancing_AMI_LoadManagerHandler_remove_load_alert::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_CosLoadBalancing_AMI_LoadManagerHandler_remove_load_alert::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);
}

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:74

class TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_remove_load_alert_excep : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_remove_load_alert_excep (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_CosLoadBalancing::AMI_LoadManagerHandler *tao_impl,
      ::CosLoadBalancing::AMI_LoadManagerExceptionHolder * excep_holder
      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_CosLoadBalancing_AMI_LoadManagerHandler_remove_load_alert_excep (
      const TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_remove_load_alert_excep &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_remove_load_alert_excep &
    );
  
private:
  POA_CosLoadBalancing::AMI_LoadManagerHandler *_tao_impl;
  
  ::CosLoadBalancing::AMI_LoadManagerExceptionHolder * excep_holder_;
};

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:438

TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_remove_load_alert_excep::TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_remove_load_alert_excep (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_CosLoadBalancing::AMI_LoadManagerHandler *tao_impl,
    ::CosLoadBalancing::AMI_LoadManagerExceptionHolder * excep_holder
    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl),
    excep_holder_ (excep_holder)
{}

Dynamic::ParameterList *
TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_remove_load_alert_excep::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_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_remove_load_alert_excep::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_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_remove_load_alert_excep::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_CosLoadBalancing_AMI_LoadManagerHandler_remove_load_alert_excep::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_CosLoadBalancing_AMI_LoadManagerHandler_remove_load_alert_excep::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);
}

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:74

class TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_register_load_monitor : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_register_load_monitor (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_CosLoadBalancing::AMI_LoadManagerHandler *tao_impl
      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_CosLoadBalancing_AMI_LoadManagerHandler_register_load_monitor (
      const TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_register_load_monitor &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_register_load_monitor &
    );
  
private:
  POA_CosLoadBalancing::AMI_LoadManagerHandler *_tao_impl;
  
};

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:438

TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_register_load_monitor::TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_register_load_monitor (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_CosLoadBalancing::AMI_LoadManagerHandler *tao_impl
    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl)
{}

Dynamic::ParameterList *
TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_register_load_monitor::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_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_register_load_monitor::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_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_register_load_monitor::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_CosLoadBalancing_AMI_LoadManagerHandler_register_load_monitor::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_CosLoadBalancing_AMI_LoadManagerHandler_register_load_monitor::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);
}

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:74

class TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_register_load_monitor_excep : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_register_load_monitor_excep (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_CosLoadBalancing::AMI_LoadManagerHandler *tao_impl,
      ::CosLoadBalancing::AMI_LoadManagerExceptionHolder * excep_holder
      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_CosLoadBalancing_AMI_LoadManagerHandler_register_load_monitor_excep (
      const TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_register_load_monitor_excep &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_register_load_monitor_excep &
    );
  
private:
  POA_CosLoadBalancing::AMI_LoadManagerHandler *_tao_impl;
  
  ::CosLoadBalancing::AMI_LoadManagerExceptionHolder * excep_holder_;
};

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:438

TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_register_load_monitor_excep::TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_register_load_monitor_excep (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_CosLoadBalancing::AMI_LoadManagerHandler *tao_impl,
    ::CosLoadBalancing::AMI_LoadManagerExceptionHolder * excep_holder
    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl),
    excep_holder_ (excep_holder)
{}

Dynamic::ParameterList *
TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_register_load_monitor_excep::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_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_register_load_monitor_excep::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_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_register_load_monitor_excep::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_CosLoadBalancing_AMI_LoadManagerHandler_register_load_monitor_excep::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_CosLoadBalancing_AMI_LoadManagerHandler_register_load_monitor_excep::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);
}

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:74

class TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_get_load_monitor : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_get_load_monitor (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_CosLoadBalancing::AMI_LoadManagerHandler *tao_impl,
      ::CosLoadBalancing::LoadMonitor_ptr ami_return_val
      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_CosLoadBalancing_AMI_LoadManagerHandler_get_load_monitor (
      const TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_get_load_monitor &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_get_load_monitor &
    );
  
private:
  POA_CosLoadBalancing::AMI_LoadManagerHandler *_tao_impl;
  
  ::CosLoadBalancing::LoadMonitor_ptr ami_return_val_;
};

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:438

TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_get_load_monitor::TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_get_load_monitor (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_CosLoadBalancing::AMI_LoadManagerHandler *tao_impl,
    ::CosLoadBalancing::LoadMonitor_ptr ami_return_val
    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl),
    ami_return_val_ (ami_return_val)
{}

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

Dynamic::ExceptionList *
TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_get_load_monitor::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_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_get_load_monitor::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_CosLoadBalancing_AMI_LoadManagerHandler_get_load_monitor::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_CosLoadBalancing_AMI_LoadManagerHandler_get_load_monitor::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);
}

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:74

class TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_get_load_monitor_excep : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_get_load_monitor_excep (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_CosLoadBalancing::AMI_LoadManagerHandler *tao_impl,
      ::CosLoadBalancing::AMI_LoadManagerExceptionHolder * excep_holder
      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_CosLoadBalancing_AMI_LoadManagerHandler_get_load_monitor_excep (
      const TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_get_load_monitor_excep &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_get_load_monitor_excep &
    );
  
private:
  POA_CosLoadBalancing::AMI_LoadManagerHandler *_tao_impl;
  
  ::CosLoadBalancing::AMI_LoadManagerExceptionHolder * excep_holder_;
};

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:438

TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_get_load_monitor_excep::TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_get_load_monitor_excep (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_CosLoadBalancing::AMI_LoadManagerHandler *tao_impl,
    ::CosLoadBalancing::AMI_LoadManagerExceptionHolder * excep_holder
    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl),
    excep_holder_ (excep_holder)
{}

Dynamic::ParameterList *
TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_get_load_monitor_excep::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_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_get_load_monitor_excep::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_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_get_load_monitor_excep::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_CosLoadBalancing_AMI_LoadManagerHandler_get_load_monitor_excep::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_CosLoadBalancing_AMI_LoadManagerHandler_get_load_monitor_excep::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);
}

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:74

class TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_remove_load_monitor : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_remove_load_monitor (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_CosLoadBalancing::AMI_LoadManagerHandler *tao_impl
      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_CosLoadBalancing_AMI_LoadManagerHandler_remove_load_monitor (
      const TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_remove_load_monitor &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_remove_load_monitor &
    );
  
private:
  POA_CosLoadBalancing::AMI_LoadManagerHandler *_tao_impl;
  
};

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:438

TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_remove_load_monitor::TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_remove_load_monitor (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_CosLoadBalancing::AMI_LoadManagerHandler *tao_impl
    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl)
{}

Dynamic::ParameterList *
TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_remove_load_monitor::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_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_remove_load_monitor::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_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_remove_load_monitor::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_CosLoadBalancing_AMI_LoadManagerHandler_remove_load_monitor::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_CosLoadBalancing_AMI_LoadManagerHandler_remove_load_monitor::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);
}

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:74

class TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_remove_load_monitor_excep : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_remove_load_monitor_excep (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_CosLoadBalancing::AMI_LoadManagerHandler *tao_impl,
      ::CosLoadBalancing::AMI_LoadManagerExceptionHolder * excep_holder
      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_CosLoadBalancing_AMI_LoadManagerHandler_remove_load_monitor_excep (
      const TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_remove_load_monitor_excep &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_remove_load_monitor_excep &
    );
  
private:
  POA_CosLoadBalancing::AMI_LoadManagerHandler *_tao_impl;
  
  ::CosLoadBalancing::AMI_LoadManagerExceptionHolder * excep_holder_;
};

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:438

TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_remove_load_monitor_excep::TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_remove_load_monitor_excep (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_CosLoadBalancing::AMI_LoadManagerHandler *tao_impl,
    ::CosLoadBalancing::AMI_LoadManagerExceptionHolder * excep_holder
    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl),
    excep_holder_ (excep_holder)
{}

Dynamic::ParameterList *
TAO_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_remove_load_monitor_excep::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_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_remove_load_monitor_excep::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_ServerRequestInfo_CosLoadBalancing_AMI_LoadManagerHandler_remove_load_monitor_excep::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_CosLoadBalancing_AMI_LoadManagerHandler_remove_load_monitor_excep::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_CosLoadBalancing_AMI_LoadManagerHandler_remove_load_monitor_excep::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);
}

#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_CosLoadBalancing::_TAO_AMI_LoadManagerHandler_Strategized_Proxy_Broker *
POA_CosLoadBalancing::_TAO_AMI_LoadManagerHandler_Strategized_Proxy_Broker::the_TAO_AMI_LoadManagerHandler_Strategized_Proxy_Broker (void)
{
  static POA_CosLoadBalancing::_TAO_AMI_LoadManagerHandler_Strategized_Proxy_Broker
  strategized_proxy_broker;
  
  return &strategized_proxy_broker;
}

POA_CosLoadBalancing::_TAO_AMI_LoadManagerHandler_Strategized_Proxy_Broker::_TAO_AMI_LoadManagerHandler_Strategized_Proxy_Broker (void)
{
}

POA_CosLoadBalancing::_TAO_AMI_LoadManagerHandler_Strategized_Proxy_Broker::~_TAO_AMI_LoadManagerHandler_Strategized_Proxy_Broker (void)
{
}

TAO::Collocation_Strategy
POA_CosLoadBalancing::_TAO_AMI_LoadManagerHandler_Strategized_Proxy_Broker::get_strategy (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  TAO::Collocation_Strategy strategy =
    TAO_ORB_Core::collocation_strategy (obj ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (TAO::TAO_CS_REMOTE_STRATEGY);
  
  return strategy;
}

void
POA_CosLoadBalancing::_TAO_AMI_LoadManagerHandler_Strategized_Proxy_Broker::dispatch (
    CORBA::Object_ptr obj,
    CORBA::Object_out forward_obj,
    TAO::Argument ** args,
    int num_args,
    const char * op,
    size_t op_len,
    TAO::Collocation_Strategy strategy
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::Exception))
{
  TAO_Object_Adapter::Servant_Upcall servant_upcall (
      obj->_stubobj ()->servant_orb_var ()->orb_core ()
    );
  
  TAO_Collocated_Skeleton collocated_skel;
  TAO_Abstract_ServantBase *servant = 0;
  
  if (strategy == TAO::TAO_CS_THRU_POA_STRATEGY)
    {
      servant_upcall.prepare_for_upcall (
          obj->_stubobj ()->object_key (),
          op,
          forward_obj
          ACE_ENV_ARG_PARAMETER
        );
      ACE_CHECK;
      
      servant_upcall.pre_invoke_collocated_request (
          ACE_ENV_SINGLE_ARG_PARAMETER
        );
      ACE_CHECK;
      
      servant = servant_upcall.servant ();
    }
  else
    {
      servant = obj->_servant ();
    }
  
  int status = servant->_find (op,
                               collocated_skel,
                               strategy,
                               op_len);
  
  if (status == -1)
    {
      ACE_THROW (CORBA::BAD_OPERATION ());
    }
  
  ACE_TRY
    {
      collocated_skel (servant,
                       args,
                       num_args
                       ACE_ENV_ARG_PARAMETER);
      ACE_TRY_CHECK;
    }
#if (TAO_HAS_MINIMUM_CORBA == 0)
  ACE_CATCH (PortableServer::ForwardRequest, forward_request)
    {
      forward_obj =
        CORBA::Object::_duplicate (forward_request.forward_reference.in ());
      return;
    }
#else
  ACE_CATCHANY
    {
      ACE_UNUSED_ARG (forward_obj);
      ACE_RE_THROW;
    }
#endif /* TAO_HAS_MINIMUM_CORBA */
  ACE_ENDTRY;
  ACE_CHECK;
}

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

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

TAO::Collocation_Proxy_Broker *
CosLoadBalancing__TAO_AMI_LoadManagerHandler_Proxy_Broker_Factory_function (CORBA::Object_ptr)
{
  return
    ::POA_CosLoadBalancing::_TAO_AMI_LoadManagerHandler_Strategized_Proxy_Broker::the_TAO_AMI_LoadManagerHandler_Strategized_Proxy_Broker ();
}

int
CosLoadBalancing__TAO_AMI_LoadManagerHandler_Proxy_Broker_Factory_Initializer (size_t)
{
  CosLoadBalancing__TAO_AMI_LoadManagerHandler_Proxy_Broker_Factory_function_pointer = 
    CosLoadBalancing__TAO_AMI_LoadManagerHandler_Proxy_Broker_Factory_function;
  
  return 0;
}

static int
CosLoadBalancing__TAO_AMI_LoadManagerHandler_Proxy_Broker_Stub_Factory_Initializer_Scarecrow =
  CosLoadBalancing__TAO_AMI_LoadManagerHandler_Proxy_Broker_Factory_Initializer (
      reinterpret_cast<
          size_t> (
          CosLoadBalancing__TAO_AMI_LoadManagerHandler_Proxy_Broker_Factory_Initializer
        )
    );


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

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

POA_CosLoadBalancing::_TAO_AMI_LoadManagerHandler_ThruPOA_Proxy_Impl::_TAO_AMI_LoadManagerHandler_ThruPOA_Proxy_Impl (void)
{}

// ThruPOA Implementation of the IDL interface methods

// TAO_IDL - Generated from 
// be/be_visitor_operation/thru_poa_proxy_impl_ss.cpp:52

void
POA_CosLoadBalancing::_TAO_AMI_LoadManagerHandler_ThruPOA_Proxy_Impl::push_loads (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument **,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  reinterpret_cast<
      POA_CosLoadBalancing::AMI_LoadManagerHandler_ptr> (
      servant->_downcast (
          "IDL:AMI_LoadManagerHandler:1.0"
        )
    )->push_loads (
        ACE_ENV_SINGLE_ARG_PARAMETER
      );
  ACE_CHECK;
}

// TAO_IDL - Generated from 
// be/be_visitor_operation/thru_poa_proxy_impl_ss.cpp:52

void
POA_CosLoadBalancing::_TAO_AMI_LoadManagerHandler_ThruPOA_Proxy_Impl::push_loads_excep (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument ** args,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  reinterpret_cast<
      POA_CosLoadBalancing::AMI_LoadManagerHandler_ptr> (
      servant->_downcast (
          "IDL:AMI_LoadManagerHandler:1.0"
        )
    )->push_loads_excep (
        ((TAO::Arg_Traits< ::CosLoadBalancing::AMI_LoadManagerExceptionHolder>::in_arg_val *) args[1])->arg ()
        ACE_ENV_ARG_PARAMETER
      );
  ACE_CHECK;
}

// TAO_IDL - Generated from 
// be/be_visitor_operation/thru_poa_proxy_impl_ss.cpp:52

void
POA_CosLoadBalancing::_TAO_AMI_LoadManagerHandler_ThruPOA_Proxy_Impl::get_loads (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument ** args,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  reinterpret_cast<
      POA_CosLoadBalancing::AMI_LoadManagerHandler_ptr> (
      servant->_downcast (
          "IDL:AMI_LoadManagerHandler:1.0"
        )
    )->get_loads (
        ((TAO::Arg_Traits< ::CosLoadBalancing::LoadList>::in_arg_val *) args[1])->arg ()
        ACE_ENV_ARG_PARAMETER
      );
  ACE_CHECK;
}

// TAO_IDL - Generated from 
// be/be_visitor_operation/thru_poa_proxy_impl_ss.cpp:52

void
POA_CosLoadBalancing::_TAO_AMI_LoadManagerHandler_ThruPOA_Proxy_Impl::get_loads_excep (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument ** args,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  reinterpret_cast<
      POA_CosLoadBalancing::AMI_LoadManagerHandler_ptr> (
      servant->_downcast (
          "IDL:AMI_LoadManagerHandler:1.0"
        )
    )->get_loads_excep (
        ((TAO::Arg_Traits< ::CosLoadBalancing::AMI_LoadManagerExceptionHolder>::in_arg_val *) args[1])->arg ()
        ACE_ENV_ARG_PARAMETER
      );
  ACE_CHECK;
}

// TAO_IDL - Generated from 
// be/be_visitor_operation/thru_poa_proxy_impl_ss.cpp:52

void
POA_CosLoadBalancing::_TAO_AMI_LoadManagerHandler_ThruPOA_Proxy_Impl::enable_alert (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument **,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  reinterpret_cast<
      POA_CosLoadBalancing::AMI_LoadManagerHandler_ptr> (
      servant->_downcast (
          "IDL:AMI_LoadManagerHandler:1.0"
        )
    )->enable_alert (
        ACE_ENV_SINGLE_ARG_PARAMETER
      );
  ACE_CHECK;
}

// TAO_IDL - Generated from 
// be/be_visitor_operation/thru_poa_proxy_impl_ss.cpp:52

void
POA_CosLoadBalancing::_TAO_AMI_LoadManagerHandler_ThruPOA_Proxy_Impl::enable_alert_excep (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument ** args,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  reinterpret_cast<
      POA_CosLoadBalancing::AMI_LoadManagerHandler_ptr> (
      servant->_downcast (
          "IDL:AMI_LoadManagerHandler:1.0"
        )
    )->enable_alert_excep (
        ((TAO::Arg_Traits< ::CosLoadBalancing::AMI_LoadManagerExceptionHolder>::in_arg_val *) args[1])->arg ()
        ACE_ENV_ARG_PARAMETER
      );
  ACE_CHECK;
}

// TAO_IDL - Generated from 
// be/be_visitor_operation/thru_poa_proxy_impl_ss.cpp:52

void
POA_CosLoadBalancing::_TAO_AMI_LoadManagerHandler_ThruPOA_Proxy_Impl::disable_alert (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument **,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  reinterpret_cast<
      POA_CosLoadBalancing::AMI_LoadManagerHandler_ptr> (
      servant->_downcast (
          "IDL:AMI_LoadManagerHandler:1.0"
        )
    )->disable_alert (
        ACE_ENV_SINGLE_ARG_PARAMETER
      );
  ACE_CHECK;
}

// TAO_IDL - Generated from 
// be/be_visitor_operation/thru_poa_proxy_impl_ss.cpp:52

void
POA_CosLoadBalancing::_TAO_AMI_LoadManagerHandler_ThruPOA_Proxy_Impl::disable_alert_excep (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument ** args,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  reinterpret_cast<
      POA_CosLoadBalancing::AMI_LoadManagerHandler_ptr> (
      servant->_downcast (
          "IDL:AMI_LoadManagerHandler:1.0"
        )
    )->disable_alert_excep (
        ((TAO::Arg_Traits< ::CosLoadBalancing::AMI_LoadManagerExceptionHolder>::in_arg_val *) args[1])->arg ()
        ACE_ENV_ARG_PARAMETER
      );
  ACE_CHECK;
}

// TAO_IDL - Generated from 
// be/be_visitor_operation/thru_poa_proxy_impl_ss.cpp:52

void
POA_CosLoadBalancing::_TAO_AMI_LoadManagerHandler_ThruPOA_Proxy_Impl::register_load_alert (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument **,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  reinterpret_cast<
      POA_CosLoadBalancing::AMI_LoadManagerHandler_ptr> (
      servant->_downcast (
          "IDL:AMI_LoadManagerHandler:1.0"
        )
    )->register_load_alert (
        ACE_ENV_SINGLE_ARG_PARAMETER
      );
  ACE_CHECK;
}

// TAO_IDL - Generated from 
// be/be_visitor_operation/thru_poa_proxy_impl_ss.cpp:52

void
POA_CosLoadBalancing::_TAO_AMI_LoadManagerHandler_ThruPOA_Proxy_Impl::register_load_alert_excep (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument ** args,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  reinterpret_cast<
      POA_CosLoadBalancing::AMI_LoadManagerHandler_ptr> (
      servant->_downcast (
          "IDL:AMI_LoadManagerHandler:1.0"
        )
    )->register_load_alert_excep (
        ((TAO::Arg_Traits< ::CosLoadBalancing::AMI_LoadManagerExceptionHolder>::in_arg_val *) args[1])->arg ()
        ACE_ENV_ARG_PARAMETER
      );
  ACE_CHECK;
}

// TAO_IDL - Generated from 
// be/be_visitor_operation/thru_poa_proxy_impl_ss.cpp:52

void
POA_CosLoadBalancing::_TAO_AMI_LoadManagerHandler_ThruPOA_Proxy_Impl::get_load_alert (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument ** args,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  reinterpret_cast<
      POA_CosLoadBalancing::AMI_LoadManagerHandler_ptr> (
      servant->_downcast (
          "IDL:AMI_LoadManagerHandler:1.0"
        )
    )->get_load_alert (
        ((TAO::Arg_Traits< ::CosLoadBalancing::LoadAlert>::in_arg_val *) args[1])->arg ()
        ACE_ENV_ARG_PARAMETER
      );
  ACE_CHECK;
}

// TAO_IDL - Generated from 
// be/be_visitor_operation/thru_poa_proxy_impl_ss.cpp:52

void
POA_CosLoadBalancing::_TAO_AMI_LoadManagerHandler_ThruPOA_Proxy_Impl::get_load_alert_excep (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument ** args,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  reinterpret_cast<
      POA_CosLoadBalancing::AMI_LoadManagerHandler_ptr> (
      servant->_downcast (
          "IDL:AMI_LoadManagerHandler:1.0"
        )
    )->get_load_alert_excep (
        ((TAO::Arg_Traits< ::CosLoadBalancing::AMI_LoadManagerExceptionHolder>::in_arg_val *) args[1])->arg ()
        ACE_ENV_ARG_PARAMETER
      );
  ACE_CHECK;
}

// TAO_IDL - Generated from 
// be/be_visitor_operation/thru_poa_proxy_impl_ss.cpp:52

void
POA_CosLoadBalancing::_TAO_AMI_LoadManagerHandler_ThruPOA_Proxy_Impl::remove_load_alert (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument **,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  reinterpret_cast<
      POA_CosLoadBalancing::AMI_LoadManagerHandler_ptr> (
      servant->_downcast (
          "IDL:AMI_LoadManagerHandler:1.0"
        )
    )->remove_load_alert (
        ACE_ENV_SINGLE_ARG_PARAMETER
      );
  ACE_CHECK;
}

// TAO_IDL - Generated from 
// be/be_visitor_operation/thru_poa_proxy_impl_ss.cpp:52

void
POA_CosLoadBalancing::_TAO_AMI_LoadManagerHandler_ThruPOA_Proxy_Impl::remove_load_alert_excep (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument ** args,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  reinterpret_cast<
      POA_CosLoadBalancing::AMI_LoadManagerHandler_ptr> (
      servant->_downcast (
          "IDL:AMI_LoadManagerHandler:1.0"
        )
    )->remove_load_alert_excep (
        ((TAO::Arg_Traits< ::CosLoadBalancing::AMI_LoadManagerExceptionHolder>::in_arg_val *) args[1])->arg ()
        ACE_ENV_ARG_PARAMETER
      );
  ACE_CHECK;
}

// TAO_IDL - Generated from 
// be/be_visitor_operation/thru_poa_proxy_impl_ss.cpp:52

void
POA_CosLoadBalancing::_TAO_AMI_LoadManagerHandler_ThruPOA_Proxy_Impl::register_load_monitor (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument **,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  reinterpret_cast<
      POA_CosLoadBalancing::AMI_LoadManagerHandler_ptr> (
      servant->_downcast (
          "IDL:AMI_LoadManagerHandler:1.0"
        )
    )->register_load_monitor (
        ACE_ENV_SINGLE_ARG_PARAMETER
      );
  ACE_CHECK;
}

// TAO_IDL - Generated from 
// be/be_visitor_operation/thru_poa_proxy_impl_ss.cpp:52

void
POA_CosLoadBalancing::_TAO_AMI_LoadManagerHandler_ThruPOA_Proxy_Impl::register_load_monitor_excep (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument ** args,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  reinterpret_cast<
      POA_CosLoadBalancing::AMI_LoadManagerHandler_ptr> (
      servant->_downcast (
          "IDL:AMI_LoadManagerHandler:1.0"
        )
    )->register_load_monitor_excep (
        ((TAO::Arg_Traits< ::CosLoadBalancing::AMI_LoadManagerExceptionHolder>::in_arg_val *) args[1])->arg ()
        ACE_ENV_ARG_PARAMETER
      );
  ACE_CHECK;
}

// TAO_IDL - Generated from 
// be/be_visitor_operation/thru_poa_proxy_impl_ss.cpp:52

void
POA_CosLoadBalancing::_TAO_AMI_LoadManagerHandler_ThruPOA_Proxy_Impl::get_load_monitor (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument ** args,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  reinterpret_cast<
      POA_CosLoadBalancing::AMI_LoadManagerHandler_ptr> (
      servant->_downcast (
          "IDL:AMI_LoadManagerHandler:1.0"
        )
    )->get_load_monitor (
        ((TAO::Arg_Traits< ::CosLoadBalancing::LoadMonitor>::in_arg_val *) args[1])->arg ()
        ACE_ENV_ARG_PARAMETER
      );
  ACE_CHECK;
}

// TAO_IDL - Generated from 
// be/be_visitor_operation/thru_poa_proxy_impl_ss.cpp:52

void
POA_CosLoadBalancing::_TAO_AMI_LoadManagerHandler_ThruPOA_Proxy_Impl::get_load_monitor_excep (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument ** args,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  reinterpret_cast<
      POA_CosLoadBalancing::AMI_LoadManagerHandler_ptr> (
      servant->_downcast (
          "IDL:AMI_LoadManagerHandler:1.0"
        )
    )->get_load_monitor_excep (
        ((TAO::Arg_Traits< ::CosLoadBalancing::AMI_LoadManagerExceptionHolder>::in_arg_val *) args[1])->arg ()
        ACE_ENV_ARG_PARAMETER
      );
  ACE_CHECK;
}

// TAO_IDL - Generated from 
// be/be_visitor_operation/thru_poa_proxy_impl_ss.cpp:52

void
POA_CosLoadBalancing::_TAO_AMI_LoadManagerHandler_ThruPOA_Proxy_Impl::remove_load_monitor (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument **,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  reinterpret_cast<
      POA_CosLoadBalancing::AMI_LoadManagerHandler_ptr> (
      servant->_downcast (
          "IDL:AMI_LoadManagerHandler:1.0"
        )
    )->remove_load_monitor (
        ACE_ENV_SINGLE_ARG_PARAMETER
      );
  ACE_CHECK;
}

// TAO_IDL - Generated from 
// be/be_visitor_operation/thru_poa_proxy_impl_ss.cpp:52

void
POA_CosLoadBalancing::_TAO_AMI_LoadManagerHandler_ThruPOA_Proxy_Impl::remove_load_monitor_excep (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument ** args,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  reinterpret_cast<
      POA_CosLoadBalancing::AMI_LoadManagerHandler_ptr> (
      servant->_downcast (
          "IDL:AMI_LoadManagerHandler:1.0"
        )
    )->remove_load_monitor_excep (
        ((TAO::Arg_Traits< ::CosLoadBalancing::AMI_LoadManagerExceptionHolder>::in_arg_val *) args[1])->arg ()
        ACE_ENV_ARG_PARAMETER
      );
  ACE_CHECK;
}

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

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

POA_CosLoadBalancing::AMI_LoadManagerHandler::AMI_LoadManagerHandler (void)
{
  this->optable_ = &tao_CosLoadBalancing_AMI_LoadManagerHandler_optable;
}

POA_CosLoadBalancing::AMI_LoadManagerHandler::AMI_LoadManagerHandler (const AMI_LoadManagerHandler& rhs)
  : TAO_Abstract_ServantBase (rhs),
    TAO_ServantBase (rhs),
    ACE_NESTED_CLASS (POA_Messaging, ReplyHandler) (rhs),
    ACE_NESTED_CLASS (POA_PortableGroup, AMI_PropertyManagerHandler) (rhs),
    ACE_NESTED_CLASS (POA_PortableGroup, AMI_ObjectGroupManagerHandler) (rhs),
    ACE_NESTED_CLASS (POA_PortableGroup, AMI_GenericFactoryHandler) (rhs)
{
}

POA_CosLoadBalancing::AMI_LoadManagerHandler::~AMI_LoadManagerHandler (void)
{
}

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

void POA_CosLoadBalancing::AMI_LoadManagerHandler::push_loads_skel (
    TAO_ServerRequest &_tao_server_request,
    void *_tao_servant,
    void *_tao_servant_upcall
    ACE_ENV_ARG_DECL
  )
{
  POA_CosLoadBalancing::AMI_LoadManagerHandler *_tao_impl =
    static_cast<
        POA_CosLoadBalancing::AMI_LoadManagerHandler *> (
        _tao_servant
      );
  _tao_server_request.argument_flag (0);
  
  
#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_Object_Adapter::Servant_Upcall *_tao_upcall =
    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_CosLoadBalancing_AMI_LoadManagerHandler_push_loads _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl
      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* 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->push_loads (
                  ACE_ENV_SINGLE_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:98

void POA_CosLoadBalancing::AMI_LoadManagerHandler::push_loads_excep_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_CosLoadBalancing::AMI_LoadManagerHandler *_tao_impl =
    static_cast<
        POA_CosLoadBalancing::AMI_LoadManagerHandler *> (
        _tao_servant
      );
  _tao_server_request.argument_flag (0);
  
  ::CosLoadBalancing::AMI_LoadManagerExceptionHolder_var excep_holder;
  
  if (!(
      (_tao_in >> excep_holder.out ())
      ))
    {
      TAO_InputCDR::throw_skel_exception (errno ACE_ENV_ARG_PARAMETER);
      ACE_CHECK;
    }
  
#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_Object_Adapter::Servant_Upcall *_tao_upcall =
    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_CosLoadBalancing_AMI_LoadManagerHandler_push_loads_excep _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl,
      
      excep_holder.in ()
      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* 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->push_loads_excep (
                  excep_holder.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:98

void POA_CosLoadBalancing::AMI_LoadManagerHandler::get_loads_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_CosLoadBalancing::AMI_LoadManagerHandler *_tao_impl =
    static_cast<
        POA_CosLoadBalancing::AMI_LoadManagerHandler *> (
        _tao_servant
      );
  _tao_server_request.argument_flag (0);
  
  ::CosLoadBalancing::LoadList ami_return_val;
  
  if (!(
      (_tao_in >> ami_return_val)
      ))
    {
      TAO_InputCDR::throw_skel_exception (errno ACE_ENV_ARG_PARAMETER);
      ACE_CHECK;
    }
  
#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_Object_Adapter::Servant_Upcall *_tao_upcall =
    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_CosLoadBalancing_AMI_LoadManagerHandler_get_loads _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl,
      
      ami_return_val
      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* 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->get_loads (
                  ami_return_val
                  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:98

void POA_CosLoadBalancing::AMI_LoadManagerHandler::get_loads_excep_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_CosLoadBalancing::AMI_LoadManagerHandler *_tao_impl =
    static_cast<
        POA_CosLoadBalancing::AMI_LoadManagerHandler *> (
        _tao_servant
      );
  _tao_server_request.argument_flag (0);
  
  ::CosLoadBalancing::AMI_LoadManagerExceptionHolder_var excep_holder;
  
  if (!(
      (_tao_in >> excep_holder.out ())
      ))
    {
      TAO_InputCDR::throw_skel_exception (errno ACE_ENV_ARG_PARAMETER);
      ACE_CHECK;
    }
  
#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_Object_Adapter::Servant_Upcall *_tao_upcall =
    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_CosLoadBalancing_AMI_LoadManagerHandler_get_loads_excep _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl,
      
      excep_holder.in ()
      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* 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->get_loads_excep (
                  excep_holder.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:98

void POA_CosLoadBalancing::AMI_LoadManagerHandler::enable_alert_skel (
    TAO_ServerRequest &_tao_server_request,
    void *_tao_servant,
    void *_tao_servant_upcall
    ACE_ENV_ARG_DECL
  )
{
  POA_CosLoadBalancing::AMI_LoadManagerHandler *_tao_impl =
    static_cast<
        POA_CosLoadBalancing::AMI_LoadManagerHandler *> (
        _tao_servant
      );
  _tao_server_request.argument_flag (0);
  
  
#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_Object_Adapter::Servant_Upcall *_tao_upcall =
    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_CosLoadBalancing_AMI_LoadManagerHandler_enable_alert _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl
      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* 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->enable_alert (
                  ACE_ENV_SINGLE_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:98

void POA_CosLoadBalancing::AMI_LoadManagerHandler::enable_alert_excep_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_CosLoadBalancing::AMI_LoadManagerHandler *_tao_impl =
    static_cast<
        POA_CosLoadBalancing::AMI_LoadManagerHandler *> (
        _tao_servant
      );
  _tao_server_request.argument_flag (0);
  
  ::CosLoadBalancing::AMI_LoadManagerExceptionHolder_var excep_holder;
  
  if (!(
      (_tao_in >> excep_holder.out ())
      ))
    {
      TAO_InputCDR::throw_skel_exception (errno ACE_ENV_ARG_PARAMETER);
      ACE_CHECK;
    }
  
#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_Object_Adapter::Servant_Upcall *_tao_upcall =
    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_CosLoadBalancing_AMI_LoadManagerHandler_enable_alert_excep _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl,
      
      excep_holder.in ()
      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* 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->enable_alert_excep (
                  excep_holder.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:98

void POA_CosLoadBalancing::AMI_LoadManagerHandler::disable_alert_skel (
    TAO_ServerRequest &_tao_server_request,
    void *_tao_servant,
    void *_tao_servant_upcall
    ACE_ENV_ARG_DECL
  )
{
  POA_CosLoadBalancing::AMI_LoadManagerHandler *_tao_impl =
    static_cast<
        POA_CosLoadBalancing::AMI_LoadManagerHandler *> (
        _tao_servant
      );
  _tao_server_request.argument_flag (0);
  
  
#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_Object_Adapter::Servant_Upcall *_tao_upcall =
    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_CosLoadBalancing_AMI_LoadManagerHandler_disable_alert _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl
      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* 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->disable_alert (
                  ACE_ENV_SINGLE_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:98

void POA_CosLoadBalancing::AMI_LoadManagerHandler::disable_alert_excep_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_CosLoadBalancing::AMI_LoadManagerHandler *_tao_impl =
    static_cast<
        POA_CosLoadBalancing::AMI_LoadManagerHandler *> (
        _tao_servant
      );
  _tao_server_request.argument_flag (0);
  
  ::CosLoadBalancing::AMI_LoadManagerExceptionHolder_var excep_holder;
  
  if (!(
      (_tao_in >> excep_holder.out ())
      ))
    {
      TAO_InputCDR::throw_skel_exception (errno ACE_ENV_ARG_PARAMETER);
      ACE_CHECK;
    }
  
#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_Object_Adapter::Servant_Upcall *_tao_upcall =
    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_CosLoadBalancing_AMI_LoadManagerHandler_disable_alert_excep _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl,
      
      excep_holder.in ()
      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* 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->disable_alert_excep (
                  excep_holder.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:98

void POA_CosLoadBalancing::AMI_LoadManagerHandler::register_load_alert_skel (
    TAO_ServerRequest &_tao_server_request,
    void *_tao_servant,
    void *_tao_servant_upcall
    ACE_ENV_ARG_DECL
  )
{
  POA_CosLoadBalancing::AMI_LoadManagerHandler *_tao_impl =
    static_cast<
        POA_CosLoadBalancing::AMI_LoadManagerHandler *> (
        _tao_servant
      );
  _tao_server_request.argument_flag (0);
  
  
#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_Object_Adapter::Servant_Upcall *_tao_upcall =
    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_CosLoadBalancing_AMI_LoadManagerHandler_register_load_alert _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl
      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* 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->register_load_alert (
                  ACE_ENV_SINGLE_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:98

void POA_CosLoadBalancing::AMI_LoadManagerHandler::register_load_alert_excep_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_CosLoadBalancing::AMI_LoadManagerHandler *_tao_impl =
    static_cast<
        POA_CosLoadBalancing::AMI_LoadManagerHandler *> (
        _tao_servant
      );
  _tao_server_request.argument_flag (0);
  
  ::CosLoadBalancing::AMI_LoadManagerExceptionHolder_var excep_holder;
  
  if (!(
      (_tao_in >> excep_holder.out ())
      ))
    {
      TAO_InputCDR::throw_skel_exception (errno ACE_ENV_ARG_PARAMETER);
      ACE_CHECK;
    }
  
#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_Object_Adapter::Servant_Upcall *_tao_upcall =
    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_CosLoadBalancing_AMI_LoadManagerHandler_register_load_alert_excep _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl,
      
      excep_holder.in ()
      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* 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->register_load_alert_excep (
                  excep_holder.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:98

void POA_CosLoadBalancing::AMI_LoadManagerHandler::get_load_alert_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_CosLoadBalancing::AMI_LoadManagerHandler *_tao_impl =
    static_cast<
        POA_CosLoadBalancing::AMI_LoadManagerHandler *> (
        _tao_servant
      );
  _tao_server_request.argument_flag (0);
  
  ::CosLoadBalancing::LoadAlert_var ami_return_val;
  
  if (!(
      (_tao_in >> ami_return_val.out ())
      ))
    {
      TAO_InputCDR::throw_skel_exception (errno ACE_ENV_ARG_PARAMETER);
      ACE_CHECK;
    }
  
#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_Object_Adapter::Servant_Upcall *_tao_upcall =
    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_CosLoadBalancing_AMI_LoadManagerHandler_get_load_alert _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl,
      
      ami_return_val.in ()
      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* 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->get_load_alert (
                  ami_return_val.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:98

void POA_CosLoadBalancing::AMI_LoadManagerHandler::get_load_alert_excep_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_CosLoadBalancing::AMI_LoadManagerHandler *_tao_impl =
    static_cast<
        POA_CosLoadBalancing::AMI_LoadManagerHandler *> (
        _tao_servant
      );
  _tao_server_request.argument_flag (0);
  
  ::CosLoadBalancing::AMI_LoadManagerExceptionHolder_var excep_holder;
  
  if (!(
      (_tao_in >> excep_holder.out ())
      ))
    {
      TAO_InputCDR::throw_skel_exception (errno ACE_ENV_ARG_PARAMETER);
      ACE_CHECK;
    }
  
#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_Object_Adapter::Servant_Upcall *_tao_upcall =
    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_CosLoadBalancing_AMI_LoadManagerHandler_get_load_alert_excep _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl,
      
      excep_holder.in ()
      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* 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->get_load_alert_excep (
                  excep_holder.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:98

void POA_CosLoadBalancing::AMI_LoadManagerHandler::remove_load_alert_skel (
    TAO_ServerRequest &_tao_server_request,
    void *_tao_servant,
    void *_tao_servant_upcall
    ACE_ENV_ARG_DECL
  )
{
  POA_CosLoadBalancing::AMI_LoadManagerHandler *_tao_impl =
    static_cast<
        POA_CosLoadBalancing::AMI_LoadManagerHandler *> (
        _tao_servant
      );
  _tao_server_request.argument_flag (0);
  
  
#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_Object_Adapter::Servant_Upcall *_tao_upcall =
    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_CosLoadBalancing_AMI_LoadManagerHandler_remove_load_alert _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl
      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* 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_load_alert (
                  ACE_ENV_SINGLE_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:98

void POA_CosLoadBalancing::AMI_LoadManagerHandler::remove_load_alert_excep_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_CosLoadBalancing::AMI_LoadManagerHandler *_tao_impl =
    static_cast<
        POA_CosLoadBalancing::AMI_LoadManagerHandler *> (
        _tao_servant
      );
  _tao_server_request.argument_flag (0);
  
  ::CosLoadBalancing::AMI_LoadManagerExceptionHolder_var excep_holder;
  
  if (!(
      (_tao_in >> excep_holder.out ())
      ))
    {
      TAO_InputCDR::throw_skel_exception (errno ACE_ENV_ARG_PARAMETER);
      ACE_CHECK;
    }
  
#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_Object_Adapter::Servant_Upcall *_tao_upcall =
    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_CosLoadBalancing_AMI_LoadManagerHandler_remove_load_alert_excep _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl,
      
      excep_holder.in ()
      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* 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_load_alert_excep (
                  excep_holder.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:98

void POA_CosLoadBalancing::AMI_LoadManagerHandler::register_load_monitor_skel (
    TAO_ServerRequest &_tao_server_request,
    void *_tao_servant,
    void *_tao_servant_upcall
    ACE_ENV_ARG_DECL
  )
{
  POA_CosLoadBalancing::AMI_LoadManagerHandler *_tao_impl =
    static_cast<
        POA_CosLoadBalancing::AMI_LoadManagerHandler *> (
        _tao_servant
      );
  _tao_server_request.argument_flag (0);
  
  
#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_Object_Adapter::Servant_Upcall *_tao_upcall =
    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_CosLoadBalancing_AMI_LoadManagerHandler_register_load_monitor _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl
      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* 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->register_load_monitor (
                  ACE_ENV_SINGLE_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:98

void POA_CosLoadBalancing::AMI_LoadManagerHandler::register_load_monitor_excep_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_CosLoadBalancing::AMI_LoadManagerHandler *_tao_impl =
    static_cast<
        POA_CosLoadBalancing::AMI_LoadManagerHandler *> (
        _tao_servant
      );
  _tao_server_request.argument_flag (0);
  
  ::CosLoadBalancing::AMI_LoadManagerExceptionHolder_var excep_holder;
  
  if (!(
      (_tao_in >> excep_holder.out ())
      ))
    {
      TAO_InputCDR::throw_skel_exception (errno ACE_ENV_ARG_PARAMETER);
      ACE_CHECK;
    }
  
#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_Object_Adapter::Servant_Upcall *_tao_upcall =
    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_CosLoadBalancing_AMI_LoadManagerHandler_register_load_monitor_excep _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl,
      
      excep_holder.in ()
      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* 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->register_load_monitor_excep (
                  excep_holder.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:98

void POA_CosLoadBalancing::AMI_LoadManagerHandler::get_load_monitor_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_CosLoadBalancing::AMI_LoadManagerHandler *_tao_impl =
    static_cast<
        POA_CosLoadBalancing::AMI_LoadManagerHandler *> (
        _tao_servant
      );
  _tao_server_request.argument_flag (0);
  
  ::CosLoadBalancing::LoadMonitor_var ami_return_val;
  
  if (!(
      (_tao_in >> ami_return_val.out ())
      ))
    {
      TAO_InputCDR::throw_skel_exception (errno ACE_ENV_ARG_PARAMETER);
      ACE_CHECK;
    }
  
#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_Object_Adapter::Servant_Upcall *_tao_upcall =
    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_CosLoadBalancing_AMI_LoadManagerHandler_get_load_monitor _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl,
      
      ami_return_val.in ()
      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* 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->get_load_monitor (
                  ami_return_val.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:98

void POA_CosLoadBalancing::AMI_LoadManagerHandler::get_load_monitor_excep_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_CosLoadBalancing::AMI_LoadManagerHandler *_tao_impl =
    static_cast<
        POA_CosLoadBalancing::AMI_LoadManagerHandler *> (
        _tao_servant
      );
  _tao_server_request.argument_flag (0);
  
  ::CosLoadBalancing::AMI_LoadManagerExceptionHolder_var excep_holder;
  
  if (!(
      (_tao_in >> excep_holder.out ())
      ))
    {
      TAO_InputCDR::throw_skel_exception (errno ACE_ENV_ARG_PARAMETER);
      ACE_CHECK;
    }
  
#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_Object_Adapter::Servant_Upcall *_tao_upcall =
    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_CosLoadBalancing_AMI_LoadManagerHandler_get_load_monitor_excep _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl,
      
      excep_holder.in ()
      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* 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->get_load_monitor_excep (
                  excep_holder.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:98

void POA_CosLoadBalancing::AMI_LoadManagerHandler::remove_load_monitor_skel (
    TAO_ServerRequest &_tao_server_request,
    void *_tao_servant,
    void *_tao_servant_upcall
    ACE_ENV_ARG_DECL
  )
{
  POA_CosLoadBalancing::AMI_LoadManagerHandler *_tao_impl =
    static_cast<
        POA_CosLoadBalancing::AMI_LoadManagerHandler *> (
        _tao_servant
      );
  _tao_server_request.argument_flag (0);
  
  
#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_Object_Adapter::Servant_Upcall *_tao_upcall =
    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_CosLoadBalancing_AMI_LoadManagerHandler_remove_load_monitor _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl
      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* 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_load_monitor (
                  ACE_ENV_SINGLE_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:98

void POA_CosLoadBalancing::AMI_LoadManagerHandler::remove_load_monitor_excep_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_CosLoadBalancing::AMI_LoadManagerHandler *_tao_impl =
    static_cast<
        POA_CosLoadBalancing::AMI_LoadManagerHandler *> (
        _tao_servant
      );
  _tao_server_request.argument_flag (0);
  
  ::CosLoadBalancing::AMI_LoadManagerExceptionHolder_var excep_holder;
  
  if (!(
      (_tao_in >> excep_holder.out ())
      ))
    {
      TAO_InputCDR::throw_skel_exception (errno ACE_ENV_ARG_PARAMETER);
      ACE_CHECK;
    }
  
#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_Object_Adapter::Servant_Upcall *_tao_upcall =
    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_CosLoadBalancing_AMI_LoadManagerHandler_remove_load_monitor_excep _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl,
      
      excep_holder.in ()
      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* 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_load_monitor_excep (
                  excep_holder.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_interface/interface_ss.cpp:162

void POA_CosLoadBalancing::AMI_LoadManagerHandler::_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_CosLoadBalancing::AMI_LoadManagerHandler *_tao_impl =
    (POA_CosLoadBalancing::AMI_LoadManagerHandler *) _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_CosLoadBalancing::AMI_LoadManagerHandler::_non_existent_skel (
    TAO_ServerRequest &_tao_server_request, 
    void * _tao_servant,
    void * /* Servant_Upcall */
    ACE_ENV_ARG_DECL
  )
{
  POA_CosLoadBalancing::AMI_LoadManagerHandler *_tao_impl =
    (POA_CosLoadBalancing::AMI_LoadManagerHandler *) _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_CosLoadBalancing::AMI_LoadManagerHandler::_interface_skel (
    TAO_ServerRequest &_tao_server_request, 
    void * _tao_servant,
    void * /* Servant_Upcall */
    ACE_ENV_ARG_DECL
  )
{
  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 ());
    }
  
  POA_CosLoadBalancing::AMI_LoadManagerHandler *_tao_impl =
    (POA_CosLoadBalancing::AMI_LoadManagerHandler *) _tao_servant;
  
  CORBA::InterfaceDef_ptr _tao_retval = 
    _tao_impl->_get_interface (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK;
  
  _tao_server_request.init_reply ();
  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
  
  CORBA::Boolean _tao_result =
    _tao_adapter->interfacedef_cdr_insert (
        _tao_out,
        _tao_retval
      );
  
  _tao_adapter->dispose (_tao_retval);
  
  if (_tao_result == 0)
    {
      ACE_THROW (CORBA::MARSHAL ());
    }
}

void POA_CosLoadBalancing::AMI_LoadManagerHandler::_component_skel (
    TAO_ServerRequest &_tao_server_request, 
    void * _tao_object_reference,
    void * /* Servant_Upcall */
    ACE_ENV_ARG_DECL
  )
{
  POA_CosLoadBalancing::AMI_LoadManagerHandler *_tao_impl =
    (POA_CosLoadBalancing::AMI_LoadManagerHandler *) _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.in ()))
    {
      ACE_THROW (CORBA::MARSHAL ());
    }
}

CORBA::Boolean POA_CosLoadBalancing::AMI_LoadManagerHandler::_is_a (
    const char* value
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  if (
      !ACE_OS::strcmp (
          (char *)value,
          "IDL:ReplyHandler:1.0"
        ) ||
      !ACE_OS::strcmp (
          (char *)value,
          "IDL:AMI_PropertyManagerHandler:1.0"
        ) ||
      !ACE_OS::strcmp (
          (char *)value,
          "IDL:AMI_ObjectGroupManagerHandler:1.0"
        ) ||
      !ACE_OS::strcmp (
          (char *)value,
          "IDL:AMI_GenericFactoryHandler:1.0"
        ) ||
      !ACE_OS::strcmp (
          (char *)value,
          "IDL:AMI_LoadManagerHandler:1.0"
        ) ||
      !ACE_OS::strcmp (
          (char *)value,
          "IDL:omg.org/CORBA/Object:1.0"
        )
     )
    {
      return 1;
    }
  else
    {
      return 0;
    }
}

void* POA_CosLoadBalancing::AMI_LoadManagerHandler::_downcast (
    const char* logical_type_id
  )
{
  if (ACE_OS::strcmp (logical_type_id,
                      "IDL:ReplyHandler:1.0") == 0)
    {
      return static_cast<POA_Messaging::ReplyHandler_ptr> (this);
    }
  
  if (ACE_OS::strcmp (logical_type_id,
                      "IDL:AMI_PropertyManagerHandler:1.0") == 0)
    {
      return static_cast<POA_PortableGroup::AMI_PropertyManagerHandler_ptr> (this);
    }
  
  if (ACE_OS::strcmp (logical_type_id,
                      "IDL:AMI_ObjectGroupManagerHandler:1.0") == 0)
    {
      return static_cast<POA_PortableGroup::AMI_ObjectGroupManagerHandler_ptr> (this);
    }
  
  if (ACE_OS::strcmp (logical_type_id,
                      "IDL:AMI_GenericFactoryHandler:1.0") == 0)
    {
      return static_cast<POA_PortableGroup::AMI_GenericFactoryHandler_ptr> (this);
    }
  
  if (ACE_OS::strcmp (logical_type_id,
                      "IDL:AMI_LoadManagerHandler:1.0") == 0)
    {
      return static_cast<POA_CosLoadBalancing::AMI_LoadManagerHandler_ptr> (this);
    }
  
  if (ACE_OS::strcmp (logical_type_id,
                      "IDL:omg.org/CORBA/Object:1.0") == 0)
    {
      return static_cast<PortableServer::Servant> (this);
    }
  
  return 0;
}

const char* POA_CosLoadBalancing::AMI_LoadManagerHandler::_interface_repository_id (void) const
{
  return "IDL:AMI_LoadManagerHandler:1.0";
}

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

void POA_CosLoadBalancing::AMI_LoadManagerHandler::_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:526

CosLoadBalancing::AMI_LoadManagerHandler *
POA_CosLoadBalancing::AMI_LoadManagerHandler::_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 ();
  
  typedef ::CosLoadBalancing::AMI_LoadManagerHandler STUB_SCOPED_NAME;
  return
    TAO::Narrow_Utils<STUB_SCOPED_NAME>::unchecked_narrow (
        obj.in (),
        CosLoadBalancing__TAO_AMI_LoadManagerHandler_Proxy_Broker_Factory_function_pointer
      );
}

#endif /* ifndef */
