// -*- 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:303


#include "CosLoadBalancingC.h"
#include "tao/CDR.h"
#include "tao/Exception_Data.h"
#include "tao/Invocation_Adapter.h"
#include "tao/Messaging/Asynch_Invocation_Adapter.h"
#include "tao/Valuetype/ValueFactory.h"
#include "tao/Object_T.h"
#include "tao/Typecode.h"
#include "tao/Any_Impl_T.h"
#include "tao/Any_Dual_Impl_T.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 "ace/OS_NS_string.h"

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

#if !defined (__ACE_INLINE__)
#include "CosLoadBalancingC.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_CS_)
#define _CORBA_ANY__ARG_TRAITS_CS_
  
  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_CS_)
#define _COSNAMING_NAME__ARG_TRAITS_CS_
  
  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_CS_)
#define _COSNAMING_BINDING__ARG_TRAITS_CS_
  
  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_CS_)
#define _COSNAMING_BINDINGLIST__ARG_TRAITS_CS_
  
  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_CS_)
#define _COSNAMING_BINDINGITERATOR__ARG_TRAITS_CS_
  
  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_CS_)
#define _COSNAMING_NAMINGCONTEXT__ARG_TRAITS_CS_
  
  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_CS_)
#define _PORTABLEGROUP_PROPERTIES__ARG_TRAITS_CS_
  
  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_CS_)
#define _PORTABLEGROUP_FACTORYINFO__ARG_TRAITS_CS_
  
  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_CS_)
#define _COSLOADBALANCING_LOADLIST__ARG_TRAITS_CS_
  
  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_CS_)
#define _COSLOADBALANCING_LOADMANAGER__ARG_TRAITS_CS_
  
  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_CS_)
#define _COSLOADBALANCING_AMI_STRATEGYEXCEPTIONHOLDER__ARG_TRAITS_CS_
  
  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_CS_)
#define _COSLOADBALANCING_LOADALERT__ARG_TRAITS_CS_
  
  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_CS_)
#define _COSLOADBALANCING_AMI_LOADALERTEXCEPTIONHOLDER__ARG_TRAITS_CS_
  
  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_CS_)
#define _COSLOADBALANCING_LOADMONITOR__ARG_TRAITS_CS_
  
  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_CS_)
#define _COSLOADBALANCING_AMI_LOADMONITOREXCEPTIONHOLDER__ARG_TRAITS_CS_
  
  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_CS_)
#define _COSLOADBALANCING_AMI_LOADMANAGEREXCEPTIONHOLDER__ARG_TRAITS_CS_
  
  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_visitor_typecode/typecode_defn.cpp:290

static const CORBA::Long _oc_CosLoadBalancing_Location[] =
{
    TAO_ENCAP_BYTE_ORDER, // byte order
  42,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x436f734c), 
  ACE_NTOHL (0x6f616442), 
  ACE_NTOHL (0x616c616e), 
  ACE_NTOHL (0x63696e67), 
  ACE_NTOHL (0x2f4c6f63), 
  ACE_NTOHL (0x6174696f), 
  ACE_NTOHL (0x6e3a312e), 
  ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CosLoadBalancing/Location:1.0
    9,
  ACE_NTOHL (0x4c6f6361), 
  ACE_NTOHL (0x74696f6e), 
  ACE_NTOHL (0x0),  // name = Location
    CORBA::tk_alias, // typecode kind for typedefs
  448, // encapsulation length
    TAO_ENCAP_BYTE_ORDER, // byte order
    39,
    ACE_NTOHL (0x49444c3a), 
    ACE_NTOHL (0x6f6d672e), 
    ACE_NTOHL (0x6f72672f), 
    ACE_NTOHL (0x506f7274), 
    ACE_NTOHL (0x61626c65), 
    ACE_NTOHL (0x47726f75), 
    ACE_NTOHL (0x702f4c6f), 
    ACE_NTOHL (0x63617469), 
    ACE_NTOHL (0x6f6e3a31), 
    ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/PortableGroup/Location:1.0
        9,
    ACE_NTOHL (0x4c6f6361), 
    ACE_NTOHL (0x74696f6e), 
    ACE_NTOHL (0x0),  // name = Location
        CORBA::tk_alias, // typecode kind for typedefs
    376, // encapsulation length
      TAO_ENCAP_BYTE_ORDER, // byte order
      35,
      ACE_NTOHL (0x49444c3a), 
      ACE_NTOHL (0x6f6d672e), 
      ACE_NTOHL (0x6f72672f), 
      ACE_NTOHL (0x506f7274), 
      ACE_NTOHL (0x61626c65), 
      ACE_NTOHL (0x47726f75), 
      ACE_NTOHL (0x702f4e61), 
      ACE_NTOHL (0x6d653a31), 
      ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/PortableGroup/Name:1.0
            5,
      ACE_NTOHL (0x4e616d65), 
      ACE_NTOHL (0x0),  // name = Name
            CORBA::tk_alias, // typecode kind for typedefs
      312, // encapsulation length
        TAO_ENCAP_BYTE_ORDER, // byte order
        31,
        ACE_NTOHL (0x49444c3a), 
        ACE_NTOHL (0x6f6d672e), 
        ACE_NTOHL (0x6f72672f), 
        ACE_NTOHL (0x436f734e), 
        ACE_NTOHL (0x616d696e), 
        ACE_NTOHL (0x672f4e61), 
        ACE_NTOHL (0x6d653a31), 
        ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CosNaming/Name:1.0
                5,
        ACE_NTOHL (0x4e616d65), 
        ACE_NTOHL (0x0),  // name = Name
                CORBA::tk_sequence, // typecode kind
        252, // encapsulation length
          TAO_ENCAP_BYTE_ORDER, // byte order
          CORBA::tk_struct, // typecode kind
          236, // encapsulation length
            TAO_ENCAP_BYTE_ORDER, // byte order
            40,
            ACE_NTOHL (0x49444c3a), 
            ACE_NTOHL (0x6f6d672e), 
            ACE_NTOHL (0x6f72672f), 
            ACE_NTOHL (0x436f734e), 
            ACE_NTOHL (0x616d696e), 
            ACE_NTOHL (0x672f4e61), 
            ACE_NTOHL (0x6d65436f), 
            ACE_NTOHL (0x6d706f6e), 
            ACE_NTOHL (0x656e743a), 
            ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CosNaming/NameComponent:1.0
                        14,
            ACE_NTOHL (0x4e616d65), 
            ACE_NTOHL (0x436f6d70), 
            ACE_NTOHL (0x6f6e656e), 
            ACE_NTOHL (0x74000000),  // name = NameComponent
            2, // member count
                        3,
            ACE_NTOHL (0x69640000),  // name = id
                        CORBA::tk_alias, // typecode kind for typedefs
            64, // encapsulation length
              TAO_ENCAP_BYTE_ORDER, // byte order
              34,
              ACE_NTOHL (0x49444c3a), 
              ACE_NTOHL (0x6f6d672e), 
              ACE_NTOHL (0x6f72672f), 
              ACE_NTOHL (0x436f734e), 
              ACE_NTOHL (0x616d696e), 
              ACE_NTOHL (0x672f4973), 
              ACE_NTOHL (0x7472696e), 
              ACE_NTOHL (0x673a312e), 
              ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CosNaming/Istring:1.0
                            8,
              ACE_NTOHL (0x49737472), 
              ACE_NTOHL (0x696e6700),  // name = Istring
                            CORBA::tk_string, 
              0U, // string length

            5,
            ACE_NTOHL (0x6b696e64), 
            ACE_NTOHL (0x0),  // name = kind
                        CORBA::tk_alias, // typecode kind for typedefs
            64, // encapsulation length
              TAO_ENCAP_BYTE_ORDER, // byte order
              34,
              ACE_NTOHL (0x49444c3a), 
              ACE_NTOHL (0x6f6d672e), 
              ACE_NTOHL (0x6f72672f), 
              ACE_NTOHL (0x436f734e), 
              ACE_NTOHL (0x616d696e), 
              ACE_NTOHL (0x672f4973), 
              ACE_NTOHL (0x7472696e), 
              ACE_NTOHL (0x673a312e), 
              ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CosNaming/Istring:1.0
                            8,
              ACE_NTOHL (0x49737472), 
              ACE_NTOHL (0x696e6700),  // name = Istring
                            CORBA::tk_string, 
              0U, // string length


          0U,




};

static CORBA::TypeCode _tc_TAO_tc_CosLoadBalancing_Location (
    CORBA::tk_alias,
    sizeof (_oc_CosLoadBalancing_Location),
    (char *) &_oc_CosLoadBalancing_Location,
    0,
    sizeof (CosLoadBalancing::Location)
  );

namespace CosLoadBalancing
{
  ::CORBA::TypeCode_ptr _tc_Location =
    &_tc_TAO_tc_CosLoadBalancing_Location;
}

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

static const CORBA::Long _oc_CosLoadBalancing_Properties[] =
{
    TAO_ENCAP_BYTE_ORDER, // byte order
  44,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x436f734c), 
  ACE_NTOHL (0x6f616442), 
  ACE_NTOHL (0x616c616e), 
  ACE_NTOHL (0x63696e67), 
  ACE_NTOHL (0x2f50726f), 
  ACE_NTOHL (0x70657274), 
  ACE_NTOHL (0x6965733a), 
  ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CosLoadBalancing/Properties:1.0
    11,
  ACE_NTOHL (0x50726f70), 
  ACE_NTOHL (0x65727469), 
  ACE_NTOHL (0x65730000),  // name = Properties
    CORBA::tk_alias, // typecode kind for typedefs
  628, // encapsulation length
    TAO_ENCAP_BYTE_ORDER, // byte order
    41,
    ACE_NTOHL (0x49444c3a), 
    ACE_NTOHL (0x6f6d672e), 
    ACE_NTOHL (0x6f72672f), 
    ACE_NTOHL (0x506f7274), 
    ACE_NTOHL (0x61626c65), 
    ACE_NTOHL (0x47726f75), 
    ACE_NTOHL (0x702f5072), 
    ACE_NTOHL (0x6f706572), 
    ACE_NTOHL (0x74696573), 
    ACE_NTOHL (0x3a312e30), 
    ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/PortableGroup/Properties:1.0
        11,
    ACE_NTOHL (0x50726f70), 
    ACE_NTOHL (0x65727469), 
    ACE_NTOHL (0x65730000),  // name = Properties
        CORBA::tk_sequence, // typecode kind
    552, // encapsulation length
      TAO_ENCAP_BYTE_ORDER, // byte order
      CORBA::tk_struct, // typecode kind
      536, // encapsulation length
        TAO_ENCAP_BYTE_ORDER, // byte order
        39,
        ACE_NTOHL (0x49444c3a), 
        ACE_NTOHL (0x6f6d672e), 
        ACE_NTOHL (0x6f72672f), 
        ACE_NTOHL (0x506f7274), 
        ACE_NTOHL (0x61626c65), 
        ACE_NTOHL (0x47726f75), 
        ACE_NTOHL (0x702f5072), 
        ACE_NTOHL (0x6f706572), 
        ACE_NTOHL (0x74793a31), 
        ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/PortableGroup/Property:1.0
                9,
        ACE_NTOHL (0x50726f70), 
        ACE_NTOHL (0x65727479), 
        ACE_NTOHL (0x0),  // name = Property
        2, // member count
                4,
        ACE_NTOHL (0x6e616d00),  // name = nam
                CORBA::tk_alias, // typecode kind for typedefs
        376, // encapsulation length
          TAO_ENCAP_BYTE_ORDER, // byte order
          35,
          ACE_NTOHL (0x49444c3a), 
          ACE_NTOHL (0x6f6d672e), 
          ACE_NTOHL (0x6f72672f), 
          ACE_NTOHL (0x506f7274), 
          ACE_NTOHL (0x61626c65), 
          ACE_NTOHL (0x47726f75), 
          ACE_NTOHL (0x702f4e61), 
          ACE_NTOHL (0x6d653a31), 
          ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/PortableGroup/Name:1.0
                    5,
          ACE_NTOHL (0x4e616d65), 
          ACE_NTOHL (0x0),  // name = Name
                    CORBA::tk_alias, // typecode kind for typedefs
          312, // encapsulation length
            TAO_ENCAP_BYTE_ORDER, // byte order
            31,
            ACE_NTOHL (0x49444c3a), 
            ACE_NTOHL (0x6f6d672e), 
            ACE_NTOHL (0x6f72672f), 
            ACE_NTOHL (0x436f734e), 
            ACE_NTOHL (0x616d696e), 
            ACE_NTOHL (0x672f4e61), 
            ACE_NTOHL (0x6d653a31), 
            ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CosNaming/Name:1.0
                        5,
            ACE_NTOHL (0x4e616d65), 
            ACE_NTOHL (0x0),  // name = Name
                        CORBA::tk_sequence, // typecode kind
            252, // encapsulation length
              TAO_ENCAP_BYTE_ORDER, // byte order
              CORBA::tk_struct, // typecode kind
              236, // encapsulation length
                TAO_ENCAP_BYTE_ORDER, // byte order
                40,
                ACE_NTOHL (0x49444c3a), 
                ACE_NTOHL (0x6f6d672e), 
                ACE_NTOHL (0x6f72672f), 
                ACE_NTOHL (0x436f734e), 
                ACE_NTOHL (0x616d696e), 
                ACE_NTOHL (0x672f4e61), 
                ACE_NTOHL (0x6d65436f), 
                ACE_NTOHL (0x6d706f6e), 
                ACE_NTOHL (0x656e743a), 
                ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CosNaming/NameComponent:1.0
                                14,
                ACE_NTOHL (0x4e616d65), 
                ACE_NTOHL (0x436f6d70), 
                ACE_NTOHL (0x6f6e656e), 
                ACE_NTOHL (0x74000000),  // name = NameComponent
                2, // member count
                                3,
                ACE_NTOHL (0x69640000),  // name = id
                                CORBA::tk_alias, // typecode kind for typedefs
                64, // encapsulation length
                  TAO_ENCAP_BYTE_ORDER, // byte order
                  34,
                  ACE_NTOHL (0x49444c3a), 
                  ACE_NTOHL (0x6f6d672e), 
                  ACE_NTOHL (0x6f72672f), 
                  ACE_NTOHL (0x436f734e), 
                  ACE_NTOHL (0x616d696e), 
                  ACE_NTOHL (0x672f4973), 
                  ACE_NTOHL (0x7472696e), 
                  ACE_NTOHL (0x673a312e), 
                  ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CosNaming/Istring:1.0
                                    8,
                  ACE_NTOHL (0x49737472), 
                  ACE_NTOHL (0x696e6700),  // name = Istring
                                    CORBA::tk_string, 
                  0U, // string length

                5,
                ACE_NTOHL (0x6b696e64), 
                ACE_NTOHL (0x0),  // name = kind
                                CORBA::tk_alias, // typecode kind for typedefs
                64, // encapsulation length
                  TAO_ENCAP_BYTE_ORDER, // byte order
                  34,
                  ACE_NTOHL (0x49444c3a), 
                  ACE_NTOHL (0x6f6d672e), 
                  ACE_NTOHL (0x6f72672f), 
                  ACE_NTOHL (0x436f734e), 
                  ACE_NTOHL (0x616d696e), 
                  ACE_NTOHL (0x672f4973), 
                  ACE_NTOHL (0x7472696e), 
                  ACE_NTOHL (0x673a312e), 
                  ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CosNaming/Istring:1.0
                                    8,
                  ACE_NTOHL (0x49737472), 
                  ACE_NTOHL (0x696e6700),  // name = Istring
                                    CORBA::tk_string, 
                  0U, // string length


              0U,



        4,
        ACE_NTOHL (0x76616c00),  // name = val
                CORBA::tk_alias, // typecode kind for typedefs
        60, // encapsulation length
          TAO_ENCAP_BYTE_ORDER, // byte order
          36,
          ACE_NTOHL (0x49444c3a), 
          ACE_NTOHL (0x6f6d672e), 
          ACE_NTOHL (0x6f72672f), 
          ACE_NTOHL (0x506f7274), 
          ACE_NTOHL (0x61626c65), 
          ACE_NTOHL (0x47726f75), 
          ACE_NTOHL (0x702f5661), 
          ACE_NTOHL (0x6c75653a), 
          ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/PortableGroup/Value:1.0
                    6,
          ACE_NTOHL (0x56616c75), 
          ACE_NTOHL (0x65000000),  // name = Value
                    CORBA::tk_any,



      0U,


};

static CORBA::TypeCode _tc_TAO_tc_CosLoadBalancing_Properties (
    CORBA::tk_alias,
    sizeof (_oc_CosLoadBalancing_Properties),
    (char *) &_oc_CosLoadBalancing_Properties,
    0,
    sizeof (CosLoadBalancing::Properties)
  );

namespace CosLoadBalancing
{
  ::CORBA::TypeCode_ptr _tc_Properties =
    &_tc_TAO_tc_CosLoadBalancing_Properties;
}

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

static const CORBA::Long _oc_CosLoadBalancing_LoadId[] =
{
    TAO_ENCAP_BYTE_ORDER, // byte order
  40,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x436f734c), 
  ACE_NTOHL (0x6f616442), 
  ACE_NTOHL (0x616c616e), 
  ACE_NTOHL (0x63696e67), 
  ACE_NTOHL (0x2f4c6f61), 
  ACE_NTOHL (0x6449643a), 
  ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CosLoadBalancing/LoadId:1.0
    7,
  ACE_NTOHL (0x4c6f6164), 
  ACE_NTOHL (0x49640000),  // name = LoadId
    CORBA::tk_ulong,

};

static CORBA::TypeCode _tc_TAO_tc_CosLoadBalancing_LoadId (
    CORBA::tk_alias,
    sizeof (_oc_CosLoadBalancing_LoadId),
    (char *) &_oc_CosLoadBalancing_LoadId,
    0,
    sizeof (CosLoadBalancing::LoadId)
  );

namespace CosLoadBalancing
{
  ::CORBA::TypeCode_ptr _tc_LoadId =
    &_tc_TAO_tc_CosLoadBalancing_LoadId;
}

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

static const CORBA::Long _oc_CosLoadBalancing_Load[] =
{
    TAO_ENCAP_BYTE_ORDER, // byte order
  38,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x436f734c), 
  ACE_NTOHL (0x6f616442), 
  ACE_NTOHL (0x616c616e), 
  ACE_NTOHL (0x63696e67), 
  ACE_NTOHL (0x2f4c6f61), 
  ACE_NTOHL (0x643a312e), 
  ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CosLoadBalancing/Load:1.0
    5,
  ACE_NTOHL (0x4c6f6164), 
  ACE_NTOHL (0x0),  // name = Load
  2, // member count
    3,
  ACE_NTOHL (0x69640000),  // name = id
    CORBA::tk_alias, // typecode kind for typedefs
  64, // encapsulation length
    TAO_ENCAP_BYTE_ORDER, // byte order
    40,
    ACE_NTOHL (0x49444c3a), 
    ACE_NTOHL (0x6f6d672e), 
    ACE_NTOHL (0x6f72672f), 
    ACE_NTOHL (0x436f734c), 
    ACE_NTOHL (0x6f616442), 
    ACE_NTOHL (0x616c616e), 
    ACE_NTOHL (0x63696e67), 
    ACE_NTOHL (0x2f4c6f61), 
    ACE_NTOHL (0x6449643a), 
    ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CosLoadBalancing/LoadId:1.0
        7,
    ACE_NTOHL (0x4c6f6164), 
    ACE_NTOHL (0x49640000),  // name = LoadId
        CORBA::tk_ulong,


  6,
  ACE_NTOHL (0x76616c75), 
  ACE_NTOHL (0x65000000),  // name = value
    CORBA::tk_float,

};

static CORBA::TypeCode _tc_TAO_tc_CosLoadBalancing_Load (
    CORBA::tk_struct,
    sizeof (_oc_CosLoadBalancing_Load),
    (char *) &_oc_CosLoadBalancing_Load,
    0,
    sizeof (CosLoadBalancing::Load)
  );

namespace CosLoadBalancing
{
  ::CORBA::TypeCode_ptr _tc_Load =
    &_tc_TAO_tc_CosLoadBalancing_Load;
}

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

void 
CosLoadBalancing::Load::_tao_any_destructor (
    void *_tao_void_pointer
  )
{
  Load *_tao_tmp_pointer =
    static_cast<Load *> (_tao_void_pointer);
  delete _tao_tmp_pointer;
}

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

#if !defined (_COSLOADBALANCING_LOADLIST_CS_)
#define _COSLOADBALANCING_LOADLIST_CS_

CosLoadBalancing::LoadList::LoadList (void)
{}

CosLoadBalancing::LoadList::LoadList (
    CORBA::ULong max
  )
  : TAO_Unbounded_Sequence<
        CosLoadBalancing::Load
      >
    (max)
{}

CosLoadBalancing::LoadList::LoadList (
    CORBA::ULong max,
    CORBA::ULong length,
    CosLoadBalancing::Load * buffer,
    CORBA::Boolean release
  )
  : TAO_Unbounded_Sequence<
        CosLoadBalancing::Load
      >
    (max, length, buffer, release)
{}

CosLoadBalancing::LoadList::LoadList (
    const LoadList &seq
  )
  : TAO_Unbounded_Sequence<
        CosLoadBalancing::Load
      >
    (seq)
{}

CosLoadBalancing::LoadList::~LoadList (void)
{}

void CosLoadBalancing::LoadList::_tao_any_destructor (
    void * _tao_void_pointer
  )
{
  LoadList * _tao_tmp_pointer =
    static_cast<LoadList *> (_tao_void_pointer);
  delete _tao_tmp_pointer;
}

#endif /* end #if !defined */

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

static const CORBA::Long _oc_CosLoadBalancing_LoadList[] =
{
    TAO_ENCAP_BYTE_ORDER, // byte order
  42,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x436f734c), 
  ACE_NTOHL (0x6f616442), 
  ACE_NTOHL (0x616c616e), 
  ACE_NTOHL (0x63696e67), 
  ACE_NTOHL (0x2f4c6f61), 
  ACE_NTOHL (0x644c6973), 
  ACE_NTOHL (0x743a312e), 
  ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CosLoadBalancing/LoadList:1.0
    9,
  ACE_NTOHL (0x4c6f6164), 
  ACE_NTOHL (0x4c697374), 
  ACE_NTOHL (0x0),  // name = LoadList
    CORBA::tk_sequence, // typecode kind
  176, // encapsulation length
    TAO_ENCAP_BYTE_ORDER, // byte order
    CORBA::tk_struct, // typecode kind
    160, // encapsulation length
      TAO_ENCAP_BYTE_ORDER, // byte order
      38,
      ACE_NTOHL (0x49444c3a), 
      ACE_NTOHL (0x6f6d672e), 
      ACE_NTOHL (0x6f72672f), 
      ACE_NTOHL (0x436f734c), 
      ACE_NTOHL (0x6f616442), 
      ACE_NTOHL (0x616c616e), 
      ACE_NTOHL (0x63696e67), 
      ACE_NTOHL (0x2f4c6f61), 
      ACE_NTOHL (0x643a312e), 
      ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CosLoadBalancing/Load:1.0
            5,
      ACE_NTOHL (0x4c6f6164), 
      ACE_NTOHL (0x0),  // name = Load
      2, // member count
            3,
      ACE_NTOHL (0x69640000),  // name = id
            CORBA::tk_alias, // typecode kind for typedefs
      64, // encapsulation length
        TAO_ENCAP_BYTE_ORDER, // byte order
        40,
        ACE_NTOHL (0x49444c3a), 
        ACE_NTOHL (0x6f6d672e), 
        ACE_NTOHL (0x6f72672f), 
        ACE_NTOHL (0x436f734c), 
        ACE_NTOHL (0x6f616442), 
        ACE_NTOHL (0x616c616e), 
        ACE_NTOHL (0x63696e67), 
        ACE_NTOHL (0x2f4c6f61), 
        ACE_NTOHL (0x6449643a), 
        ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CosLoadBalancing/LoadId:1.0
                7,
        ACE_NTOHL (0x4c6f6164), 
        ACE_NTOHL (0x49640000),  // name = LoadId
                CORBA::tk_ulong,


      6,
      ACE_NTOHL (0x76616c75), 
      ACE_NTOHL (0x65000000),  // name = value
            CORBA::tk_float,


    0U,

};

static CORBA::TypeCode _tc_TAO_tc_CosLoadBalancing_LoadList (
    CORBA::tk_alias,
    sizeof (_oc_CosLoadBalancing_LoadList),
    (char *) &_oc_CosLoadBalancing_LoadList,
    0,
    sizeof (CosLoadBalancing::LoadList)
  );

namespace CosLoadBalancing
{
  ::CORBA::TypeCode_ptr _tc_LoadList =
    &_tc_TAO_tc_CosLoadBalancing_LoadList;
}

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

CosLoadBalancing::MonitorAlreadyPresent::MonitorAlreadyPresent (void)
  : CORBA::UserException (
        "IDL:omg.org/CosLoadBalancing/MonitorAlreadyPresent:1.0",
        "MonitorAlreadyPresent"
      )
{
}

CosLoadBalancing::MonitorAlreadyPresent::~MonitorAlreadyPresent (void)
{
}

CosLoadBalancing::MonitorAlreadyPresent::MonitorAlreadyPresent (const ::CosLoadBalancing::MonitorAlreadyPresent &_tao_excp)
  : CORBA::UserException (
        _tao_excp._rep_id (),
        _tao_excp._name ()
      )
{
}

CosLoadBalancing::MonitorAlreadyPresent&
CosLoadBalancing::MonitorAlreadyPresent::operator= (const ::CosLoadBalancing::MonitorAlreadyPresent &_tao_excp)
{
  this->ACE_NESTED_CLASS (CORBA, UserException)::operator= (_tao_excp);
  return *this;
}

void CosLoadBalancing::MonitorAlreadyPresent::_tao_any_destructor (void *_tao_void_pointer)
{
  MonitorAlreadyPresent *_tao_tmp_pointer =
    static_cast<MonitorAlreadyPresent*> (_tao_void_pointer);
  delete _tao_tmp_pointer;
}

CosLoadBalancing::MonitorAlreadyPresent *
CosLoadBalancing::MonitorAlreadyPresent::_downcast (CORBA::Exception *_tao_excp)
{
  if (!ACE_OS::strcmp ("IDL:omg.org/CosLoadBalancing/MonitorAlreadyPresent:1.0", _tao_excp->_rep_id ()))
    {
      return dynamic_cast<MonitorAlreadyPresent *> (_tao_excp);
    }
  else
    {
      return 0;
    }
}

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

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

void CosLoadBalancing::MonitorAlreadyPresent::_raise (void) const
{
  TAO_RAISE (*this);
}

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

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

// TAO extension - the virtual _type method.
CORBA::TypeCode_ptr CosLoadBalancing::MonitorAlreadyPresent::_type (void) const
{
  return ::CosLoadBalancing::_tc_MonitorAlreadyPresent;
}

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

static const CORBA::Long _oc_CosLoadBalancing_MonitorAlreadyPresent[] =
{
    TAO_ENCAP_BYTE_ORDER, // byte order
  55,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x436f734c), 
  ACE_NTOHL (0x6f616442), 
  ACE_NTOHL (0x616c616e), 
  ACE_NTOHL (0x63696e67), 
  ACE_NTOHL (0x2f4d6f6e), 
  ACE_NTOHL (0x69746f72), 
  ACE_NTOHL (0x416c7265), 
  ACE_NTOHL (0x61647950), 
  ACE_NTOHL (0x72657365), 
  ACE_NTOHL (0x6e743a31), 
  ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CosLoadBalancing/MonitorAlreadyPresent:1.0
    22,
  ACE_NTOHL (0x4d6f6e69), 
  ACE_NTOHL (0x746f7241), 
  ACE_NTOHL (0x6c726561), 
  ACE_NTOHL (0x64795072), 
  ACE_NTOHL (0x6573656e), 
  ACE_NTOHL (0x74000000),  // name = MonitorAlreadyPresent
  0, // member count
  };

static CORBA::TypeCode _tc_TAO_tc_CosLoadBalancing_MonitorAlreadyPresent (
    CORBA::tk_except,
    sizeof (_oc_CosLoadBalancing_MonitorAlreadyPresent),
    (char *) &_oc_CosLoadBalancing_MonitorAlreadyPresent,
    0,
    sizeof (CosLoadBalancing::MonitorAlreadyPresent)
  );

namespace CosLoadBalancing
{
  ::CORBA::TypeCode_ptr _tc_MonitorAlreadyPresent =
    &_tc_TAO_tc_CosLoadBalancing_MonitorAlreadyPresent;
}

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

CosLoadBalancing::LocationNotFound::LocationNotFound (void)
  : CORBA::UserException (
        "IDL:omg.org/CosLoadBalancing/LocationNotFound:1.0",
        "LocationNotFound"
      )
{
}

CosLoadBalancing::LocationNotFound::~LocationNotFound (void)
{
}

CosLoadBalancing::LocationNotFound::LocationNotFound (const ::CosLoadBalancing::LocationNotFound &_tao_excp)
  : CORBA::UserException (
        _tao_excp._rep_id (),
        _tao_excp._name ()
      )
{
}

CosLoadBalancing::LocationNotFound&
CosLoadBalancing::LocationNotFound::operator= (const ::CosLoadBalancing::LocationNotFound &_tao_excp)
{
  this->ACE_NESTED_CLASS (CORBA, UserException)::operator= (_tao_excp);
  return *this;
}

void CosLoadBalancing::LocationNotFound::_tao_any_destructor (void *_tao_void_pointer)
{
  LocationNotFound *_tao_tmp_pointer =
    static_cast<LocationNotFound*> (_tao_void_pointer);
  delete _tao_tmp_pointer;
}

CosLoadBalancing::LocationNotFound *
CosLoadBalancing::LocationNotFound::_downcast (CORBA::Exception *_tao_excp)
{
  if (!ACE_OS::strcmp ("IDL:omg.org/CosLoadBalancing/LocationNotFound:1.0", _tao_excp->_rep_id ()))
    {
      return dynamic_cast<LocationNotFound *> (_tao_excp);
    }
  else
    {
      return 0;
    }
}

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

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

void CosLoadBalancing::LocationNotFound::_raise (void) const
{
  TAO_RAISE (*this);
}

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

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

// TAO extension - the virtual _type method.
CORBA::TypeCode_ptr CosLoadBalancing::LocationNotFound::_type (void) const
{
  return ::CosLoadBalancing::_tc_LocationNotFound;
}

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

static const CORBA::Long _oc_CosLoadBalancing_LocationNotFound[] =
{
    TAO_ENCAP_BYTE_ORDER, // byte order
  50,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x436f734c), 
  ACE_NTOHL (0x6f616442), 
  ACE_NTOHL (0x616c616e), 
  ACE_NTOHL (0x63696e67), 
  ACE_NTOHL (0x2f4c6f63), 
  ACE_NTOHL (0x6174696f), 
  ACE_NTOHL (0x6e4e6f74), 
  ACE_NTOHL (0x466f756e), 
  ACE_NTOHL (0x643a312e), 
  ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CosLoadBalancing/LocationNotFound:1.0
    17,
  ACE_NTOHL (0x4c6f6361), 
  ACE_NTOHL (0x74696f6e), 
  ACE_NTOHL (0x4e6f7446), 
  ACE_NTOHL (0x6f756e64), 
  ACE_NTOHL (0x0),  // name = LocationNotFound
  0, // member count
  };

static CORBA::TypeCode _tc_TAO_tc_CosLoadBalancing_LocationNotFound (
    CORBA::tk_except,
    sizeof (_oc_CosLoadBalancing_LocationNotFound),
    (char *) &_oc_CosLoadBalancing_LocationNotFound,
    0,
    sizeof (CosLoadBalancing::LocationNotFound)
  );

namespace CosLoadBalancing
{
  ::CORBA::TypeCode_ptr _tc_LocationNotFound =
    &_tc_TAO_tc_CosLoadBalancing_LocationNotFound;
}

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

CosLoadBalancing::LoadAlertNotFound::LoadAlertNotFound (void)
  : CORBA::UserException (
        "IDL:omg.org/CosLoadBalancing/LoadAlertNotFound:1.0",
        "LoadAlertNotFound"
      )
{
}

CosLoadBalancing::LoadAlertNotFound::~LoadAlertNotFound (void)
{
}

CosLoadBalancing::LoadAlertNotFound::LoadAlertNotFound (const ::CosLoadBalancing::LoadAlertNotFound &_tao_excp)
  : CORBA::UserException (
        _tao_excp._rep_id (),
        _tao_excp._name ()
      )
{
}

CosLoadBalancing::LoadAlertNotFound&
CosLoadBalancing::LoadAlertNotFound::operator= (const ::CosLoadBalancing::LoadAlertNotFound &_tao_excp)
{
  this->ACE_NESTED_CLASS (CORBA, UserException)::operator= (_tao_excp);
  return *this;
}

void CosLoadBalancing::LoadAlertNotFound::_tao_any_destructor (void *_tao_void_pointer)
{
  LoadAlertNotFound *_tao_tmp_pointer =
    static_cast<LoadAlertNotFound*> (_tao_void_pointer);
  delete _tao_tmp_pointer;
}

CosLoadBalancing::LoadAlertNotFound *
CosLoadBalancing::LoadAlertNotFound::_downcast (CORBA::Exception *_tao_excp)
{
  if (!ACE_OS::strcmp ("IDL:omg.org/CosLoadBalancing/LoadAlertNotFound:1.0", _tao_excp->_rep_id ()))
    {
      return dynamic_cast<LoadAlertNotFound *> (_tao_excp);
    }
  else
    {
      return 0;
    }
}

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

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

void CosLoadBalancing::LoadAlertNotFound::_raise (void) const
{
  TAO_RAISE (*this);
}

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

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

// TAO extension - the virtual _type method.
CORBA::TypeCode_ptr CosLoadBalancing::LoadAlertNotFound::_type (void) const
{
  return ::CosLoadBalancing::_tc_LoadAlertNotFound;
}

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

static const CORBA::Long _oc_CosLoadBalancing_LoadAlertNotFound[] =
{
    TAO_ENCAP_BYTE_ORDER, // byte order
  51,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x436f734c), 
  ACE_NTOHL (0x6f616442), 
  ACE_NTOHL (0x616c616e), 
  ACE_NTOHL (0x63696e67), 
  ACE_NTOHL (0x2f4c6f61), 
  ACE_NTOHL (0x64416c65), 
  ACE_NTOHL (0x72744e6f), 
  ACE_NTOHL (0x74466f75), 
  ACE_NTOHL (0x6e643a31), 
  ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CosLoadBalancing/LoadAlertNotFound:1.0
    18,
  ACE_NTOHL (0x4c6f6164), 
  ACE_NTOHL (0x416c6572), 
  ACE_NTOHL (0x744e6f74), 
  ACE_NTOHL (0x466f756e), 
  ACE_NTOHL (0x64000000),  // name = LoadAlertNotFound
  0, // member count
  };

static CORBA::TypeCode _tc_TAO_tc_CosLoadBalancing_LoadAlertNotFound (
    CORBA::tk_except,
    sizeof (_oc_CosLoadBalancing_LoadAlertNotFound),
    (char *) &_oc_CosLoadBalancing_LoadAlertNotFound,
    0,
    sizeof (CosLoadBalancing::LoadAlertNotFound)
  );

namespace CosLoadBalancing
{
  ::CORBA::TypeCode_ptr _tc_LoadAlertNotFound =
    &_tc_TAO_tc_CosLoadBalancing_LoadAlertNotFound;
}

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

CosLoadBalancing::LoadAlertAlreadyPresent::LoadAlertAlreadyPresent (void)
  : CORBA::UserException (
        "IDL:omg.org/CosLoadBalancing/LoadAlertAlreadyPresent:1.0",
        "LoadAlertAlreadyPresent"
      )
{
}

CosLoadBalancing::LoadAlertAlreadyPresent::~LoadAlertAlreadyPresent (void)
{
}

CosLoadBalancing::LoadAlertAlreadyPresent::LoadAlertAlreadyPresent (const ::CosLoadBalancing::LoadAlertAlreadyPresent &_tao_excp)
  : CORBA::UserException (
        _tao_excp._rep_id (),
        _tao_excp._name ()
      )
{
}

CosLoadBalancing::LoadAlertAlreadyPresent&
CosLoadBalancing::LoadAlertAlreadyPresent::operator= (const ::CosLoadBalancing::LoadAlertAlreadyPresent &_tao_excp)
{
  this->ACE_NESTED_CLASS (CORBA, UserException)::operator= (_tao_excp);
  return *this;
}

void CosLoadBalancing::LoadAlertAlreadyPresent::_tao_any_destructor (void *_tao_void_pointer)
{
  LoadAlertAlreadyPresent *_tao_tmp_pointer =
    static_cast<LoadAlertAlreadyPresent*> (_tao_void_pointer);
  delete _tao_tmp_pointer;
}

CosLoadBalancing::LoadAlertAlreadyPresent *
CosLoadBalancing::LoadAlertAlreadyPresent::_downcast (CORBA::Exception *_tao_excp)
{
  if (!ACE_OS::strcmp ("IDL:omg.org/CosLoadBalancing/LoadAlertAlreadyPresent:1.0", _tao_excp->_rep_id ()))
    {
      return dynamic_cast<LoadAlertAlreadyPresent *> (_tao_excp);
    }
  else
    {
      return 0;
    }
}

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

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

void CosLoadBalancing::LoadAlertAlreadyPresent::_raise (void) const
{
  TAO_RAISE (*this);
}

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

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

// TAO extension - the virtual _type method.
CORBA::TypeCode_ptr CosLoadBalancing::LoadAlertAlreadyPresent::_type (void) const
{
  return ::CosLoadBalancing::_tc_LoadAlertAlreadyPresent;
}

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

static const CORBA::Long _oc_CosLoadBalancing_LoadAlertAlreadyPresent[] =
{
    TAO_ENCAP_BYTE_ORDER, // byte order
  57,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x436f734c), 
  ACE_NTOHL (0x6f616442), 
  ACE_NTOHL (0x616c616e), 
  ACE_NTOHL (0x63696e67), 
  ACE_NTOHL (0x2f4c6f61), 
  ACE_NTOHL (0x64416c65), 
  ACE_NTOHL (0x7274416c), 
  ACE_NTOHL (0x72656164), 
  ACE_NTOHL (0x79507265), 
  ACE_NTOHL (0x73656e74), 
  ACE_NTOHL (0x3a312e30), 
  ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CosLoadBalancing/LoadAlertAlreadyPresent:1.0
    24,
  ACE_NTOHL (0x4c6f6164), 
  ACE_NTOHL (0x416c6572), 
  ACE_NTOHL (0x74416c72), 
  ACE_NTOHL (0x65616479), 
  ACE_NTOHL (0x50726573), 
  ACE_NTOHL (0x656e7400),  // name = LoadAlertAlreadyPresent
  0, // member count
  };

static CORBA::TypeCode _tc_TAO_tc_CosLoadBalancing_LoadAlertAlreadyPresent (
    CORBA::tk_except,
    sizeof (_oc_CosLoadBalancing_LoadAlertAlreadyPresent),
    (char *) &_oc_CosLoadBalancing_LoadAlertAlreadyPresent,
    0,
    sizeof (CosLoadBalancing::LoadAlertAlreadyPresent)
  );

namespace CosLoadBalancing
{
  ::CORBA::TypeCode_ptr _tc_LoadAlertAlreadyPresent =
    &_tc_TAO_tc_CosLoadBalancing_LoadAlertAlreadyPresent;
}

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

CosLoadBalancing::LoadAlertNotAdded::LoadAlertNotAdded (void)
  : CORBA::UserException (
        "IDL:omg.org/CosLoadBalancing/LoadAlertNotAdded:1.0",
        "LoadAlertNotAdded"
      )
{
}

CosLoadBalancing::LoadAlertNotAdded::~LoadAlertNotAdded (void)
{
}

CosLoadBalancing::LoadAlertNotAdded::LoadAlertNotAdded (const ::CosLoadBalancing::LoadAlertNotAdded &_tao_excp)
  : CORBA::UserException (
        _tao_excp._rep_id (),
        _tao_excp._name ()
      )
{
}

CosLoadBalancing::LoadAlertNotAdded&
CosLoadBalancing::LoadAlertNotAdded::operator= (const ::CosLoadBalancing::LoadAlertNotAdded &_tao_excp)
{
  this->ACE_NESTED_CLASS (CORBA, UserException)::operator= (_tao_excp);
  return *this;
}

void CosLoadBalancing::LoadAlertNotAdded::_tao_any_destructor (void *_tao_void_pointer)
{
  LoadAlertNotAdded *_tao_tmp_pointer =
    static_cast<LoadAlertNotAdded*> (_tao_void_pointer);
  delete _tao_tmp_pointer;
}

CosLoadBalancing::LoadAlertNotAdded *
CosLoadBalancing::LoadAlertNotAdded::_downcast (CORBA::Exception *_tao_excp)
{
  if (!ACE_OS::strcmp ("IDL:omg.org/CosLoadBalancing/LoadAlertNotAdded:1.0", _tao_excp->_rep_id ()))
    {
      return dynamic_cast<LoadAlertNotAdded *> (_tao_excp);
    }
  else
    {
      return 0;
    }
}

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

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

void CosLoadBalancing::LoadAlertNotAdded::_raise (void) const
{
  TAO_RAISE (*this);
}

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

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

// TAO extension - the virtual _type method.
CORBA::TypeCode_ptr CosLoadBalancing::LoadAlertNotAdded::_type (void) const
{
  return ::CosLoadBalancing::_tc_LoadAlertNotAdded;
}

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

static const CORBA::Long _oc_CosLoadBalancing_LoadAlertNotAdded[] =
{
    TAO_ENCAP_BYTE_ORDER, // byte order
  51,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x436f734c), 
  ACE_NTOHL (0x6f616442), 
  ACE_NTOHL (0x616c616e), 
  ACE_NTOHL (0x63696e67), 
  ACE_NTOHL (0x2f4c6f61), 
  ACE_NTOHL (0x64416c65), 
  ACE_NTOHL (0x72744e6f), 
  ACE_NTOHL (0x74416464), 
  ACE_NTOHL (0x65643a31), 
  ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CosLoadBalancing/LoadAlertNotAdded:1.0
    18,
  ACE_NTOHL (0x4c6f6164), 
  ACE_NTOHL (0x416c6572), 
  ACE_NTOHL (0x744e6f74), 
  ACE_NTOHL (0x41646465), 
  ACE_NTOHL (0x64000000),  // name = LoadAlertNotAdded
  0, // member count
  };

static CORBA::TypeCode _tc_TAO_tc_CosLoadBalancing_LoadAlertNotAdded (
    CORBA::tk_except,
    sizeof (_oc_CosLoadBalancing_LoadAlertNotAdded),
    (char *) &_oc_CosLoadBalancing_LoadAlertNotAdded,
    0,
    sizeof (CosLoadBalancing::LoadAlertNotAdded)
  );

namespace CosLoadBalancing
{
  ::CORBA::TypeCode_ptr _tc_LoadAlertNotAdded =
    &_tc_TAO_tc_CosLoadBalancing_LoadAlertNotAdded;
}

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

CosLoadBalancing::StrategyNotAdaptive::StrategyNotAdaptive (void)
  : CORBA::UserException (
        "IDL:omg.org/CosLoadBalancing/StrategyNotAdaptive:1.0",
        "StrategyNotAdaptive"
      )
{
}

CosLoadBalancing::StrategyNotAdaptive::~StrategyNotAdaptive (void)
{
}

CosLoadBalancing::StrategyNotAdaptive::StrategyNotAdaptive (const ::CosLoadBalancing::StrategyNotAdaptive &_tao_excp)
  : CORBA::UserException (
        _tao_excp._rep_id (),
        _tao_excp._name ()
      )
{
}

CosLoadBalancing::StrategyNotAdaptive&
CosLoadBalancing::StrategyNotAdaptive::operator= (const ::CosLoadBalancing::StrategyNotAdaptive &_tao_excp)
{
  this->ACE_NESTED_CLASS (CORBA, UserException)::operator= (_tao_excp);
  return *this;
}

void CosLoadBalancing::StrategyNotAdaptive::_tao_any_destructor (void *_tao_void_pointer)
{
  StrategyNotAdaptive *_tao_tmp_pointer =
    static_cast<StrategyNotAdaptive*> (_tao_void_pointer);
  delete _tao_tmp_pointer;
}

CosLoadBalancing::StrategyNotAdaptive *
CosLoadBalancing::StrategyNotAdaptive::_downcast (CORBA::Exception *_tao_excp)
{
  if (!ACE_OS::strcmp ("IDL:omg.org/CosLoadBalancing/StrategyNotAdaptive:1.0", _tao_excp->_rep_id ()))
    {
      return dynamic_cast<StrategyNotAdaptive *> (_tao_excp);
    }
  else
    {
      return 0;
    }
}

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

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

void CosLoadBalancing::StrategyNotAdaptive::_raise (void) const
{
  TAO_RAISE (*this);
}

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

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

// TAO extension - the virtual _type method.
CORBA::TypeCode_ptr CosLoadBalancing::StrategyNotAdaptive::_type (void) const
{
  return ::CosLoadBalancing::_tc_StrategyNotAdaptive;
}

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

static const CORBA::Long _oc_CosLoadBalancing_StrategyNotAdaptive[] =
{
    TAO_ENCAP_BYTE_ORDER, // byte order
  53,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x436f734c), 
  ACE_NTOHL (0x6f616442), 
  ACE_NTOHL (0x616c616e), 
  ACE_NTOHL (0x63696e67), 
  ACE_NTOHL (0x2f537472), 
  ACE_NTOHL (0x61746567), 
  ACE_NTOHL (0x794e6f74), 
  ACE_NTOHL (0x41646170), 
  ACE_NTOHL (0x74697665), 
  ACE_NTOHL (0x3a312e30), 
  ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CosLoadBalancing/StrategyNotAdaptive:1.0
    20,
  ACE_NTOHL (0x53747261), 
  ACE_NTOHL (0x74656779), 
  ACE_NTOHL (0x4e6f7441), 
  ACE_NTOHL (0x64617074), 
  ACE_NTOHL (0x69766500),  // name = StrategyNotAdaptive
  0, // member count
  };

static CORBA::TypeCode _tc_TAO_tc_CosLoadBalancing_StrategyNotAdaptive (
    CORBA::tk_except,
    sizeof (_oc_CosLoadBalancing_StrategyNotAdaptive),
    (char *) &_oc_CosLoadBalancing_StrategyNotAdaptive,
    0,
    sizeof (CosLoadBalancing::StrategyNotAdaptive)
  );

namespace CosLoadBalancing
{
  ::CORBA::TypeCode_ptr _tc_StrategyNotAdaptive =
    &_tc_TAO_tc_CosLoadBalancing_StrategyNotAdaptive;
}

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

// Traits specializations for CosLoadBalancing::Strategy.

ACE_TEMPLATE_CLASS_MEMBER_SPECIALIZATION
CosLoadBalancing::Strategy_ptr
TAO::Objref_Traits<CosLoadBalancing::Strategy>::tao_duplicate (
    CosLoadBalancing::Strategy_ptr p
  )
{
  return CosLoadBalancing::Strategy::_duplicate (p);
}

ACE_TEMPLATE_CLASS_MEMBER_SPECIALIZATION
void
TAO::Objref_Traits<CosLoadBalancing::Strategy>::tao_release (
    CosLoadBalancing::Strategy_ptr p
  )
{
  CORBA::release (p);
}

ACE_TEMPLATE_CLASS_MEMBER_SPECIALIZATION
CosLoadBalancing::Strategy_ptr
TAO::Objref_Traits<CosLoadBalancing::Strategy>::tao_nil (void)
{
  return CosLoadBalancing::Strategy::_nil ();
}

ACE_TEMPLATE_CLASS_MEMBER_SPECIALIZATION
CORBA::Boolean
TAO::Objref_Traits<CosLoadBalancing::Strategy>::tao_marshal (
    CosLoadBalancing::Strategy_ptr p,
    TAO_OutputCDR & cdr
  )
{
  return CORBA::Object::marshal (p, cdr);
}

// Function pointer for collocation factory initialization.
TAO::Collocation_Proxy_Broker * 
(*CosLoadBalancing__TAO_Strategy_Proxy_Broker_Factory_function_pointer) (
    CORBA::Object_ptr obj
  ) = 0;

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

char * CosLoadBalancing::Strategy::name (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_Strategy_Proxy_Broker_ == 0)
    {
      CosLoadBalancing_Strategy_setup_collocation ();
    }
  
  TAO::Arg_Traits< ::CORBA::Char *>::ret_val _tao_retval;
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      1,
      "_get_name",
      9,
      this->the_TAO_Strategy_Proxy_Broker_
    );
  
  _tao_call.invoke (0, 0 ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (_tao_retval.excp ());
  
  return _tao_retval.retn ();
}

// TAO_IDL - Generated from
// be/be_visitor_operation/ami_cs.cpp:71

void
CosLoadBalancing::Strategy::sendc_get_name (
    ::CosLoadBalancing::AMI_StrategyHandler_ptr ami_handler
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_Strategy_Proxy_Broker_ == 0)
    {
      CosLoadBalancing_Strategy_setup_collocation ();
    }
  
  TAO::Arg_Traits<void>::ret_val _tao_retval;
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval
    };
  
  TAO::Asynch_Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      1,
      "_get_name",
      9,
      this->the_TAO_Strategy_Proxy_Broker_
    );
  
  _tao_call.invoke (
      ami_handler,
      &CosLoadBalancing::AMI_StrategyHandler::get_name_reply_stub
      ACE_ENV_ARG_PARAMETER
    );
  ACE_CHECK;
}

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

::CosLoadBalancing::Properties * CosLoadBalancing::Strategy::get_properties (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_Strategy_Proxy_Broker_ == 0)
    {
      CosLoadBalancing_Strategy_setup_collocation ();
    }
  
  TAO::Arg_Traits< ::CosLoadBalancing::Properties>::ret_val _tao_retval;
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      1,
      "get_properties",
      14,
      this->the_TAO_Strategy_Proxy_Broker_
    );
  
  _tao_call.invoke (0, 0 ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (_tao_retval.excp ());
  
  return _tao_retval.retn ();
}

// TAO_IDL - Generated from
// be/be_visitor_operation/ami_cs.cpp:71

void
CosLoadBalancing::Strategy::sendc_get_properties (
    ::CosLoadBalancing::AMI_StrategyHandler_ptr ami_handler
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_Strategy_Proxy_Broker_ == 0)
    {
      CosLoadBalancing_Strategy_setup_collocation ();
    }
  
  TAO::Arg_Traits<void>::ret_val _tao_retval;
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval
    };
  
  TAO::Asynch_Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      1,
      "get_properties",
      14,
      this->the_TAO_Strategy_Proxy_Broker_
    );
  
  _tao_call.invoke (
      ami_handler,
      &CosLoadBalancing::AMI_StrategyHandler::get_properties_reply_stub
      ACE_ENV_ARG_PARAMETER
    );
  ACE_CHECK;
}

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

void CosLoadBalancing::Strategy::push_loads (
    const ::PortableGroup::Location & the_location,
    const ::CosLoadBalancing::LoadList & loads
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException,
    ::CosLoadBalancing::StrategyNotAdaptive
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_Strategy_Proxy_Broker_ == 0)
    {
      CosLoadBalancing_Strategy_setup_collocation ();
    }
  
  TAO::Arg_Traits< void>::ret_val _tao_retval;
  TAO::Arg_Traits< ::PortableGroup::Location>::in_arg_val _tao_the_location (the_location);
  TAO::Arg_Traits< ::CosLoadBalancing::LoadList>::in_arg_val _tao_loads (loads);
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval,
      &_tao_the_location,
      &_tao_loads
    };
  
  static TAO::Exception_Data
  _tao_CosLoadBalancing_Strategy_push_loads_exceptiondata [] = 
    {
      {
        "IDL:omg.org/CosLoadBalancing/StrategyNotAdaptive:1.0",
        CosLoadBalancing::StrategyNotAdaptive::_alloc,
        CosLoadBalancing::_tc_StrategyNotAdaptive
      }
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      3,
      "push_loads",
      10,
      this->the_TAO_Strategy_Proxy_Broker_
    );
  
  _tao_call.invoke (
      _tao_CosLoadBalancing_Strategy_push_loads_exceptiondata,
      1
      ACE_ENV_ARG_PARAMETER
    );
  ACE_CHECK;
}

// TAO_IDL - Generated from
// be/be_visitor_operation/ami_cs.cpp:71

void
CosLoadBalancing::Strategy::sendc_push_loads (
    ::CosLoadBalancing::AMI_StrategyHandler_ptr ami_handler,
    const ::PortableGroup::Location & the_location,
    const ::CosLoadBalancing::LoadList & loads
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_Strategy_Proxy_Broker_ == 0)
    {
      CosLoadBalancing_Strategy_setup_collocation ();
    }
  
  TAO::Arg_Traits<void>::ret_val _tao_retval;
  TAO::Arg_Traits< ::PortableGroup::Location>::in_arg_val _tao_the_location (the_location);
  TAO::Arg_Traits< ::CosLoadBalancing::LoadList>::in_arg_val _tao_loads (loads);
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval,
      &_tao_the_location,
      &_tao_loads
    };
  
  TAO::Asynch_Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      3,
      "push_loads",
      10,
      this->the_TAO_Strategy_Proxy_Broker_
    );
  
  _tao_call.invoke (
      ami_handler,
      &CosLoadBalancing::AMI_StrategyHandler::push_loads_reply_stub
      ACE_ENV_ARG_PARAMETER
    );
  ACE_CHECK;
}

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

::CosLoadBalancing::LoadList * CosLoadBalancing::Strategy::get_loads (
    ::CosLoadBalancing::LoadManager_ptr load_manager,
    const ::PortableGroup::Location & the_location
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException,
    ::CosLoadBalancing::LocationNotFound
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_Strategy_Proxy_Broker_ == 0)
    {
      CosLoadBalancing_Strategy_setup_collocation ();
    }
  
  TAO::Arg_Traits< ::CosLoadBalancing::LoadList>::ret_val _tao_retval;
  TAO::Arg_Traits< ::CosLoadBalancing::LoadManager>::in_arg_val _tao_load_manager (load_manager);
  TAO::Arg_Traits< ::PortableGroup::Location>::in_arg_val _tao_the_location (the_location);
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval,
      &_tao_load_manager,
      &_tao_the_location
    };
  
  static TAO::Exception_Data
  _tao_CosLoadBalancing_Strategy_get_loads_exceptiondata [] = 
    {
      {
        "IDL:omg.org/CosLoadBalancing/LocationNotFound:1.0",
        CosLoadBalancing::LocationNotFound::_alloc,
        CosLoadBalancing::_tc_LocationNotFound
      }
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      3,
      "get_loads",
      9,
      this->the_TAO_Strategy_Proxy_Broker_
    );
  
  _tao_call.invoke (
      _tao_CosLoadBalancing_Strategy_get_loads_exceptiondata,
      1
      ACE_ENV_ARG_PARAMETER
    );
  ACE_CHECK_RETURN (_tao_retval.excp ());
  
  return _tao_retval.retn ();
}

// TAO_IDL - Generated from
// be/be_visitor_operation/ami_cs.cpp:71

void
CosLoadBalancing::Strategy::sendc_get_loads (
    ::CosLoadBalancing::AMI_StrategyHandler_ptr ami_handler,
    ::CosLoadBalancing::LoadManager_ptr load_manager,
    const ::PortableGroup::Location & the_location
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_Strategy_Proxy_Broker_ == 0)
    {
      CosLoadBalancing_Strategy_setup_collocation ();
    }
  
  TAO::Arg_Traits<void>::ret_val _tao_retval;
  TAO::Arg_Traits< ::CosLoadBalancing::LoadManager>::in_arg_val _tao_load_manager (load_manager);
  TAO::Arg_Traits< ::PortableGroup::Location>::in_arg_val _tao_the_location (the_location);
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval,
      &_tao_load_manager,
      &_tao_the_location
    };
  
  TAO::Asynch_Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      3,
      "get_loads",
      9,
      this->the_TAO_Strategy_Proxy_Broker_
    );
  
  _tao_call.invoke (
      ami_handler,
      &CosLoadBalancing::AMI_StrategyHandler::get_loads_reply_stub
      ACE_ENV_ARG_PARAMETER
    );
  ACE_CHECK;
}

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

CORBA::Object_ptr CosLoadBalancing::Strategy::next_member (
    ::PortableGroup::ObjectGroup_ptr object_group,
    ::CosLoadBalancing::LoadManager_ptr load_manager
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException,
    ::PortableGroup::ObjectGroupNotFound,
    ::PortableGroup::MemberNotFound
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_Strategy_Proxy_Broker_ == 0)
    {
      CosLoadBalancing_Strategy_setup_collocation ();
    }
  
  TAO::Arg_Traits< CORBA::Object>::ret_val _tao_retval;
  TAO::Arg_Traits< PortableGroup::ObjectGroup>::in_arg_val _tao_object_group (object_group);
  TAO::Arg_Traits< ::CosLoadBalancing::LoadManager>::in_arg_val _tao_load_manager (load_manager);
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval,
      &_tao_object_group,
      &_tao_load_manager
    };
  
  static TAO::Exception_Data
  _tao_CosLoadBalancing_Strategy_next_member_exceptiondata [] = 
    {
      {
        "IDL:omg.org/PortableGroup/ObjectGroupNotFound:1.0",
        PortableGroup::ObjectGroupNotFound::_alloc,
        PortableGroup::_tc_ObjectGroupNotFound
      },
      
      {
        "IDL:omg.org/PortableGroup/MemberNotFound:1.0",
        PortableGroup::MemberNotFound::_alloc,
        PortableGroup::_tc_MemberNotFound
      }
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      3,
      "next_member",
      11,
      this->the_TAO_Strategy_Proxy_Broker_
    );
  
  _tao_call.invoke (
      _tao_CosLoadBalancing_Strategy_next_member_exceptiondata,
      2
      ACE_ENV_ARG_PARAMETER
    );
  ACE_CHECK_RETURN (_tao_retval.excp ());
  
  return _tao_retval.retn ();
}

// TAO_IDL - Generated from
// be/be_visitor_operation/ami_cs.cpp:71

void
CosLoadBalancing::Strategy::sendc_next_member (
    ::CosLoadBalancing::AMI_StrategyHandler_ptr ami_handler,
    ::PortableGroup::ObjectGroup_ptr object_group,
    ::CosLoadBalancing::LoadManager_ptr load_manager
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_Strategy_Proxy_Broker_ == 0)
    {
      CosLoadBalancing_Strategy_setup_collocation ();
    }
  
  TAO::Arg_Traits<void>::ret_val _tao_retval;
  TAO::Arg_Traits< PortableGroup::ObjectGroup>::in_arg_val _tao_object_group (object_group);
  TAO::Arg_Traits< ::CosLoadBalancing::LoadManager>::in_arg_val _tao_load_manager (load_manager);
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval,
      &_tao_object_group,
      &_tao_load_manager
    };
  
  TAO::Asynch_Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      3,
      "next_member",
      11,
      this->the_TAO_Strategy_Proxy_Broker_
    );
  
  _tao_call.invoke (
      ami_handler,
      &CosLoadBalancing::AMI_StrategyHandler::next_member_reply_stub
      ACE_ENV_ARG_PARAMETER
    );
  ACE_CHECK;
}

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

void CosLoadBalancing::Strategy::analyze_loads (
    ::PortableGroup::ObjectGroup_ptr object_group,
    ::CosLoadBalancing::LoadManager_ptr load_manager
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_Strategy_Proxy_Broker_ == 0)
    {
      CosLoadBalancing_Strategy_setup_collocation ();
    }
  
  TAO::Arg_Traits< void>::ret_val _tao_retval;
  TAO::Arg_Traits< PortableGroup::ObjectGroup>::in_arg_val _tao_object_group (object_group);
  TAO::Arg_Traits< ::CosLoadBalancing::LoadManager>::in_arg_val _tao_load_manager (load_manager);
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval,
      &_tao_object_group,
      &_tao_load_manager
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      3,
      "analyze_loads",
      13,
      this->the_TAO_Strategy_Proxy_Broker_,
      TAO::TAO_ONEWAY_INVOCATION
    );
  
  _tao_call.invoke (0, 0 ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
}

CosLoadBalancing::Strategy::Strategy (void)
 : the_TAO_Strategy_Proxy_Broker_ (0)
{
  this->CosLoadBalancing_Strategy_setup_collocation ();
}

void
CosLoadBalancing::Strategy::CosLoadBalancing_Strategy_setup_collocation ()
{
  if (::CosLoadBalancing__TAO_Strategy_Proxy_Broker_Factory_function_pointer)
    {
      this->the_TAO_Strategy_Proxy_Broker_ =
        ::CosLoadBalancing__TAO_Strategy_Proxy_Broker_Factory_function_pointer (this);
    }
}

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

void 
CosLoadBalancing::Strategy::_tao_any_destructor (void *_tao_void_pointer)
{
  Strategy *_tao_tmp_pointer =
    static_cast<Strategy *> (_tao_void_pointer);
  CORBA::release (_tao_tmp_pointer);
}

CosLoadBalancing::Strategy_ptr
CosLoadBalancing::Strategy::_narrow (
    CORBA::Object_ptr _tao_objref
    ACE_ENV_ARG_DECL
  )
{
  return
    TAO::Narrow_Utils<Strategy>::narrow (
        _tao_objref,
        "IDL:omg.org/CosLoadBalancing/Strategy:1.0",
        CosLoadBalancing__TAO_Strategy_Proxy_Broker_Factory_function_pointer
        ACE_ENV_ARG_PARAMETER
      );
}

CosLoadBalancing::Strategy_ptr
CosLoadBalancing::Strategy::_unchecked_narrow (
    CORBA::Object_ptr _tao_objref
    ACE_ENV_ARG_DECL
  )
{
  return
    TAO::Narrow_Utils<Strategy>::unchecked_narrow (
        _tao_objref,
        "IDL:omg.org/CosLoadBalancing/Strategy:1.0",
        CosLoadBalancing__TAO_Strategy_Proxy_Broker_Factory_function_pointer
        ACE_ENV_ARG_PARAMETER
      );
}

CosLoadBalancing::Strategy_ptr
CosLoadBalancing::Strategy::_duplicate (Strategy_ptr obj)
{
  if (! CORBA::is_nil (obj))
    {
      obj->_add_ref ();
    }
  
  return obj;
}

CORBA::Boolean
CosLoadBalancing::Strategy::_is_a (
    const char *value
    ACE_ENV_ARG_DECL
  )
{
  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; // success using local knowledge
    }
  else
    {
      return this->ACE_NESTED_CLASS (CORBA, Object)::_is_a (
          value
          ACE_ENV_ARG_PARAMETER
        );
    }
}

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

CORBA::Boolean
CosLoadBalancing::Strategy::marshal (TAO_OutputCDR &cdr)
{
  return (cdr << this);
}

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

static const CORBA::Long _oc_CosLoadBalancing_Strategy[] =
{
    TAO_ENCAP_BYTE_ORDER, // byte order
  42,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x436f734c), 
  ACE_NTOHL (0x6f616442), 
  ACE_NTOHL (0x616c616e), 
  ACE_NTOHL (0x63696e67), 
  ACE_NTOHL (0x2f537472), 
  ACE_NTOHL (0x61746567), 
  ACE_NTOHL (0x793a312e), 
  ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CosLoadBalancing/Strategy:1.0
    9,
  ACE_NTOHL (0x53747261), 
  ACE_NTOHL (0x74656779), 
  ACE_NTOHL (0x0),  // name = Strategy
  };

static CORBA::TypeCode _tc_TAO_tc_CosLoadBalancing_Strategy (
    CORBA::tk_objref,
    sizeof (_oc_CosLoadBalancing_Strategy),
    (char *) &_oc_CosLoadBalancing_Strategy,
    0,
    sizeof (CosLoadBalancing::Strategy)
  );

namespace CosLoadBalancing
{
  ::CORBA::TypeCode_ptr _tc_Strategy =
    &_tc_TAO_tc_CosLoadBalancing_Strategy;
}

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

static const CORBA::Long _oc_CosLoadBalancing_AMI_StrategyExceptionHolder[] =
{
    TAO_ENCAP_BYTE_ORDER, // byte order
  9,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x3a312e30), 
  ACE_NTOHL (0x0),  // repository ID = IDL::1.0
    28,
  ACE_NTOHL (0x414d495f), 
  ACE_NTOHL (0x53747261), 
  ACE_NTOHL (0x74656779), 
  ACE_NTOHL (0x45786365), 
  ACE_NTOHL (0x7074696f), 
  ACE_NTOHL (0x6e486f6c), 
  ACE_NTOHL (0x64657200),  // name = AMI_StrategyExceptionHolder
    0, // value modifier
  CORBA::tk_value, // typecode kind
  64, // encapsulation length
    TAO_ENCAP_BYTE_ORDER, // byte order
    24,
    ACE_NTOHL (0x49444c3a), 
    ACE_NTOHL (0x45786365), 
    ACE_NTOHL (0x7074696f), 
    ACE_NTOHL (0x6e486f6c), 
    ACE_NTOHL (0x6465723a), 
    ACE_NTOHL (0x312e3000),  // repository ID = IDL:ExceptionHolder:1.0
        16,
    ACE_NTOHL (0x45786365), 
    ACE_NTOHL (0x7074696f), 
    ACE_NTOHL (0x6e486f6c), 
    ACE_NTOHL (0x64657200),  // name = ExceptionHolder
        0, // value modifier
    CORBA::tk_null, // no stateful base valuetype

0, // member count
    
0, // member count
  };

static CORBA::TypeCode _tc_TAO_tc_CosLoadBalancing_AMI_StrategyExceptionHolder (
    CORBA::tk_value,
    sizeof (_oc_CosLoadBalancing_AMI_StrategyExceptionHolder),
    (char *) &_oc_CosLoadBalancing_AMI_StrategyExceptionHolder,
    0,
    sizeof (CosLoadBalancing::AMI_StrategyExceptionHolder)
  );

namespace CosLoadBalancing
{
  ::CORBA::TypeCode_ptr _tc_AMI_StrategyExceptionHolder =
    &_tc_TAO_tc_CosLoadBalancing_AMI_StrategyExceptionHolder;
}

// TAO_IDL - Generated from
// be/be_visitor_valuetype/valuetype_cs.cpp:66

ACE_TEMPLATE_CLASS_MEMBER_SPECIALIZATION 
void
TAO::Value_Traits<CosLoadBalancing::AMI_StrategyExceptionHolder>::tao_add_ref (
    CosLoadBalancing::AMI_StrategyExceptionHolder * p
  )
{
  CORBA::add_ref (p);
}

ACE_TEMPLATE_CLASS_MEMBER_SPECIALIZATION 
void
TAO::Value_Traits<CosLoadBalancing::AMI_StrategyExceptionHolder>::tao_remove_ref (
    CosLoadBalancing::AMI_StrategyExceptionHolder * p
  )
{
  CORBA::remove_ref (p);
}

ACE_TEMPLATE_CLASS_MEMBER_SPECIALIZATION 
void
TAO::Value_Traits<CosLoadBalancing::AMI_StrategyExceptionHolder>::tao_release (
    CosLoadBalancing::AMI_StrategyExceptionHolder * p
  )
{
  CORBA::remove_ref (p);
}

CosLoadBalancing::AMI_StrategyExceptionHolder *
CosLoadBalancing::AMI_StrategyExceptionHolder::_downcast (CORBA::ValueBase *v)
{
  if (v == 0)
    {
      return 0;
    }
  
  return dynamic_cast< ::CosLoadBalancing::AMI_StrategyExceptionHolder * > (v);
}

const char *
CosLoadBalancing::AMI_StrategyExceptionHolder::_tao_obv_repository_id (void) const
{
  return this->_tao_obv_static_repository_id ();
}

void
CosLoadBalancing::AMI_StrategyExceptionHolder::_tao_any_destructor (void *_tao_void_pointer)
{
  AMI_StrategyExceptionHolder *_tao_tmp_pointer =
    static_cast<
        AMI_StrategyExceptionHolder *> (
        _tao_void_pointer
      );
  CORBA::remove_ref (_tao_tmp_pointer);
}

CORBA::Boolean CosLoadBalancing::AMI_StrategyExceptionHolder::_tao_marshal_v (TAO_OutputCDR & strm)
{
  return this->_tao_marshal__CosLoadBalancing_AMI_StrategyExceptionHolder (strm);
}

CORBA::Boolean CosLoadBalancing::AMI_StrategyExceptionHolder::_tao_unmarshal_v (TAO_InputCDR & strm)
{
  return this->_tao_unmarshal__CosLoadBalancing_AMI_StrategyExceptionHolder (strm);
}

CORBA::Boolean CosLoadBalancing::AMI_StrategyExceptionHolder::_tao_unmarshal (
    TAO_InputCDR &strm,
    AMI_StrategyExceptionHolder *&new_object
  )
{
  CORBA::ValueBase *base = 0;
  CORBA::ValueFactory_var factory;
  CORBA::Boolean retval =
    CORBA::ValueBase::_tao_unmarshal_pre (
        strm,
        factory.out (),
        base,
        AMI_StrategyExceptionHolder::_tao_obv_static_repository_id ()
      );
  
  if (retval == 0)
    {
      return 0;
    }
  
  if (factory.in () != 0)
    {
      base = factory->create_for_unmarshal ();
      
      if (base == 0)
        {
          return 0;  // %! except.?
        }
      
      retval = base->_tao_unmarshal_v (strm);
      
      if (retval == 0)
        {
          return 0;
        }
    }
  
  // Now base must be null or point to the unmarshaled object.
  // Align the pointer to the right subobject.
  new_object = AMI_StrategyExceptionHolder::_downcast (base);
  return retval;
}

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

// Traits specializations for CosLoadBalancing::AMI_StrategyHandler.

ACE_TEMPLATE_CLASS_MEMBER_SPECIALIZATION
CosLoadBalancing::AMI_StrategyHandler_ptr
TAO::Objref_Traits<CosLoadBalancing::AMI_StrategyHandler>::tao_duplicate (
    CosLoadBalancing::AMI_StrategyHandler_ptr p
  )
{
  return CosLoadBalancing::AMI_StrategyHandler::_duplicate (p);
}

ACE_TEMPLATE_CLASS_MEMBER_SPECIALIZATION
void
TAO::Objref_Traits<CosLoadBalancing::AMI_StrategyHandler>::tao_release (
    CosLoadBalancing::AMI_StrategyHandler_ptr p
  )
{
  CORBA::release (p);
}

ACE_TEMPLATE_CLASS_MEMBER_SPECIALIZATION
CosLoadBalancing::AMI_StrategyHandler_ptr
TAO::Objref_Traits<CosLoadBalancing::AMI_StrategyHandler>::tao_nil (void)
{
  return CosLoadBalancing::AMI_StrategyHandler::_nil ();
}

ACE_TEMPLATE_CLASS_MEMBER_SPECIALIZATION
CORBA::Boolean
TAO::Objref_Traits<CosLoadBalancing::AMI_StrategyHandler>::tao_marshal (
    CosLoadBalancing::AMI_StrategyHandler_ptr p,
    TAO_OutputCDR & cdr
  )
{
  return CORBA::Object::marshal (p, cdr);
}

// Function pointer for collocation factory initialization.
TAO::Collocation_Proxy_Broker * 
(*CosLoadBalancing__TAO_AMI_StrategyHandler_Proxy_Broker_Factory_function_pointer) (
    CORBA::Object_ptr obj
  ) = 0;

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

void CosLoadBalancing::AMI_StrategyHandler::get_name (
    const char * ami_return_val
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_AMI_StrategyHandler_Proxy_Broker_ == 0)
    {
      CosLoadBalancing_AMI_StrategyHandler_setup_collocation ();
    }
  
  TAO::Arg_Traits< void>::ret_val _tao_retval;
  TAO::Arg_Traits< ::CORBA::Char *>::in_arg_val _tao_ami_return_val (ami_return_val);
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval,
      &_tao_ami_return_val
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      2,
      "get_name",
      8,
      this->the_TAO_AMI_StrategyHandler_Proxy_Broker_
    );
  
  _tao_call.invoke (0, 0 ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
}
void
CosLoadBalancing::AMI_StrategyHandler::get_name_reply_stub (
  TAO_InputCDR &_tao_in, 
  Messaging::ReplyHandler_ptr _tao_reply_handler,
  CORBA::ULong reply_status
  ACE_ENV_ARG_DECL)
{
  // Retrieve Reply Handler object.
  CosLoadBalancing::AMI_StrategyHandler_var _tao_reply_handler_object =
    CosLoadBalancing::AMI_StrategyHandler::_narrow (_tao_reply_handler ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
  
  // Exception handling
  switch (reply_status)
  {
    case TAO_AMI_REPLY_OK:
    {

      ::CORBA::String_var ami_return_val;      // Demarshall all the arguments.
      if (!(

            (_tao_in >> ami_return_val.out ())
         ))
        ACE_THROW (CORBA::MARSHAL ());
      
      // Invoke the call back method.
      _tao_reply_handler_object->get_name (
          
          ami_return_val.in ()
          ACE_ENV_ARG_PARAMETER
        );
      ACE_CHECK;
      break;
    }
    case TAO_AMI_REPLY_USER_EXCEPTION:
    case TAO_AMI_REPLY_SYSTEM_EXCEPTION:
    {
      const ACE_Message_Block* cdr = _tao_in.start ();
      
      AMI_StrategyExceptionHolder_var exception_holder_var;
      ACE_NEW (
          exception_holder_var,
          OBV_CosLoadBalancing::_tao_AMI_StrategyExceptionHolder ()
        );
      
      CORBA::OctetSeq _tao_marshaled_exception (
          cdr->length (),
          cdr->length (),
          (unsigned char*) cdr->rd_ptr (),
          0
        );
      exception_holder_var->marshaled_exception (_tao_marshaled_exception);
      
      if (reply_status == TAO_AMI_REPLY_SYSTEM_EXCEPTION)
        exception_holder_var->is_system_exception (1);
      else
        exception_holder_var->is_system_exception (0);
      
      exception_holder_var->byte_order (_tao_in.byte_order ());
      
      _tao_reply_handler_object->get_name_excep (
          exception_holder_var ACE_ENV_ARG_PARAMETER
        );
      ACE_CHECK;
      break;
    }
    case TAO_AMI_REPLY_NOT_OK:
      // @@ Michael: Not even the spec mentions this case.
      //             We have to think about this case.
      break;
  }
}



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

void CosLoadBalancing::AMI_StrategyHandler::get_name_excep (
    ::CosLoadBalancing::AMI_StrategyExceptionHolder * excep_holder
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_AMI_StrategyHandler_Proxy_Broker_ == 0)
    {
      CosLoadBalancing_AMI_StrategyHandler_setup_collocation ();
    }
  
  TAO::Arg_Traits< void>::ret_val _tao_retval;
  TAO::Arg_Traits< ::CosLoadBalancing::AMI_StrategyExceptionHolder>::in_arg_val _tao_excep_holder (excep_holder);
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval,
      &_tao_excep_holder
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      2,
      "get_name_excep",
      14,
      this->the_TAO_AMI_StrategyHandler_Proxy_Broker_
    );
  
  _tao_call.invoke (0, 0 ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
}

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

void CosLoadBalancing::AMI_StrategyHandler::get_properties (
    const ::CosLoadBalancing::Properties & ami_return_val
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_AMI_StrategyHandler_Proxy_Broker_ == 0)
    {
      CosLoadBalancing_AMI_StrategyHandler_setup_collocation ();
    }
  
  TAO::Arg_Traits< void>::ret_val _tao_retval;
  TAO::Arg_Traits< ::CosLoadBalancing::Properties>::in_arg_val _tao_ami_return_val (ami_return_val);
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval,
      &_tao_ami_return_val
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      2,
      "get_properties",
      14,
      this->the_TAO_AMI_StrategyHandler_Proxy_Broker_
    );
  
  _tao_call.invoke (0, 0 ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
}
void
CosLoadBalancing::AMI_StrategyHandler::get_properties_reply_stub (
  TAO_InputCDR &_tao_in, 
  Messaging::ReplyHandler_ptr _tao_reply_handler,
  CORBA::ULong reply_status
  ACE_ENV_ARG_DECL)
{
  // Retrieve Reply Handler object.
  CosLoadBalancing::AMI_StrategyHandler_var _tao_reply_handler_object =
    CosLoadBalancing::AMI_StrategyHandler::_narrow (_tao_reply_handler ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
  
  // Exception handling
  switch (reply_status)
  {
    case TAO_AMI_REPLY_OK:
    {

      ::CosLoadBalancing::Properties ami_return_val;      // Demarshall all the arguments.
      if (!(

            (_tao_in >> ami_return_val)
         ))
        ACE_THROW (CORBA::MARSHAL ());
      
      // Invoke the call back method.
      _tao_reply_handler_object->get_properties (
          
          ami_return_val
          ACE_ENV_ARG_PARAMETER
        );
      ACE_CHECK;
      break;
    }
    case TAO_AMI_REPLY_USER_EXCEPTION:
    case TAO_AMI_REPLY_SYSTEM_EXCEPTION:
    {
      const ACE_Message_Block* cdr = _tao_in.start ();
      
      AMI_StrategyExceptionHolder_var exception_holder_var;
      ACE_NEW (
          exception_holder_var,
          OBV_CosLoadBalancing::_tao_AMI_StrategyExceptionHolder ()
        );
      
      CORBA::OctetSeq _tao_marshaled_exception (
          cdr->length (),
          cdr->length (),
          (unsigned char*) cdr->rd_ptr (),
          0
        );
      exception_holder_var->marshaled_exception (_tao_marshaled_exception);
      
      if (reply_status == TAO_AMI_REPLY_SYSTEM_EXCEPTION)
        exception_holder_var->is_system_exception (1);
      else
        exception_holder_var->is_system_exception (0);
      
      exception_holder_var->byte_order (_tao_in.byte_order ());
      
      _tao_reply_handler_object->get_properties_excep (
          exception_holder_var ACE_ENV_ARG_PARAMETER
        );
      ACE_CHECK;
      break;
    }
    case TAO_AMI_REPLY_NOT_OK:
      // @@ Michael: Not even the spec mentions this case.
      //             We have to think about this case.
      break;
  }
}



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

void CosLoadBalancing::AMI_StrategyHandler::get_properties_excep (
    ::CosLoadBalancing::AMI_StrategyExceptionHolder * excep_holder
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_AMI_StrategyHandler_Proxy_Broker_ == 0)
    {
      CosLoadBalancing_AMI_StrategyHandler_setup_collocation ();
    }
  
  TAO::Arg_Traits< void>::ret_val _tao_retval;
  TAO::Arg_Traits< ::CosLoadBalancing::AMI_StrategyExceptionHolder>::in_arg_val _tao_excep_holder (excep_holder);
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval,
      &_tao_excep_holder
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      2,
      "get_properties_excep",
      20,
      this->the_TAO_AMI_StrategyHandler_Proxy_Broker_
    );
  
  _tao_call.invoke (0, 0 ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
}

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

void CosLoadBalancing::AMI_StrategyHandler::push_loads (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_AMI_StrategyHandler_Proxy_Broker_ == 0)
    {
      CosLoadBalancing_AMI_StrategyHandler_setup_collocation ();
    }
  
  TAO::Arg_Traits< void>::ret_val _tao_retval;
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      1,
      "push_loads",
      10,
      this->the_TAO_AMI_StrategyHandler_Proxy_Broker_
    );
  
  _tao_call.invoke (0, 0 ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
}
void
CosLoadBalancing::AMI_StrategyHandler::push_loads_reply_stub (
  TAO_InputCDR &_tao_in, 
  Messaging::ReplyHandler_ptr _tao_reply_handler,
  CORBA::ULong reply_status
  ACE_ENV_ARG_DECL)
{
  // Retrieve Reply Handler object.
  CosLoadBalancing::AMI_StrategyHandler_var _tao_reply_handler_object =
    CosLoadBalancing::AMI_StrategyHandler::_narrow (_tao_reply_handler ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
  
  // Exception handling
  switch (reply_status)
  {
    case TAO_AMI_REPLY_OK:
    {
      // Demarshall all the arguments.
      // Invoke the call back method.
      _tao_reply_handler_object->push_loads (
          
          ACE_ENV_SINGLE_ARG_PARAMETER
        );
      ACE_CHECK;
      break;
    }
    case TAO_AMI_REPLY_USER_EXCEPTION:
    case TAO_AMI_REPLY_SYSTEM_EXCEPTION:
    {
      const ACE_Message_Block* cdr = _tao_in.start ();
      
      AMI_StrategyExceptionHolder_var exception_holder_var;
      ACE_NEW (
          exception_holder_var,
          OBV_CosLoadBalancing::_tao_AMI_StrategyExceptionHolder ()
        );
      
      CORBA::OctetSeq _tao_marshaled_exception (
          cdr->length (),
          cdr->length (),
          (unsigned char*) cdr->rd_ptr (),
          0
        );
      exception_holder_var->marshaled_exception (_tao_marshaled_exception);
      
      if (reply_status == TAO_AMI_REPLY_SYSTEM_EXCEPTION)
        exception_holder_var->is_system_exception (1);
      else
        exception_holder_var->is_system_exception (0);
      
      exception_holder_var->byte_order (_tao_in.byte_order ());
      
      _tao_reply_handler_object->push_loads_excep (
          exception_holder_var ACE_ENV_ARG_PARAMETER
        );
      ACE_CHECK;
      break;
    }
    case TAO_AMI_REPLY_NOT_OK:
      // @@ Michael: Not even the spec mentions this case.
      //             We have to think about this case.
      break;
  }
}



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

void CosLoadBalancing::AMI_StrategyHandler::push_loads_excep (
    ::CosLoadBalancing::AMI_StrategyExceptionHolder * excep_holder
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_AMI_StrategyHandler_Proxy_Broker_ == 0)
    {
      CosLoadBalancing_AMI_StrategyHandler_setup_collocation ();
    }
  
  TAO::Arg_Traits< void>::ret_val _tao_retval;
  TAO::Arg_Traits< ::CosLoadBalancing::AMI_StrategyExceptionHolder>::in_arg_val _tao_excep_holder (excep_holder);
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval,
      &_tao_excep_holder
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      2,
      "push_loads_excep",
      16,
      this->the_TAO_AMI_StrategyHandler_Proxy_Broker_
    );
  
  _tao_call.invoke (0, 0 ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
}

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

void CosLoadBalancing::AMI_StrategyHandler::get_loads (
    const ::CosLoadBalancing::LoadList & ami_return_val
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_AMI_StrategyHandler_Proxy_Broker_ == 0)
    {
      CosLoadBalancing_AMI_StrategyHandler_setup_collocation ();
    }
  
  TAO::Arg_Traits< void>::ret_val _tao_retval;
  TAO::Arg_Traits< ::CosLoadBalancing::LoadList>::in_arg_val _tao_ami_return_val (ami_return_val);
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval,
      &_tao_ami_return_val
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      2,
      "get_loads",
      9,
      this->the_TAO_AMI_StrategyHandler_Proxy_Broker_
    );
  
  _tao_call.invoke (0, 0 ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
}
void
CosLoadBalancing::AMI_StrategyHandler::get_loads_reply_stub (
  TAO_InputCDR &_tao_in, 
  Messaging::ReplyHandler_ptr _tao_reply_handler,
  CORBA::ULong reply_status
  ACE_ENV_ARG_DECL)
{
  // Retrieve Reply Handler object.
  CosLoadBalancing::AMI_StrategyHandler_var _tao_reply_handler_object =
    CosLoadBalancing::AMI_StrategyHandler::_narrow (_tao_reply_handler ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
  
  // Exception handling
  switch (reply_status)
  {
    case TAO_AMI_REPLY_OK:
    {

      ::CosLoadBalancing::LoadList ami_return_val;      // Demarshall all the arguments.
      if (!(

            (_tao_in >> ami_return_val)
         ))
        ACE_THROW (CORBA::MARSHAL ());
      
      // Invoke the call back method.
      _tao_reply_handler_object->get_loads (
          
          ami_return_val
          ACE_ENV_ARG_PARAMETER
        );
      ACE_CHECK;
      break;
    }
    case TAO_AMI_REPLY_USER_EXCEPTION:
    case TAO_AMI_REPLY_SYSTEM_EXCEPTION:
    {
      const ACE_Message_Block* cdr = _tao_in.start ();
      
      AMI_StrategyExceptionHolder_var exception_holder_var;
      ACE_NEW (
          exception_holder_var,
          OBV_CosLoadBalancing::_tao_AMI_StrategyExceptionHolder ()
        );
      
      CORBA::OctetSeq _tao_marshaled_exception (
          cdr->length (),
          cdr->length (),
          (unsigned char*) cdr->rd_ptr (),
          0
        );
      exception_holder_var->marshaled_exception (_tao_marshaled_exception);
      
      if (reply_status == TAO_AMI_REPLY_SYSTEM_EXCEPTION)
        exception_holder_var->is_system_exception (1);
      else
        exception_holder_var->is_system_exception (0);
      
      exception_holder_var->byte_order (_tao_in.byte_order ());
      
      _tao_reply_handler_object->get_loads_excep (
          exception_holder_var ACE_ENV_ARG_PARAMETER
        );
      ACE_CHECK;
      break;
    }
    case TAO_AMI_REPLY_NOT_OK:
      // @@ Michael: Not even the spec mentions this case.
      //             We have to think about this case.
      break;
  }
}



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

void CosLoadBalancing::AMI_StrategyHandler::get_loads_excep (
    ::CosLoadBalancing::AMI_StrategyExceptionHolder * excep_holder
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_AMI_StrategyHandler_Proxy_Broker_ == 0)
    {
      CosLoadBalancing_AMI_StrategyHandler_setup_collocation ();
    }
  
  TAO::Arg_Traits< void>::ret_val _tao_retval;
  TAO::Arg_Traits< ::CosLoadBalancing::AMI_StrategyExceptionHolder>::in_arg_val _tao_excep_holder (excep_holder);
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval,
      &_tao_excep_holder
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      2,
      "get_loads_excep",
      15,
      this->the_TAO_AMI_StrategyHandler_Proxy_Broker_
    );
  
  _tao_call.invoke (0, 0 ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
}

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

void CosLoadBalancing::AMI_StrategyHandler::next_member (
    ::CORBA::Object_ptr ami_return_val
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_AMI_StrategyHandler_Proxy_Broker_ == 0)
    {
      CosLoadBalancing_AMI_StrategyHandler_setup_collocation ();
    }
  
  TAO::Arg_Traits< void>::ret_val _tao_retval;
  TAO::Arg_Traits< CORBA::Object>::in_arg_val _tao_ami_return_val (ami_return_val);
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval,
      &_tao_ami_return_val
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      2,
      "next_member",
      11,
      this->the_TAO_AMI_StrategyHandler_Proxy_Broker_
    );
  
  _tao_call.invoke (0, 0 ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
}
void
CosLoadBalancing::AMI_StrategyHandler::next_member_reply_stub (
  TAO_InputCDR &_tao_in, 
  Messaging::ReplyHandler_ptr _tao_reply_handler,
  CORBA::ULong reply_status
  ACE_ENV_ARG_DECL)
{
  // Retrieve Reply Handler object.
  CosLoadBalancing::AMI_StrategyHandler_var _tao_reply_handler_object =
    CosLoadBalancing::AMI_StrategyHandler::_narrow (_tao_reply_handler ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
  
  // Exception handling
  switch (reply_status)
  {
    case TAO_AMI_REPLY_OK:
    {

      ::CORBA::Object_var ami_return_val;      // Demarshall all the arguments.
      if (!(

            (_tao_in >> ami_return_val.out ())
         ))
        ACE_THROW (CORBA::MARSHAL ());
      
      // Invoke the call back method.
      _tao_reply_handler_object->next_member (
          
          ami_return_val.in ()
          ACE_ENV_ARG_PARAMETER
        );
      ACE_CHECK;
      break;
    }
    case TAO_AMI_REPLY_USER_EXCEPTION:
    case TAO_AMI_REPLY_SYSTEM_EXCEPTION:
    {
      const ACE_Message_Block* cdr = _tao_in.start ();
      
      AMI_StrategyExceptionHolder_var exception_holder_var;
      ACE_NEW (
          exception_holder_var,
          OBV_CosLoadBalancing::_tao_AMI_StrategyExceptionHolder ()
        );
      
      CORBA::OctetSeq _tao_marshaled_exception (
          cdr->length (),
          cdr->length (),
          (unsigned char*) cdr->rd_ptr (),
          0
        );
      exception_holder_var->marshaled_exception (_tao_marshaled_exception);
      
      if (reply_status == TAO_AMI_REPLY_SYSTEM_EXCEPTION)
        exception_holder_var->is_system_exception (1);
      else
        exception_holder_var->is_system_exception (0);
      
      exception_holder_var->byte_order (_tao_in.byte_order ());
      
      _tao_reply_handler_object->next_member_excep (
          exception_holder_var ACE_ENV_ARG_PARAMETER
        );
      ACE_CHECK;
      break;
    }
    case TAO_AMI_REPLY_NOT_OK:
      // @@ Michael: Not even the spec mentions this case.
      //             We have to think about this case.
      break;
  }
}



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

void CosLoadBalancing::AMI_StrategyHandler::next_member_excep (
    ::CosLoadBalancing::AMI_StrategyExceptionHolder * excep_holder
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_AMI_StrategyHandler_Proxy_Broker_ == 0)
    {
      CosLoadBalancing_AMI_StrategyHandler_setup_collocation ();
    }
  
  TAO::Arg_Traits< void>::ret_val _tao_retval;
  TAO::Arg_Traits< ::CosLoadBalancing::AMI_StrategyExceptionHolder>::in_arg_val _tao_excep_holder (excep_holder);
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval,
      &_tao_excep_holder
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      2,
      "next_member_excep",
      17,
      this->the_TAO_AMI_StrategyHandler_Proxy_Broker_
    );
  
  _tao_call.invoke (0, 0 ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
}

CosLoadBalancing::AMI_StrategyHandler::AMI_StrategyHandler (void)
 : the_TAO_AMI_StrategyHandler_Proxy_Broker_ (0)
{
  this->CosLoadBalancing_AMI_StrategyHandler_setup_collocation ();
}

void
CosLoadBalancing::AMI_StrategyHandler::CosLoadBalancing_AMI_StrategyHandler_setup_collocation ()
{
  if (::CosLoadBalancing__TAO_AMI_StrategyHandler_Proxy_Broker_Factory_function_pointer)
    {
      this->the_TAO_AMI_StrategyHandler_Proxy_Broker_ =
        ::CosLoadBalancing__TAO_AMI_StrategyHandler_Proxy_Broker_Factory_function_pointer (this);
    }
  
  this->Messaging_ReplyHandler_setup_collocation ();
}

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

void 
CosLoadBalancing::AMI_StrategyHandler::_tao_any_destructor (void *_tao_void_pointer)
{
  AMI_StrategyHandler *_tao_tmp_pointer =
    static_cast<AMI_StrategyHandler *> (_tao_void_pointer);
  CORBA::release (_tao_tmp_pointer);
}

CosLoadBalancing::AMI_StrategyHandler_ptr
CosLoadBalancing::AMI_StrategyHandler::_narrow (
    CORBA::Object_ptr _tao_objref
    ACE_ENV_ARG_DECL
  )
{
  return
    TAO::Narrow_Utils<AMI_StrategyHandler>::narrow (
        _tao_objref,
        "IDL:AMI_StrategyHandler:1.0",
        CosLoadBalancing__TAO_AMI_StrategyHandler_Proxy_Broker_Factory_function_pointer
        ACE_ENV_ARG_PARAMETER
      );
}

CosLoadBalancing::AMI_StrategyHandler_ptr
CosLoadBalancing::AMI_StrategyHandler::_unchecked_narrow (
    CORBA::Object_ptr _tao_objref
    ACE_ENV_ARG_DECL
  )
{
  return
    TAO::Narrow_Utils<AMI_StrategyHandler>::unchecked_narrow (
        _tao_objref,
        "IDL:AMI_StrategyHandler:1.0",
        CosLoadBalancing__TAO_AMI_StrategyHandler_Proxy_Broker_Factory_function_pointer
        ACE_ENV_ARG_PARAMETER
      );
}

CosLoadBalancing::AMI_StrategyHandler_ptr
CosLoadBalancing::AMI_StrategyHandler::_duplicate (AMI_StrategyHandler_ptr obj)
{
  if (! CORBA::is_nil (obj))
    {
      obj->_add_ref ();
    }
  
  return obj;
}

CORBA::Boolean
CosLoadBalancing::AMI_StrategyHandler::_is_a (
    const char *value
    ACE_ENV_ARG_DECL
  )
{
  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; // success using local knowledge
    }
  else
    {
      return this->ACE_NESTED_CLASS (CORBA, Object)::_is_a (
          value
          ACE_ENV_ARG_PARAMETER
        );
    }
}

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

CORBA::Boolean
CosLoadBalancing::AMI_StrategyHandler::marshal (TAO_OutputCDR &cdr)
{
  return (cdr << this);
}

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

static const CORBA::Long _oc_CosLoadBalancing_AMI_StrategyHandler[] =
{
    TAO_ENCAP_BYTE_ORDER, // byte order
  28,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x414d495f), 
  ACE_NTOHL (0x53747261), 
  ACE_NTOHL (0x74656779), 
  ACE_NTOHL (0x48616e64), 
  ACE_NTOHL (0x6c65723a), 
  ACE_NTOHL (0x312e3000),  // repository ID = IDL:AMI_StrategyHandler:1.0
    20,
  ACE_NTOHL (0x414d495f), 
  ACE_NTOHL (0x53747261), 
  ACE_NTOHL (0x74656779), 
  ACE_NTOHL (0x48616e64), 
  ACE_NTOHL (0x6c657200),  // name = AMI_StrategyHandler
  };

static CORBA::TypeCode _tc_TAO_tc_CosLoadBalancing_AMI_StrategyHandler (
    CORBA::tk_objref,
    sizeof (_oc_CosLoadBalancing_AMI_StrategyHandler),
    (char *) &_oc_CosLoadBalancing_AMI_StrategyHandler,
    0,
    sizeof (CosLoadBalancing::AMI_StrategyHandler)
  );

namespace CosLoadBalancing
{
  ::CORBA::TypeCode_ptr _tc_AMI_StrategyHandler =
    &_tc_TAO_tc_CosLoadBalancing_AMI_StrategyHandler;
}

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

static const CORBA::Long _oc_CosLoadBalancing_CustomStrategy[] =
{
    TAO_ENCAP_BYTE_ORDER, // byte order
  48,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x436f734c), 
  ACE_NTOHL (0x6f616442), 
  ACE_NTOHL (0x616c616e), 
  ACE_NTOHL (0x63696e67), 
  ACE_NTOHL (0x2f437573), 
  ACE_NTOHL (0x746f6d53), 
  ACE_NTOHL (0x74726174), 
  ACE_NTOHL (0x6567793a), 
  ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CosLoadBalancing/CustomStrategy:1.0
    15,
  ACE_NTOHL (0x43757374), 
  ACE_NTOHL (0x6f6d5374), 
  ACE_NTOHL (0x72617465), 
  ACE_NTOHL (0x67790000),  // name = CustomStrategy
    CORBA::tk_objref, // typecode kind
  68, // encapsulation length
    TAO_ENCAP_BYTE_ORDER, // byte order
    42,
    ACE_NTOHL (0x49444c3a), 
    ACE_NTOHL (0x6f6d672e), 
    ACE_NTOHL (0x6f72672f), 
    ACE_NTOHL (0x436f734c), 
    ACE_NTOHL (0x6f616442), 
    ACE_NTOHL (0x616c616e), 
    ACE_NTOHL (0x63696e67), 
    ACE_NTOHL (0x2f537472), 
    ACE_NTOHL (0x61746567), 
    ACE_NTOHL (0x793a312e), 
    ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CosLoadBalancing/Strategy:1.0
        9,
    ACE_NTOHL (0x53747261), 
    ACE_NTOHL (0x74656779), 
    ACE_NTOHL (0x0),  // name = Strategy
    
};

static CORBA::TypeCode _tc_TAO_tc_CosLoadBalancing_CustomStrategy (
    CORBA::tk_alias,
    sizeof (_oc_CosLoadBalancing_CustomStrategy),
    (char *) &_oc_CosLoadBalancing_CustomStrategy,
    0,
    sizeof (CosLoadBalancing::CustomStrategy)
  );

namespace CosLoadBalancing
{
  ::CORBA::TypeCode_ptr _tc_CustomStrategy =
    &_tc_TAO_tc_CosLoadBalancing_CustomStrategy;
}

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

static const CORBA::Long _oc_CosLoadBalancing_StrategyInfo[] =
{
    TAO_ENCAP_BYTE_ORDER, // byte order
  46,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x436f734c), 
  ACE_NTOHL (0x6f616442), 
  ACE_NTOHL (0x616c616e), 
  ACE_NTOHL (0x63696e67), 
  ACE_NTOHL (0x2f537472), 
  ACE_NTOHL (0x61746567), 
  ACE_NTOHL (0x79496e66), 
  ACE_NTOHL (0x6f3a312e), 
  ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CosLoadBalancing/StrategyInfo:1.0
    13,
  ACE_NTOHL (0x53747261), 
  ACE_NTOHL (0x74656779), 
  ACE_NTOHL (0x496e666f), 
  ACE_NTOHL (0x0),  // name = StrategyInfo
  2, // member count
    5,
  ACE_NTOHL (0x6e616d65), 
  ACE_NTOHL (0x0),  // name = name
    CORBA::tk_string, 
  0U, // string length
  6,
  ACE_NTOHL (0x70726f70), 
  ACE_NTOHL (0x73000000),  // name = props
    CORBA::tk_alias, // typecode kind for typedefs
  704, // encapsulation length
    TAO_ENCAP_BYTE_ORDER, // byte order
    44,
    ACE_NTOHL (0x49444c3a), 
    ACE_NTOHL (0x6f6d672e), 
    ACE_NTOHL (0x6f72672f), 
    ACE_NTOHL (0x436f734c), 
    ACE_NTOHL (0x6f616442), 
    ACE_NTOHL (0x616c616e), 
    ACE_NTOHL (0x63696e67), 
    ACE_NTOHL (0x2f50726f), 
    ACE_NTOHL (0x70657274), 
    ACE_NTOHL (0x6965733a), 
    ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CosLoadBalancing/Properties:1.0
        11,
    ACE_NTOHL (0x50726f70), 
    ACE_NTOHL (0x65727469), 
    ACE_NTOHL (0x65730000),  // name = Properties
        CORBA::tk_alias, // typecode kind for typedefs
    628, // encapsulation length
      TAO_ENCAP_BYTE_ORDER, // byte order
      41,
      ACE_NTOHL (0x49444c3a), 
      ACE_NTOHL (0x6f6d672e), 
      ACE_NTOHL (0x6f72672f), 
      ACE_NTOHL (0x506f7274), 
      ACE_NTOHL (0x61626c65), 
      ACE_NTOHL (0x47726f75), 
      ACE_NTOHL (0x702f5072), 
      ACE_NTOHL (0x6f706572), 
      ACE_NTOHL (0x74696573), 
      ACE_NTOHL (0x3a312e30), 
      ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/PortableGroup/Properties:1.0
            11,
      ACE_NTOHL (0x50726f70), 
      ACE_NTOHL (0x65727469), 
      ACE_NTOHL (0x65730000),  // name = Properties
            CORBA::tk_sequence, // typecode kind
      552, // encapsulation length
        TAO_ENCAP_BYTE_ORDER, // byte order
        CORBA::tk_struct, // typecode kind
        536, // encapsulation length
          TAO_ENCAP_BYTE_ORDER, // byte order
          39,
          ACE_NTOHL (0x49444c3a), 
          ACE_NTOHL (0x6f6d672e), 
          ACE_NTOHL (0x6f72672f), 
          ACE_NTOHL (0x506f7274), 
          ACE_NTOHL (0x61626c65), 
          ACE_NTOHL (0x47726f75), 
          ACE_NTOHL (0x702f5072), 
          ACE_NTOHL (0x6f706572), 
          ACE_NTOHL (0x74793a31), 
          ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/PortableGroup/Property:1.0
                    9,
          ACE_NTOHL (0x50726f70), 
          ACE_NTOHL (0x65727479), 
          ACE_NTOHL (0x0),  // name = Property
          2, // member count
                    4,
          ACE_NTOHL (0x6e616d00),  // name = nam
                    CORBA::tk_alias, // typecode kind for typedefs
          376, // encapsulation length
            TAO_ENCAP_BYTE_ORDER, // byte order
            35,
            ACE_NTOHL (0x49444c3a), 
            ACE_NTOHL (0x6f6d672e), 
            ACE_NTOHL (0x6f72672f), 
            ACE_NTOHL (0x506f7274), 
            ACE_NTOHL (0x61626c65), 
            ACE_NTOHL (0x47726f75), 
            ACE_NTOHL (0x702f4e61), 
            ACE_NTOHL (0x6d653a31), 
            ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/PortableGroup/Name:1.0
                        5,
            ACE_NTOHL (0x4e616d65), 
            ACE_NTOHL (0x0),  // name = Name
                        CORBA::tk_alias, // typecode kind for typedefs
            312, // encapsulation length
              TAO_ENCAP_BYTE_ORDER, // byte order
              31,
              ACE_NTOHL (0x49444c3a), 
              ACE_NTOHL (0x6f6d672e), 
              ACE_NTOHL (0x6f72672f), 
              ACE_NTOHL (0x436f734e), 
              ACE_NTOHL (0x616d696e), 
              ACE_NTOHL (0x672f4e61), 
              ACE_NTOHL (0x6d653a31), 
              ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CosNaming/Name:1.0
                            5,
              ACE_NTOHL (0x4e616d65), 
              ACE_NTOHL (0x0),  // name = Name
                            CORBA::tk_sequence, // typecode kind
              252, // encapsulation length
                TAO_ENCAP_BYTE_ORDER, // byte order
                CORBA::tk_struct, // typecode kind
                236, // encapsulation length
                  TAO_ENCAP_BYTE_ORDER, // byte order
                  40,
                  ACE_NTOHL (0x49444c3a), 
                  ACE_NTOHL (0x6f6d672e), 
                  ACE_NTOHL (0x6f72672f), 
                  ACE_NTOHL (0x436f734e), 
                  ACE_NTOHL (0x616d696e), 
                  ACE_NTOHL (0x672f4e61), 
                  ACE_NTOHL (0x6d65436f), 
                  ACE_NTOHL (0x6d706f6e), 
                  ACE_NTOHL (0x656e743a), 
                  ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CosNaming/NameComponent:1.0
                                    14,
                  ACE_NTOHL (0x4e616d65), 
                  ACE_NTOHL (0x436f6d70), 
                  ACE_NTOHL (0x6f6e656e), 
                  ACE_NTOHL (0x74000000),  // name = NameComponent
                  2, // member count
                                    3,
                  ACE_NTOHL (0x69640000),  // name = id
                                    CORBA::tk_alias, // typecode kind for typedefs
                  64, // encapsulation length
                    TAO_ENCAP_BYTE_ORDER, // byte order
                    34,
                    ACE_NTOHL (0x49444c3a), 
                    ACE_NTOHL (0x6f6d672e), 
                    ACE_NTOHL (0x6f72672f), 
                    ACE_NTOHL (0x436f734e), 
                    ACE_NTOHL (0x616d696e), 
                    ACE_NTOHL (0x672f4973), 
                    ACE_NTOHL (0x7472696e), 
                    ACE_NTOHL (0x673a312e), 
                    ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CosNaming/Istring:1.0
                                        8,
                    ACE_NTOHL (0x49737472), 
                    ACE_NTOHL (0x696e6700),  // name = Istring
                                        CORBA::tk_string, 
                    0U, // string length

                  5,
                  ACE_NTOHL (0x6b696e64), 
                  ACE_NTOHL (0x0),  // name = kind
                                    CORBA::tk_alias, // typecode kind for typedefs
                  64, // encapsulation length
                    TAO_ENCAP_BYTE_ORDER, // byte order
                    34,
                    ACE_NTOHL (0x49444c3a), 
                    ACE_NTOHL (0x6f6d672e), 
                    ACE_NTOHL (0x6f72672f), 
                    ACE_NTOHL (0x436f734e), 
                    ACE_NTOHL (0x616d696e), 
                    ACE_NTOHL (0x672f4973), 
                    ACE_NTOHL (0x7472696e), 
                    ACE_NTOHL (0x673a312e), 
                    ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CosNaming/Istring:1.0
                                        8,
                    ACE_NTOHL (0x49737472), 
                    ACE_NTOHL (0x696e6700),  // name = Istring
                                        CORBA::tk_string, 
                    0U, // string length


                0U,



          4,
          ACE_NTOHL (0x76616c00),  // name = val
                    CORBA::tk_alias, // typecode kind for typedefs
          60, // encapsulation length
            TAO_ENCAP_BYTE_ORDER, // byte order
            36,
            ACE_NTOHL (0x49444c3a), 
            ACE_NTOHL (0x6f6d672e), 
            ACE_NTOHL (0x6f72672f), 
            ACE_NTOHL (0x506f7274), 
            ACE_NTOHL (0x61626c65), 
            ACE_NTOHL (0x47726f75), 
            ACE_NTOHL (0x702f5661), 
            ACE_NTOHL (0x6c75653a), 
            ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/PortableGroup/Value:1.0
                        6,
            ACE_NTOHL (0x56616c75), 
            ACE_NTOHL (0x65000000),  // name = Value
                        CORBA::tk_any,



        0U,



};

static CORBA::TypeCode _tc_TAO_tc_CosLoadBalancing_StrategyInfo (
    CORBA::tk_struct,
    sizeof (_oc_CosLoadBalancing_StrategyInfo),
    (char *) &_oc_CosLoadBalancing_StrategyInfo,
    0,
    sizeof (CosLoadBalancing::StrategyInfo)
  );

namespace CosLoadBalancing
{
  ::CORBA::TypeCode_ptr _tc_StrategyInfo =
    &_tc_TAO_tc_CosLoadBalancing_StrategyInfo;
}

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

void 
CosLoadBalancing::StrategyInfo::_tao_any_destructor (
    void *_tao_void_pointer
  )
{
  StrategyInfo *_tao_tmp_pointer =
    static_cast<StrategyInfo *> (_tao_void_pointer);
  delete _tao_tmp_pointer;
}

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

// Traits specializations for CosLoadBalancing::LoadAlert.

ACE_TEMPLATE_CLASS_MEMBER_SPECIALIZATION
CosLoadBalancing::LoadAlert_ptr
TAO::Objref_Traits<CosLoadBalancing::LoadAlert>::tao_duplicate (
    CosLoadBalancing::LoadAlert_ptr p
  )
{
  return CosLoadBalancing::LoadAlert::_duplicate (p);
}

ACE_TEMPLATE_CLASS_MEMBER_SPECIALIZATION
void
TAO::Objref_Traits<CosLoadBalancing::LoadAlert>::tao_release (
    CosLoadBalancing::LoadAlert_ptr p
  )
{
  CORBA::release (p);
}

ACE_TEMPLATE_CLASS_MEMBER_SPECIALIZATION
CosLoadBalancing::LoadAlert_ptr
TAO::Objref_Traits<CosLoadBalancing::LoadAlert>::tao_nil (void)
{
  return CosLoadBalancing::LoadAlert::_nil ();
}

ACE_TEMPLATE_CLASS_MEMBER_SPECIALIZATION
CORBA::Boolean
TAO::Objref_Traits<CosLoadBalancing::LoadAlert>::tao_marshal (
    CosLoadBalancing::LoadAlert_ptr p,
    TAO_OutputCDR & cdr
  )
{
  return CORBA::Object::marshal (p, cdr);
}

// Function pointer for collocation factory initialization.
TAO::Collocation_Proxy_Broker * 
(*CosLoadBalancing__TAO_LoadAlert_Proxy_Broker_Factory_function_pointer) (
    CORBA::Object_ptr obj
  ) = 0;

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

void CosLoadBalancing::LoadAlert::enable_alert (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_LoadAlert_Proxy_Broker_ == 0)
    {
      CosLoadBalancing_LoadAlert_setup_collocation ();
    }
  
  TAO::Arg_Traits< void>::ret_val _tao_retval;
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      1,
      "enable_alert",
      12,
      this->the_TAO_LoadAlert_Proxy_Broker_
    );
  
  _tao_call.invoke (0, 0 ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
}

// TAO_IDL - Generated from
// be/be_visitor_operation/ami_cs.cpp:71

void
CosLoadBalancing::LoadAlert::sendc_enable_alert (
    ::CosLoadBalancing::AMI_LoadAlertHandler_ptr ami_handler
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_LoadAlert_Proxy_Broker_ == 0)
    {
      CosLoadBalancing_LoadAlert_setup_collocation ();
    }
  
  TAO::Arg_Traits<void>::ret_val _tao_retval;
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval
    };
  
  TAO::Asynch_Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      1,
      "enable_alert",
      12,
      this->the_TAO_LoadAlert_Proxy_Broker_
    );
  
  _tao_call.invoke (
      ami_handler,
      &CosLoadBalancing::AMI_LoadAlertHandler::enable_alert_reply_stub
      ACE_ENV_ARG_PARAMETER
    );
  ACE_CHECK;
}

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

void CosLoadBalancing::LoadAlert::disable_alert (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_LoadAlert_Proxy_Broker_ == 0)
    {
      CosLoadBalancing_LoadAlert_setup_collocation ();
    }
  
  TAO::Arg_Traits< void>::ret_val _tao_retval;
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      1,
      "disable_alert",
      13,
      this->the_TAO_LoadAlert_Proxy_Broker_
    );
  
  _tao_call.invoke (0, 0 ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
}

// TAO_IDL - Generated from
// be/be_visitor_operation/ami_cs.cpp:71

void
CosLoadBalancing::LoadAlert::sendc_disable_alert (
    ::CosLoadBalancing::AMI_LoadAlertHandler_ptr ami_handler
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_LoadAlert_Proxy_Broker_ == 0)
    {
      CosLoadBalancing_LoadAlert_setup_collocation ();
    }
  
  TAO::Arg_Traits<void>::ret_val _tao_retval;
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval
    };
  
  TAO::Asynch_Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      1,
      "disable_alert",
      13,
      this->the_TAO_LoadAlert_Proxy_Broker_
    );
  
  _tao_call.invoke (
      ami_handler,
      &CosLoadBalancing::AMI_LoadAlertHandler::disable_alert_reply_stub
      ACE_ENV_ARG_PARAMETER
    );
  ACE_CHECK;
}

CosLoadBalancing::LoadAlert::LoadAlert (void)
 : the_TAO_LoadAlert_Proxy_Broker_ (0)
{
  this->CosLoadBalancing_LoadAlert_setup_collocation ();
}

void
CosLoadBalancing::LoadAlert::CosLoadBalancing_LoadAlert_setup_collocation ()
{
  if (::CosLoadBalancing__TAO_LoadAlert_Proxy_Broker_Factory_function_pointer)
    {
      this->the_TAO_LoadAlert_Proxy_Broker_ =
        ::CosLoadBalancing__TAO_LoadAlert_Proxy_Broker_Factory_function_pointer (this);
    }
}

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

void 
CosLoadBalancing::LoadAlert::_tao_any_destructor (void *_tao_void_pointer)
{
  LoadAlert *_tao_tmp_pointer =
    static_cast<LoadAlert *> (_tao_void_pointer);
  CORBA::release (_tao_tmp_pointer);
}

CosLoadBalancing::LoadAlert_ptr
CosLoadBalancing::LoadAlert::_narrow (
    CORBA::Object_ptr _tao_objref
    ACE_ENV_ARG_DECL
  )
{
  return
    TAO::Narrow_Utils<LoadAlert>::narrow (
        _tao_objref,
        "IDL:omg.org/CosLoadBalancing/LoadAlert:1.0",
        CosLoadBalancing__TAO_LoadAlert_Proxy_Broker_Factory_function_pointer
        ACE_ENV_ARG_PARAMETER
      );
}

CosLoadBalancing::LoadAlert_ptr
CosLoadBalancing::LoadAlert::_unchecked_narrow (
    CORBA::Object_ptr _tao_objref
    ACE_ENV_ARG_DECL
  )
{
  return
    TAO::Narrow_Utils<LoadAlert>::unchecked_narrow (
        _tao_objref,
        "IDL:omg.org/CosLoadBalancing/LoadAlert:1.0",
        CosLoadBalancing__TAO_LoadAlert_Proxy_Broker_Factory_function_pointer
        ACE_ENV_ARG_PARAMETER
      );
}

CosLoadBalancing::LoadAlert_ptr
CosLoadBalancing::LoadAlert::_duplicate (LoadAlert_ptr obj)
{
  if (! CORBA::is_nil (obj))
    {
      obj->_add_ref ();
    }
  
  return obj;
}

CORBA::Boolean
CosLoadBalancing::LoadAlert::_is_a (
    const char *value
    ACE_ENV_ARG_DECL
  )
{
  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; // success using local knowledge
    }
  else
    {
      return this->ACE_NESTED_CLASS (CORBA, Object)::_is_a (
          value
          ACE_ENV_ARG_PARAMETER
        );
    }
}

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

CORBA::Boolean
CosLoadBalancing::LoadAlert::marshal (TAO_OutputCDR &cdr)
{
  return (cdr << this);
}

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

static const CORBA::Long _oc_CosLoadBalancing_LoadAlert[] =
{
    TAO_ENCAP_BYTE_ORDER, // byte order
  43,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x436f734c), 
  ACE_NTOHL (0x6f616442), 
  ACE_NTOHL (0x616c616e), 
  ACE_NTOHL (0x63696e67), 
  ACE_NTOHL (0x2f4c6f61), 
  ACE_NTOHL (0x64416c65), 
  ACE_NTOHL (0x72743a31), 
  ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CosLoadBalancing/LoadAlert:1.0
    10,
  ACE_NTOHL (0x4c6f6164), 
  ACE_NTOHL (0x416c6572), 
  ACE_NTOHL (0x74000000),  // name = LoadAlert
  };

static CORBA::TypeCode _tc_TAO_tc_CosLoadBalancing_LoadAlert (
    CORBA::tk_objref,
    sizeof (_oc_CosLoadBalancing_LoadAlert),
    (char *) &_oc_CosLoadBalancing_LoadAlert,
    0,
    sizeof (CosLoadBalancing::LoadAlert)
  );

namespace CosLoadBalancing
{
  ::CORBA::TypeCode_ptr _tc_LoadAlert =
    &_tc_TAO_tc_CosLoadBalancing_LoadAlert;
}

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

static const CORBA::Long _oc_CosLoadBalancing_AMI_LoadAlertExceptionHolder[] =
{
    TAO_ENCAP_BYTE_ORDER, // byte order
  9,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x3a312e30), 
  ACE_NTOHL (0x0),  // repository ID = IDL::1.0
    29,
  ACE_NTOHL (0x414d495f), 
  ACE_NTOHL (0x4c6f6164), 
  ACE_NTOHL (0x416c6572), 
  ACE_NTOHL (0x74457863), 
  ACE_NTOHL (0x65707469), 
  ACE_NTOHL (0x6f6e486f), 
  ACE_NTOHL (0x6c646572), 
  ACE_NTOHL (0x0),  // name = AMI_LoadAlertExceptionHolder
    0, // value modifier
  CORBA::tk_value, // typecode kind
  64, // encapsulation length
    TAO_ENCAP_BYTE_ORDER, // byte order
    24,
    ACE_NTOHL (0x49444c3a), 
    ACE_NTOHL (0x45786365), 
    ACE_NTOHL (0x7074696f), 
    ACE_NTOHL (0x6e486f6c), 
    ACE_NTOHL (0x6465723a), 
    ACE_NTOHL (0x312e3000),  // repository ID = IDL:ExceptionHolder:1.0
        16,
    ACE_NTOHL (0x45786365), 
    ACE_NTOHL (0x7074696f), 
    ACE_NTOHL (0x6e486f6c), 
    ACE_NTOHL (0x64657200),  // name = ExceptionHolder
        0, // value modifier
    CORBA::tk_null, // no stateful base valuetype

0, // member count
    
0, // member count
  };

static CORBA::TypeCode _tc_TAO_tc_CosLoadBalancing_AMI_LoadAlertExceptionHolder (
    CORBA::tk_value,
    sizeof (_oc_CosLoadBalancing_AMI_LoadAlertExceptionHolder),
    (char *) &_oc_CosLoadBalancing_AMI_LoadAlertExceptionHolder,
    0,
    sizeof (CosLoadBalancing::AMI_LoadAlertExceptionHolder)
  );

namespace CosLoadBalancing
{
  ::CORBA::TypeCode_ptr _tc_AMI_LoadAlertExceptionHolder =
    &_tc_TAO_tc_CosLoadBalancing_AMI_LoadAlertExceptionHolder;
}

// TAO_IDL - Generated from
// be/be_visitor_valuetype/valuetype_cs.cpp:66

ACE_TEMPLATE_CLASS_MEMBER_SPECIALIZATION 
void
TAO::Value_Traits<CosLoadBalancing::AMI_LoadAlertExceptionHolder>::tao_add_ref (
    CosLoadBalancing::AMI_LoadAlertExceptionHolder * p
  )
{
  CORBA::add_ref (p);
}

ACE_TEMPLATE_CLASS_MEMBER_SPECIALIZATION 
void
TAO::Value_Traits<CosLoadBalancing::AMI_LoadAlertExceptionHolder>::tao_remove_ref (
    CosLoadBalancing::AMI_LoadAlertExceptionHolder * p
  )
{
  CORBA::remove_ref (p);
}

ACE_TEMPLATE_CLASS_MEMBER_SPECIALIZATION 
void
TAO::Value_Traits<CosLoadBalancing::AMI_LoadAlertExceptionHolder>::tao_release (
    CosLoadBalancing::AMI_LoadAlertExceptionHolder * p
  )
{
  CORBA::remove_ref (p);
}

CosLoadBalancing::AMI_LoadAlertExceptionHolder *
CosLoadBalancing::AMI_LoadAlertExceptionHolder::_downcast (CORBA::ValueBase *v)
{
  if (v == 0)
    {
      return 0;
    }
  
  return dynamic_cast< ::CosLoadBalancing::AMI_LoadAlertExceptionHolder * > (v);
}

const char *
CosLoadBalancing::AMI_LoadAlertExceptionHolder::_tao_obv_repository_id (void) const
{
  return this->_tao_obv_static_repository_id ();
}

void
CosLoadBalancing::AMI_LoadAlertExceptionHolder::_tao_any_destructor (void *_tao_void_pointer)
{
  AMI_LoadAlertExceptionHolder *_tao_tmp_pointer =
    static_cast<
        AMI_LoadAlertExceptionHolder *> (
        _tao_void_pointer
      );
  CORBA::remove_ref (_tao_tmp_pointer);
}

CORBA::Boolean CosLoadBalancing::AMI_LoadAlertExceptionHolder::_tao_marshal_v (TAO_OutputCDR & strm)
{
  return this->_tao_marshal__CosLoadBalancing_AMI_LoadAlertExceptionHolder (strm);
}

CORBA::Boolean CosLoadBalancing::AMI_LoadAlertExceptionHolder::_tao_unmarshal_v (TAO_InputCDR & strm)
{
  return this->_tao_unmarshal__CosLoadBalancing_AMI_LoadAlertExceptionHolder (strm);
}

CORBA::Boolean CosLoadBalancing::AMI_LoadAlertExceptionHolder::_tao_unmarshal (
    TAO_InputCDR &strm,
    AMI_LoadAlertExceptionHolder *&new_object
  )
{
  CORBA::ValueBase *base = 0;
  CORBA::ValueFactory_var factory;
  CORBA::Boolean retval =
    CORBA::ValueBase::_tao_unmarshal_pre (
        strm,
        factory.out (),
        base,
        AMI_LoadAlertExceptionHolder::_tao_obv_static_repository_id ()
      );
  
  if (retval == 0)
    {
      return 0;
    }
  
  if (factory.in () != 0)
    {
      base = factory->create_for_unmarshal ();
      
      if (base == 0)
        {
          return 0;  // %! except.?
        }
      
      retval = base->_tao_unmarshal_v (strm);
      
      if (retval == 0)
        {
          return 0;
        }
    }
  
  // Now base must be null or point to the unmarshaled object.
  // Align the pointer to the right subobject.
  new_object = AMI_LoadAlertExceptionHolder::_downcast (base);
  return retval;
}

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

// Traits specializations for CosLoadBalancing::AMI_LoadAlertHandler.

ACE_TEMPLATE_CLASS_MEMBER_SPECIALIZATION
CosLoadBalancing::AMI_LoadAlertHandler_ptr
TAO::Objref_Traits<CosLoadBalancing::AMI_LoadAlertHandler>::tao_duplicate (
    CosLoadBalancing::AMI_LoadAlertHandler_ptr p
  )
{
  return CosLoadBalancing::AMI_LoadAlertHandler::_duplicate (p);
}

ACE_TEMPLATE_CLASS_MEMBER_SPECIALIZATION
void
TAO::Objref_Traits<CosLoadBalancing::AMI_LoadAlertHandler>::tao_release (
    CosLoadBalancing::AMI_LoadAlertHandler_ptr p
  )
{
  CORBA::release (p);
}

ACE_TEMPLATE_CLASS_MEMBER_SPECIALIZATION
CosLoadBalancing::AMI_LoadAlertHandler_ptr
TAO::Objref_Traits<CosLoadBalancing::AMI_LoadAlertHandler>::tao_nil (void)
{
  return CosLoadBalancing::AMI_LoadAlertHandler::_nil ();
}

ACE_TEMPLATE_CLASS_MEMBER_SPECIALIZATION
CORBA::Boolean
TAO::Objref_Traits<CosLoadBalancing::AMI_LoadAlertHandler>::tao_marshal (
    CosLoadBalancing::AMI_LoadAlertHandler_ptr p,
    TAO_OutputCDR & cdr
  )
{
  return CORBA::Object::marshal (p, cdr);
}

// Function pointer for collocation factory initialization.
TAO::Collocation_Proxy_Broker * 
(*CosLoadBalancing__TAO_AMI_LoadAlertHandler_Proxy_Broker_Factory_function_pointer) (
    CORBA::Object_ptr obj
  ) = 0;

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

void CosLoadBalancing::AMI_LoadAlertHandler::enable_alert (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_AMI_LoadAlertHandler_Proxy_Broker_ == 0)
    {
      CosLoadBalancing_AMI_LoadAlertHandler_setup_collocation ();
    }
  
  TAO::Arg_Traits< void>::ret_val _tao_retval;
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      1,
      "enable_alert",
      12,
      this->the_TAO_AMI_LoadAlertHandler_Proxy_Broker_
    );
  
  _tao_call.invoke (0, 0 ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
}
void
CosLoadBalancing::AMI_LoadAlertHandler::enable_alert_reply_stub (
  TAO_InputCDR &_tao_in, 
  Messaging::ReplyHandler_ptr _tao_reply_handler,
  CORBA::ULong reply_status
  ACE_ENV_ARG_DECL)
{
  // Retrieve Reply Handler object.
  CosLoadBalancing::AMI_LoadAlertHandler_var _tao_reply_handler_object =
    CosLoadBalancing::AMI_LoadAlertHandler::_narrow (_tao_reply_handler ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
  
  // Exception handling
  switch (reply_status)
  {
    case TAO_AMI_REPLY_OK:
    {
      // Demarshall all the arguments.
      // Invoke the call back method.
      _tao_reply_handler_object->enable_alert (
          
          ACE_ENV_SINGLE_ARG_PARAMETER
        );
      ACE_CHECK;
      break;
    }
    case TAO_AMI_REPLY_USER_EXCEPTION:
    case TAO_AMI_REPLY_SYSTEM_EXCEPTION:
    {
      const ACE_Message_Block* cdr = _tao_in.start ();
      
      AMI_LoadAlertExceptionHolder_var exception_holder_var;
      ACE_NEW (
          exception_holder_var,
          OBV_CosLoadBalancing::_tao_AMI_LoadAlertExceptionHolder ()
        );
      
      CORBA::OctetSeq _tao_marshaled_exception (
          cdr->length (),
          cdr->length (),
          (unsigned char*) cdr->rd_ptr (),
          0
        );
      exception_holder_var->marshaled_exception (_tao_marshaled_exception);
      
      if (reply_status == TAO_AMI_REPLY_SYSTEM_EXCEPTION)
        exception_holder_var->is_system_exception (1);
      else
        exception_holder_var->is_system_exception (0);
      
      exception_holder_var->byte_order (_tao_in.byte_order ());
      
      _tao_reply_handler_object->enable_alert_excep (
          exception_holder_var ACE_ENV_ARG_PARAMETER
        );
      ACE_CHECK;
      break;
    }
    case TAO_AMI_REPLY_NOT_OK:
      // @@ Michael: Not even the spec mentions this case.
      //             We have to think about this case.
      break;
  }
}



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

void CosLoadBalancing::AMI_LoadAlertHandler::enable_alert_excep (
    ::CosLoadBalancing::AMI_LoadAlertExceptionHolder * excep_holder
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_AMI_LoadAlertHandler_Proxy_Broker_ == 0)
    {
      CosLoadBalancing_AMI_LoadAlertHandler_setup_collocation ();
    }
  
  TAO::Arg_Traits< void>::ret_val _tao_retval;
  TAO::Arg_Traits< ::CosLoadBalancing::AMI_LoadAlertExceptionHolder>::in_arg_val _tao_excep_holder (excep_holder);
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval,
      &_tao_excep_holder
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      2,
      "enable_alert_excep",
      18,
      this->the_TAO_AMI_LoadAlertHandler_Proxy_Broker_
    );
  
  _tao_call.invoke (0, 0 ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
}

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

void CosLoadBalancing::AMI_LoadAlertHandler::disable_alert (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_AMI_LoadAlertHandler_Proxy_Broker_ == 0)
    {
      CosLoadBalancing_AMI_LoadAlertHandler_setup_collocation ();
    }
  
  TAO::Arg_Traits< void>::ret_val _tao_retval;
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      1,
      "disable_alert",
      13,
      this->the_TAO_AMI_LoadAlertHandler_Proxy_Broker_
    );
  
  _tao_call.invoke (0, 0 ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
}
void
CosLoadBalancing::AMI_LoadAlertHandler::disable_alert_reply_stub (
  TAO_InputCDR &_tao_in, 
  Messaging::ReplyHandler_ptr _tao_reply_handler,
  CORBA::ULong reply_status
  ACE_ENV_ARG_DECL)
{
  // Retrieve Reply Handler object.
  CosLoadBalancing::AMI_LoadAlertHandler_var _tao_reply_handler_object =
    CosLoadBalancing::AMI_LoadAlertHandler::_narrow (_tao_reply_handler ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
  
  // Exception handling
  switch (reply_status)
  {
    case TAO_AMI_REPLY_OK:
    {
      // Demarshall all the arguments.
      // Invoke the call back method.
      _tao_reply_handler_object->disable_alert (
          
          ACE_ENV_SINGLE_ARG_PARAMETER
        );
      ACE_CHECK;
      break;
    }
    case TAO_AMI_REPLY_USER_EXCEPTION:
    case TAO_AMI_REPLY_SYSTEM_EXCEPTION:
    {
      const ACE_Message_Block* cdr = _tao_in.start ();
      
      AMI_LoadAlertExceptionHolder_var exception_holder_var;
      ACE_NEW (
          exception_holder_var,
          OBV_CosLoadBalancing::_tao_AMI_LoadAlertExceptionHolder ()
        );
      
      CORBA::OctetSeq _tao_marshaled_exception (
          cdr->length (),
          cdr->length (),
          (unsigned char*) cdr->rd_ptr (),
          0
        );
      exception_holder_var->marshaled_exception (_tao_marshaled_exception);
      
      if (reply_status == TAO_AMI_REPLY_SYSTEM_EXCEPTION)
        exception_holder_var->is_system_exception (1);
      else
        exception_holder_var->is_system_exception (0);
      
      exception_holder_var->byte_order (_tao_in.byte_order ());
      
      _tao_reply_handler_object->disable_alert_excep (
          exception_holder_var ACE_ENV_ARG_PARAMETER
        );
      ACE_CHECK;
      break;
    }
    case TAO_AMI_REPLY_NOT_OK:
      // @@ Michael: Not even the spec mentions this case.
      //             We have to think about this case.
      break;
  }
}



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

void CosLoadBalancing::AMI_LoadAlertHandler::disable_alert_excep (
    ::CosLoadBalancing::AMI_LoadAlertExceptionHolder * excep_holder
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_AMI_LoadAlertHandler_Proxy_Broker_ == 0)
    {
      CosLoadBalancing_AMI_LoadAlertHandler_setup_collocation ();
    }
  
  TAO::Arg_Traits< void>::ret_val _tao_retval;
  TAO::Arg_Traits< ::CosLoadBalancing::AMI_LoadAlertExceptionHolder>::in_arg_val _tao_excep_holder (excep_holder);
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval,
      &_tao_excep_holder
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      2,
      "disable_alert_excep",
      19,
      this->the_TAO_AMI_LoadAlertHandler_Proxy_Broker_
    );
  
  _tao_call.invoke (0, 0 ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
}

CosLoadBalancing::AMI_LoadAlertHandler::AMI_LoadAlertHandler (void)
 : the_TAO_AMI_LoadAlertHandler_Proxy_Broker_ (0)
{
  this->CosLoadBalancing_AMI_LoadAlertHandler_setup_collocation ();
}

void
CosLoadBalancing::AMI_LoadAlertHandler::CosLoadBalancing_AMI_LoadAlertHandler_setup_collocation ()
{
  if (::CosLoadBalancing__TAO_AMI_LoadAlertHandler_Proxy_Broker_Factory_function_pointer)
    {
      this->the_TAO_AMI_LoadAlertHandler_Proxy_Broker_ =
        ::CosLoadBalancing__TAO_AMI_LoadAlertHandler_Proxy_Broker_Factory_function_pointer (this);
    }
  
  this->Messaging_ReplyHandler_setup_collocation ();
}

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

void 
CosLoadBalancing::AMI_LoadAlertHandler::_tao_any_destructor (void *_tao_void_pointer)
{
  AMI_LoadAlertHandler *_tao_tmp_pointer =
    static_cast<AMI_LoadAlertHandler *> (_tao_void_pointer);
  CORBA::release (_tao_tmp_pointer);
}

CosLoadBalancing::AMI_LoadAlertHandler_ptr
CosLoadBalancing::AMI_LoadAlertHandler::_narrow (
    CORBA::Object_ptr _tao_objref
    ACE_ENV_ARG_DECL
  )
{
  return
    TAO::Narrow_Utils<AMI_LoadAlertHandler>::narrow (
        _tao_objref,
        "IDL:AMI_LoadAlertHandler:1.0",
        CosLoadBalancing__TAO_AMI_LoadAlertHandler_Proxy_Broker_Factory_function_pointer
        ACE_ENV_ARG_PARAMETER
      );
}

CosLoadBalancing::AMI_LoadAlertHandler_ptr
CosLoadBalancing::AMI_LoadAlertHandler::_unchecked_narrow (
    CORBA::Object_ptr _tao_objref
    ACE_ENV_ARG_DECL
  )
{
  return
    TAO::Narrow_Utils<AMI_LoadAlertHandler>::unchecked_narrow (
        _tao_objref,
        "IDL:AMI_LoadAlertHandler:1.0",
        CosLoadBalancing__TAO_AMI_LoadAlertHandler_Proxy_Broker_Factory_function_pointer
        ACE_ENV_ARG_PARAMETER
      );
}

CosLoadBalancing::AMI_LoadAlertHandler_ptr
CosLoadBalancing::AMI_LoadAlertHandler::_duplicate (AMI_LoadAlertHandler_ptr obj)
{
  if (! CORBA::is_nil (obj))
    {
      obj->_add_ref ();
    }
  
  return obj;
}

CORBA::Boolean
CosLoadBalancing::AMI_LoadAlertHandler::_is_a (
    const char *value
    ACE_ENV_ARG_DECL
  )
{
  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; // success using local knowledge
    }
  else
    {
      return this->ACE_NESTED_CLASS (CORBA, Object)::_is_a (
          value
          ACE_ENV_ARG_PARAMETER
        );
    }
}

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

CORBA::Boolean
CosLoadBalancing::AMI_LoadAlertHandler::marshal (TAO_OutputCDR &cdr)
{
  return (cdr << this);
}

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

static const CORBA::Long _oc_CosLoadBalancing_AMI_LoadAlertHandler[] =
{
    TAO_ENCAP_BYTE_ORDER, // byte order
  29,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x414d495f), 
  ACE_NTOHL (0x4c6f6164), 
  ACE_NTOHL (0x416c6572), 
  ACE_NTOHL (0x7448616e), 
  ACE_NTOHL (0x646c6572), 
  ACE_NTOHL (0x3a312e30), 
  ACE_NTOHL (0x0),  // repository ID = IDL:AMI_LoadAlertHandler:1.0
    21,
  ACE_NTOHL (0x414d495f), 
  ACE_NTOHL (0x4c6f6164), 
  ACE_NTOHL (0x416c6572), 
  ACE_NTOHL (0x7448616e), 
  ACE_NTOHL (0x646c6572), 
  ACE_NTOHL (0x0),  // name = AMI_LoadAlertHandler
  };

static CORBA::TypeCode _tc_TAO_tc_CosLoadBalancing_AMI_LoadAlertHandler (
    CORBA::tk_objref,
    sizeof (_oc_CosLoadBalancing_AMI_LoadAlertHandler),
    (char *) &_oc_CosLoadBalancing_AMI_LoadAlertHandler,
    0,
    sizeof (CosLoadBalancing::AMI_LoadAlertHandler)
  );

namespace CosLoadBalancing
{
  ::CORBA::TypeCode_ptr _tc_AMI_LoadAlertHandler =
    &_tc_TAO_tc_CosLoadBalancing_AMI_LoadAlertHandler;
}

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

// Traits specializations for CosLoadBalancing::LoadMonitor.

ACE_TEMPLATE_CLASS_MEMBER_SPECIALIZATION
CosLoadBalancing::LoadMonitor_ptr
TAO::Objref_Traits<CosLoadBalancing::LoadMonitor>::tao_duplicate (
    CosLoadBalancing::LoadMonitor_ptr p
  )
{
  return CosLoadBalancing::LoadMonitor::_duplicate (p);
}

ACE_TEMPLATE_CLASS_MEMBER_SPECIALIZATION
void
TAO::Objref_Traits<CosLoadBalancing::LoadMonitor>::tao_release (
    CosLoadBalancing::LoadMonitor_ptr p
  )
{
  CORBA::release (p);
}

ACE_TEMPLATE_CLASS_MEMBER_SPECIALIZATION
CosLoadBalancing::LoadMonitor_ptr
TAO::Objref_Traits<CosLoadBalancing::LoadMonitor>::tao_nil (void)
{
  return CosLoadBalancing::LoadMonitor::_nil ();
}

ACE_TEMPLATE_CLASS_MEMBER_SPECIALIZATION
CORBA::Boolean
TAO::Objref_Traits<CosLoadBalancing::LoadMonitor>::tao_marshal (
    CosLoadBalancing::LoadMonitor_ptr p,
    TAO_OutputCDR & cdr
  )
{
  return CORBA::Object::marshal (p, cdr);
}

// Function pointer for collocation factory initialization.
TAO::Collocation_Proxy_Broker * 
(*CosLoadBalancing__TAO_LoadMonitor_Proxy_Broker_Factory_function_pointer) (
    CORBA::Object_ptr obj
  ) = 0;

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

::CosLoadBalancing::Location * CosLoadBalancing::LoadMonitor::the_location (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_LoadMonitor_Proxy_Broker_ == 0)
    {
      CosLoadBalancing_LoadMonitor_setup_collocation ();
    }
  
  TAO::Arg_Traits< ::CosLoadBalancing::Location>::ret_val _tao_retval;
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      1,
      "_get_the_location",
      17,
      this->the_TAO_LoadMonitor_Proxy_Broker_
    );
  
  _tao_call.invoke (0, 0 ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (_tao_retval.excp ());
  
  return _tao_retval.retn ();
}

// TAO_IDL - Generated from
// be/be_visitor_operation/ami_cs.cpp:71

void
CosLoadBalancing::LoadMonitor::sendc_get_the_location (
    ::CosLoadBalancing::AMI_LoadMonitorHandler_ptr ami_handler
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_LoadMonitor_Proxy_Broker_ == 0)
    {
      CosLoadBalancing_LoadMonitor_setup_collocation ();
    }
  
  TAO::Arg_Traits<void>::ret_val _tao_retval;
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval
    };
  
  TAO::Asynch_Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      1,
      "_get_the_location",
      17,
      this->the_TAO_LoadMonitor_Proxy_Broker_
    );
  
  _tao_call.invoke (
      ami_handler,
      &CosLoadBalancing::AMI_LoadMonitorHandler::get_the_location_reply_stub
      ACE_ENV_ARG_PARAMETER
    );
  ACE_CHECK;
}

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

::CosLoadBalancing::LoadList * CosLoadBalancing::LoadMonitor::loads (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_LoadMonitor_Proxy_Broker_ == 0)
    {
      CosLoadBalancing_LoadMonitor_setup_collocation ();
    }
  
  TAO::Arg_Traits< ::CosLoadBalancing::LoadList>::ret_val _tao_retval;
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      1,
      "_get_loads",
      10,
      this->the_TAO_LoadMonitor_Proxy_Broker_
    );
  
  _tao_call.invoke (0, 0 ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (_tao_retval.excp ());
  
  return _tao_retval.retn ();
}

// TAO_IDL - Generated from
// be/be_visitor_operation/ami_cs.cpp:71

void
CosLoadBalancing::LoadMonitor::sendc_get_loads (
    ::CosLoadBalancing::AMI_LoadMonitorHandler_ptr ami_handler
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_LoadMonitor_Proxy_Broker_ == 0)
    {
      CosLoadBalancing_LoadMonitor_setup_collocation ();
    }
  
  TAO::Arg_Traits<void>::ret_val _tao_retval;
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval
    };
  
  TAO::Asynch_Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      1,
      "_get_loads",
      10,
      this->the_TAO_LoadMonitor_Proxy_Broker_
    );
  
  _tao_call.invoke (
      ami_handler,
      &CosLoadBalancing::AMI_LoadMonitorHandler::get_loads_reply_stub
      ACE_ENV_ARG_PARAMETER
    );
  ACE_CHECK;
}

CosLoadBalancing::LoadMonitor::LoadMonitor (void)
 : the_TAO_LoadMonitor_Proxy_Broker_ (0)
{
  this->CosLoadBalancing_LoadMonitor_setup_collocation ();
}

void
CosLoadBalancing::LoadMonitor::CosLoadBalancing_LoadMonitor_setup_collocation ()
{
  if (::CosLoadBalancing__TAO_LoadMonitor_Proxy_Broker_Factory_function_pointer)
    {
      this->the_TAO_LoadMonitor_Proxy_Broker_ =
        ::CosLoadBalancing__TAO_LoadMonitor_Proxy_Broker_Factory_function_pointer (this);
    }
}

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

void 
CosLoadBalancing::LoadMonitor::_tao_any_destructor (void *_tao_void_pointer)
{
  LoadMonitor *_tao_tmp_pointer =
    static_cast<LoadMonitor *> (_tao_void_pointer);
  CORBA::release (_tao_tmp_pointer);
}

CosLoadBalancing::LoadMonitor_ptr
CosLoadBalancing::LoadMonitor::_narrow (
    CORBA::Object_ptr _tao_objref
    ACE_ENV_ARG_DECL
  )
{
  return
    TAO::Narrow_Utils<LoadMonitor>::narrow (
        _tao_objref,
        "IDL:omg.org/CosLoadBalancing/LoadMonitor:1.0",
        CosLoadBalancing__TAO_LoadMonitor_Proxy_Broker_Factory_function_pointer
        ACE_ENV_ARG_PARAMETER
      );
}

CosLoadBalancing::LoadMonitor_ptr
CosLoadBalancing::LoadMonitor::_unchecked_narrow (
    CORBA::Object_ptr _tao_objref
    ACE_ENV_ARG_DECL
  )
{
  return
    TAO::Narrow_Utils<LoadMonitor>::unchecked_narrow (
        _tao_objref,
        "IDL:omg.org/CosLoadBalancing/LoadMonitor:1.0",
        CosLoadBalancing__TAO_LoadMonitor_Proxy_Broker_Factory_function_pointer
        ACE_ENV_ARG_PARAMETER
      );
}

CosLoadBalancing::LoadMonitor_ptr
CosLoadBalancing::LoadMonitor::_duplicate (LoadMonitor_ptr obj)
{
  if (! CORBA::is_nil (obj))
    {
      obj->_add_ref ();
    }
  
  return obj;
}

CORBA::Boolean
CosLoadBalancing::LoadMonitor::_is_a (
    const char *value
    ACE_ENV_ARG_DECL
  )
{
  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; // success using local knowledge
    }
  else
    {
      return this->ACE_NESTED_CLASS (CORBA, Object)::_is_a (
          value
          ACE_ENV_ARG_PARAMETER
        );
    }
}

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

CORBA::Boolean
CosLoadBalancing::LoadMonitor::marshal (TAO_OutputCDR &cdr)
{
  return (cdr << this);
}

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

static const CORBA::Long _oc_CosLoadBalancing_LoadMonitor[] =
{
    TAO_ENCAP_BYTE_ORDER, // byte order
  45,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x436f734c), 
  ACE_NTOHL (0x6f616442), 
  ACE_NTOHL (0x616c616e), 
  ACE_NTOHL (0x63696e67), 
  ACE_NTOHL (0x2f4c6f61), 
  ACE_NTOHL (0x644d6f6e), 
  ACE_NTOHL (0x69746f72), 
  ACE_NTOHL (0x3a312e30), 
  ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CosLoadBalancing/LoadMonitor:1.0
    12,
  ACE_NTOHL (0x4c6f6164), 
  ACE_NTOHL (0x4d6f6e69), 
  ACE_NTOHL (0x746f7200),  // name = LoadMonitor
  };

static CORBA::TypeCode _tc_TAO_tc_CosLoadBalancing_LoadMonitor (
    CORBA::tk_objref,
    sizeof (_oc_CosLoadBalancing_LoadMonitor),
    (char *) &_oc_CosLoadBalancing_LoadMonitor,
    0,
    sizeof (CosLoadBalancing::LoadMonitor)
  );

namespace CosLoadBalancing
{
  ::CORBA::TypeCode_ptr _tc_LoadMonitor =
    &_tc_TAO_tc_CosLoadBalancing_LoadMonitor;
}

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

static const CORBA::Long _oc_CosLoadBalancing_AMI_LoadMonitorExceptionHolder[] =
{
    TAO_ENCAP_BYTE_ORDER, // byte order
  9,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x3a312e30), 
  ACE_NTOHL (0x0),  // repository ID = IDL::1.0
    31,
  ACE_NTOHL (0x414d495f), 
  ACE_NTOHL (0x4c6f6164), 
  ACE_NTOHL (0x4d6f6e69), 
  ACE_NTOHL (0x746f7245), 
  ACE_NTOHL (0x78636570), 
  ACE_NTOHL (0x74696f6e), 
  ACE_NTOHL (0x486f6c64), 
  ACE_NTOHL (0x65720000),  // name = AMI_LoadMonitorExceptionHolder
    0, // value modifier
  CORBA::tk_value, // typecode kind
  64, // encapsulation length
    TAO_ENCAP_BYTE_ORDER, // byte order
    24,
    ACE_NTOHL (0x49444c3a), 
    ACE_NTOHL (0x45786365), 
    ACE_NTOHL (0x7074696f), 
    ACE_NTOHL (0x6e486f6c), 
    ACE_NTOHL (0x6465723a), 
    ACE_NTOHL (0x312e3000),  // repository ID = IDL:ExceptionHolder:1.0
        16,
    ACE_NTOHL (0x45786365), 
    ACE_NTOHL (0x7074696f), 
    ACE_NTOHL (0x6e486f6c), 
    ACE_NTOHL (0x64657200),  // name = ExceptionHolder
        0, // value modifier
    CORBA::tk_null, // no stateful base valuetype

0, // member count
    
0, // member count
  };

static CORBA::TypeCode _tc_TAO_tc_CosLoadBalancing_AMI_LoadMonitorExceptionHolder (
    CORBA::tk_value,
    sizeof (_oc_CosLoadBalancing_AMI_LoadMonitorExceptionHolder),
    (char *) &_oc_CosLoadBalancing_AMI_LoadMonitorExceptionHolder,
    0,
    sizeof (CosLoadBalancing::AMI_LoadMonitorExceptionHolder)
  );

namespace CosLoadBalancing
{
  ::CORBA::TypeCode_ptr _tc_AMI_LoadMonitorExceptionHolder =
    &_tc_TAO_tc_CosLoadBalancing_AMI_LoadMonitorExceptionHolder;
}

// TAO_IDL - Generated from
// be/be_visitor_valuetype/valuetype_cs.cpp:66

ACE_TEMPLATE_CLASS_MEMBER_SPECIALIZATION 
void
TAO::Value_Traits<CosLoadBalancing::AMI_LoadMonitorExceptionHolder>::tao_add_ref (
    CosLoadBalancing::AMI_LoadMonitorExceptionHolder * p
  )
{
  CORBA::add_ref (p);
}

ACE_TEMPLATE_CLASS_MEMBER_SPECIALIZATION 
void
TAO::Value_Traits<CosLoadBalancing::AMI_LoadMonitorExceptionHolder>::tao_remove_ref (
    CosLoadBalancing::AMI_LoadMonitorExceptionHolder * p
  )
{
  CORBA::remove_ref (p);
}

ACE_TEMPLATE_CLASS_MEMBER_SPECIALIZATION 
void
TAO::Value_Traits<CosLoadBalancing::AMI_LoadMonitorExceptionHolder>::tao_release (
    CosLoadBalancing::AMI_LoadMonitorExceptionHolder * p
  )
{
  CORBA::remove_ref (p);
}

CosLoadBalancing::AMI_LoadMonitorExceptionHolder *
CosLoadBalancing::AMI_LoadMonitorExceptionHolder::_downcast (CORBA::ValueBase *v)
{
  if (v == 0)
    {
      return 0;
    }
  
  return dynamic_cast< ::CosLoadBalancing::AMI_LoadMonitorExceptionHolder * > (v);
}

const char *
CosLoadBalancing::AMI_LoadMonitorExceptionHolder::_tao_obv_repository_id (void) const
{
  return this->_tao_obv_static_repository_id ();
}

void
CosLoadBalancing::AMI_LoadMonitorExceptionHolder::_tao_any_destructor (void *_tao_void_pointer)
{
  AMI_LoadMonitorExceptionHolder *_tao_tmp_pointer =
    static_cast<
        AMI_LoadMonitorExceptionHolder *> (
        _tao_void_pointer
      );
  CORBA::remove_ref (_tao_tmp_pointer);
}

CORBA::Boolean CosLoadBalancing::AMI_LoadMonitorExceptionHolder::_tao_marshal_v (TAO_OutputCDR & strm)
{
  return this->_tao_marshal__CosLoadBalancing_AMI_LoadMonitorExceptionHolder (strm);
}

CORBA::Boolean CosLoadBalancing::AMI_LoadMonitorExceptionHolder::_tao_unmarshal_v (TAO_InputCDR & strm)
{
  return this->_tao_unmarshal__CosLoadBalancing_AMI_LoadMonitorExceptionHolder (strm);
}

CORBA::Boolean CosLoadBalancing::AMI_LoadMonitorExceptionHolder::_tao_unmarshal (
    TAO_InputCDR &strm,
    AMI_LoadMonitorExceptionHolder *&new_object
  )
{
  CORBA::ValueBase *base = 0;
  CORBA::ValueFactory_var factory;
  CORBA::Boolean retval =
    CORBA::ValueBase::_tao_unmarshal_pre (
        strm,
        factory.out (),
        base,
        AMI_LoadMonitorExceptionHolder::_tao_obv_static_repository_id ()
      );
  
  if (retval == 0)
    {
      return 0;
    }
  
  if (factory.in () != 0)
    {
      base = factory->create_for_unmarshal ();
      
      if (base == 0)
        {
          return 0;  // %! except.?
        }
      
      retval = base->_tao_unmarshal_v (strm);
      
      if (retval == 0)
        {
          return 0;
        }
    }
  
  // Now base must be null or point to the unmarshaled object.
  // Align the pointer to the right subobject.
  new_object = AMI_LoadMonitorExceptionHolder::_downcast (base);
  return retval;
}

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

// Traits specializations for CosLoadBalancing::AMI_LoadMonitorHandler.

ACE_TEMPLATE_CLASS_MEMBER_SPECIALIZATION
CosLoadBalancing::AMI_LoadMonitorHandler_ptr
TAO::Objref_Traits<CosLoadBalancing::AMI_LoadMonitorHandler>::tao_duplicate (
    CosLoadBalancing::AMI_LoadMonitorHandler_ptr p
  )
{
  return CosLoadBalancing::AMI_LoadMonitorHandler::_duplicate (p);
}

ACE_TEMPLATE_CLASS_MEMBER_SPECIALIZATION
void
TAO::Objref_Traits<CosLoadBalancing::AMI_LoadMonitorHandler>::tao_release (
    CosLoadBalancing::AMI_LoadMonitorHandler_ptr p
  )
{
  CORBA::release (p);
}

ACE_TEMPLATE_CLASS_MEMBER_SPECIALIZATION
CosLoadBalancing::AMI_LoadMonitorHandler_ptr
TAO::Objref_Traits<CosLoadBalancing::AMI_LoadMonitorHandler>::tao_nil (void)
{
  return CosLoadBalancing::AMI_LoadMonitorHandler::_nil ();
}

ACE_TEMPLATE_CLASS_MEMBER_SPECIALIZATION
CORBA::Boolean
TAO::Objref_Traits<CosLoadBalancing::AMI_LoadMonitorHandler>::tao_marshal (
    CosLoadBalancing::AMI_LoadMonitorHandler_ptr p,
    TAO_OutputCDR & cdr
  )
{
  return CORBA::Object::marshal (p, cdr);
}

// Function pointer for collocation factory initialization.
TAO::Collocation_Proxy_Broker * 
(*CosLoadBalancing__TAO_AMI_LoadMonitorHandler_Proxy_Broker_Factory_function_pointer) (
    CORBA::Object_ptr obj
  ) = 0;

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

void CosLoadBalancing::AMI_LoadMonitorHandler::get_the_location (
    const ::CosLoadBalancing::Location & ami_return_val
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_AMI_LoadMonitorHandler_Proxy_Broker_ == 0)
    {
      CosLoadBalancing_AMI_LoadMonitorHandler_setup_collocation ();
    }
  
  TAO::Arg_Traits< void>::ret_val _tao_retval;
  TAO::Arg_Traits< ::CosLoadBalancing::Location>::in_arg_val _tao_ami_return_val (ami_return_val);
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval,
      &_tao_ami_return_val
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      2,
      "get_the_location",
      16,
      this->the_TAO_AMI_LoadMonitorHandler_Proxy_Broker_
    );
  
  _tao_call.invoke (0, 0 ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
}
void
CosLoadBalancing::AMI_LoadMonitorHandler::get_the_location_reply_stub (
  TAO_InputCDR &_tao_in, 
  Messaging::ReplyHandler_ptr _tao_reply_handler,
  CORBA::ULong reply_status
  ACE_ENV_ARG_DECL)
{
  // Retrieve Reply Handler object.
  CosLoadBalancing::AMI_LoadMonitorHandler_var _tao_reply_handler_object =
    CosLoadBalancing::AMI_LoadMonitorHandler::_narrow (_tao_reply_handler ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
  
  // Exception handling
  switch (reply_status)
  {
    case TAO_AMI_REPLY_OK:
    {

      ::CosLoadBalancing::Location ami_return_val;      // Demarshall all the arguments.
      if (!(

            (_tao_in >> ami_return_val)
         ))
        ACE_THROW (CORBA::MARSHAL ());
      
      // Invoke the call back method.
      _tao_reply_handler_object->get_the_location (
          
          ami_return_val
          ACE_ENV_ARG_PARAMETER
        );
      ACE_CHECK;
      break;
    }
    case TAO_AMI_REPLY_USER_EXCEPTION:
    case TAO_AMI_REPLY_SYSTEM_EXCEPTION:
    {
      const ACE_Message_Block* cdr = _tao_in.start ();
      
      AMI_LoadMonitorExceptionHolder_var exception_holder_var;
      ACE_NEW (
          exception_holder_var,
          OBV_CosLoadBalancing::_tao_AMI_LoadMonitorExceptionHolder ()
        );
      
      CORBA::OctetSeq _tao_marshaled_exception (
          cdr->length (),
          cdr->length (),
          (unsigned char*) cdr->rd_ptr (),
          0
        );
      exception_holder_var->marshaled_exception (_tao_marshaled_exception);
      
      if (reply_status == TAO_AMI_REPLY_SYSTEM_EXCEPTION)
        exception_holder_var->is_system_exception (1);
      else
        exception_holder_var->is_system_exception (0);
      
      exception_holder_var->byte_order (_tao_in.byte_order ());
      
      _tao_reply_handler_object->get_the_location_excep (
          exception_holder_var ACE_ENV_ARG_PARAMETER
        );
      ACE_CHECK;
      break;
    }
    case TAO_AMI_REPLY_NOT_OK:
      // @@ Michael: Not even the spec mentions this case.
      //             We have to think about this case.
      break;
  }
}



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

void CosLoadBalancing::AMI_LoadMonitorHandler::get_the_location_excep (
    ::CosLoadBalancing::AMI_LoadMonitorExceptionHolder * excep_holder
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_AMI_LoadMonitorHandler_Proxy_Broker_ == 0)
    {
      CosLoadBalancing_AMI_LoadMonitorHandler_setup_collocation ();
    }
  
  TAO::Arg_Traits< void>::ret_val _tao_retval;
  TAO::Arg_Traits< ::CosLoadBalancing::AMI_LoadMonitorExceptionHolder>::in_arg_val _tao_excep_holder (excep_holder);
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval,
      &_tao_excep_holder
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      2,
      "get_the_location_excep",
      22,
      this->the_TAO_AMI_LoadMonitorHandler_Proxy_Broker_
    );
  
  _tao_call.invoke (0, 0 ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
}

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

void CosLoadBalancing::AMI_LoadMonitorHandler::get_loads (
    const ::CosLoadBalancing::LoadList & ami_return_val
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_AMI_LoadMonitorHandler_Proxy_Broker_ == 0)
    {
      CosLoadBalancing_AMI_LoadMonitorHandler_setup_collocation ();
    }
  
  TAO::Arg_Traits< void>::ret_val _tao_retval;
  TAO::Arg_Traits< ::CosLoadBalancing::LoadList>::in_arg_val _tao_ami_return_val (ami_return_val);
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval,
      &_tao_ami_return_val
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      2,
      "get_loads",
      9,
      this->the_TAO_AMI_LoadMonitorHandler_Proxy_Broker_
    );
  
  _tao_call.invoke (0, 0 ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
}
void
CosLoadBalancing::AMI_LoadMonitorHandler::get_loads_reply_stub (
  TAO_InputCDR &_tao_in, 
  Messaging::ReplyHandler_ptr _tao_reply_handler,
  CORBA::ULong reply_status
  ACE_ENV_ARG_DECL)
{
  // Retrieve Reply Handler object.
  CosLoadBalancing::AMI_LoadMonitorHandler_var _tao_reply_handler_object =
    CosLoadBalancing::AMI_LoadMonitorHandler::_narrow (_tao_reply_handler ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
  
  // Exception handling
  switch (reply_status)
  {
    case TAO_AMI_REPLY_OK:
    {

      ::CosLoadBalancing::LoadList ami_return_val;      // Demarshall all the arguments.
      if (!(

            (_tao_in >> ami_return_val)
         ))
        ACE_THROW (CORBA::MARSHAL ());
      
      // Invoke the call back method.
      _tao_reply_handler_object->get_loads (
          
          ami_return_val
          ACE_ENV_ARG_PARAMETER
        );
      ACE_CHECK;
      break;
    }
    case TAO_AMI_REPLY_USER_EXCEPTION:
    case TAO_AMI_REPLY_SYSTEM_EXCEPTION:
    {
      const ACE_Message_Block* cdr = _tao_in.start ();
      
      AMI_LoadMonitorExceptionHolder_var exception_holder_var;
      ACE_NEW (
          exception_holder_var,
          OBV_CosLoadBalancing::_tao_AMI_LoadMonitorExceptionHolder ()
        );
      
      CORBA::OctetSeq _tao_marshaled_exception (
          cdr->length (),
          cdr->length (),
          (unsigned char*) cdr->rd_ptr (),
          0
        );
      exception_holder_var->marshaled_exception (_tao_marshaled_exception);
      
      if (reply_status == TAO_AMI_REPLY_SYSTEM_EXCEPTION)
        exception_holder_var->is_system_exception (1);
      else
        exception_holder_var->is_system_exception (0);
      
      exception_holder_var->byte_order (_tao_in.byte_order ());
      
      _tao_reply_handler_object->get_loads_excep (
          exception_holder_var ACE_ENV_ARG_PARAMETER
        );
      ACE_CHECK;
      break;
    }
    case TAO_AMI_REPLY_NOT_OK:
      // @@ Michael: Not even the spec mentions this case.
      //             We have to think about this case.
      break;
  }
}



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

void CosLoadBalancing::AMI_LoadMonitorHandler::get_loads_excep (
    ::CosLoadBalancing::AMI_LoadMonitorExceptionHolder * excep_holder
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_AMI_LoadMonitorHandler_Proxy_Broker_ == 0)
    {
      CosLoadBalancing_AMI_LoadMonitorHandler_setup_collocation ();
    }
  
  TAO::Arg_Traits< void>::ret_val _tao_retval;
  TAO::Arg_Traits< ::CosLoadBalancing::AMI_LoadMonitorExceptionHolder>::in_arg_val _tao_excep_holder (excep_holder);
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval,
      &_tao_excep_holder
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      2,
      "get_loads_excep",
      15,
      this->the_TAO_AMI_LoadMonitorHandler_Proxy_Broker_
    );
  
  _tao_call.invoke (0, 0 ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
}

CosLoadBalancing::AMI_LoadMonitorHandler::AMI_LoadMonitorHandler (void)
 : the_TAO_AMI_LoadMonitorHandler_Proxy_Broker_ (0)
{
  this->CosLoadBalancing_AMI_LoadMonitorHandler_setup_collocation ();
}

void
CosLoadBalancing::AMI_LoadMonitorHandler::CosLoadBalancing_AMI_LoadMonitorHandler_setup_collocation ()
{
  if (::CosLoadBalancing__TAO_AMI_LoadMonitorHandler_Proxy_Broker_Factory_function_pointer)
    {
      this->the_TAO_AMI_LoadMonitorHandler_Proxy_Broker_ =
        ::CosLoadBalancing__TAO_AMI_LoadMonitorHandler_Proxy_Broker_Factory_function_pointer (this);
    }
  
  this->Messaging_ReplyHandler_setup_collocation ();
}

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

void 
CosLoadBalancing::AMI_LoadMonitorHandler::_tao_any_destructor (void *_tao_void_pointer)
{
  AMI_LoadMonitorHandler *_tao_tmp_pointer =
    static_cast<AMI_LoadMonitorHandler *> (_tao_void_pointer);
  CORBA::release (_tao_tmp_pointer);
}

CosLoadBalancing::AMI_LoadMonitorHandler_ptr
CosLoadBalancing::AMI_LoadMonitorHandler::_narrow (
    CORBA::Object_ptr _tao_objref
    ACE_ENV_ARG_DECL
  )
{
  return
    TAO::Narrow_Utils<AMI_LoadMonitorHandler>::narrow (
        _tao_objref,
        "IDL:AMI_LoadMonitorHandler:1.0",
        CosLoadBalancing__TAO_AMI_LoadMonitorHandler_Proxy_Broker_Factory_function_pointer
        ACE_ENV_ARG_PARAMETER
      );
}

CosLoadBalancing::AMI_LoadMonitorHandler_ptr
CosLoadBalancing::AMI_LoadMonitorHandler::_unchecked_narrow (
    CORBA::Object_ptr _tao_objref
    ACE_ENV_ARG_DECL
  )
{
  return
    TAO::Narrow_Utils<AMI_LoadMonitorHandler>::unchecked_narrow (
        _tao_objref,
        "IDL:AMI_LoadMonitorHandler:1.0",
        CosLoadBalancing__TAO_AMI_LoadMonitorHandler_Proxy_Broker_Factory_function_pointer
        ACE_ENV_ARG_PARAMETER
      );
}

CosLoadBalancing::AMI_LoadMonitorHandler_ptr
CosLoadBalancing::AMI_LoadMonitorHandler::_duplicate (AMI_LoadMonitorHandler_ptr obj)
{
  if (! CORBA::is_nil (obj))
    {
      obj->_add_ref ();
    }
  
  return obj;
}

CORBA::Boolean
CosLoadBalancing::AMI_LoadMonitorHandler::_is_a (
    const char *value
    ACE_ENV_ARG_DECL
  )
{
  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; // success using local knowledge
    }
  else
    {
      return this->ACE_NESTED_CLASS (CORBA, Object)::_is_a (
          value
          ACE_ENV_ARG_PARAMETER
        );
    }
}

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

CORBA::Boolean
CosLoadBalancing::AMI_LoadMonitorHandler::marshal (TAO_OutputCDR &cdr)
{
  return (cdr << this);
}

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

static const CORBA::Long _oc_CosLoadBalancing_AMI_LoadMonitorHandler[] =
{
    TAO_ENCAP_BYTE_ORDER, // byte order
  31,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x414d495f), 
  ACE_NTOHL (0x4c6f6164), 
  ACE_NTOHL (0x4d6f6e69), 
  ACE_NTOHL (0x746f7248), 
  ACE_NTOHL (0x616e646c), 
  ACE_NTOHL (0x65723a31), 
  ACE_NTOHL (0x2e300000),  // repository ID = IDL:AMI_LoadMonitorHandler:1.0
    23,
  ACE_NTOHL (0x414d495f), 
  ACE_NTOHL (0x4c6f6164), 
  ACE_NTOHL (0x4d6f6e69), 
  ACE_NTOHL (0x746f7248), 
  ACE_NTOHL (0x616e646c), 
  ACE_NTOHL (0x65720000),  // name = AMI_LoadMonitorHandler
  };

static CORBA::TypeCode _tc_TAO_tc_CosLoadBalancing_AMI_LoadMonitorHandler (
    CORBA::tk_objref,
    sizeof (_oc_CosLoadBalancing_AMI_LoadMonitorHandler),
    (char *) &_oc_CosLoadBalancing_AMI_LoadMonitorHandler,
    0,
    sizeof (CosLoadBalancing::AMI_LoadMonitorHandler)
  );

namespace CosLoadBalancing
{
  ::CORBA::TypeCode_ptr _tc_AMI_LoadMonitorHandler =
    &_tc_TAO_tc_CosLoadBalancing_AMI_LoadMonitorHandler;
}

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

// Traits specializations for CosLoadBalancing::LoadManager.

ACE_TEMPLATE_CLASS_MEMBER_SPECIALIZATION
CosLoadBalancing::LoadManager_ptr
TAO::Objref_Traits<CosLoadBalancing::LoadManager>::tao_duplicate (
    CosLoadBalancing::LoadManager_ptr p
  )
{
  return CosLoadBalancing::LoadManager::_duplicate (p);
}

ACE_TEMPLATE_CLASS_MEMBER_SPECIALIZATION
void
TAO::Objref_Traits<CosLoadBalancing::LoadManager>::tao_release (
    CosLoadBalancing::LoadManager_ptr p
  )
{
  CORBA::release (p);
}

ACE_TEMPLATE_CLASS_MEMBER_SPECIALIZATION
CosLoadBalancing::LoadManager_ptr
TAO::Objref_Traits<CosLoadBalancing::LoadManager>::tao_nil (void)
{
  return CosLoadBalancing::LoadManager::_nil ();
}

ACE_TEMPLATE_CLASS_MEMBER_SPECIALIZATION
CORBA::Boolean
TAO::Objref_Traits<CosLoadBalancing::LoadManager>::tao_marshal (
    CosLoadBalancing::LoadManager_ptr p,
    TAO_OutputCDR & cdr
  )
{
  return CORBA::Object::marshal (p, cdr);
}

// Function pointer for collocation factory initialization.
TAO::Collocation_Proxy_Broker * 
(*CosLoadBalancing__TAO_LoadManager_Proxy_Broker_Factory_function_pointer) (
    CORBA::Object_ptr obj
  ) = 0;

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

void CosLoadBalancing::LoadManager::push_loads (
    const ::PortableGroup::Location & the_location,
    const ::CosLoadBalancing::LoadList & loads
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_LoadManager_Proxy_Broker_ == 0)
    {
      CosLoadBalancing_LoadManager_setup_collocation ();
    }
  
  TAO::Arg_Traits< void>::ret_val _tao_retval;
  TAO::Arg_Traits< ::PortableGroup::Location>::in_arg_val _tao_the_location (the_location);
  TAO::Arg_Traits< ::CosLoadBalancing::LoadList>::in_arg_val _tao_loads (loads);
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval,
      &_tao_the_location,
      &_tao_loads
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      3,
      "push_loads",
      10,
      this->the_TAO_LoadManager_Proxy_Broker_
    );
  
  _tao_call.invoke (0, 0 ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
}

// TAO_IDL - Generated from
// be/be_visitor_operation/ami_cs.cpp:71

void
CosLoadBalancing::LoadManager::sendc_push_loads (
    ::CosLoadBalancing::AMI_LoadManagerHandler_ptr ami_handler,
    const ::PortableGroup::Location & the_location,
    const ::CosLoadBalancing::LoadList & loads
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_LoadManager_Proxy_Broker_ == 0)
    {
      CosLoadBalancing_LoadManager_setup_collocation ();
    }
  
  TAO::Arg_Traits<void>::ret_val _tao_retval;
  TAO::Arg_Traits< ::PortableGroup::Location>::in_arg_val _tao_the_location (the_location);
  TAO::Arg_Traits< ::CosLoadBalancing::LoadList>::in_arg_val _tao_loads (loads);
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval,
      &_tao_the_location,
      &_tao_loads
    };
  
  TAO::Asynch_Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      3,
      "push_loads",
      10,
      this->the_TAO_LoadManager_Proxy_Broker_
    );
  
  _tao_call.invoke (
      ami_handler,
      &CosLoadBalancing::AMI_LoadManagerHandler::push_loads_reply_stub
      ACE_ENV_ARG_PARAMETER
    );
  ACE_CHECK;
}

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

::CosLoadBalancing::LoadList * CosLoadBalancing::LoadManager::get_loads (
    const ::PortableGroup::Location & the_location
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException,
    ::CosLoadBalancing::LocationNotFound
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_LoadManager_Proxy_Broker_ == 0)
    {
      CosLoadBalancing_LoadManager_setup_collocation ();
    }
  
  TAO::Arg_Traits< ::CosLoadBalancing::LoadList>::ret_val _tao_retval;
  TAO::Arg_Traits< ::PortableGroup::Location>::in_arg_val _tao_the_location (the_location);
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval,
      &_tao_the_location
    };
  
  static TAO::Exception_Data
  _tao_CosLoadBalancing_LoadManager_get_loads_exceptiondata [] = 
    {
      {
        "IDL:omg.org/CosLoadBalancing/LocationNotFound:1.0",
        CosLoadBalancing::LocationNotFound::_alloc,
        CosLoadBalancing::_tc_LocationNotFound
      }
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      2,
      "get_loads",
      9,
      this->the_TAO_LoadManager_Proxy_Broker_
    );
  
  _tao_call.invoke (
      _tao_CosLoadBalancing_LoadManager_get_loads_exceptiondata,
      1
      ACE_ENV_ARG_PARAMETER
    );
  ACE_CHECK_RETURN (_tao_retval.excp ());
  
  return _tao_retval.retn ();
}

// TAO_IDL - Generated from
// be/be_visitor_operation/ami_cs.cpp:71

void
CosLoadBalancing::LoadManager::sendc_get_loads (
    ::CosLoadBalancing::AMI_LoadManagerHandler_ptr ami_handler,
    const ::PortableGroup::Location & the_location
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_LoadManager_Proxy_Broker_ == 0)
    {
      CosLoadBalancing_LoadManager_setup_collocation ();
    }
  
  TAO::Arg_Traits<void>::ret_val _tao_retval;
  TAO::Arg_Traits< ::PortableGroup::Location>::in_arg_val _tao_the_location (the_location);
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval,
      &_tao_the_location
    };
  
  TAO::Asynch_Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      2,
      "get_loads",
      9,
      this->the_TAO_LoadManager_Proxy_Broker_
    );
  
  _tao_call.invoke (
      ami_handler,
      &CosLoadBalancing::AMI_LoadManagerHandler::get_loads_reply_stub
      ACE_ENV_ARG_PARAMETER
    );
  ACE_CHECK;
}

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

void CosLoadBalancing::LoadManager::enable_alert (
    const ::PortableGroup::Location & the_location
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException,
    ::CosLoadBalancing::LoadAlertNotFound
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_LoadManager_Proxy_Broker_ == 0)
    {
      CosLoadBalancing_LoadManager_setup_collocation ();
    }
  
  TAO::Arg_Traits< void>::ret_val _tao_retval;
  TAO::Arg_Traits< ::PortableGroup::Location>::in_arg_val _tao_the_location (the_location);
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval,
      &_tao_the_location
    };
  
  static TAO::Exception_Data
  _tao_CosLoadBalancing_LoadManager_enable_alert_exceptiondata [] = 
    {
      {
        "IDL:omg.org/CosLoadBalancing/LoadAlertNotFound:1.0",
        CosLoadBalancing::LoadAlertNotFound::_alloc,
        CosLoadBalancing::_tc_LoadAlertNotFound
      }
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      2,
      "enable_alert",
      12,
      this->the_TAO_LoadManager_Proxy_Broker_
    );
  
  _tao_call.invoke (
      _tao_CosLoadBalancing_LoadManager_enable_alert_exceptiondata,
      1
      ACE_ENV_ARG_PARAMETER
    );
  ACE_CHECK;
}

// TAO_IDL - Generated from
// be/be_visitor_operation/ami_cs.cpp:71

void
CosLoadBalancing::LoadManager::sendc_enable_alert (
    ::CosLoadBalancing::AMI_LoadManagerHandler_ptr ami_handler,
    const ::PortableGroup::Location & the_location
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_LoadManager_Proxy_Broker_ == 0)
    {
      CosLoadBalancing_LoadManager_setup_collocation ();
    }
  
  TAO::Arg_Traits<void>::ret_val _tao_retval;
  TAO::Arg_Traits< ::PortableGroup::Location>::in_arg_val _tao_the_location (the_location);
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval,
      &_tao_the_location
    };
  
  TAO::Asynch_Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      2,
      "enable_alert",
      12,
      this->the_TAO_LoadManager_Proxy_Broker_
    );
  
  _tao_call.invoke (
      ami_handler,
      &CosLoadBalancing::AMI_LoadManagerHandler::enable_alert_reply_stub
      ACE_ENV_ARG_PARAMETER
    );
  ACE_CHECK;
}

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

void CosLoadBalancing::LoadManager::disable_alert (
    const ::PortableGroup::Location & the_location
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException,
    ::CosLoadBalancing::LoadAlertNotFound
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_LoadManager_Proxy_Broker_ == 0)
    {
      CosLoadBalancing_LoadManager_setup_collocation ();
    }
  
  TAO::Arg_Traits< void>::ret_val _tao_retval;
  TAO::Arg_Traits< ::PortableGroup::Location>::in_arg_val _tao_the_location (the_location);
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval,
      &_tao_the_location
    };
  
  static TAO::Exception_Data
  _tao_CosLoadBalancing_LoadManager_disable_alert_exceptiondata [] = 
    {
      {
        "IDL:omg.org/CosLoadBalancing/LoadAlertNotFound:1.0",
        CosLoadBalancing::LoadAlertNotFound::_alloc,
        CosLoadBalancing::_tc_LoadAlertNotFound
      }
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      2,
      "disable_alert",
      13,
      this->the_TAO_LoadManager_Proxy_Broker_
    );
  
  _tao_call.invoke (
      _tao_CosLoadBalancing_LoadManager_disable_alert_exceptiondata,
      1
      ACE_ENV_ARG_PARAMETER
    );
  ACE_CHECK;
}

// TAO_IDL - Generated from
// be/be_visitor_operation/ami_cs.cpp:71

void
CosLoadBalancing::LoadManager::sendc_disable_alert (
    ::CosLoadBalancing::AMI_LoadManagerHandler_ptr ami_handler,
    const ::PortableGroup::Location & the_location
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_LoadManager_Proxy_Broker_ == 0)
    {
      CosLoadBalancing_LoadManager_setup_collocation ();
    }
  
  TAO::Arg_Traits<void>::ret_val _tao_retval;
  TAO::Arg_Traits< ::PortableGroup::Location>::in_arg_val _tao_the_location (the_location);
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval,
      &_tao_the_location
    };
  
  TAO::Asynch_Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      2,
      "disable_alert",
      13,
      this->the_TAO_LoadManager_Proxy_Broker_
    );
  
  _tao_call.invoke (
      ami_handler,
      &CosLoadBalancing::AMI_LoadManagerHandler::disable_alert_reply_stub
      ACE_ENV_ARG_PARAMETER
    );
  ACE_CHECK;
}

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

void CosLoadBalancing::LoadManager::register_load_alert (
    const ::PortableGroup::Location & the_location,
    ::CosLoadBalancing::LoadAlert_ptr load_alert
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException,
    ::CosLoadBalancing::LoadAlertAlreadyPresent,
    ::CosLoadBalancing::LoadAlertNotAdded
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_LoadManager_Proxy_Broker_ == 0)
    {
      CosLoadBalancing_LoadManager_setup_collocation ();
    }
  
  TAO::Arg_Traits< void>::ret_val _tao_retval;
  TAO::Arg_Traits< ::PortableGroup::Location>::in_arg_val _tao_the_location (the_location);
  TAO::Arg_Traits< ::CosLoadBalancing::LoadAlert>::in_arg_val _tao_load_alert (load_alert);
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval,
      &_tao_the_location,
      &_tao_load_alert
    };
  
  static TAO::Exception_Data
  _tao_CosLoadBalancing_LoadManager_register_load_alert_exceptiondata [] = 
    {
      {
        "IDL:omg.org/CosLoadBalancing/LoadAlertAlreadyPresent:1.0",
        CosLoadBalancing::LoadAlertAlreadyPresent::_alloc,
        CosLoadBalancing::_tc_LoadAlertAlreadyPresent
      },
      
      {
        "IDL:omg.org/CosLoadBalancing/LoadAlertNotAdded:1.0",
        CosLoadBalancing::LoadAlertNotAdded::_alloc,
        CosLoadBalancing::_tc_LoadAlertNotAdded
      }
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      3,
      "register_load_alert",
      19,
      this->the_TAO_LoadManager_Proxy_Broker_
    );
  
  _tao_call.invoke (
      _tao_CosLoadBalancing_LoadManager_register_load_alert_exceptiondata,
      2
      ACE_ENV_ARG_PARAMETER
    );
  ACE_CHECK;
}

// TAO_IDL - Generated from
// be/be_visitor_operation/ami_cs.cpp:71

void
CosLoadBalancing::LoadManager::sendc_register_load_alert (
    ::CosLoadBalancing::AMI_LoadManagerHandler_ptr ami_handler,
    const ::PortableGroup::Location & the_location,
    ::CosLoadBalancing::LoadAlert_ptr load_alert
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_LoadManager_Proxy_Broker_ == 0)
    {
      CosLoadBalancing_LoadManager_setup_collocation ();
    }
  
  TAO::Arg_Traits<void>::ret_val _tao_retval;
  TAO::Arg_Traits< ::PortableGroup::Location>::in_arg_val _tao_the_location (the_location);
  TAO::Arg_Traits< ::CosLoadBalancing::LoadAlert>::in_arg_val _tao_load_alert (load_alert);
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval,
      &_tao_the_location,
      &_tao_load_alert
    };
  
  TAO::Asynch_Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      3,
      "register_load_alert",
      19,
      this->the_TAO_LoadManager_Proxy_Broker_
    );
  
  _tao_call.invoke (
      ami_handler,
      &CosLoadBalancing::AMI_LoadManagerHandler::register_load_alert_reply_stub
      ACE_ENV_ARG_PARAMETER
    );
  ACE_CHECK;
}

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

::CosLoadBalancing::LoadAlert_ptr CosLoadBalancing::LoadManager::get_load_alert (
    const ::PortableGroup::Location & the_location
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException,
    ::CosLoadBalancing::LoadAlertNotFound
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_LoadManager_Proxy_Broker_ == 0)
    {
      CosLoadBalancing_LoadManager_setup_collocation ();
    }
  
  TAO::Arg_Traits< ::CosLoadBalancing::LoadAlert>::ret_val _tao_retval;
  TAO::Arg_Traits< ::PortableGroup::Location>::in_arg_val _tao_the_location (the_location);
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval,
      &_tao_the_location
    };
  
  static TAO::Exception_Data
  _tao_CosLoadBalancing_LoadManager_get_load_alert_exceptiondata [] = 
    {
      {
        "IDL:omg.org/CosLoadBalancing/LoadAlertNotFound:1.0",
        CosLoadBalancing::LoadAlertNotFound::_alloc,
        CosLoadBalancing::_tc_LoadAlertNotFound
      }
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      2,
      "get_load_alert",
      14,
      this->the_TAO_LoadManager_Proxy_Broker_
    );
  
  _tao_call.invoke (
      _tao_CosLoadBalancing_LoadManager_get_load_alert_exceptiondata,
      1
      ACE_ENV_ARG_PARAMETER
    );
  ACE_CHECK_RETURN (_tao_retval.excp ());
  
  return _tao_retval.retn ();
}

// TAO_IDL - Generated from
// be/be_visitor_operation/ami_cs.cpp:71

void
CosLoadBalancing::LoadManager::sendc_get_load_alert (
    ::CosLoadBalancing::AMI_LoadManagerHandler_ptr ami_handler,
    const ::PortableGroup::Location & the_location
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_LoadManager_Proxy_Broker_ == 0)
    {
      CosLoadBalancing_LoadManager_setup_collocation ();
    }
  
  TAO::Arg_Traits<void>::ret_val _tao_retval;
  TAO::Arg_Traits< ::PortableGroup::Location>::in_arg_val _tao_the_location (the_location);
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval,
      &_tao_the_location
    };
  
  TAO::Asynch_Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      2,
      "get_load_alert",
      14,
      this->the_TAO_LoadManager_Proxy_Broker_
    );
  
  _tao_call.invoke (
      ami_handler,
      &CosLoadBalancing::AMI_LoadManagerHandler::get_load_alert_reply_stub
      ACE_ENV_ARG_PARAMETER
    );
  ACE_CHECK;
}

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

void CosLoadBalancing::LoadManager::remove_load_alert (
    const ::PortableGroup::Location & the_location
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException,
    ::CosLoadBalancing::LoadAlertNotFound
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_LoadManager_Proxy_Broker_ == 0)
    {
      CosLoadBalancing_LoadManager_setup_collocation ();
    }
  
  TAO::Arg_Traits< void>::ret_val _tao_retval;
  TAO::Arg_Traits< ::PortableGroup::Location>::in_arg_val _tao_the_location (the_location);
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval,
      &_tao_the_location
    };
  
  static TAO::Exception_Data
  _tao_CosLoadBalancing_LoadManager_remove_load_alert_exceptiondata [] = 
    {
      {
        "IDL:omg.org/CosLoadBalancing/LoadAlertNotFound:1.0",
        CosLoadBalancing::LoadAlertNotFound::_alloc,
        CosLoadBalancing::_tc_LoadAlertNotFound
      }
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      2,
      "remove_load_alert",
      17,
      this->the_TAO_LoadManager_Proxy_Broker_
    );
  
  _tao_call.invoke (
      _tao_CosLoadBalancing_LoadManager_remove_load_alert_exceptiondata,
      1
      ACE_ENV_ARG_PARAMETER
    );
  ACE_CHECK;
}

// TAO_IDL - Generated from
// be/be_visitor_operation/ami_cs.cpp:71

void
CosLoadBalancing::LoadManager::sendc_remove_load_alert (
    ::CosLoadBalancing::AMI_LoadManagerHandler_ptr ami_handler,
    const ::PortableGroup::Location & the_location
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_LoadManager_Proxy_Broker_ == 0)
    {
      CosLoadBalancing_LoadManager_setup_collocation ();
    }
  
  TAO::Arg_Traits<void>::ret_val _tao_retval;
  TAO::Arg_Traits< ::PortableGroup::Location>::in_arg_val _tao_the_location (the_location);
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval,
      &_tao_the_location
    };
  
  TAO::Asynch_Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      2,
      "remove_load_alert",
      17,
      this->the_TAO_LoadManager_Proxy_Broker_
    );
  
  _tao_call.invoke (
      ami_handler,
      &CosLoadBalancing::AMI_LoadManagerHandler::remove_load_alert_reply_stub
      ACE_ENV_ARG_PARAMETER
    );
  ACE_CHECK;
}

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

void CosLoadBalancing::LoadManager::register_load_monitor (
    const ::PortableGroup::Location & the_location,
    ::CosLoadBalancing::LoadMonitor_ptr load_monitor
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException,
    ::CosLoadBalancing::MonitorAlreadyPresent
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_LoadManager_Proxy_Broker_ == 0)
    {
      CosLoadBalancing_LoadManager_setup_collocation ();
    }
  
  TAO::Arg_Traits< void>::ret_val _tao_retval;
  TAO::Arg_Traits< ::PortableGroup::Location>::in_arg_val _tao_the_location (the_location);
  TAO::Arg_Traits< ::CosLoadBalancing::LoadMonitor>::in_arg_val _tao_load_monitor (load_monitor);
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval,
      &_tao_the_location,
      &_tao_load_monitor
    };
  
  static TAO::Exception_Data
  _tao_CosLoadBalancing_LoadManager_register_load_monitor_exceptiondata [] = 
    {
      {
        "IDL:omg.org/CosLoadBalancing/MonitorAlreadyPresent:1.0",
        CosLoadBalancing::MonitorAlreadyPresent::_alloc,
        CosLoadBalancing::_tc_MonitorAlreadyPresent
      }
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      3,
      "register_load_monitor",
      21,
      this->the_TAO_LoadManager_Proxy_Broker_
    );
  
  _tao_call.invoke (
      _tao_CosLoadBalancing_LoadManager_register_load_monitor_exceptiondata,
      1
      ACE_ENV_ARG_PARAMETER
    );
  ACE_CHECK;
}

// TAO_IDL - Generated from
// be/be_visitor_operation/ami_cs.cpp:71

void
CosLoadBalancing::LoadManager::sendc_register_load_monitor (
    ::CosLoadBalancing::AMI_LoadManagerHandler_ptr ami_handler,
    const ::PortableGroup::Location & the_location,
    ::CosLoadBalancing::LoadMonitor_ptr load_monitor
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_LoadManager_Proxy_Broker_ == 0)
    {
      CosLoadBalancing_LoadManager_setup_collocation ();
    }
  
  TAO::Arg_Traits<void>::ret_val _tao_retval;
  TAO::Arg_Traits< ::PortableGroup::Location>::in_arg_val _tao_the_location (the_location);
  TAO::Arg_Traits< ::CosLoadBalancing::LoadMonitor>::in_arg_val _tao_load_monitor (load_monitor);
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval,
      &_tao_the_location,
      &_tao_load_monitor
    };
  
  TAO::Asynch_Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      3,
      "register_load_monitor",
      21,
      this->the_TAO_LoadManager_Proxy_Broker_
    );
  
  _tao_call.invoke (
      ami_handler,
      &CosLoadBalancing::AMI_LoadManagerHandler::register_load_monitor_reply_stub
      ACE_ENV_ARG_PARAMETER
    );
  ACE_CHECK;
}

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

::CosLoadBalancing::LoadMonitor_ptr CosLoadBalancing::LoadManager::get_load_monitor (
    const ::PortableGroup::Location & the_location
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException,
    ::CosLoadBalancing::LocationNotFound
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_LoadManager_Proxy_Broker_ == 0)
    {
      CosLoadBalancing_LoadManager_setup_collocation ();
    }
  
  TAO::Arg_Traits< ::CosLoadBalancing::LoadMonitor>::ret_val _tao_retval;
  TAO::Arg_Traits< ::PortableGroup::Location>::in_arg_val _tao_the_location (the_location);
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval,
      &_tao_the_location
    };
  
  static TAO::Exception_Data
  _tao_CosLoadBalancing_LoadManager_get_load_monitor_exceptiondata [] = 
    {
      {
        "IDL:omg.org/CosLoadBalancing/LocationNotFound:1.0",
        CosLoadBalancing::LocationNotFound::_alloc,
        CosLoadBalancing::_tc_LocationNotFound
      }
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      2,
      "get_load_monitor",
      16,
      this->the_TAO_LoadManager_Proxy_Broker_
    );
  
  _tao_call.invoke (
      _tao_CosLoadBalancing_LoadManager_get_load_monitor_exceptiondata,
      1
      ACE_ENV_ARG_PARAMETER
    );
  ACE_CHECK_RETURN (_tao_retval.excp ());
  
  return _tao_retval.retn ();
}

// TAO_IDL - Generated from
// be/be_visitor_operation/ami_cs.cpp:71

void
CosLoadBalancing::LoadManager::sendc_get_load_monitor (
    ::CosLoadBalancing::AMI_LoadManagerHandler_ptr ami_handler,
    const ::PortableGroup::Location & the_location
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_LoadManager_Proxy_Broker_ == 0)
    {
      CosLoadBalancing_LoadManager_setup_collocation ();
    }
  
  TAO::Arg_Traits<void>::ret_val _tao_retval;
  TAO::Arg_Traits< ::PortableGroup::Location>::in_arg_val _tao_the_location (the_location);
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval,
      &_tao_the_location
    };
  
  TAO::Asynch_Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      2,
      "get_load_monitor",
      16,
      this->the_TAO_LoadManager_Proxy_Broker_
    );
  
  _tao_call.invoke (
      ami_handler,
      &CosLoadBalancing::AMI_LoadManagerHandler::get_load_monitor_reply_stub
      ACE_ENV_ARG_PARAMETER
    );
  ACE_CHECK;
}

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

void CosLoadBalancing::LoadManager::remove_load_monitor (
    const ::PortableGroup::Location & the_location
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException,
    ::CosLoadBalancing::LocationNotFound
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_LoadManager_Proxy_Broker_ == 0)
    {
      CosLoadBalancing_LoadManager_setup_collocation ();
    }
  
  TAO::Arg_Traits< void>::ret_val _tao_retval;
  TAO::Arg_Traits< ::PortableGroup::Location>::in_arg_val _tao_the_location (the_location);
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval,
      &_tao_the_location
    };
  
  static TAO::Exception_Data
  _tao_CosLoadBalancing_LoadManager_remove_load_monitor_exceptiondata [] = 
    {
      {
        "IDL:omg.org/CosLoadBalancing/LocationNotFound:1.0",
        CosLoadBalancing::LocationNotFound::_alloc,
        CosLoadBalancing::_tc_LocationNotFound
      }
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      2,
      "remove_load_monitor",
      19,
      this->the_TAO_LoadManager_Proxy_Broker_
    );
  
  _tao_call.invoke (
      _tao_CosLoadBalancing_LoadManager_remove_load_monitor_exceptiondata,
      1
      ACE_ENV_ARG_PARAMETER
    );
  ACE_CHECK;
}

// TAO_IDL - Generated from
// be/be_visitor_operation/ami_cs.cpp:71

void
CosLoadBalancing::LoadManager::sendc_remove_load_monitor (
    ::CosLoadBalancing::AMI_LoadManagerHandler_ptr ami_handler,
    const ::PortableGroup::Location & the_location
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_LoadManager_Proxy_Broker_ == 0)
    {
      CosLoadBalancing_LoadManager_setup_collocation ();
    }
  
  TAO::Arg_Traits<void>::ret_val _tao_retval;
  TAO::Arg_Traits< ::PortableGroup::Location>::in_arg_val _tao_the_location (the_location);
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval,
      &_tao_the_location
    };
  
  TAO::Asynch_Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      2,
      "remove_load_monitor",
      19,
      this->the_TAO_LoadManager_Proxy_Broker_
    );
  
  _tao_call.invoke (
      ami_handler,
      &CosLoadBalancing::AMI_LoadManagerHandler::remove_load_monitor_reply_stub
      ACE_ENV_ARG_PARAMETER
    );
  ACE_CHECK;
}

CosLoadBalancing::LoadManager::LoadManager (void)
 : the_TAO_LoadManager_Proxy_Broker_ (0)
{
  this->CosLoadBalancing_LoadManager_setup_collocation ();
}

void
CosLoadBalancing::LoadManager::CosLoadBalancing_LoadManager_setup_collocation ()
{
  if (::CosLoadBalancing__TAO_LoadManager_Proxy_Broker_Factory_function_pointer)
    {
      this->the_TAO_LoadManager_Proxy_Broker_ =
        ::CosLoadBalancing__TAO_LoadManager_Proxy_Broker_Factory_function_pointer (this);
    }
  
  this->PortableGroup_PropertyManager_setup_collocation ();
  this->PortableGroup_ObjectGroupManager_setup_collocation ();
  this->PortableGroup_GenericFactory_setup_collocation ();
}

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

void 
CosLoadBalancing::LoadManager::_tao_any_destructor (void *_tao_void_pointer)
{
  LoadManager *_tao_tmp_pointer =
    static_cast<LoadManager *> (_tao_void_pointer);
  CORBA::release (_tao_tmp_pointer);
}

CosLoadBalancing::LoadManager_ptr
CosLoadBalancing::LoadManager::_narrow (
    CORBA::Object_ptr _tao_objref
    ACE_ENV_ARG_DECL
  )
{
  return
    TAO::Narrow_Utils<LoadManager>::narrow (
        _tao_objref,
        "IDL:omg.org/CosLoadBalancing/LoadManager:1.0",
        CosLoadBalancing__TAO_LoadManager_Proxy_Broker_Factory_function_pointer
        ACE_ENV_ARG_PARAMETER
      );
}

CosLoadBalancing::LoadManager_ptr
CosLoadBalancing::LoadManager::_unchecked_narrow (
    CORBA::Object_ptr _tao_objref
    ACE_ENV_ARG_DECL
  )
{
  return
    TAO::Narrow_Utils<LoadManager>::unchecked_narrow (
        _tao_objref,
        "IDL:omg.org/CosLoadBalancing/LoadManager:1.0",
        CosLoadBalancing__TAO_LoadManager_Proxy_Broker_Factory_function_pointer
        ACE_ENV_ARG_PARAMETER
      );
}

CosLoadBalancing::LoadManager_ptr
CosLoadBalancing::LoadManager::_duplicate (LoadManager_ptr obj)
{
  if (! CORBA::is_nil (obj))
    {
      obj->_add_ref ();
    }
  
  return obj;
}

CORBA::Boolean
CosLoadBalancing::LoadManager::_is_a (
    const char *value
    ACE_ENV_ARG_DECL
  )
{
  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; // success using local knowledge
    }
  else
    {
      return this->ACE_NESTED_CLASS (CORBA, Object)::_is_a (
          value
          ACE_ENV_ARG_PARAMETER
        );
    }
}

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

CORBA::Boolean
CosLoadBalancing::LoadManager::marshal (TAO_OutputCDR &cdr)
{
  return (cdr << this);
}

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

static const CORBA::Long _oc_CosLoadBalancing_LoadManager[] =
{
    TAO_ENCAP_BYTE_ORDER, // byte order
  45,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x436f734c), 
  ACE_NTOHL (0x6f616442), 
  ACE_NTOHL (0x616c616e), 
  ACE_NTOHL (0x63696e67), 
  ACE_NTOHL (0x2f4c6f61), 
  ACE_NTOHL (0x644d616e), 
  ACE_NTOHL (0x61676572), 
  ACE_NTOHL (0x3a312e30), 
  ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CosLoadBalancing/LoadManager:1.0
    12,
  ACE_NTOHL (0x4c6f6164), 
  ACE_NTOHL (0x4d616e61), 
  ACE_NTOHL (0x67657200),  // name = LoadManager
  };

static CORBA::TypeCode _tc_TAO_tc_CosLoadBalancing_LoadManager (
    CORBA::tk_objref,
    sizeof (_oc_CosLoadBalancing_LoadManager),
    (char *) &_oc_CosLoadBalancing_LoadManager,
    0,
    sizeof (CosLoadBalancing::LoadManager)
  );

namespace CosLoadBalancing
{
  ::CORBA::TypeCode_ptr _tc_LoadManager =
    &_tc_TAO_tc_CosLoadBalancing_LoadManager;
}

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

static const CORBA::Long _oc_CosLoadBalancing_AMI_LoadManagerExceptionHolder[] =
{
    TAO_ENCAP_BYTE_ORDER, // byte order
  9,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x3a312e30), 
  ACE_NTOHL (0x0),  // repository ID = IDL::1.0
    31,
  ACE_NTOHL (0x414d495f), 
  ACE_NTOHL (0x4c6f6164), 
  ACE_NTOHL (0x4d616e61), 
  ACE_NTOHL (0x67657245), 
  ACE_NTOHL (0x78636570), 
  ACE_NTOHL (0x74696f6e), 
  ACE_NTOHL (0x486f6c64), 
  ACE_NTOHL (0x65720000),  // name = AMI_LoadManagerExceptionHolder
    0, // value modifier
  CORBA::tk_value, // typecode kind
  64, // encapsulation length
    TAO_ENCAP_BYTE_ORDER, // byte order
    24,
    ACE_NTOHL (0x49444c3a), 
    ACE_NTOHL (0x45786365), 
    ACE_NTOHL (0x7074696f), 
    ACE_NTOHL (0x6e486f6c), 
    ACE_NTOHL (0x6465723a), 
    ACE_NTOHL (0x312e3000),  // repository ID = IDL:ExceptionHolder:1.0
        16,
    ACE_NTOHL (0x45786365), 
    ACE_NTOHL (0x7074696f), 
    ACE_NTOHL (0x6e486f6c), 
    ACE_NTOHL (0x64657200),  // name = ExceptionHolder
        0, // value modifier
    CORBA::tk_null, // no stateful base valuetype

0, // member count
    
0, // member count
  };

static CORBA::TypeCode _tc_TAO_tc_CosLoadBalancing_AMI_LoadManagerExceptionHolder (
    CORBA::tk_value,
    sizeof (_oc_CosLoadBalancing_AMI_LoadManagerExceptionHolder),
    (char *) &_oc_CosLoadBalancing_AMI_LoadManagerExceptionHolder,
    0,
    sizeof (CosLoadBalancing::AMI_LoadManagerExceptionHolder)
  );

namespace CosLoadBalancing
{
  ::CORBA::TypeCode_ptr _tc_AMI_LoadManagerExceptionHolder =
    &_tc_TAO_tc_CosLoadBalancing_AMI_LoadManagerExceptionHolder;
}

// TAO_IDL - Generated from
// be/be_visitor_valuetype/valuetype_cs.cpp:66

ACE_TEMPLATE_CLASS_MEMBER_SPECIALIZATION 
void
TAO::Value_Traits<CosLoadBalancing::AMI_LoadManagerExceptionHolder>::tao_add_ref (
    CosLoadBalancing::AMI_LoadManagerExceptionHolder * p
  )
{
  CORBA::add_ref (p);
}

ACE_TEMPLATE_CLASS_MEMBER_SPECIALIZATION 
void
TAO::Value_Traits<CosLoadBalancing::AMI_LoadManagerExceptionHolder>::tao_remove_ref (
    CosLoadBalancing::AMI_LoadManagerExceptionHolder * p
  )
{
  CORBA::remove_ref (p);
}

ACE_TEMPLATE_CLASS_MEMBER_SPECIALIZATION 
void
TAO::Value_Traits<CosLoadBalancing::AMI_LoadManagerExceptionHolder>::tao_release (
    CosLoadBalancing::AMI_LoadManagerExceptionHolder * p
  )
{
  CORBA::remove_ref (p);
}

CosLoadBalancing::AMI_LoadManagerExceptionHolder *
CosLoadBalancing::AMI_LoadManagerExceptionHolder::_downcast (CORBA::ValueBase *v)
{
  if (v == 0)
    {
      return 0;
    }
  
  return dynamic_cast< ::CosLoadBalancing::AMI_LoadManagerExceptionHolder * > (v);
}

const char *
CosLoadBalancing::AMI_LoadManagerExceptionHolder::_tao_obv_repository_id (void) const
{
  return this->_tao_obv_static_repository_id ();
}

void
CosLoadBalancing::AMI_LoadManagerExceptionHolder::_tao_any_destructor (void *_tao_void_pointer)
{
  AMI_LoadManagerExceptionHolder *_tao_tmp_pointer =
    static_cast<
        AMI_LoadManagerExceptionHolder *> (
        _tao_void_pointer
      );
  CORBA::remove_ref (_tao_tmp_pointer);
}

CORBA::Boolean CosLoadBalancing::AMI_LoadManagerExceptionHolder::_tao_marshal_v (TAO_OutputCDR & strm)
{
  return this->_tao_marshal__CosLoadBalancing_AMI_LoadManagerExceptionHolder (strm);
}

CORBA::Boolean CosLoadBalancing::AMI_LoadManagerExceptionHolder::_tao_unmarshal_v (TAO_InputCDR & strm)
{
  return this->_tao_unmarshal__CosLoadBalancing_AMI_LoadManagerExceptionHolder (strm);
}

CORBA::Boolean CosLoadBalancing::AMI_LoadManagerExceptionHolder::_tao_unmarshal (
    TAO_InputCDR &strm,
    AMI_LoadManagerExceptionHolder *&new_object
  )
{
  CORBA::ValueBase *base = 0;
  CORBA::ValueFactory_var factory;
  CORBA::Boolean retval =
    CORBA::ValueBase::_tao_unmarshal_pre (
        strm,
        factory.out (),
        base,
        AMI_LoadManagerExceptionHolder::_tao_obv_static_repository_id ()
      );
  
  if (retval == 0)
    {
      return 0;
    }
  
  if (factory.in () != 0)
    {
      base = factory->create_for_unmarshal ();
      
      if (base == 0)
        {
          return 0;  // %! except.?
        }
      
      retval = base->_tao_unmarshal_v (strm);
      
      if (retval == 0)
        {
          return 0;
        }
    }
  
  // Now base must be null or point to the unmarshaled object.
  // Align the pointer to the right subobject.
  new_object = AMI_LoadManagerExceptionHolder::_downcast (base);
  return retval;
}

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

// Traits specializations for CosLoadBalancing::AMI_LoadManagerHandler.

ACE_TEMPLATE_CLASS_MEMBER_SPECIALIZATION
CosLoadBalancing::AMI_LoadManagerHandler_ptr
TAO::Objref_Traits<CosLoadBalancing::AMI_LoadManagerHandler>::tao_duplicate (
    CosLoadBalancing::AMI_LoadManagerHandler_ptr p
  )
{
  return CosLoadBalancing::AMI_LoadManagerHandler::_duplicate (p);
}

ACE_TEMPLATE_CLASS_MEMBER_SPECIALIZATION
void
TAO::Objref_Traits<CosLoadBalancing::AMI_LoadManagerHandler>::tao_release (
    CosLoadBalancing::AMI_LoadManagerHandler_ptr p
  )
{
  CORBA::release (p);
}

ACE_TEMPLATE_CLASS_MEMBER_SPECIALIZATION
CosLoadBalancing::AMI_LoadManagerHandler_ptr
TAO::Objref_Traits<CosLoadBalancing::AMI_LoadManagerHandler>::tao_nil (void)
{
  return CosLoadBalancing::AMI_LoadManagerHandler::_nil ();
}

ACE_TEMPLATE_CLASS_MEMBER_SPECIALIZATION
CORBA::Boolean
TAO::Objref_Traits<CosLoadBalancing::AMI_LoadManagerHandler>::tao_marshal (
    CosLoadBalancing::AMI_LoadManagerHandler_ptr p,
    TAO_OutputCDR & cdr
  )
{
  return CORBA::Object::marshal (p, cdr);
}

// Function pointer for collocation factory initialization.
TAO::Collocation_Proxy_Broker * 
(*CosLoadBalancing__TAO_AMI_LoadManagerHandler_Proxy_Broker_Factory_function_pointer) (
    CORBA::Object_ptr obj
  ) = 0;

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

void CosLoadBalancing::AMI_LoadManagerHandler::push_loads (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_AMI_LoadManagerHandler_Proxy_Broker_ == 0)
    {
      CosLoadBalancing_AMI_LoadManagerHandler_setup_collocation ();
    }
  
  TAO::Arg_Traits< void>::ret_val _tao_retval;
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      1,
      "push_loads",
      10,
      this->the_TAO_AMI_LoadManagerHandler_Proxy_Broker_
    );
  
  _tao_call.invoke (0, 0 ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
}
void
CosLoadBalancing::AMI_LoadManagerHandler::push_loads_reply_stub (
  TAO_InputCDR &_tao_in, 
  Messaging::ReplyHandler_ptr _tao_reply_handler,
  CORBA::ULong reply_status
  ACE_ENV_ARG_DECL)
{
  // Retrieve Reply Handler object.
  CosLoadBalancing::AMI_LoadManagerHandler_var _tao_reply_handler_object =
    CosLoadBalancing::AMI_LoadManagerHandler::_narrow (_tao_reply_handler ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
  
  // Exception handling
  switch (reply_status)
  {
    case TAO_AMI_REPLY_OK:
    {
      // Demarshall all the arguments.
      // Invoke the call back method.
      _tao_reply_handler_object->push_loads (
          
          ACE_ENV_SINGLE_ARG_PARAMETER
        );
      ACE_CHECK;
      break;
    }
    case TAO_AMI_REPLY_USER_EXCEPTION:
    case TAO_AMI_REPLY_SYSTEM_EXCEPTION:
    {
      const ACE_Message_Block* cdr = _tao_in.start ();
      
      AMI_LoadManagerExceptionHolder_var exception_holder_var;
      ACE_NEW (
          exception_holder_var,
          OBV_CosLoadBalancing::_tao_AMI_LoadManagerExceptionHolder ()
        );
      
      CORBA::OctetSeq _tao_marshaled_exception (
          cdr->length (),
          cdr->length (),
          (unsigned char*) cdr->rd_ptr (),
          0
        );
      exception_holder_var->marshaled_exception (_tao_marshaled_exception);
      
      if (reply_status == TAO_AMI_REPLY_SYSTEM_EXCEPTION)
        exception_holder_var->is_system_exception (1);
      else
        exception_holder_var->is_system_exception (0);
      
      exception_holder_var->byte_order (_tao_in.byte_order ());
      
      _tao_reply_handler_object->push_loads_excep (
          exception_holder_var ACE_ENV_ARG_PARAMETER
        );
      ACE_CHECK;
      break;
    }
    case TAO_AMI_REPLY_NOT_OK:
      // @@ Michael: Not even the spec mentions this case.
      //             We have to think about this case.
      break;
  }
}



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

void CosLoadBalancing::AMI_LoadManagerHandler::push_loads_excep (
    ::CosLoadBalancing::AMI_LoadManagerExceptionHolder * excep_holder
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_AMI_LoadManagerHandler_Proxy_Broker_ == 0)
    {
      CosLoadBalancing_AMI_LoadManagerHandler_setup_collocation ();
    }
  
  TAO::Arg_Traits< void>::ret_val _tao_retval;
  TAO::Arg_Traits< ::CosLoadBalancing::AMI_LoadManagerExceptionHolder>::in_arg_val _tao_excep_holder (excep_holder);
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval,
      &_tao_excep_holder
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      2,
      "push_loads_excep",
      16,
      this->the_TAO_AMI_LoadManagerHandler_Proxy_Broker_
    );
  
  _tao_call.invoke (0, 0 ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
}

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

void CosLoadBalancing::AMI_LoadManagerHandler::get_loads (
    const ::CosLoadBalancing::LoadList & ami_return_val
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_AMI_LoadManagerHandler_Proxy_Broker_ == 0)
    {
      CosLoadBalancing_AMI_LoadManagerHandler_setup_collocation ();
    }
  
  TAO::Arg_Traits< void>::ret_val _tao_retval;
  TAO::Arg_Traits< ::CosLoadBalancing::LoadList>::in_arg_val _tao_ami_return_val (ami_return_val);
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval,
      &_tao_ami_return_val
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      2,
      "get_loads",
      9,
      this->the_TAO_AMI_LoadManagerHandler_Proxy_Broker_
    );
  
  _tao_call.invoke (0, 0 ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
}
void
CosLoadBalancing::AMI_LoadManagerHandler::get_loads_reply_stub (
  TAO_InputCDR &_tao_in, 
  Messaging::ReplyHandler_ptr _tao_reply_handler,
  CORBA::ULong reply_status
  ACE_ENV_ARG_DECL)
{
  // Retrieve Reply Handler object.
  CosLoadBalancing::AMI_LoadManagerHandler_var _tao_reply_handler_object =
    CosLoadBalancing::AMI_LoadManagerHandler::_narrow (_tao_reply_handler ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
  
  // Exception handling
  switch (reply_status)
  {
    case TAO_AMI_REPLY_OK:
    {

      ::CosLoadBalancing::LoadList ami_return_val;      // Demarshall all the arguments.
      if (!(

            (_tao_in >> ami_return_val)
         ))
        ACE_THROW (CORBA::MARSHAL ());
      
      // Invoke the call back method.
      _tao_reply_handler_object->get_loads (
          
          ami_return_val
          ACE_ENV_ARG_PARAMETER
        );
      ACE_CHECK;
      break;
    }
    case TAO_AMI_REPLY_USER_EXCEPTION:
    case TAO_AMI_REPLY_SYSTEM_EXCEPTION:
    {
      const ACE_Message_Block* cdr = _tao_in.start ();
      
      AMI_LoadManagerExceptionHolder_var exception_holder_var;
      ACE_NEW (
          exception_holder_var,
          OBV_CosLoadBalancing::_tao_AMI_LoadManagerExceptionHolder ()
        );
      
      CORBA::OctetSeq _tao_marshaled_exception (
          cdr->length (),
          cdr->length (),
          (unsigned char*) cdr->rd_ptr (),
          0
        );
      exception_holder_var->marshaled_exception (_tao_marshaled_exception);
      
      if (reply_status == TAO_AMI_REPLY_SYSTEM_EXCEPTION)
        exception_holder_var->is_system_exception (1);
      else
        exception_holder_var->is_system_exception (0);
      
      exception_holder_var->byte_order (_tao_in.byte_order ());
      
      _tao_reply_handler_object->get_loads_excep (
          exception_holder_var ACE_ENV_ARG_PARAMETER
        );
      ACE_CHECK;
      break;
    }
    case TAO_AMI_REPLY_NOT_OK:
      // @@ Michael: Not even the spec mentions this case.
      //             We have to think about this case.
      break;
  }
}



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

void CosLoadBalancing::AMI_LoadManagerHandler::get_loads_excep (
    ::CosLoadBalancing::AMI_LoadManagerExceptionHolder * excep_holder
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_AMI_LoadManagerHandler_Proxy_Broker_ == 0)
    {
      CosLoadBalancing_AMI_LoadManagerHandler_setup_collocation ();
    }
  
  TAO::Arg_Traits< void>::ret_val _tao_retval;
  TAO::Arg_Traits< ::CosLoadBalancing::AMI_LoadManagerExceptionHolder>::in_arg_val _tao_excep_holder (excep_holder);
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval,
      &_tao_excep_holder
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      2,
      "get_loads_excep",
      15,
      this->the_TAO_AMI_LoadManagerHandler_Proxy_Broker_
    );
  
  _tao_call.invoke (0, 0 ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
}

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

void CosLoadBalancing::AMI_LoadManagerHandler::enable_alert (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_AMI_LoadManagerHandler_Proxy_Broker_ == 0)
    {
      CosLoadBalancing_AMI_LoadManagerHandler_setup_collocation ();
    }
  
  TAO::Arg_Traits< void>::ret_val _tao_retval;
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      1,
      "enable_alert",
      12,
      this->the_TAO_AMI_LoadManagerHandler_Proxy_Broker_
    );
  
  _tao_call.invoke (0, 0 ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
}
void
CosLoadBalancing::AMI_LoadManagerHandler::enable_alert_reply_stub (
  TAO_InputCDR &_tao_in, 
  Messaging::ReplyHandler_ptr _tao_reply_handler,
  CORBA::ULong reply_status
  ACE_ENV_ARG_DECL)
{
  // Retrieve Reply Handler object.
  CosLoadBalancing::AMI_LoadManagerHandler_var _tao_reply_handler_object =
    CosLoadBalancing::AMI_LoadManagerHandler::_narrow (_tao_reply_handler ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
  
  // Exception handling
  switch (reply_status)
  {
    case TAO_AMI_REPLY_OK:
    {
      // Demarshall all the arguments.
      // Invoke the call back method.
      _tao_reply_handler_object->enable_alert (
          
          ACE_ENV_SINGLE_ARG_PARAMETER
        );
      ACE_CHECK;
      break;
    }
    case TAO_AMI_REPLY_USER_EXCEPTION:
    case TAO_AMI_REPLY_SYSTEM_EXCEPTION:
    {
      const ACE_Message_Block* cdr = _tao_in.start ();
      
      AMI_LoadManagerExceptionHolder_var exception_holder_var;
      ACE_NEW (
          exception_holder_var,
          OBV_CosLoadBalancing::_tao_AMI_LoadManagerExceptionHolder ()
        );
      
      CORBA::OctetSeq _tao_marshaled_exception (
          cdr->length (),
          cdr->length (),
          (unsigned char*) cdr->rd_ptr (),
          0
        );
      exception_holder_var->marshaled_exception (_tao_marshaled_exception);
      
      if (reply_status == TAO_AMI_REPLY_SYSTEM_EXCEPTION)
        exception_holder_var->is_system_exception (1);
      else
        exception_holder_var->is_system_exception (0);
      
      exception_holder_var->byte_order (_tao_in.byte_order ());
      
      _tao_reply_handler_object->enable_alert_excep (
          exception_holder_var ACE_ENV_ARG_PARAMETER
        );
      ACE_CHECK;
      break;
    }
    case TAO_AMI_REPLY_NOT_OK:
      // @@ Michael: Not even the spec mentions this case.
      //             We have to think about this case.
      break;
  }
}



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

void CosLoadBalancing::AMI_LoadManagerHandler::enable_alert_excep (
    ::CosLoadBalancing::AMI_LoadManagerExceptionHolder * excep_holder
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_AMI_LoadManagerHandler_Proxy_Broker_ == 0)
    {
      CosLoadBalancing_AMI_LoadManagerHandler_setup_collocation ();
    }
  
  TAO::Arg_Traits< void>::ret_val _tao_retval;
  TAO::Arg_Traits< ::CosLoadBalancing::AMI_LoadManagerExceptionHolder>::in_arg_val _tao_excep_holder (excep_holder);
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval,
      &_tao_excep_holder
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      2,
      "enable_alert_excep",
      18,
      this->the_TAO_AMI_LoadManagerHandler_Proxy_Broker_
    );
  
  _tao_call.invoke (0, 0 ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
}

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

void CosLoadBalancing::AMI_LoadManagerHandler::disable_alert (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_AMI_LoadManagerHandler_Proxy_Broker_ == 0)
    {
      CosLoadBalancing_AMI_LoadManagerHandler_setup_collocation ();
    }
  
  TAO::Arg_Traits< void>::ret_val _tao_retval;
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      1,
      "disable_alert",
      13,
      this->the_TAO_AMI_LoadManagerHandler_Proxy_Broker_
    );
  
  _tao_call.invoke (0, 0 ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
}
void
CosLoadBalancing::AMI_LoadManagerHandler::disable_alert_reply_stub (
  TAO_InputCDR &_tao_in, 
  Messaging::ReplyHandler_ptr _tao_reply_handler,
  CORBA::ULong reply_status
  ACE_ENV_ARG_DECL)
{
  // Retrieve Reply Handler object.
  CosLoadBalancing::AMI_LoadManagerHandler_var _tao_reply_handler_object =
    CosLoadBalancing::AMI_LoadManagerHandler::_narrow (_tao_reply_handler ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
  
  // Exception handling
  switch (reply_status)
  {
    case TAO_AMI_REPLY_OK:
    {
      // Demarshall all the arguments.
      // Invoke the call back method.
      _tao_reply_handler_object->disable_alert (
          
          ACE_ENV_SINGLE_ARG_PARAMETER
        );
      ACE_CHECK;
      break;
    }
    case TAO_AMI_REPLY_USER_EXCEPTION:
    case TAO_AMI_REPLY_SYSTEM_EXCEPTION:
    {
      const ACE_Message_Block* cdr = _tao_in.start ();
      
      AMI_LoadManagerExceptionHolder_var exception_holder_var;
      ACE_NEW (
          exception_holder_var,
          OBV_CosLoadBalancing::_tao_AMI_LoadManagerExceptionHolder ()
        );
      
      CORBA::OctetSeq _tao_marshaled_exception (
          cdr->length (),
          cdr->length (),
          (unsigned char*) cdr->rd_ptr (),
          0
        );
      exception_holder_var->marshaled_exception (_tao_marshaled_exception);
      
      if (reply_status == TAO_AMI_REPLY_SYSTEM_EXCEPTION)
        exception_holder_var->is_system_exception (1);
      else
        exception_holder_var->is_system_exception (0);
      
      exception_holder_var->byte_order (_tao_in.byte_order ());
      
      _tao_reply_handler_object->disable_alert_excep (
          exception_holder_var ACE_ENV_ARG_PARAMETER
        );
      ACE_CHECK;
      break;
    }
    case TAO_AMI_REPLY_NOT_OK:
      // @@ Michael: Not even the spec mentions this case.
      //             We have to think about this case.
      break;
  }
}



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

void CosLoadBalancing::AMI_LoadManagerHandler::disable_alert_excep (
    ::CosLoadBalancing::AMI_LoadManagerExceptionHolder * excep_holder
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_AMI_LoadManagerHandler_Proxy_Broker_ == 0)
    {
      CosLoadBalancing_AMI_LoadManagerHandler_setup_collocation ();
    }
  
  TAO::Arg_Traits< void>::ret_val _tao_retval;
  TAO::Arg_Traits< ::CosLoadBalancing::AMI_LoadManagerExceptionHolder>::in_arg_val _tao_excep_holder (excep_holder);
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval,
      &_tao_excep_holder
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      2,
      "disable_alert_excep",
      19,
      this->the_TAO_AMI_LoadManagerHandler_Proxy_Broker_
    );
  
  _tao_call.invoke (0, 0 ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
}

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

void CosLoadBalancing::AMI_LoadManagerHandler::register_load_alert (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_AMI_LoadManagerHandler_Proxy_Broker_ == 0)
    {
      CosLoadBalancing_AMI_LoadManagerHandler_setup_collocation ();
    }
  
  TAO::Arg_Traits< void>::ret_val _tao_retval;
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      1,
      "register_load_alert",
      19,
      this->the_TAO_AMI_LoadManagerHandler_Proxy_Broker_
    );
  
  _tao_call.invoke (0, 0 ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
}
void
CosLoadBalancing::AMI_LoadManagerHandler::register_load_alert_reply_stub (
  TAO_InputCDR &_tao_in, 
  Messaging::ReplyHandler_ptr _tao_reply_handler,
  CORBA::ULong reply_status
  ACE_ENV_ARG_DECL)
{
  // Retrieve Reply Handler object.
  CosLoadBalancing::AMI_LoadManagerHandler_var _tao_reply_handler_object =
    CosLoadBalancing::AMI_LoadManagerHandler::_narrow (_tao_reply_handler ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
  
  // Exception handling
  switch (reply_status)
  {
    case TAO_AMI_REPLY_OK:
    {
      // Demarshall all the arguments.
      // Invoke the call back method.
      _tao_reply_handler_object->register_load_alert (
          
          ACE_ENV_SINGLE_ARG_PARAMETER
        );
      ACE_CHECK;
      break;
    }
    case TAO_AMI_REPLY_USER_EXCEPTION:
    case TAO_AMI_REPLY_SYSTEM_EXCEPTION:
    {
      const ACE_Message_Block* cdr = _tao_in.start ();
      
      AMI_LoadManagerExceptionHolder_var exception_holder_var;
      ACE_NEW (
          exception_holder_var,
          OBV_CosLoadBalancing::_tao_AMI_LoadManagerExceptionHolder ()
        );
      
      CORBA::OctetSeq _tao_marshaled_exception (
          cdr->length (),
          cdr->length (),
          (unsigned char*) cdr->rd_ptr (),
          0
        );
      exception_holder_var->marshaled_exception (_tao_marshaled_exception);
      
      if (reply_status == TAO_AMI_REPLY_SYSTEM_EXCEPTION)
        exception_holder_var->is_system_exception (1);
      else
        exception_holder_var->is_system_exception (0);
      
      exception_holder_var->byte_order (_tao_in.byte_order ());
      
      _tao_reply_handler_object->register_load_alert_excep (
          exception_holder_var ACE_ENV_ARG_PARAMETER
        );
      ACE_CHECK;
      break;
    }
    case TAO_AMI_REPLY_NOT_OK:
      // @@ Michael: Not even the spec mentions this case.
      //             We have to think about this case.
      break;
  }
}



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

void CosLoadBalancing::AMI_LoadManagerHandler::register_load_alert_excep (
    ::CosLoadBalancing::AMI_LoadManagerExceptionHolder * excep_holder
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_AMI_LoadManagerHandler_Proxy_Broker_ == 0)
    {
      CosLoadBalancing_AMI_LoadManagerHandler_setup_collocation ();
    }
  
  TAO::Arg_Traits< void>::ret_val _tao_retval;
  TAO::Arg_Traits< ::CosLoadBalancing::AMI_LoadManagerExceptionHolder>::in_arg_val _tao_excep_holder (excep_holder);
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval,
      &_tao_excep_holder
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      2,
      "register_load_alert_excep",
      25,
      this->the_TAO_AMI_LoadManagerHandler_Proxy_Broker_
    );
  
  _tao_call.invoke (0, 0 ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
}

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

void CosLoadBalancing::AMI_LoadManagerHandler::get_load_alert (
    ::CosLoadBalancing::LoadAlert_ptr ami_return_val
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_AMI_LoadManagerHandler_Proxy_Broker_ == 0)
    {
      CosLoadBalancing_AMI_LoadManagerHandler_setup_collocation ();
    }
  
  TAO::Arg_Traits< void>::ret_val _tao_retval;
  TAO::Arg_Traits< ::CosLoadBalancing::LoadAlert>::in_arg_val _tao_ami_return_val (ami_return_val);
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval,
      &_tao_ami_return_val
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      2,
      "get_load_alert",
      14,
      this->the_TAO_AMI_LoadManagerHandler_Proxy_Broker_
    );
  
  _tao_call.invoke (0, 0 ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
}
void
CosLoadBalancing::AMI_LoadManagerHandler::get_load_alert_reply_stub (
  TAO_InputCDR &_tao_in, 
  Messaging::ReplyHandler_ptr _tao_reply_handler,
  CORBA::ULong reply_status
  ACE_ENV_ARG_DECL)
{
  // Retrieve Reply Handler object.
  CosLoadBalancing::AMI_LoadManagerHandler_var _tao_reply_handler_object =
    CosLoadBalancing::AMI_LoadManagerHandler::_narrow (_tao_reply_handler ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
  
  // Exception handling
  switch (reply_status)
  {
    case TAO_AMI_REPLY_OK:
    {

      ::CosLoadBalancing::LoadAlert_var ami_return_val;      // Demarshall all the arguments.
      if (!(

            (_tao_in >> ami_return_val.out ())
         ))
        ACE_THROW (CORBA::MARSHAL ());
      
      // Invoke the call back method.
      _tao_reply_handler_object->get_load_alert (
          
          ami_return_val.in ()
          ACE_ENV_ARG_PARAMETER
        );
      ACE_CHECK;
      break;
    }
    case TAO_AMI_REPLY_USER_EXCEPTION:
    case TAO_AMI_REPLY_SYSTEM_EXCEPTION:
    {
      const ACE_Message_Block* cdr = _tao_in.start ();
      
      AMI_LoadManagerExceptionHolder_var exception_holder_var;
      ACE_NEW (
          exception_holder_var,
          OBV_CosLoadBalancing::_tao_AMI_LoadManagerExceptionHolder ()
        );
      
      CORBA::OctetSeq _tao_marshaled_exception (
          cdr->length (),
          cdr->length (),
          (unsigned char*) cdr->rd_ptr (),
          0
        );
      exception_holder_var->marshaled_exception (_tao_marshaled_exception);
      
      if (reply_status == TAO_AMI_REPLY_SYSTEM_EXCEPTION)
        exception_holder_var->is_system_exception (1);
      else
        exception_holder_var->is_system_exception (0);
      
      exception_holder_var->byte_order (_tao_in.byte_order ());
      
      _tao_reply_handler_object->get_load_alert_excep (
          exception_holder_var ACE_ENV_ARG_PARAMETER
        );
      ACE_CHECK;
      break;
    }
    case TAO_AMI_REPLY_NOT_OK:
      // @@ Michael: Not even the spec mentions this case.
      //             We have to think about this case.
      break;
  }
}



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

void CosLoadBalancing::AMI_LoadManagerHandler::get_load_alert_excep (
    ::CosLoadBalancing::AMI_LoadManagerExceptionHolder * excep_holder
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_AMI_LoadManagerHandler_Proxy_Broker_ == 0)
    {
      CosLoadBalancing_AMI_LoadManagerHandler_setup_collocation ();
    }
  
  TAO::Arg_Traits< void>::ret_val _tao_retval;
  TAO::Arg_Traits< ::CosLoadBalancing::AMI_LoadManagerExceptionHolder>::in_arg_val _tao_excep_holder (excep_holder);
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval,
      &_tao_excep_holder
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      2,
      "get_load_alert_excep",
      20,
      this->the_TAO_AMI_LoadManagerHandler_Proxy_Broker_
    );
  
  _tao_call.invoke (0, 0 ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
}

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

void CosLoadBalancing::AMI_LoadManagerHandler::remove_load_alert (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_AMI_LoadManagerHandler_Proxy_Broker_ == 0)
    {
      CosLoadBalancing_AMI_LoadManagerHandler_setup_collocation ();
    }
  
  TAO::Arg_Traits< void>::ret_val _tao_retval;
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      1,
      "remove_load_alert",
      17,
      this->the_TAO_AMI_LoadManagerHandler_Proxy_Broker_
    );
  
  _tao_call.invoke (0, 0 ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
}
void
CosLoadBalancing::AMI_LoadManagerHandler::remove_load_alert_reply_stub (
  TAO_InputCDR &_tao_in, 
  Messaging::ReplyHandler_ptr _tao_reply_handler,
  CORBA::ULong reply_status
  ACE_ENV_ARG_DECL)
{
  // Retrieve Reply Handler object.
  CosLoadBalancing::AMI_LoadManagerHandler_var _tao_reply_handler_object =
    CosLoadBalancing::AMI_LoadManagerHandler::_narrow (_tao_reply_handler ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
  
  // Exception handling
  switch (reply_status)
  {
    case TAO_AMI_REPLY_OK:
    {
      // Demarshall all the arguments.
      // Invoke the call back method.
      _tao_reply_handler_object->remove_load_alert (
          
          ACE_ENV_SINGLE_ARG_PARAMETER
        );
      ACE_CHECK;
      break;
    }
    case TAO_AMI_REPLY_USER_EXCEPTION:
    case TAO_AMI_REPLY_SYSTEM_EXCEPTION:
    {
      const ACE_Message_Block* cdr = _tao_in.start ();
      
      AMI_LoadManagerExceptionHolder_var exception_holder_var;
      ACE_NEW (
          exception_holder_var,
          OBV_CosLoadBalancing::_tao_AMI_LoadManagerExceptionHolder ()
        );
      
      CORBA::OctetSeq _tao_marshaled_exception (
          cdr->length (),
          cdr->length (),
          (unsigned char*) cdr->rd_ptr (),
          0
        );
      exception_holder_var->marshaled_exception (_tao_marshaled_exception);
      
      if (reply_status == TAO_AMI_REPLY_SYSTEM_EXCEPTION)
        exception_holder_var->is_system_exception (1);
      else
        exception_holder_var->is_system_exception (0);
      
      exception_holder_var->byte_order (_tao_in.byte_order ());
      
      _tao_reply_handler_object->remove_load_alert_excep (
          exception_holder_var ACE_ENV_ARG_PARAMETER
        );
      ACE_CHECK;
      break;
    }
    case TAO_AMI_REPLY_NOT_OK:
      // @@ Michael: Not even the spec mentions this case.
      //             We have to think about this case.
      break;
  }
}



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

void CosLoadBalancing::AMI_LoadManagerHandler::remove_load_alert_excep (
    ::CosLoadBalancing::AMI_LoadManagerExceptionHolder * excep_holder
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_AMI_LoadManagerHandler_Proxy_Broker_ == 0)
    {
      CosLoadBalancing_AMI_LoadManagerHandler_setup_collocation ();
    }
  
  TAO::Arg_Traits< void>::ret_val _tao_retval;
  TAO::Arg_Traits< ::CosLoadBalancing::AMI_LoadManagerExceptionHolder>::in_arg_val _tao_excep_holder (excep_holder);
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval,
      &_tao_excep_holder
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      2,
      "remove_load_alert_excep",
      23,
      this->the_TAO_AMI_LoadManagerHandler_Proxy_Broker_
    );
  
  _tao_call.invoke (0, 0 ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
}

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

void CosLoadBalancing::AMI_LoadManagerHandler::register_load_monitor (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_AMI_LoadManagerHandler_Proxy_Broker_ == 0)
    {
      CosLoadBalancing_AMI_LoadManagerHandler_setup_collocation ();
    }
  
  TAO::Arg_Traits< void>::ret_val _tao_retval;
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      1,
      "register_load_monitor",
      21,
      this->the_TAO_AMI_LoadManagerHandler_Proxy_Broker_
    );
  
  _tao_call.invoke (0, 0 ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
}
void
CosLoadBalancing::AMI_LoadManagerHandler::register_load_monitor_reply_stub (
  TAO_InputCDR &_tao_in, 
  Messaging::ReplyHandler_ptr _tao_reply_handler,
  CORBA::ULong reply_status
  ACE_ENV_ARG_DECL)
{
  // Retrieve Reply Handler object.
  CosLoadBalancing::AMI_LoadManagerHandler_var _tao_reply_handler_object =
    CosLoadBalancing::AMI_LoadManagerHandler::_narrow (_tao_reply_handler ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
  
  // Exception handling
  switch (reply_status)
  {
    case TAO_AMI_REPLY_OK:
    {
      // Demarshall all the arguments.
      // Invoke the call back method.
      _tao_reply_handler_object->register_load_monitor (
          
          ACE_ENV_SINGLE_ARG_PARAMETER
        );
      ACE_CHECK;
      break;
    }
    case TAO_AMI_REPLY_USER_EXCEPTION:
    case TAO_AMI_REPLY_SYSTEM_EXCEPTION:
    {
      const ACE_Message_Block* cdr = _tao_in.start ();
      
      AMI_LoadManagerExceptionHolder_var exception_holder_var;
      ACE_NEW (
          exception_holder_var,
          OBV_CosLoadBalancing::_tao_AMI_LoadManagerExceptionHolder ()
        );
      
      CORBA::OctetSeq _tao_marshaled_exception (
          cdr->length (),
          cdr->length (),
          (unsigned char*) cdr->rd_ptr (),
          0
        );
      exception_holder_var->marshaled_exception (_tao_marshaled_exception);
      
      if (reply_status == TAO_AMI_REPLY_SYSTEM_EXCEPTION)
        exception_holder_var->is_system_exception (1);
      else
        exception_holder_var->is_system_exception (0);
      
      exception_holder_var->byte_order (_tao_in.byte_order ());
      
      _tao_reply_handler_object->register_load_monitor_excep (
          exception_holder_var ACE_ENV_ARG_PARAMETER
        );
      ACE_CHECK;
      break;
    }
    case TAO_AMI_REPLY_NOT_OK:
      // @@ Michael: Not even the spec mentions this case.
      //             We have to think about this case.
      break;
  }
}



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

void CosLoadBalancing::AMI_LoadManagerHandler::register_load_monitor_excep (
    ::CosLoadBalancing::AMI_LoadManagerExceptionHolder * excep_holder
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_AMI_LoadManagerHandler_Proxy_Broker_ == 0)
    {
      CosLoadBalancing_AMI_LoadManagerHandler_setup_collocation ();
    }
  
  TAO::Arg_Traits< void>::ret_val _tao_retval;
  TAO::Arg_Traits< ::CosLoadBalancing::AMI_LoadManagerExceptionHolder>::in_arg_val _tao_excep_holder (excep_holder);
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval,
      &_tao_excep_holder
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      2,
      "register_load_monitor_excep",
      27,
      this->the_TAO_AMI_LoadManagerHandler_Proxy_Broker_
    );
  
  _tao_call.invoke (0, 0 ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
}

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

void CosLoadBalancing::AMI_LoadManagerHandler::get_load_monitor (
    ::CosLoadBalancing::LoadMonitor_ptr ami_return_val
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_AMI_LoadManagerHandler_Proxy_Broker_ == 0)
    {
      CosLoadBalancing_AMI_LoadManagerHandler_setup_collocation ();
    }
  
  TAO::Arg_Traits< void>::ret_val _tao_retval;
  TAO::Arg_Traits< ::CosLoadBalancing::LoadMonitor>::in_arg_val _tao_ami_return_val (ami_return_val);
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval,
      &_tao_ami_return_val
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      2,
      "get_load_monitor",
      16,
      this->the_TAO_AMI_LoadManagerHandler_Proxy_Broker_
    );
  
  _tao_call.invoke (0, 0 ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
}
void
CosLoadBalancing::AMI_LoadManagerHandler::get_load_monitor_reply_stub (
  TAO_InputCDR &_tao_in, 
  Messaging::ReplyHandler_ptr _tao_reply_handler,
  CORBA::ULong reply_status
  ACE_ENV_ARG_DECL)
{
  // Retrieve Reply Handler object.
  CosLoadBalancing::AMI_LoadManagerHandler_var _tao_reply_handler_object =
    CosLoadBalancing::AMI_LoadManagerHandler::_narrow (_tao_reply_handler ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
  
  // Exception handling
  switch (reply_status)
  {
    case TAO_AMI_REPLY_OK:
    {

      ::CosLoadBalancing::LoadMonitor_var ami_return_val;      // Demarshall all the arguments.
      if (!(

            (_tao_in >> ami_return_val.out ())
         ))
        ACE_THROW (CORBA::MARSHAL ());
      
      // Invoke the call back method.
      _tao_reply_handler_object->get_load_monitor (
          
          ami_return_val.in ()
          ACE_ENV_ARG_PARAMETER
        );
      ACE_CHECK;
      break;
    }
    case TAO_AMI_REPLY_USER_EXCEPTION:
    case TAO_AMI_REPLY_SYSTEM_EXCEPTION:
    {
      const ACE_Message_Block* cdr = _tao_in.start ();
      
      AMI_LoadManagerExceptionHolder_var exception_holder_var;
      ACE_NEW (
          exception_holder_var,
          OBV_CosLoadBalancing::_tao_AMI_LoadManagerExceptionHolder ()
        );
      
      CORBA::OctetSeq _tao_marshaled_exception (
          cdr->length (),
          cdr->length (),
          (unsigned char*) cdr->rd_ptr (),
          0
        );
      exception_holder_var->marshaled_exception (_tao_marshaled_exception);
      
      if (reply_status == TAO_AMI_REPLY_SYSTEM_EXCEPTION)
        exception_holder_var->is_system_exception (1);
      else
        exception_holder_var->is_system_exception (0);
      
      exception_holder_var->byte_order (_tao_in.byte_order ());
      
      _tao_reply_handler_object->get_load_monitor_excep (
          exception_holder_var ACE_ENV_ARG_PARAMETER
        );
      ACE_CHECK;
      break;
    }
    case TAO_AMI_REPLY_NOT_OK:
      // @@ Michael: Not even the spec mentions this case.
      //             We have to think about this case.
      break;
  }
}



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

void CosLoadBalancing::AMI_LoadManagerHandler::get_load_monitor_excep (
    ::CosLoadBalancing::AMI_LoadManagerExceptionHolder * excep_holder
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_AMI_LoadManagerHandler_Proxy_Broker_ == 0)
    {
      CosLoadBalancing_AMI_LoadManagerHandler_setup_collocation ();
    }
  
  TAO::Arg_Traits< void>::ret_val _tao_retval;
  TAO::Arg_Traits< ::CosLoadBalancing::AMI_LoadManagerExceptionHolder>::in_arg_val _tao_excep_holder (excep_holder);
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval,
      &_tao_excep_holder
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      2,
      "get_load_monitor_excep",
      22,
      this->the_TAO_AMI_LoadManagerHandler_Proxy_Broker_
    );
  
  _tao_call.invoke (0, 0 ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
}

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

void CosLoadBalancing::AMI_LoadManagerHandler::remove_load_monitor (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_AMI_LoadManagerHandler_Proxy_Broker_ == 0)
    {
      CosLoadBalancing_AMI_LoadManagerHandler_setup_collocation ();
    }
  
  TAO::Arg_Traits< void>::ret_val _tao_retval;
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      1,
      "remove_load_monitor",
      19,
      this->the_TAO_AMI_LoadManagerHandler_Proxy_Broker_
    );
  
  _tao_call.invoke (0, 0 ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
}
void
CosLoadBalancing::AMI_LoadManagerHandler::remove_load_monitor_reply_stub (
  TAO_InputCDR &_tao_in, 
  Messaging::ReplyHandler_ptr _tao_reply_handler,
  CORBA::ULong reply_status
  ACE_ENV_ARG_DECL)
{
  // Retrieve Reply Handler object.
  CosLoadBalancing::AMI_LoadManagerHandler_var _tao_reply_handler_object =
    CosLoadBalancing::AMI_LoadManagerHandler::_narrow (_tao_reply_handler ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
  
  // Exception handling
  switch (reply_status)
  {
    case TAO_AMI_REPLY_OK:
    {
      // Demarshall all the arguments.
      // Invoke the call back method.
      _tao_reply_handler_object->remove_load_monitor (
          
          ACE_ENV_SINGLE_ARG_PARAMETER
        );
      ACE_CHECK;
      break;
    }
    case TAO_AMI_REPLY_USER_EXCEPTION:
    case TAO_AMI_REPLY_SYSTEM_EXCEPTION:
    {
      const ACE_Message_Block* cdr = _tao_in.start ();
      
      AMI_LoadManagerExceptionHolder_var exception_holder_var;
      ACE_NEW (
          exception_holder_var,
          OBV_CosLoadBalancing::_tao_AMI_LoadManagerExceptionHolder ()
        );
      
      CORBA::OctetSeq _tao_marshaled_exception (
          cdr->length (),
          cdr->length (),
          (unsigned char*) cdr->rd_ptr (),
          0
        );
      exception_holder_var->marshaled_exception (_tao_marshaled_exception);
      
      if (reply_status == TAO_AMI_REPLY_SYSTEM_EXCEPTION)
        exception_holder_var->is_system_exception (1);
      else
        exception_holder_var->is_system_exception (0);
      
      exception_holder_var->byte_order (_tao_in.byte_order ());
      
      _tao_reply_handler_object->remove_load_monitor_excep (
          exception_holder_var ACE_ENV_ARG_PARAMETER
        );
      ACE_CHECK;
      break;
    }
    case TAO_AMI_REPLY_NOT_OK:
      // @@ Michael: Not even the spec mentions this case.
      //             We have to think about this case.
      break;
  }
}



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

void CosLoadBalancing::AMI_LoadManagerHandler::remove_load_monitor_excep (
    ::CosLoadBalancing::AMI_LoadManagerExceptionHolder * excep_holder
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_AMI_LoadManagerHandler_Proxy_Broker_ == 0)
    {
      CosLoadBalancing_AMI_LoadManagerHandler_setup_collocation ();
    }
  
  TAO::Arg_Traits< void>::ret_val _tao_retval;
  TAO::Arg_Traits< ::CosLoadBalancing::AMI_LoadManagerExceptionHolder>::in_arg_val _tao_excep_holder (excep_holder);
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval,
      &_tao_excep_holder
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      2,
      "remove_load_monitor_excep",
      25,
      this->the_TAO_AMI_LoadManagerHandler_Proxy_Broker_
    );
  
  _tao_call.invoke (0, 0 ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
}

CosLoadBalancing::AMI_LoadManagerHandler::AMI_LoadManagerHandler (void)
 : the_TAO_AMI_LoadManagerHandler_Proxy_Broker_ (0)
{
  this->CosLoadBalancing_AMI_LoadManagerHandler_setup_collocation ();
}

void
CosLoadBalancing::AMI_LoadManagerHandler::CosLoadBalancing_AMI_LoadManagerHandler_setup_collocation ()
{
  if (::CosLoadBalancing__TAO_AMI_LoadManagerHandler_Proxy_Broker_Factory_function_pointer)
    {
      this->the_TAO_AMI_LoadManagerHandler_Proxy_Broker_ =
        ::CosLoadBalancing__TAO_AMI_LoadManagerHandler_Proxy_Broker_Factory_function_pointer (this);
    }
  
  this->PortableGroup_AMI_PropertyManagerHandler_setup_collocation ();
  this->PortableGroup_AMI_ObjectGroupManagerHandler_setup_collocation ();
  this->PortableGroup_AMI_GenericFactoryHandler_setup_collocation ();
}

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

void 
CosLoadBalancing::AMI_LoadManagerHandler::_tao_any_destructor (void *_tao_void_pointer)
{
  AMI_LoadManagerHandler *_tao_tmp_pointer =
    static_cast<AMI_LoadManagerHandler *> (_tao_void_pointer);
  CORBA::release (_tao_tmp_pointer);
}

CosLoadBalancing::AMI_LoadManagerHandler_ptr
CosLoadBalancing::AMI_LoadManagerHandler::_narrow (
    CORBA::Object_ptr _tao_objref
    ACE_ENV_ARG_DECL
  )
{
  return
    TAO::Narrow_Utils<AMI_LoadManagerHandler>::narrow (
        _tao_objref,
        "IDL:AMI_LoadManagerHandler:1.0",
        CosLoadBalancing__TAO_AMI_LoadManagerHandler_Proxy_Broker_Factory_function_pointer
        ACE_ENV_ARG_PARAMETER
      );
}

CosLoadBalancing::AMI_LoadManagerHandler_ptr
CosLoadBalancing::AMI_LoadManagerHandler::_unchecked_narrow (
    CORBA::Object_ptr _tao_objref
    ACE_ENV_ARG_DECL
  )
{
  return
    TAO::Narrow_Utils<AMI_LoadManagerHandler>::unchecked_narrow (
        _tao_objref,
        "IDL:AMI_LoadManagerHandler:1.0",
        CosLoadBalancing__TAO_AMI_LoadManagerHandler_Proxy_Broker_Factory_function_pointer
        ACE_ENV_ARG_PARAMETER
      );
}

CosLoadBalancing::AMI_LoadManagerHandler_ptr
CosLoadBalancing::AMI_LoadManagerHandler::_duplicate (AMI_LoadManagerHandler_ptr obj)
{
  if (! CORBA::is_nil (obj))
    {
      obj->_add_ref ();
    }
  
  return obj;
}

CORBA::Boolean
CosLoadBalancing::AMI_LoadManagerHandler::_is_a (
    const char *value
    ACE_ENV_ARG_DECL
  )
{
  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; // success using local knowledge
    }
  else
    {
      return this->ACE_NESTED_CLASS (CORBA, Object)::_is_a (
          value
          ACE_ENV_ARG_PARAMETER
        );
    }
}

const char* CosLoadBalancing::AMI_LoadManagerHandler::_interface_repository_id (void) const
{
  return "IDL:AMI_LoadManagerHandler:1.0";
}

CORBA::Boolean
CosLoadBalancing::AMI_LoadManagerHandler::marshal (TAO_OutputCDR &cdr)
{
  return (cdr << this);
}

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

static const CORBA::Long _oc_CosLoadBalancing_AMI_LoadManagerHandler[] =
{
    TAO_ENCAP_BYTE_ORDER, // byte order
  31,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x414d495f), 
  ACE_NTOHL (0x4c6f6164), 
  ACE_NTOHL (0x4d616e61), 
  ACE_NTOHL (0x67657248), 
  ACE_NTOHL (0x616e646c), 
  ACE_NTOHL (0x65723a31), 
  ACE_NTOHL (0x2e300000),  // repository ID = IDL:AMI_LoadManagerHandler:1.0
    23,
  ACE_NTOHL (0x414d495f), 
  ACE_NTOHL (0x4c6f6164), 
  ACE_NTOHL (0x4d616e61), 
  ACE_NTOHL (0x67657248), 
  ACE_NTOHL (0x616e646c), 
  ACE_NTOHL (0x65720000),  // name = AMI_LoadManagerHandler
  };

static CORBA::TypeCode _tc_TAO_tc_CosLoadBalancing_AMI_LoadManagerHandler (
    CORBA::tk_objref,
    sizeof (_oc_CosLoadBalancing_AMI_LoadManagerHandler),
    (char *) &_oc_CosLoadBalancing_AMI_LoadManagerHandler,
    0,
    sizeof (CosLoadBalancing::AMI_LoadManagerHandler)
  );

namespace CosLoadBalancing
{
  ::CORBA::TypeCode_ptr _tc_AMI_LoadManagerHandler =
    &_tc_TAO_tc_CosLoadBalancing_AMI_LoadManagerHandler;
}

// TAO_IDL - Generated from
// be/be_visitor_valuetype/valuetype_obv_cs.cpp:58

OBV_CosLoadBalancing::AMI_StrategyExceptionHolder::AMI_StrategyExceptionHolder (void)
{}

OBV_CosLoadBalancing::AMI_StrategyExceptionHolder::~AMI_StrategyExceptionHolder (void)
{}

CORBA::Boolean
OBV_CosLoadBalancing::AMI_StrategyExceptionHolder::_tao_marshal__CosLoadBalancing_AMI_StrategyExceptionHolder (TAO_OutputCDR &strm)
{
  return _tao_marshal_state (strm);
}

CORBA::Boolean
OBV_CosLoadBalancing::AMI_StrategyExceptionHolder::_tao_unmarshal__CosLoadBalancing_AMI_StrategyExceptionHolder (TAO_InputCDR &strm)
{
  return _tao_unmarshal_state (strm);
}OBV_CosLoadBalancing::_tao_AMI_StrategyExceptionHolder::_tao_AMI_StrategyExceptionHolder () { }

OBV_CosLoadBalancing::_tao_AMI_StrategyExceptionHolder::~_tao_AMI_StrategyExceptionHolder () { }

void 
OBV_CosLoadBalancing::_tao_AMI_StrategyExceptionHolder::raise_get_name(ACE_ENV_SINGLE_ARG_DECL)
{
  
  TAO_Messaging_Helper::exception_holder_raise (
    0,
    0,
    this->marshaled_exception ().get_buffer (),
    this->marshaled_exception ().length (),
    this->byte_order (),
    this->is_system_exception ()
    ACE_ENV_ARG_PARAMETER);
}

void 
OBV_CosLoadBalancing::_tao_AMI_StrategyExceptionHolder::raise_get_properties(ACE_ENV_SINGLE_ARG_DECL)
{
  
  TAO_Messaging_Helper::exception_holder_raise (
    0,
    0,
    this->marshaled_exception ().get_buffer (),
    this->marshaled_exception ().length (),
    this->byte_order (),
    this->is_system_exception ()
    ACE_ENV_ARG_PARAMETER);
}

void 
OBV_CosLoadBalancing::_tao_AMI_StrategyExceptionHolder::raise_push_loads(ACE_ENV_SINGLE_ARG_DECL)
{
  
  static TAO::Exception_Data exceptions_data [] = 
  {
    {
      "IDL:omg.org/CosLoadBalancing/StrategyNotAdaptive:1.0",
      CosLoadBalancing::StrategyNotAdaptive::_alloc,
      CosLoadBalancing::_tc_StrategyNotAdaptive
    }
  };

  CORBA::ULong exceptions_count = 1;

  TAO_Messaging_Helper::exception_holder_raise (
    exceptions_data,
    exceptions_count,
    this->marshaled_exception ().get_buffer (),
    this->marshaled_exception ().length (),
    this->byte_order (),
    this->is_system_exception ()
    ACE_ENV_ARG_PARAMETER);
}

void 
OBV_CosLoadBalancing::_tao_AMI_StrategyExceptionHolder::raise_get_loads(ACE_ENV_SINGLE_ARG_DECL)
{
  
  static TAO::Exception_Data exceptions_data [] = 
  {
    {
      "IDL:omg.org/CosLoadBalancing/LocationNotFound:1.0",
      CosLoadBalancing::LocationNotFound::_alloc,
      CosLoadBalancing::_tc_LocationNotFound
    }
  };

  CORBA::ULong exceptions_count = 1;

  TAO_Messaging_Helper::exception_holder_raise (
    exceptions_data,
    exceptions_count,
    this->marshaled_exception ().get_buffer (),
    this->marshaled_exception ().length (),
    this->byte_order (),
    this->is_system_exception ()
    ACE_ENV_ARG_PARAMETER);
}

void 
OBV_CosLoadBalancing::_tao_AMI_StrategyExceptionHolder::raise_next_member(ACE_ENV_SINGLE_ARG_DECL)
{
  
  static TAO::Exception_Data exceptions_data [] = 
  {
    {
      "IDL:omg.org/PortableGroup/ObjectGroupNotFound:1.0",
      PortableGroup::ObjectGroupNotFound::_alloc,
      PortableGroup::_tc_ObjectGroupNotFound
    },
    {
      "IDL:omg.org/PortableGroup/MemberNotFound:1.0",
      PortableGroup::MemberNotFound::_alloc,
      PortableGroup::_tc_MemberNotFound
    }
  };

  CORBA::ULong exceptions_count = 2;

  TAO_Messaging_Helper::exception_holder_raise (
    exceptions_data,
    exceptions_count,
    this->marshaled_exception ().get_buffer (),
    this->marshaled_exception ().length (),
    this->byte_order (),
    this->is_system_exception ()
    ACE_ENV_ARG_PARAMETER);
}



// TAO_IDL - Generated from
// be/be_visitor_valuetype/valuetype_obv_cs.cpp:58

OBV_CosLoadBalancing::AMI_LoadAlertExceptionHolder::AMI_LoadAlertExceptionHolder (void)
{}

OBV_CosLoadBalancing::AMI_LoadAlertExceptionHolder::~AMI_LoadAlertExceptionHolder (void)
{}

CORBA::Boolean
OBV_CosLoadBalancing::AMI_LoadAlertExceptionHolder::_tao_marshal__CosLoadBalancing_AMI_LoadAlertExceptionHolder (TAO_OutputCDR &strm)
{
  return _tao_marshal_state (strm);
}

CORBA::Boolean
OBV_CosLoadBalancing::AMI_LoadAlertExceptionHolder::_tao_unmarshal__CosLoadBalancing_AMI_LoadAlertExceptionHolder (TAO_InputCDR &strm)
{
  return _tao_unmarshal_state (strm);
}OBV_CosLoadBalancing::_tao_AMI_LoadAlertExceptionHolder::_tao_AMI_LoadAlertExceptionHolder () { }

OBV_CosLoadBalancing::_tao_AMI_LoadAlertExceptionHolder::~_tao_AMI_LoadAlertExceptionHolder () { }

void 
OBV_CosLoadBalancing::_tao_AMI_LoadAlertExceptionHolder::raise_enable_alert(ACE_ENV_SINGLE_ARG_DECL)
{
  
  TAO_Messaging_Helper::exception_holder_raise (
    0,
    0,
    this->marshaled_exception ().get_buffer (),
    this->marshaled_exception ().length (),
    this->byte_order (),
    this->is_system_exception ()
    ACE_ENV_ARG_PARAMETER);
}

void 
OBV_CosLoadBalancing::_tao_AMI_LoadAlertExceptionHolder::raise_disable_alert(ACE_ENV_SINGLE_ARG_DECL)
{
  
  TAO_Messaging_Helper::exception_holder_raise (
    0,
    0,
    this->marshaled_exception ().get_buffer (),
    this->marshaled_exception ().length (),
    this->byte_order (),
    this->is_system_exception ()
    ACE_ENV_ARG_PARAMETER);
}



// TAO_IDL - Generated from
// be/be_visitor_valuetype/valuetype_obv_cs.cpp:58

OBV_CosLoadBalancing::AMI_LoadMonitorExceptionHolder::AMI_LoadMonitorExceptionHolder (void)
{}

OBV_CosLoadBalancing::AMI_LoadMonitorExceptionHolder::~AMI_LoadMonitorExceptionHolder (void)
{}

CORBA::Boolean
OBV_CosLoadBalancing::AMI_LoadMonitorExceptionHolder::_tao_marshal__CosLoadBalancing_AMI_LoadMonitorExceptionHolder (TAO_OutputCDR &strm)
{
  return _tao_marshal_state (strm);
}

CORBA::Boolean
OBV_CosLoadBalancing::AMI_LoadMonitorExceptionHolder::_tao_unmarshal__CosLoadBalancing_AMI_LoadMonitorExceptionHolder (TAO_InputCDR &strm)
{
  return _tao_unmarshal_state (strm);
}OBV_CosLoadBalancing::_tao_AMI_LoadMonitorExceptionHolder::_tao_AMI_LoadMonitorExceptionHolder () { }

OBV_CosLoadBalancing::_tao_AMI_LoadMonitorExceptionHolder::~_tao_AMI_LoadMonitorExceptionHolder () { }

void 
OBV_CosLoadBalancing::_tao_AMI_LoadMonitorExceptionHolder::raise_get_the_location(ACE_ENV_SINGLE_ARG_DECL)
{
  
  TAO_Messaging_Helper::exception_holder_raise (
    0,
    0,
    this->marshaled_exception ().get_buffer (),
    this->marshaled_exception ().length (),
    this->byte_order (),
    this->is_system_exception ()
    ACE_ENV_ARG_PARAMETER);
}

void 
OBV_CosLoadBalancing::_tao_AMI_LoadMonitorExceptionHolder::raise_get_loads(ACE_ENV_SINGLE_ARG_DECL)
{
  
  TAO_Messaging_Helper::exception_holder_raise (
    0,
    0,
    this->marshaled_exception ().get_buffer (),
    this->marshaled_exception ().length (),
    this->byte_order (),
    this->is_system_exception ()
    ACE_ENV_ARG_PARAMETER);
}



// TAO_IDL - Generated from
// be/be_visitor_valuetype/valuetype_obv_cs.cpp:58

OBV_CosLoadBalancing::AMI_LoadManagerExceptionHolder::AMI_LoadManagerExceptionHolder (void)
{}

OBV_CosLoadBalancing::AMI_LoadManagerExceptionHolder::~AMI_LoadManagerExceptionHolder (void)
{}

CORBA::Boolean
OBV_CosLoadBalancing::AMI_LoadManagerExceptionHolder::_tao_marshal__CosLoadBalancing_AMI_LoadManagerExceptionHolder (TAO_OutputCDR &strm)
{
  return _tao_marshal_state (strm);
}

CORBA::Boolean
OBV_CosLoadBalancing::AMI_LoadManagerExceptionHolder::_tao_unmarshal__CosLoadBalancing_AMI_LoadManagerExceptionHolder (TAO_InputCDR &strm)
{
  return _tao_unmarshal_state (strm);
}OBV_CosLoadBalancing::_tao_AMI_LoadManagerExceptionHolder::_tao_AMI_LoadManagerExceptionHolder () { }

OBV_CosLoadBalancing::_tao_AMI_LoadManagerExceptionHolder::~_tao_AMI_LoadManagerExceptionHolder () { }

void 
OBV_CosLoadBalancing::_tao_AMI_LoadManagerExceptionHolder::raise_push_loads(ACE_ENV_SINGLE_ARG_DECL)
{
  
  TAO_Messaging_Helper::exception_holder_raise (
    0,
    0,
    this->marshaled_exception ().get_buffer (),
    this->marshaled_exception ().length (),
    this->byte_order (),
    this->is_system_exception ()
    ACE_ENV_ARG_PARAMETER);
}

void 
OBV_CosLoadBalancing::_tao_AMI_LoadManagerExceptionHolder::raise_get_loads(ACE_ENV_SINGLE_ARG_DECL)
{
  
  static TAO::Exception_Data exceptions_data [] = 
  {
    {
      "IDL:omg.org/CosLoadBalancing/LocationNotFound:1.0",
      CosLoadBalancing::LocationNotFound::_alloc,
      CosLoadBalancing::_tc_LocationNotFound
    }
  };

  CORBA::ULong exceptions_count = 1;

  TAO_Messaging_Helper::exception_holder_raise (
    exceptions_data,
    exceptions_count,
    this->marshaled_exception ().get_buffer (),
    this->marshaled_exception ().length (),
    this->byte_order (),
    this->is_system_exception ()
    ACE_ENV_ARG_PARAMETER);
}

void 
OBV_CosLoadBalancing::_tao_AMI_LoadManagerExceptionHolder::raise_enable_alert(ACE_ENV_SINGLE_ARG_DECL)
{
  
  static TAO::Exception_Data exceptions_data [] = 
  {
    {
      "IDL:omg.org/CosLoadBalancing/LoadAlertNotFound:1.0",
      CosLoadBalancing::LoadAlertNotFound::_alloc,
      CosLoadBalancing::_tc_LoadAlertNotFound
    }
  };

  CORBA::ULong exceptions_count = 1;

  TAO_Messaging_Helper::exception_holder_raise (
    exceptions_data,
    exceptions_count,
    this->marshaled_exception ().get_buffer (),
    this->marshaled_exception ().length (),
    this->byte_order (),
    this->is_system_exception ()
    ACE_ENV_ARG_PARAMETER);
}

void 
OBV_CosLoadBalancing::_tao_AMI_LoadManagerExceptionHolder::raise_disable_alert(ACE_ENV_SINGLE_ARG_DECL)
{
  
  static TAO::Exception_Data exceptions_data [] = 
  {
    {
      "IDL:omg.org/CosLoadBalancing/LoadAlertNotFound:1.0",
      CosLoadBalancing::LoadAlertNotFound::_alloc,
      CosLoadBalancing::_tc_LoadAlertNotFound
    }
  };

  CORBA::ULong exceptions_count = 1;

  TAO_Messaging_Helper::exception_holder_raise (
    exceptions_data,
    exceptions_count,
    this->marshaled_exception ().get_buffer (),
    this->marshaled_exception ().length (),
    this->byte_order (),
    this->is_system_exception ()
    ACE_ENV_ARG_PARAMETER);
}

void 
OBV_CosLoadBalancing::_tao_AMI_LoadManagerExceptionHolder::raise_register_load_alert(ACE_ENV_SINGLE_ARG_DECL)
{
  
  static TAO::Exception_Data exceptions_data [] = 
  {
    {
      "IDL:omg.org/CosLoadBalancing/LoadAlertAlreadyPresent:1.0",
      CosLoadBalancing::LoadAlertAlreadyPresent::_alloc,
      CosLoadBalancing::_tc_LoadAlertAlreadyPresent
    },
    {
      "IDL:omg.org/CosLoadBalancing/LoadAlertNotAdded:1.0",
      CosLoadBalancing::LoadAlertNotAdded::_alloc,
      CosLoadBalancing::_tc_LoadAlertNotAdded
    }
  };

  CORBA::ULong exceptions_count = 2;

  TAO_Messaging_Helper::exception_holder_raise (
    exceptions_data,
    exceptions_count,
    this->marshaled_exception ().get_buffer (),
    this->marshaled_exception ().length (),
    this->byte_order (),
    this->is_system_exception ()
    ACE_ENV_ARG_PARAMETER);
}

void 
OBV_CosLoadBalancing::_tao_AMI_LoadManagerExceptionHolder::raise_get_load_alert(ACE_ENV_SINGLE_ARG_DECL)
{
  
  static TAO::Exception_Data exceptions_data [] = 
  {
    {
      "IDL:omg.org/CosLoadBalancing/LoadAlertNotFound:1.0",
      CosLoadBalancing::LoadAlertNotFound::_alloc,
      CosLoadBalancing::_tc_LoadAlertNotFound
    }
  };

  CORBA::ULong exceptions_count = 1;

  TAO_Messaging_Helper::exception_holder_raise (
    exceptions_data,
    exceptions_count,
    this->marshaled_exception ().get_buffer (),
    this->marshaled_exception ().length (),
    this->byte_order (),
    this->is_system_exception ()
    ACE_ENV_ARG_PARAMETER);
}

void 
OBV_CosLoadBalancing::_tao_AMI_LoadManagerExceptionHolder::raise_remove_load_alert(ACE_ENV_SINGLE_ARG_DECL)
{
  
  static TAO::Exception_Data exceptions_data [] = 
  {
    {
      "IDL:omg.org/CosLoadBalancing/LoadAlertNotFound:1.0",
      CosLoadBalancing::LoadAlertNotFound::_alloc,
      CosLoadBalancing::_tc_LoadAlertNotFound
    }
  };

  CORBA::ULong exceptions_count = 1;

  TAO_Messaging_Helper::exception_holder_raise (
    exceptions_data,
    exceptions_count,
    this->marshaled_exception ().get_buffer (),
    this->marshaled_exception ().length (),
    this->byte_order (),
    this->is_system_exception ()
    ACE_ENV_ARG_PARAMETER);
}

void 
OBV_CosLoadBalancing::_tao_AMI_LoadManagerExceptionHolder::raise_register_load_monitor(ACE_ENV_SINGLE_ARG_DECL)
{
  
  static TAO::Exception_Data exceptions_data [] = 
  {
    {
      "IDL:omg.org/CosLoadBalancing/MonitorAlreadyPresent:1.0",
      CosLoadBalancing::MonitorAlreadyPresent::_alloc,
      CosLoadBalancing::_tc_MonitorAlreadyPresent
    }
  };

  CORBA::ULong exceptions_count = 1;

  TAO_Messaging_Helper::exception_holder_raise (
    exceptions_data,
    exceptions_count,
    this->marshaled_exception ().get_buffer (),
    this->marshaled_exception ().length (),
    this->byte_order (),
    this->is_system_exception ()
    ACE_ENV_ARG_PARAMETER);
}

void 
OBV_CosLoadBalancing::_tao_AMI_LoadManagerExceptionHolder::raise_get_load_monitor(ACE_ENV_SINGLE_ARG_DECL)
{
  
  static TAO::Exception_Data exceptions_data [] = 
  {
    {
      "IDL:omg.org/CosLoadBalancing/LocationNotFound:1.0",
      CosLoadBalancing::LocationNotFound::_alloc,
      CosLoadBalancing::_tc_LocationNotFound
    }
  };

  CORBA::ULong exceptions_count = 1;

  TAO_Messaging_Helper::exception_holder_raise (
    exceptions_data,
    exceptions_count,
    this->marshaled_exception ().get_buffer (),
    this->marshaled_exception ().length (),
    this->byte_order (),
    this->is_system_exception ()
    ACE_ENV_ARG_PARAMETER);
}

void 
OBV_CosLoadBalancing::_tao_AMI_LoadManagerExceptionHolder::raise_remove_load_monitor(ACE_ENV_SINGLE_ARG_DECL)
{
  
  static TAO::Exception_Data exceptions_data [] = 
  {
    {
      "IDL:omg.org/CosLoadBalancing/LocationNotFound:1.0",
      CosLoadBalancing::LocationNotFound::_alloc,
      CosLoadBalancing::_tc_LocationNotFound
    }
  };

  CORBA::ULong exceptions_count = 1;

  TAO_Messaging_Helper::exception_holder_raise (
    exceptions_data,
    exceptions_count,
    this->marshaled_exception ().get_buffer (),
    this->marshaled_exception ().length (),
    this->byte_order (),
    this->is_system_exception ()
    ACE_ENV_ARG_PARAMETER);
}



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

// Copying insertion.
void operator<<= (
    CORBA::Any &_tao_any,
    const CosLoadBalancing::Load &_tao_elem
  )
{
  TAO::Any_Dual_Impl_T<CosLoadBalancing::Load>::insert_copy (
      _tao_any,
      CosLoadBalancing::Load::_tao_any_destructor,
      CosLoadBalancing::_tc_Load,
      _tao_elem
    );
}

// Non-copying insertion.
void operator<<= (
    CORBA::Any &_tao_any,
    CosLoadBalancing::Load *_tao_elem
  )
{
  TAO::Any_Dual_Impl_T<CosLoadBalancing::Load>::insert (
      _tao_any,
      CosLoadBalancing::Load::_tao_any_destructor,
      CosLoadBalancing::_tc_Load,
      _tao_elem
    );
}

// Extraction to non-const pointer (deprecated).
CORBA::Boolean operator>>= (
    const CORBA::Any &_tao_any,
    CosLoadBalancing::Load *&_tao_elem
  )
{
  return _tao_any >>= const_cast<
      const CosLoadBalancing::Load *&> (
      _tao_elem
    );
}

// Extraction to const pointer.
CORBA::Boolean operator>>= (
    const CORBA::Any &_tao_any,
    const CosLoadBalancing::Load *&_tao_elem
  )
{
  return
    TAO::Any_Dual_Impl_T<CosLoadBalancing::Load>::extract (
        _tao_any,
        CosLoadBalancing::Load::_tao_any_destructor,
        CosLoadBalancing::_tc_Load,
        _tao_elem
      );
}

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

// Copying insertion.
void operator<<= (
    CORBA::Any &_tao_any,
    const CosLoadBalancing::LoadList &_tao_elem
  )
{
  TAO::Any_Dual_Impl_T<CosLoadBalancing::LoadList>::insert_copy (
      _tao_any,
      CosLoadBalancing::LoadList::_tao_any_destructor,
      CosLoadBalancing::_tc_LoadList,
      _tao_elem
    );
}

// Non-copying insertion.
void operator<<= (
    CORBA::Any &_tao_any,
    CosLoadBalancing::LoadList *_tao_elem
  )
{
  TAO::Any_Dual_Impl_T<CosLoadBalancing::LoadList>::insert (
      _tao_any,
      CosLoadBalancing::LoadList::_tao_any_destructor,
      CosLoadBalancing::_tc_LoadList,
      _tao_elem
    );
}

// Extraction to non-const pointer (deprecated).
CORBA::Boolean operator>>= (
    const CORBA::Any &_tao_any,
    CosLoadBalancing::LoadList *&_tao_elem
  )
{
  return _tao_any >>= const_cast<
      const CosLoadBalancing::LoadList *&> (
      _tao_elem
    );
}

// Extraction to const pointer.
CORBA::Boolean operator>>= (
    const CORBA::Any &_tao_any,
    const CosLoadBalancing::LoadList *&_tao_elem
  )
{
  return
    TAO::Any_Dual_Impl_T<CosLoadBalancing::LoadList>::extract (
        _tao_any,
        CosLoadBalancing::LoadList::_tao_any_destructor,
        CosLoadBalancing::_tc_LoadList,
        _tao_elem
      );
}

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

ACE_TEMPLATE_SPECIALIZATION
CORBA::Boolean
TAO::Any_Dual_Impl_T<CosLoadBalancing::MonitorAlreadyPresent>::demarshal_value (
    TAO_InputCDR & cdr
  )
{
  CORBA::String_var id;
  
  if ((cdr >> id.out ()) == 0)
    {
      return 0;
    }
  
  ACE_TRY_NEW_ENV
    {
      this->value_->_tao_decode (cdr ACE_ENV_ARG_PARAMETER);
      ACE_TRY_CHECK;
    }
  ACE_CATCHANY
    {
      return 0;
    }
  ACE_ENDTRY;
  
  return 1;
}

// Copying insertion.
void operator<<= (
    CORBA::Any &_tao_any,
    const CosLoadBalancing::MonitorAlreadyPresent &_tao_elem
  )
{
  TAO::Any_Dual_Impl_T<CosLoadBalancing::MonitorAlreadyPresent>::insert_copy (
      _tao_any,
      CosLoadBalancing::MonitorAlreadyPresent::_tao_any_destructor,
      CosLoadBalancing::_tc_MonitorAlreadyPresent,
      _tao_elem
    );
}

// Non-copying insertion.
void operator<<= (
    CORBA::Any &_tao_any,
    CosLoadBalancing::MonitorAlreadyPresent *_tao_elem
  )
{
  TAO::Any_Dual_Impl_T<CosLoadBalancing::MonitorAlreadyPresent>::insert (
      _tao_any,
      CosLoadBalancing::MonitorAlreadyPresent::_tao_any_destructor,
      CosLoadBalancing::_tc_MonitorAlreadyPresent,
      _tao_elem
    );
}

// Extraction to non-const pointer (deprecated).
CORBA::Boolean operator>>= (
    const CORBA::Any &_tao_any,
    CosLoadBalancing::MonitorAlreadyPresent *&_tao_elem
  )
{
  return _tao_any >>= const_cast<
      const CosLoadBalancing::MonitorAlreadyPresent *&> (
      _tao_elem
    );
}

// Extraction to const pointer.
CORBA::Boolean operator>>= (
    const CORBA::Any &_tao_any,
    const CosLoadBalancing::MonitorAlreadyPresent *&_tao_elem
  )
{
  return
    TAO::Any_Dual_Impl_T<CosLoadBalancing::MonitorAlreadyPresent>::extract (
        _tao_any,
        CosLoadBalancing::MonitorAlreadyPresent::_tao_any_destructor,
        CosLoadBalancing::_tc_MonitorAlreadyPresent,
        _tao_elem
      );
}

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

ACE_TEMPLATE_SPECIALIZATION
CORBA::Boolean
TAO::Any_Dual_Impl_T<CosLoadBalancing::LocationNotFound>::demarshal_value (
    TAO_InputCDR & cdr
  )
{
  CORBA::String_var id;
  
  if ((cdr >> id.out ()) == 0)
    {
      return 0;
    }
  
  ACE_TRY_NEW_ENV
    {
      this->value_->_tao_decode (cdr ACE_ENV_ARG_PARAMETER);
      ACE_TRY_CHECK;
    }
  ACE_CATCHANY
    {
      return 0;
    }
  ACE_ENDTRY;
  
  return 1;
}

// Copying insertion.
void operator<<= (
    CORBA::Any &_tao_any,
    const CosLoadBalancing::LocationNotFound &_tao_elem
  )
{
  TAO::Any_Dual_Impl_T<CosLoadBalancing::LocationNotFound>::insert_copy (
      _tao_any,
      CosLoadBalancing::LocationNotFound::_tao_any_destructor,
      CosLoadBalancing::_tc_LocationNotFound,
      _tao_elem
    );
}

// Non-copying insertion.
void operator<<= (
    CORBA::Any &_tao_any,
    CosLoadBalancing::LocationNotFound *_tao_elem
  )
{
  TAO::Any_Dual_Impl_T<CosLoadBalancing::LocationNotFound>::insert (
      _tao_any,
      CosLoadBalancing::LocationNotFound::_tao_any_destructor,
      CosLoadBalancing::_tc_LocationNotFound,
      _tao_elem
    );
}

// Extraction to non-const pointer (deprecated).
CORBA::Boolean operator>>= (
    const CORBA::Any &_tao_any,
    CosLoadBalancing::LocationNotFound *&_tao_elem
  )
{
  return _tao_any >>= const_cast<
      const CosLoadBalancing::LocationNotFound *&> (
      _tao_elem
    );
}

// Extraction to const pointer.
CORBA::Boolean operator>>= (
    const CORBA::Any &_tao_any,
    const CosLoadBalancing::LocationNotFound *&_tao_elem
  )
{
  return
    TAO::Any_Dual_Impl_T<CosLoadBalancing::LocationNotFound>::extract (
        _tao_any,
        CosLoadBalancing::LocationNotFound::_tao_any_destructor,
        CosLoadBalancing::_tc_LocationNotFound,
        _tao_elem
      );
}

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

ACE_TEMPLATE_SPECIALIZATION
CORBA::Boolean
TAO::Any_Dual_Impl_T<CosLoadBalancing::LoadAlertNotFound>::demarshal_value (
    TAO_InputCDR & cdr
  )
{
  CORBA::String_var id;
  
  if ((cdr >> id.out ()) == 0)
    {
      return 0;
    }
  
  ACE_TRY_NEW_ENV
    {
      this->value_->_tao_decode (cdr ACE_ENV_ARG_PARAMETER);
      ACE_TRY_CHECK;
    }
  ACE_CATCHANY
    {
      return 0;
    }
  ACE_ENDTRY;
  
  return 1;
}

// Copying insertion.
void operator<<= (
    CORBA::Any &_tao_any,
    const CosLoadBalancing::LoadAlertNotFound &_tao_elem
  )
{
  TAO::Any_Dual_Impl_T<CosLoadBalancing::LoadAlertNotFound>::insert_copy (
      _tao_any,
      CosLoadBalancing::LoadAlertNotFound::_tao_any_destructor,
      CosLoadBalancing::_tc_LoadAlertNotFound,
      _tao_elem
    );
}

// Non-copying insertion.
void operator<<= (
    CORBA::Any &_tao_any,
    CosLoadBalancing::LoadAlertNotFound *_tao_elem
  )
{
  TAO::Any_Dual_Impl_T<CosLoadBalancing::LoadAlertNotFound>::insert (
      _tao_any,
      CosLoadBalancing::LoadAlertNotFound::_tao_any_destructor,
      CosLoadBalancing::_tc_LoadAlertNotFound,
      _tao_elem
    );
}

// Extraction to non-const pointer (deprecated).
CORBA::Boolean operator>>= (
    const CORBA::Any &_tao_any,
    CosLoadBalancing::LoadAlertNotFound *&_tao_elem
  )
{
  return _tao_any >>= const_cast<
      const CosLoadBalancing::LoadAlertNotFound *&> (
      _tao_elem
    );
}

// Extraction to const pointer.
CORBA::Boolean operator>>= (
    const CORBA::Any &_tao_any,
    const CosLoadBalancing::LoadAlertNotFound *&_tao_elem
  )
{
  return
    TAO::Any_Dual_Impl_T<CosLoadBalancing::LoadAlertNotFound>::extract (
        _tao_any,
        CosLoadBalancing::LoadAlertNotFound::_tao_any_destructor,
        CosLoadBalancing::_tc_LoadAlertNotFound,
        _tao_elem
      );
}

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

ACE_TEMPLATE_SPECIALIZATION
CORBA::Boolean
TAO::Any_Dual_Impl_T<CosLoadBalancing::LoadAlertAlreadyPresent>::demarshal_value (
    TAO_InputCDR & cdr
  )
{
  CORBA::String_var id;
  
  if ((cdr >> id.out ()) == 0)
    {
      return 0;
    }
  
  ACE_TRY_NEW_ENV
    {
      this->value_->_tao_decode (cdr ACE_ENV_ARG_PARAMETER);
      ACE_TRY_CHECK;
    }
  ACE_CATCHANY
    {
      return 0;
    }
  ACE_ENDTRY;
  
  return 1;
}

// Copying insertion.
void operator<<= (
    CORBA::Any &_tao_any,
    const CosLoadBalancing::LoadAlertAlreadyPresent &_tao_elem
  )
{
  TAO::Any_Dual_Impl_T<CosLoadBalancing::LoadAlertAlreadyPresent>::insert_copy (
      _tao_any,
      CosLoadBalancing::LoadAlertAlreadyPresent::_tao_any_destructor,
      CosLoadBalancing::_tc_LoadAlertAlreadyPresent,
      _tao_elem
    );
}

// Non-copying insertion.
void operator<<= (
    CORBA::Any &_tao_any,
    CosLoadBalancing::LoadAlertAlreadyPresent *_tao_elem
  )
{
  TAO::Any_Dual_Impl_T<CosLoadBalancing::LoadAlertAlreadyPresent>::insert (
      _tao_any,
      CosLoadBalancing::LoadAlertAlreadyPresent::_tao_any_destructor,
      CosLoadBalancing::_tc_LoadAlertAlreadyPresent,
      _tao_elem
    );
}

// Extraction to non-const pointer (deprecated).
CORBA::Boolean operator>>= (
    const CORBA::Any &_tao_any,
    CosLoadBalancing::LoadAlertAlreadyPresent *&_tao_elem
  )
{
  return _tao_any >>= const_cast<
      const CosLoadBalancing::LoadAlertAlreadyPresent *&> (
      _tao_elem
    );
}

// Extraction to const pointer.
CORBA::Boolean operator>>= (
    const CORBA::Any &_tao_any,
    const CosLoadBalancing::LoadAlertAlreadyPresent *&_tao_elem
  )
{
  return
    TAO::Any_Dual_Impl_T<CosLoadBalancing::LoadAlertAlreadyPresent>::extract (
        _tao_any,
        CosLoadBalancing::LoadAlertAlreadyPresent::_tao_any_destructor,
        CosLoadBalancing::_tc_LoadAlertAlreadyPresent,
        _tao_elem
      );
}

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

ACE_TEMPLATE_SPECIALIZATION
CORBA::Boolean
TAO::Any_Dual_Impl_T<CosLoadBalancing::LoadAlertNotAdded>::demarshal_value (
    TAO_InputCDR & cdr
  )
{
  CORBA::String_var id;
  
  if ((cdr >> id.out ()) == 0)
    {
      return 0;
    }
  
  ACE_TRY_NEW_ENV
    {
      this->value_->_tao_decode (cdr ACE_ENV_ARG_PARAMETER);
      ACE_TRY_CHECK;
    }
  ACE_CATCHANY
    {
      return 0;
    }
  ACE_ENDTRY;
  
  return 1;
}

// Copying insertion.
void operator<<= (
    CORBA::Any &_tao_any,
    const CosLoadBalancing::LoadAlertNotAdded &_tao_elem
  )
{
  TAO::Any_Dual_Impl_T<CosLoadBalancing::LoadAlertNotAdded>::insert_copy (
      _tao_any,
      CosLoadBalancing::LoadAlertNotAdded::_tao_any_destructor,
      CosLoadBalancing::_tc_LoadAlertNotAdded,
      _tao_elem
    );
}

// Non-copying insertion.
void operator<<= (
    CORBA::Any &_tao_any,
    CosLoadBalancing::LoadAlertNotAdded *_tao_elem
  )
{
  TAO::Any_Dual_Impl_T<CosLoadBalancing::LoadAlertNotAdded>::insert (
      _tao_any,
      CosLoadBalancing::LoadAlertNotAdded::_tao_any_destructor,
      CosLoadBalancing::_tc_LoadAlertNotAdded,
      _tao_elem
    );
}

// Extraction to non-const pointer (deprecated).
CORBA::Boolean operator>>= (
    const CORBA::Any &_tao_any,
    CosLoadBalancing::LoadAlertNotAdded *&_tao_elem
  )
{
  return _tao_any >>= const_cast<
      const CosLoadBalancing::LoadAlertNotAdded *&> (
      _tao_elem
    );
}

// Extraction to const pointer.
CORBA::Boolean operator>>= (
    const CORBA::Any &_tao_any,
    const CosLoadBalancing::LoadAlertNotAdded *&_tao_elem
  )
{
  return
    TAO::Any_Dual_Impl_T<CosLoadBalancing::LoadAlertNotAdded>::extract (
        _tao_any,
        CosLoadBalancing::LoadAlertNotAdded::_tao_any_destructor,
        CosLoadBalancing::_tc_LoadAlertNotAdded,
        _tao_elem
      );
}

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

ACE_TEMPLATE_SPECIALIZATION
CORBA::Boolean
TAO::Any_Dual_Impl_T<CosLoadBalancing::StrategyNotAdaptive>::demarshal_value (
    TAO_InputCDR & cdr
  )
{
  CORBA::String_var id;
  
  if ((cdr >> id.out ()) == 0)
    {
      return 0;
    }
  
  ACE_TRY_NEW_ENV
    {
      this->value_->_tao_decode (cdr ACE_ENV_ARG_PARAMETER);
      ACE_TRY_CHECK;
    }
  ACE_CATCHANY
    {
      return 0;
    }
  ACE_ENDTRY;
  
  return 1;
}

// Copying insertion.
void operator<<= (
    CORBA::Any &_tao_any,
    const CosLoadBalancing::StrategyNotAdaptive &_tao_elem
  )
{
  TAO::Any_Dual_Impl_T<CosLoadBalancing::StrategyNotAdaptive>::insert_copy (
      _tao_any,
      CosLoadBalancing::StrategyNotAdaptive::_tao_any_destructor,
      CosLoadBalancing::_tc_StrategyNotAdaptive,
      _tao_elem
    );
}

// Non-copying insertion.
void operator<<= (
    CORBA::Any &_tao_any,
    CosLoadBalancing::StrategyNotAdaptive *_tao_elem
  )
{
  TAO::Any_Dual_Impl_T<CosLoadBalancing::StrategyNotAdaptive>::insert (
      _tao_any,
      CosLoadBalancing::StrategyNotAdaptive::_tao_any_destructor,
      CosLoadBalancing::_tc_StrategyNotAdaptive,
      _tao_elem
    );
}

// Extraction to non-const pointer (deprecated).
CORBA::Boolean operator>>= (
    const CORBA::Any &_tao_any,
    CosLoadBalancing::StrategyNotAdaptive *&_tao_elem
  )
{
  return _tao_any >>= const_cast<
      const CosLoadBalancing::StrategyNotAdaptive *&> (
      _tao_elem
    );
}

// Extraction to const pointer.
CORBA::Boolean operator>>= (
    const CORBA::Any &_tao_any,
    const CosLoadBalancing::StrategyNotAdaptive *&_tao_elem
  )
{
  return
    TAO::Any_Dual_Impl_T<CosLoadBalancing::StrategyNotAdaptive>::extract (
        _tao_any,
        CosLoadBalancing::StrategyNotAdaptive::_tao_any_destructor,
        CosLoadBalancing::_tc_StrategyNotAdaptive,
        _tao_elem
      );
}

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

ACE_TEMPLATE_SPECIALIZATION
CORBA::Boolean
TAO::Any_Impl_T<CosLoadBalancing::Strategy>::to_object (
    CORBA::Object_ptr &_tao_elem
  ) const
{
  _tao_elem = CORBA::Object::_duplicate (this->value_);
  return 1;
}

// Copying insertion.
void
operator<<= (
    CORBA::Any &_tao_any,
    CosLoadBalancing::Strategy_ptr _tao_elem
  )
{
  CosLoadBalancing::Strategy_ptr _tao_objptr =
    CosLoadBalancing::Strategy::_duplicate (_tao_elem);
  _tao_any <<= &_tao_objptr;
}

// Non-copying insertion.
void
operator<<= (
    CORBA::Any &_tao_any,
    CosLoadBalancing::Strategy_ptr *_tao_elem
  )
{
  TAO::Any_Impl_T<CosLoadBalancing::Strategy>::insert (
      _tao_any,
      CosLoadBalancing::Strategy::_tao_any_destructor,
      CosLoadBalancing::_tc_Strategy,
      *_tao_elem
    );
}

CORBA::Boolean
operator>>= (
    const CORBA::Any &_tao_any,
    CosLoadBalancing::Strategy_ptr &_tao_elem
  )
{
  return
    TAO::Any_Impl_T<CosLoadBalancing::Strategy>::extract (
        _tao_any,
        CosLoadBalancing::Strategy::_tao_any_destructor,
        CosLoadBalancing::_tc_Strategy,
        _tao_elem
      );
}

// TAO_IDL - Generated from
// be/be_visitor_valuetype/any_op_cs.cpp:57

template<>
CORBA::Boolean
TAO::Any_Impl_T<CosLoadBalancing::AMI_StrategyExceptionHolder>::to_value (
    CORBA::ValueBase *&_tao_elem
  ) const
{
  CORBA::add_ref (this->value_);
  _tao_elem = this->value_;
  return 1;
}
// Copying insertion.
void
operator<<= (
    CORBA::Any &_tao_any,
    CosLoadBalancing::AMI_StrategyExceptionHolder *_tao_elem
  )
{
  CORBA::add_ref (_tao_elem);
  _tao_any <<= &_tao_elem;
}

// Non-copying insertion.
void
operator<<= (
    CORBA::Any &_tao_any,
    CosLoadBalancing::AMI_StrategyExceptionHolder **_tao_elem
  )
{
  TAO::Any_Impl_T<CosLoadBalancing::AMI_StrategyExceptionHolder>::insert (
      _tao_any,
      CosLoadBalancing::AMI_StrategyExceptionHolder::_tao_any_destructor,
      CosLoadBalancing::_tc_AMI_StrategyExceptionHolder,
      *_tao_elem
    );
}

CORBA::Boolean
operator>>= (
    const CORBA::Any &_tao_any,
    CosLoadBalancing::AMI_StrategyExceptionHolder *&_tao_elem
  )
{
  return
    TAO::Any_Impl_T<CosLoadBalancing::AMI_StrategyExceptionHolder>::extract (
        _tao_any,
        CosLoadBalancing::AMI_StrategyExceptionHolder::_tao_any_destructor,
        CosLoadBalancing::_tc_AMI_StrategyExceptionHolder,
        _tao_elem
      );
}



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

ACE_TEMPLATE_SPECIALIZATION
CORBA::Boolean
TAO::Any_Impl_T<CosLoadBalancing::AMI_StrategyHandler>::to_object (
    CORBA::Object_ptr &_tao_elem
  ) const
{
  _tao_elem = CORBA::Object::_duplicate (this->value_);
  return 1;
}

// Copying insertion.
void
operator<<= (
    CORBA::Any &_tao_any,
    CosLoadBalancing::AMI_StrategyHandler_ptr _tao_elem
  )
{
  CosLoadBalancing::AMI_StrategyHandler_ptr _tao_objptr =
    CosLoadBalancing::AMI_StrategyHandler::_duplicate (_tao_elem);
  _tao_any <<= &_tao_objptr;
}

// Non-copying insertion.
void
operator<<= (
    CORBA::Any &_tao_any,
    CosLoadBalancing::AMI_StrategyHandler_ptr *_tao_elem
  )
{
  TAO::Any_Impl_T<CosLoadBalancing::AMI_StrategyHandler>::insert (
      _tao_any,
      CosLoadBalancing::AMI_StrategyHandler::_tao_any_destructor,
      CosLoadBalancing::_tc_AMI_StrategyHandler,
      *_tao_elem
    );
}

CORBA::Boolean
operator>>= (
    const CORBA::Any &_tao_any,
    CosLoadBalancing::AMI_StrategyHandler_ptr &_tao_elem
  )
{
  return
    TAO::Any_Impl_T<CosLoadBalancing::AMI_StrategyHandler>::extract (
        _tao_any,
        CosLoadBalancing::AMI_StrategyHandler::_tao_any_destructor,
        CosLoadBalancing::_tc_AMI_StrategyHandler,
        _tao_elem
      );
}

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

// Copying insertion.
void operator<<= (
    CORBA::Any &_tao_any,
    const CosLoadBalancing::StrategyInfo &_tao_elem
  )
{
  TAO::Any_Dual_Impl_T<CosLoadBalancing::StrategyInfo>::insert_copy (
      _tao_any,
      CosLoadBalancing::StrategyInfo::_tao_any_destructor,
      CosLoadBalancing::_tc_StrategyInfo,
      _tao_elem
    );
}

// Non-copying insertion.
void operator<<= (
    CORBA::Any &_tao_any,
    CosLoadBalancing::StrategyInfo *_tao_elem
  )
{
  TAO::Any_Dual_Impl_T<CosLoadBalancing::StrategyInfo>::insert (
      _tao_any,
      CosLoadBalancing::StrategyInfo::_tao_any_destructor,
      CosLoadBalancing::_tc_StrategyInfo,
      _tao_elem
    );
}

// Extraction to non-const pointer (deprecated).
CORBA::Boolean operator>>= (
    const CORBA::Any &_tao_any,
    CosLoadBalancing::StrategyInfo *&_tao_elem
  )
{
  return _tao_any >>= const_cast<
      const CosLoadBalancing::StrategyInfo *&> (
      _tao_elem
    );
}

// Extraction to const pointer.
CORBA::Boolean operator>>= (
    const CORBA::Any &_tao_any,
    const CosLoadBalancing::StrategyInfo *&_tao_elem
  )
{
  return
    TAO::Any_Dual_Impl_T<CosLoadBalancing::StrategyInfo>::extract (
        _tao_any,
        CosLoadBalancing::StrategyInfo::_tao_any_destructor,
        CosLoadBalancing::_tc_StrategyInfo,
        _tao_elem
      );
}

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

ACE_TEMPLATE_SPECIALIZATION
CORBA::Boolean
TAO::Any_Impl_T<CosLoadBalancing::LoadAlert>::to_object (
    CORBA::Object_ptr &_tao_elem
  ) const
{
  _tao_elem = CORBA::Object::_duplicate (this->value_);
  return 1;
}

// Copying insertion.
void
operator<<= (
    CORBA::Any &_tao_any,
    CosLoadBalancing::LoadAlert_ptr _tao_elem
  )
{
  CosLoadBalancing::LoadAlert_ptr _tao_objptr =
    CosLoadBalancing::LoadAlert::_duplicate (_tao_elem);
  _tao_any <<= &_tao_objptr;
}

// Non-copying insertion.
void
operator<<= (
    CORBA::Any &_tao_any,
    CosLoadBalancing::LoadAlert_ptr *_tao_elem
  )
{
  TAO::Any_Impl_T<CosLoadBalancing::LoadAlert>::insert (
      _tao_any,
      CosLoadBalancing::LoadAlert::_tao_any_destructor,
      CosLoadBalancing::_tc_LoadAlert,
      *_tao_elem
    );
}

CORBA::Boolean
operator>>= (
    const CORBA::Any &_tao_any,
    CosLoadBalancing::LoadAlert_ptr &_tao_elem
  )
{
  return
    TAO::Any_Impl_T<CosLoadBalancing::LoadAlert>::extract (
        _tao_any,
        CosLoadBalancing::LoadAlert::_tao_any_destructor,
        CosLoadBalancing::_tc_LoadAlert,
        _tao_elem
      );
}

// TAO_IDL - Generated from
// be/be_visitor_valuetype/any_op_cs.cpp:57

template<>
CORBA::Boolean
TAO::Any_Impl_T<CosLoadBalancing::AMI_LoadAlertExceptionHolder>::to_value (
    CORBA::ValueBase *&_tao_elem
  ) const
{
  CORBA::add_ref (this->value_);
  _tao_elem = this->value_;
  return 1;
}
// Copying insertion.
void
operator<<= (
    CORBA::Any &_tao_any,
    CosLoadBalancing::AMI_LoadAlertExceptionHolder *_tao_elem
  )
{
  CORBA::add_ref (_tao_elem);
  _tao_any <<= &_tao_elem;
}

// Non-copying insertion.
void
operator<<= (
    CORBA::Any &_tao_any,
    CosLoadBalancing::AMI_LoadAlertExceptionHolder **_tao_elem
  )
{
  TAO::Any_Impl_T<CosLoadBalancing::AMI_LoadAlertExceptionHolder>::insert (
      _tao_any,
      CosLoadBalancing::AMI_LoadAlertExceptionHolder::_tao_any_destructor,
      CosLoadBalancing::_tc_AMI_LoadAlertExceptionHolder,
      *_tao_elem
    );
}

CORBA::Boolean
operator>>= (
    const CORBA::Any &_tao_any,
    CosLoadBalancing::AMI_LoadAlertExceptionHolder *&_tao_elem
  )
{
  return
    TAO::Any_Impl_T<CosLoadBalancing::AMI_LoadAlertExceptionHolder>::extract (
        _tao_any,
        CosLoadBalancing::AMI_LoadAlertExceptionHolder::_tao_any_destructor,
        CosLoadBalancing::_tc_AMI_LoadAlertExceptionHolder,
        _tao_elem
      );
}



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

ACE_TEMPLATE_SPECIALIZATION
CORBA::Boolean
TAO::Any_Impl_T<CosLoadBalancing::AMI_LoadAlertHandler>::to_object (
    CORBA::Object_ptr &_tao_elem
  ) const
{
  _tao_elem = CORBA::Object::_duplicate (this->value_);
  return 1;
}

// Copying insertion.
void
operator<<= (
    CORBA::Any &_tao_any,
    CosLoadBalancing::AMI_LoadAlertHandler_ptr _tao_elem
  )
{
  CosLoadBalancing::AMI_LoadAlertHandler_ptr _tao_objptr =
    CosLoadBalancing::AMI_LoadAlertHandler::_duplicate (_tao_elem);
  _tao_any <<= &_tao_objptr;
}

// Non-copying insertion.
void
operator<<= (
    CORBA::Any &_tao_any,
    CosLoadBalancing::AMI_LoadAlertHandler_ptr *_tao_elem
  )
{
  TAO::Any_Impl_T<CosLoadBalancing::AMI_LoadAlertHandler>::insert (
      _tao_any,
      CosLoadBalancing::AMI_LoadAlertHandler::_tao_any_destructor,
      CosLoadBalancing::_tc_AMI_LoadAlertHandler,
      *_tao_elem
    );
}

CORBA::Boolean
operator>>= (
    const CORBA::Any &_tao_any,
    CosLoadBalancing::AMI_LoadAlertHandler_ptr &_tao_elem
  )
{
  return
    TAO::Any_Impl_T<CosLoadBalancing::AMI_LoadAlertHandler>::extract (
        _tao_any,
        CosLoadBalancing::AMI_LoadAlertHandler::_tao_any_destructor,
        CosLoadBalancing::_tc_AMI_LoadAlertHandler,
        _tao_elem
      );
}

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

ACE_TEMPLATE_SPECIALIZATION
CORBA::Boolean
TAO::Any_Impl_T<CosLoadBalancing::LoadMonitor>::to_object (
    CORBA::Object_ptr &_tao_elem
  ) const
{
  _tao_elem = CORBA::Object::_duplicate (this->value_);
  return 1;
}

// Copying insertion.
void
operator<<= (
    CORBA::Any &_tao_any,
    CosLoadBalancing::LoadMonitor_ptr _tao_elem
  )
{
  CosLoadBalancing::LoadMonitor_ptr _tao_objptr =
    CosLoadBalancing::LoadMonitor::_duplicate (_tao_elem);
  _tao_any <<= &_tao_objptr;
}

// Non-copying insertion.
void
operator<<= (
    CORBA::Any &_tao_any,
    CosLoadBalancing::LoadMonitor_ptr *_tao_elem
  )
{
  TAO::Any_Impl_T<CosLoadBalancing::LoadMonitor>::insert (
      _tao_any,
      CosLoadBalancing::LoadMonitor::_tao_any_destructor,
      CosLoadBalancing::_tc_LoadMonitor,
      *_tao_elem
    );
}

CORBA::Boolean
operator>>= (
    const CORBA::Any &_tao_any,
    CosLoadBalancing::LoadMonitor_ptr &_tao_elem
  )
{
  return
    TAO::Any_Impl_T<CosLoadBalancing::LoadMonitor>::extract (
        _tao_any,
        CosLoadBalancing::LoadMonitor::_tao_any_destructor,
        CosLoadBalancing::_tc_LoadMonitor,
        _tao_elem
      );
}

// TAO_IDL - Generated from
// be/be_visitor_valuetype/any_op_cs.cpp:57

template<>
CORBA::Boolean
TAO::Any_Impl_T<CosLoadBalancing::AMI_LoadMonitorExceptionHolder>::to_value (
    CORBA::ValueBase *&_tao_elem
  ) const
{
  CORBA::add_ref (this->value_);
  _tao_elem = this->value_;
  return 1;
}
// Copying insertion.
void
operator<<= (
    CORBA::Any &_tao_any,
    CosLoadBalancing::AMI_LoadMonitorExceptionHolder *_tao_elem
  )
{
  CORBA::add_ref (_tao_elem);
  _tao_any <<= &_tao_elem;
}

// Non-copying insertion.
void
operator<<= (
    CORBA::Any &_tao_any,
    CosLoadBalancing::AMI_LoadMonitorExceptionHolder **_tao_elem
  )
{
  TAO::Any_Impl_T<CosLoadBalancing::AMI_LoadMonitorExceptionHolder>::insert (
      _tao_any,
      CosLoadBalancing::AMI_LoadMonitorExceptionHolder::_tao_any_destructor,
      CosLoadBalancing::_tc_AMI_LoadMonitorExceptionHolder,
      *_tao_elem
    );
}

CORBA::Boolean
operator>>= (
    const CORBA::Any &_tao_any,
    CosLoadBalancing::AMI_LoadMonitorExceptionHolder *&_tao_elem
  )
{
  return
    TAO::Any_Impl_T<CosLoadBalancing::AMI_LoadMonitorExceptionHolder>::extract (
        _tao_any,
        CosLoadBalancing::AMI_LoadMonitorExceptionHolder::_tao_any_destructor,
        CosLoadBalancing::_tc_AMI_LoadMonitorExceptionHolder,
        _tao_elem
      );
}



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

ACE_TEMPLATE_SPECIALIZATION
CORBA::Boolean
TAO::Any_Impl_T<CosLoadBalancing::AMI_LoadMonitorHandler>::to_object (
    CORBA::Object_ptr &_tao_elem
  ) const
{
  _tao_elem = CORBA::Object::_duplicate (this->value_);
  return 1;
}

// Copying insertion.
void
operator<<= (
    CORBA::Any &_tao_any,
    CosLoadBalancing::AMI_LoadMonitorHandler_ptr _tao_elem
  )
{
  CosLoadBalancing::AMI_LoadMonitorHandler_ptr _tao_objptr =
    CosLoadBalancing::AMI_LoadMonitorHandler::_duplicate (_tao_elem);
  _tao_any <<= &_tao_objptr;
}

// Non-copying insertion.
void
operator<<= (
    CORBA::Any &_tao_any,
    CosLoadBalancing::AMI_LoadMonitorHandler_ptr *_tao_elem
  )
{
  TAO::Any_Impl_T<CosLoadBalancing::AMI_LoadMonitorHandler>::insert (
      _tao_any,
      CosLoadBalancing::AMI_LoadMonitorHandler::_tao_any_destructor,
      CosLoadBalancing::_tc_AMI_LoadMonitorHandler,
      *_tao_elem
    );
}

CORBA::Boolean
operator>>= (
    const CORBA::Any &_tao_any,
    CosLoadBalancing::AMI_LoadMonitorHandler_ptr &_tao_elem
  )
{
  return
    TAO::Any_Impl_T<CosLoadBalancing::AMI_LoadMonitorHandler>::extract (
        _tao_any,
        CosLoadBalancing::AMI_LoadMonitorHandler::_tao_any_destructor,
        CosLoadBalancing::_tc_AMI_LoadMonitorHandler,
        _tao_elem
      );
}

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

ACE_TEMPLATE_SPECIALIZATION
CORBA::Boolean
TAO::Any_Impl_T<CosLoadBalancing::LoadManager>::to_object (
    CORBA::Object_ptr &_tao_elem
  ) const
{
  _tao_elem = CORBA::Object::_duplicate (this->value_);
  return 1;
}

// Copying insertion.
void
operator<<= (
    CORBA::Any &_tao_any,
    CosLoadBalancing::LoadManager_ptr _tao_elem
  )
{
  CosLoadBalancing::LoadManager_ptr _tao_objptr =
    CosLoadBalancing::LoadManager::_duplicate (_tao_elem);
  _tao_any <<= &_tao_objptr;
}

// Non-copying insertion.
void
operator<<= (
    CORBA::Any &_tao_any,
    CosLoadBalancing::LoadManager_ptr *_tao_elem
  )
{
  TAO::Any_Impl_T<CosLoadBalancing::LoadManager>::insert (
      _tao_any,
      CosLoadBalancing::LoadManager::_tao_any_destructor,
      CosLoadBalancing::_tc_LoadManager,
      *_tao_elem
    );
}

CORBA::Boolean
operator>>= (
    const CORBA::Any &_tao_any,
    CosLoadBalancing::LoadManager_ptr &_tao_elem
  )
{
  return
    TAO::Any_Impl_T<CosLoadBalancing::LoadManager>::extract (
        _tao_any,
        CosLoadBalancing::LoadManager::_tao_any_destructor,
        CosLoadBalancing::_tc_LoadManager,
        _tao_elem
      );
}

// TAO_IDL - Generated from
// be/be_visitor_valuetype/any_op_cs.cpp:57

template<>
CORBA::Boolean
TAO::Any_Impl_T<CosLoadBalancing::AMI_LoadManagerExceptionHolder>::to_value (
    CORBA::ValueBase *&_tao_elem
  ) const
{
  CORBA::add_ref (this->value_);
  _tao_elem = this->value_;
  return 1;
}
// Copying insertion.
void
operator<<= (
    CORBA::Any &_tao_any,
    CosLoadBalancing::AMI_LoadManagerExceptionHolder *_tao_elem
  )
{
  CORBA::add_ref (_tao_elem);
  _tao_any <<= &_tao_elem;
}

// Non-copying insertion.
void
operator<<= (
    CORBA::Any &_tao_any,
    CosLoadBalancing::AMI_LoadManagerExceptionHolder **_tao_elem
  )
{
  TAO::Any_Impl_T<CosLoadBalancing::AMI_LoadManagerExceptionHolder>::insert (
      _tao_any,
      CosLoadBalancing::AMI_LoadManagerExceptionHolder::_tao_any_destructor,
      CosLoadBalancing::_tc_AMI_LoadManagerExceptionHolder,
      *_tao_elem
    );
}

CORBA::Boolean
operator>>= (
    const CORBA::Any &_tao_any,
    CosLoadBalancing::AMI_LoadManagerExceptionHolder *&_tao_elem
  )
{
  return
    TAO::Any_Impl_T<CosLoadBalancing::AMI_LoadManagerExceptionHolder>::extract (
        _tao_any,
        CosLoadBalancing::AMI_LoadManagerExceptionHolder::_tao_any_destructor,
        CosLoadBalancing::_tc_AMI_LoadManagerExceptionHolder,
        _tao_elem
      );
}



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

ACE_TEMPLATE_SPECIALIZATION
CORBA::Boolean
TAO::Any_Impl_T<CosLoadBalancing::AMI_LoadManagerHandler>::to_object (
    CORBA::Object_ptr &_tao_elem
  ) const
{
  _tao_elem = CORBA::Object::_duplicate (this->value_);
  return 1;
}

// Copying insertion.
void
operator<<= (
    CORBA::Any &_tao_any,
    CosLoadBalancing::AMI_LoadManagerHandler_ptr _tao_elem
  )
{
  CosLoadBalancing::AMI_LoadManagerHandler_ptr _tao_objptr =
    CosLoadBalancing::AMI_LoadManagerHandler::_duplicate (_tao_elem);
  _tao_any <<= &_tao_objptr;
}

// Non-copying insertion.
void
operator<<= (
    CORBA::Any &_tao_any,
    CosLoadBalancing::AMI_LoadManagerHandler_ptr *_tao_elem
  )
{
  TAO::Any_Impl_T<CosLoadBalancing::AMI_LoadManagerHandler>::insert (
      _tao_any,
      CosLoadBalancing::AMI_LoadManagerHandler::_tao_any_destructor,
      CosLoadBalancing::_tc_AMI_LoadManagerHandler,
      *_tao_elem
    );
}

CORBA::Boolean
operator>>= (
    const CORBA::Any &_tao_any,
    CosLoadBalancing::AMI_LoadManagerHandler_ptr &_tao_elem
  )
{
  return
    TAO::Any_Impl_T<CosLoadBalancing::AMI_LoadManagerHandler>::extract (
        _tao_any,
        CosLoadBalancing::AMI_LoadManagerHandler::_tao_any_destructor,
        CosLoadBalancing::_tc_AMI_LoadManagerHandler,
        _tao_elem
      );
}

// TAO_IDL - Generated from
// be/be_visitor_structure/cdr_op_cs.cpp:61

CORBA::Boolean operator<< (
    TAO_OutputCDR &strm,
    const CosLoadBalancing::Load &_tao_aggregate
  )
{
  return
    (strm << _tao_aggregate.id) &&
    (strm << _tao_aggregate.value);
}

CORBA::Boolean operator>> (
    TAO_InputCDR &strm,
    CosLoadBalancing::Load &_tao_aggregate
  )
{
  return
    (strm >> _tao_aggregate.id) &&
    (strm >> _tao_aggregate.value);
}

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

#if !defined _TAO_CDR_OP_CosLoadBalancing_LoadList_CPP_
#define _TAO_CDR_OP_CosLoadBalancing_LoadList_CPP_

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

CORBA::Boolean operator>> (
    TAO_InputCDR &strm,
    CosLoadBalancing::LoadList &_tao_sequence
  )
{
  CORBA::ULong _tao_seq_len;
  
  if (strm >> _tao_seq_len)
    {
      // Add a check to the length of the sequence
      // to make sure it does not exceed the length
      // of the stream. (See bug 58.)
      if (_tao_seq_len > strm.length ())
        {
          return 0;
        }
      
      // Set the length of the sequence.
      _tao_sequence.length (_tao_seq_len);
      
      // If length is 0 we return true.
      if (0 >= _tao_seq_len) 
        {
          return 1;
        }
      
      // Retrieve all the elements.
      CORBA::Boolean _tao_marshal_flag = 1;
      
      for (CORBA::ULong i = 0; i < _tao_seq_len && _tao_marshal_flag; ++i)
        {
          _tao_marshal_flag = (strm >> _tao_sequence[i]);
        }
      
      return _tao_marshal_flag;
    
    }
  
  return 0;
}

#endif /* _TAO_CDR_OP_CosLoadBalancing_LoadList_CPP_ */

// TAO_IDL - Generated from
// be/be_visitor_exception/cdr_op_cs.cpp:60

CORBA::Boolean operator<< (
    TAO_OutputCDR &strm,
    const CosLoadBalancing::MonitorAlreadyPresent &_tao_aggregate
  )
{
  // First marshal the repository ID.
  if (strm << _tao_aggregate._rep_id ())
    {
      return 1;
    }
  else
    {
      return 0;
    }
}

CORBA::Boolean operator>> (
    TAO_InputCDR &,
    CosLoadBalancing::MonitorAlreadyPresent&
  )
{
  return 1;
}

// TAO_IDL - Generated from
// be/be_visitor_exception/cdr_op_cs.cpp:60

CORBA::Boolean operator<< (
    TAO_OutputCDR &strm,
    const CosLoadBalancing::LocationNotFound &_tao_aggregate
  )
{
  // First marshal the repository ID.
  if (strm << _tao_aggregate._rep_id ())
    {
      return 1;
    }
  else
    {
      return 0;
    }
}

CORBA::Boolean operator>> (
    TAO_InputCDR &,
    CosLoadBalancing::LocationNotFound&
  )
{
  return 1;
}

// TAO_IDL - Generated from
// be/be_visitor_exception/cdr_op_cs.cpp:60

CORBA::Boolean operator<< (
    TAO_OutputCDR &strm,
    const CosLoadBalancing::LoadAlertNotFound &_tao_aggregate
  )
{
  // First marshal the repository ID.
  if (strm << _tao_aggregate._rep_id ())
    {
      return 1;
    }
  else
    {
      return 0;
    }
}

CORBA::Boolean operator>> (
    TAO_InputCDR &,
    CosLoadBalancing::LoadAlertNotFound&
  )
{
  return 1;
}

// TAO_IDL - Generated from
// be/be_visitor_exception/cdr_op_cs.cpp:60

CORBA::Boolean operator<< (
    TAO_OutputCDR &strm,
    const CosLoadBalancing::LoadAlertAlreadyPresent &_tao_aggregate
  )
{
  // First marshal the repository ID.
  if (strm << _tao_aggregate._rep_id ())
    {
      return 1;
    }
  else
    {
      return 0;
    }
}

CORBA::Boolean operator>> (
    TAO_InputCDR &,
    CosLoadBalancing::LoadAlertAlreadyPresent&
  )
{
  return 1;
}

// TAO_IDL - Generated from
// be/be_visitor_exception/cdr_op_cs.cpp:60

CORBA::Boolean operator<< (
    TAO_OutputCDR &strm,
    const CosLoadBalancing::LoadAlertNotAdded &_tao_aggregate
  )
{
  // First marshal the repository ID.
  if (strm << _tao_aggregate._rep_id ())
    {
      return 1;
    }
  else
    {
      return 0;
    }
}

CORBA::Boolean operator>> (
    TAO_InputCDR &,
    CosLoadBalancing::LoadAlertNotAdded&
  )
{
  return 1;
}

// TAO_IDL - Generated from
// be/be_visitor_exception/cdr_op_cs.cpp:60

CORBA::Boolean operator<< (
    TAO_OutputCDR &strm,
    const CosLoadBalancing::StrategyNotAdaptive &_tao_aggregate
  )
{
  // First marshal the repository ID.
  if (strm << _tao_aggregate._rep_id ())
    {
      return 1;
    }
  else
    {
      return 0;
    }
}

CORBA::Boolean operator>> (
    TAO_InputCDR &,
    CosLoadBalancing::StrategyNotAdaptive&
  )
{
  return 1;
}

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

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

CORBA::Boolean operator>> (
    TAO_InputCDR &strm,
    CosLoadBalancing::Strategy_ptr &_tao_objref
  )
{
  CORBA::Object_var obj;
  
  if ((strm >> obj.inout ()) == 0)
    {
      return 0;
    }
  
  typedef ::CosLoadBalancing::Strategy RHS_SCOPED_NAME;
  
  // Narrow to the right type.
  _tao_objref =
    TAO::Narrow_Utils<RHS_SCOPED_NAME>::unchecked_narrow (
        obj.in (),
        CosLoadBalancing__TAO_Strategy_Proxy_Broker_Factory_function_pointer
      );
    
  return 1;
}

// TAO_IDL - Generated from
// be/be_valuetype.cpp:490

void
CORBA::add_ref (CosLoadBalancing::AMI_StrategyExceptionHolder * vt)
{
  if (vt != 0)
    {
      vt->_add_ref ();
    }
}

void
CORBA::remove_ref (CosLoadBalancing::AMI_StrategyExceptionHolder * vt)
{
  if (vt != 0)
    {
      vt->_remove_ref ();
    }
}

// TAO_IDL - Generated from
// be/be_visitor_valuetype/cdr_op_cs.cpp:73

CORBA::Boolean
operator<< (
    TAO_OutputCDR &strm,
    const CosLoadBalancing::AMI_StrategyExceptionHolder *_tao_valuetype
  )
{
  return
    CORBA::ValueBase::_tao_marshal (
        strm,
        const_cast<
            CosLoadBalancing::AMI_StrategyExceptionHolder *> (
            _tao_valuetype
          ),
        (ptrdiff_t) &CosLoadBalancing::AMI_StrategyExceptionHolder::_downcast
      );
}

CORBA::Boolean
operator>> (
    TAO_InputCDR &strm,
    CosLoadBalancing::AMI_StrategyExceptionHolder *&_tao_valuetype
  )
{
  return CosLoadBalancing::AMI_StrategyExceptionHolder::_tao_unmarshal (strm, _tao_valuetype);
}

// TAO_IDL - Generated from
// be/be_visitor_valuetype/marshal_cs.cpp:44

CORBA::Boolean
OBV_CosLoadBalancing::AMI_StrategyExceptionHolder::_tao_marshal_state (TAO_OutputCDR &strm)
{
  if (! this->_tao_marshal__Messaging_ExceptionHolder (strm))
    {
      return 0;
    }
  
  return (
      1
    );
}

CORBA::Boolean
OBV_CosLoadBalancing::AMI_StrategyExceptionHolder::_tao_unmarshal_state (TAO_InputCDR &strm)
{
  if (! this->_tao_unmarshal__Messaging_ExceptionHolder (strm))
    {
      return 0;
    }
  
  return (
    1
  );
}

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

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

CORBA::Boolean operator>> (
    TAO_InputCDR &strm,
    CosLoadBalancing::AMI_StrategyHandler_ptr &_tao_objref
  )
{
  CORBA::Object_var obj;
  
  if ((strm >> obj.inout ()) == 0)
    {
      return 0;
    }
  
  typedef ::CosLoadBalancing::AMI_StrategyHandler RHS_SCOPED_NAME;
  
  // Narrow to the right type.
  _tao_objref =
    TAO::Narrow_Utils<RHS_SCOPED_NAME>::unchecked_narrow (
        obj.in (),
        CosLoadBalancing__TAO_AMI_StrategyHandler_Proxy_Broker_Factory_function_pointer
      );
    
  return 1;
}

// TAO_IDL - Generated from
// be/be_visitor_structure/cdr_op_cs.cpp:61

CORBA::Boolean operator<< (
    TAO_OutputCDR &strm,
    const CosLoadBalancing::StrategyInfo &_tao_aggregate
  )
{
  return
    (strm << _tao_aggregate.name.in ()) &&
    (strm << _tao_aggregate.props);
}

CORBA::Boolean operator>> (
    TAO_InputCDR &strm,
    CosLoadBalancing::StrategyInfo &_tao_aggregate
  )
{
  return
    (strm >> _tao_aggregate.name.out ()) &&
    (strm >> _tao_aggregate.props);
}

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

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

CORBA::Boolean operator>> (
    TAO_InputCDR &strm,
    CosLoadBalancing::LoadAlert_ptr &_tao_objref
  )
{
  CORBA::Object_var obj;
  
  if ((strm >> obj.inout ()) == 0)
    {
      return 0;
    }
  
  typedef ::CosLoadBalancing::LoadAlert RHS_SCOPED_NAME;
  
  // Narrow to the right type.
  _tao_objref =
    TAO::Narrow_Utils<RHS_SCOPED_NAME>::unchecked_narrow (
        obj.in (),
        CosLoadBalancing__TAO_LoadAlert_Proxy_Broker_Factory_function_pointer
      );
    
  return 1;
}

// TAO_IDL - Generated from
// be/be_valuetype.cpp:490

void
CORBA::add_ref (CosLoadBalancing::AMI_LoadAlertExceptionHolder * vt)
{
  if (vt != 0)
    {
      vt->_add_ref ();
    }
}

void
CORBA::remove_ref (CosLoadBalancing::AMI_LoadAlertExceptionHolder * vt)
{
  if (vt != 0)
    {
      vt->_remove_ref ();
    }
}

// TAO_IDL - Generated from
// be/be_visitor_valuetype/cdr_op_cs.cpp:73

CORBA::Boolean
operator<< (
    TAO_OutputCDR &strm,
    const CosLoadBalancing::AMI_LoadAlertExceptionHolder *_tao_valuetype
  )
{
  return
    CORBA::ValueBase::_tao_marshal (
        strm,
        const_cast<
            CosLoadBalancing::AMI_LoadAlertExceptionHolder *> (
            _tao_valuetype
          ),
        (ptrdiff_t) &CosLoadBalancing::AMI_LoadAlertExceptionHolder::_downcast
      );
}

CORBA::Boolean
operator>> (
    TAO_InputCDR &strm,
    CosLoadBalancing::AMI_LoadAlertExceptionHolder *&_tao_valuetype
  )
{
  return CosLoadBalancing::AMI_LoadAlertExceptionHolder::_tao_unmarshal (strm, _tao_valuetype);
}

// TAO_IDL - Generated from
// be/be_visitor_valuetype/marshal_cs.cpp:44

CORBA::Boolean
OBV_CosLoadBalancing::AMI_LoadAlertExceptionHolder::_tao_marshal_state (TAO_OutputCDR &strm)
{
  if (! this->_tao_marshal__Messaging_ExceptionHolder (strm))
    {
      return 0;
    }
  
  return (
      1
    );
}

CORBA::Boolean
OBV_CosLoadBalancing::AMI_LoadAlertExceptionHolder::_tao_unmarshal_state (TAO_InputCDR &strm)
{
  if (! this->_tao_unmarshal__Messaging_ExceptionHolder (strm))
    {
      return 0;
    }
  
  return (
    1
  );
}

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

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

CORBA::Boolean operator>> (
    TAO_InputCDR &strm,
    CosLoadBalancing::AMI_LoadAlertHandler_ptr &_tao_objref
  )
{
  CORBA::Object_var obj;
  
  if ((strm >> obj.inout ()) == 0)
    {
      return 0;
    }
  
  typedef ::CosLoadBalancing::AMI_LoadAlertHandler RHS_SCOPED_NAME;
  
  // Narrow to the right type.
  _tao_objref =
    TAO::Narrow_Utils<RHS_SCOPED_NAME>::unchecked_narrow (
        obj.in (),
        CosLoadBalancing__TAO_AMI_LoadAlertHandler_Proxy_Broker_Factory_function_pointer
      );
    
  return 1;
}

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

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

CORBA::Boolean operator>> (
    TAO_InputCDR &strm,
    CosLoadBalancing::LoadMonitor_ptr &_tao_objref
  )
{
  CORBA::Object_var obj;
  
  if ((strm >> obj.inout ()) == 0)
    {
      return 0;
    }
  
  typedef ::CosLoadBalancing::LoadMonitor RHS_SCOPED_NAME;
  
  // Narrow to the right type.
  _tao_objref =
    TAO::Narrow_Utils<RHS_SCOPED_NAME>::unchecked_narrow (
        obj.in (),
        CosLoadBalancing__TAO_LoadMonitor_Proxy_Broker_Factory_function_pointer
      );
    
  return 1;
}

// TAO_IDL - Generated from
// be/be_valuetype.cpp:490

void
CORBA::add_ref (CosLoadBalancing::AMI_LoadMonitorExceptionHolder * vt)
{
  if (vt != 0)
    {
      vt->_add_ref ();
    }
}

void
CORBA::remove_ref (CosLoadBalancing::AMI_LoadMonitorExceptionHolder * vt)
{
  if (vt != 0)
    {
      vt->_remove_ref ();
    }
}

// TAO_IDL - Generated from
// be/be_visitor_valuetype/cdr_op_cs.cpp:73

CORBA::Boolean
operator<< (
    TAO_OutputCDR &strm,
    const CosLoadBalancing::AMI_LoadMonitorExceptionHolder *_tao_valuetype
  )
{
  return
    CORBA::ValueBase::_tao_marshal (
        strm,
        const_cast<
            CosLoadBalancing::AMI_LoadMonitorExceptionHolder *> (
            _tao_valuetype
          ),
        (ptrdiff_t) &CosLoadBalancing::AMI_LoadMonitorExceptionHolder::_downcast
      );
}

CORBA::Boolean
operator>> (
    TAO_InputCDR &strm,
    CosLoadBalancing::AMI_LoadMonitorExceptionHolder *&_tao_valuetype
  )
{
  return CosLoadBalancing::AMI_LoadMonitorExceptionHolder::_tao_unmarshal (strm, _tao_valuetype);
}

// TAO_IDL - Generated from
// be/be_visitor_valuetype/marshal_cs.cpp:44

CORBA::Boolean
OBV_CosLoadBalancing::AMI_LoadMonitorExceptionHolder::_tao_marshal_state (TAO_OutputCDR &strm)
{
  if (! this->_tao_marshal__Messaging_ExceptionHolder (strm))
    {
      return 0;
    }
  
  return (
      1
    );
}

CORBA::Boolean
OBV_CosLoadBalancing::AMI_LoadMonitorExceptionHolder::_tao_unmarshal_state (TAO_InputCDR &strm)
{
  if (! this->_tao_unmarshal__Messaging_ExceptionHolder (strm))
    {
      return 0;
    }
  
  return (
    1
  );
}

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

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

CORBA::Boolean operator>> (
    TAO_InputCDR &strm,
    CosLoadBalancing::AMI_LoadMonitorHandler_ptr &_tao_objref
  )
{
  CORBA::Object_var obj;
  
  if ((strm >> obj.inout ()) == 0)
    {
      return 0;
    }
  
  typedef ::CosLoadBalancing::AMI_LoadMonitorHandler RHS_SCOPED_NAME;
  
  // Narrow to the right type.
  _tao_objref =
    TAO::Narrow_Utils<RHS_SCOPED_NAME>::unchecked_narrow (
        obj.in (),
        CosLoadBalancing__TAO_AMI_LoadMonitorHandler_Proxy_Broker_Factory_function_pointer
      );
    
  return 1;
}

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

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

CORBA::Boolean operator>> (
    TAO_InputCDR &strm,
    CosLoadBalancing::LoadManager_ptr &_tao_objref
  )
{
  CORBA::Object_var obj;
  
  if ((strm >> obj.inout ()) == 0)
    {
      return 0;
    }
  
  typedef ::CosLoadBalancing::LoadManager RHS_SCOPED_NAME;
  
  // Narrow to the right type.
  _tao_objref =
    TAO::Narrow_Utils<RHS_SCOPED_NAME>::unchecked_narrow (
        obj.in (),
        CosLoadBalancing__TAO_LoadManager_Proxy_Broker_Factory_function_pointer
      );
    
  return 1;
}

// TAO_IDL - Generated from
// be/be_valuetype.cpp:490

void
CORBA::add_ref (CosLoadBalancing::AMI_LoadManagerExceptionHolder * vt)
{
  if (vt != 0)
    {
      vt->_add_ref ();
    }
}

void
CORBA::remove_ref (CosLoadBalancing::AMI_LoadManagerExceptionHolder * vt)
{
  if (vt != 0)
    {
      vt->_remove_ref ();
    }
}

// TAO_IDL - Generated from
// be/be_visitor_valuetype/cdr_op_cs.cpp:73

CORBA::Boolean
operator<< (
    TAO_OutputCDR &strm,
    const CosLoadBalancing::AMI_LoadManagerExceptionHolder *_tao_valuetype
  )
{
  return
    CORBA::ValueBase::_tao_marshal (
        strm,
        const_cast<
            CosLoadBalancing::AMI_LoadManagerExceptionHolder *> (
            _tao_valuetype
          ),
        (ptrdiff_t) &CosLoadBalancing::AMI_LoadManagerExceptionHolder::_downcast
      );
}

CORBA::Boolean
operator>> (
    TAO_InputCDR &strm,
    CosLoadBalancing::AMI_LoadManagerExceptionHolder *&_tao_valuetype
  )
{
  return CosLoadBalancing::AMI_LoadManagerExceptionHolder::_tao_unmarshal (strm, _tao_valuetype);
}

// TAO_IDL - Generated from
// be/be_visitor_valuetype/marshal_cs.cpp:44

CORBA::Boolean
OBV_CosLoadBalancing::AMI_LoadManagerExceptionHolder::_tao_marshal_state (TAO_OutputCDR &strm)
{
  if (! this->_tao_marshal__Messaging_ExceptionHolder (strm))
    {
      return 0;
    }
  
  return (
      1
    );
}

CORBA::Boolean
OBV_CosLoadBalancing::AMI_LoadManagerExceptionHolder::_tao_unmarshal_state (TAO_InputCDR &strm)
{
  if (! this->_tao_unmarshal__Messaging_ExceptionHolder (strm))
    {
      return 0;
    }
  
  return (
    1
  );
}

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

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

CORBA::Boolean operator>> (
    TAO_InputCDR &strm,
    CosLoadBalancing::AMI_LoadManagerHandler_ptr &_tao_objref
  )
{
  CORBA::Object_var obj;
  
  if ((strm >> obj.inout ()) == 0)
    {
      return 0;
    }
  
  typedef ::CosLoadBalancing::AMI_LoadManagerHandler RHS_SCOPED_NAME;
  
  // Narrow to the right type.
  _tao_objref =
    TAO::Narrow_Utils<RHS_SCOPED_NAME>::unchecked_narrow (
        obj.in (),
        CosLoadBalancing__TAO_AMI_LoadManagerHandler_Proxy_Broker_Factory_function_pointer
      );
    
  return 1;
}

