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

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


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

#ifndef _TAO_IDL_RTEVENTLOGADMINS_CPP_
#define _TAO_IDL_RTEVENTLOGADMINS_CPP_


#include "RTEventLogAdminS.h"
#include "tao/PortableServer/Object_Adapter.h"
#include "tao/PortableServer/Operation_Table.h"
#include "tao/TAO_Server_Request.h"
#include "tao/ORB_Core.h"
#include "tao/Profile.h"
#include "tao/Stub.h"
#include "tao/IFR_Client_Adapter.h"
#include "tao/Object_T.h"
#include "tao/Typecode.h"
#include "tao/DynamicC.h"
#include "tao/CDR.h"
#include "tao/Basic_Arguments.h"
#include "tao/Fixed_Size_Argument_T.h"
#include "tao/Object_Argument_T.h"
#include "tao/UB_String_Arguments.h"
#include "tao/Var_Size_Argument_T.h"
#include "tao/PortableInterceptor.h"
#if TAO_HAS_INTERCEPTORS == 1
#include "tao/PortableServer/PICurrent_Guard.h"
#include "tao/PortableServer/ServerRequestInfo.h"
#include "tao/PortableServer/ServerInterceptorAdapter.h"
#include "tao/RequestInfo_Util.h"
#endif  /* TAO_HAS_INTERCEPTORS == 1 */

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

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

#if !defined (__ACE_INLINE__)
#include "RTEventLogAdminS.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:379

#if !defined (_RTECEVENTCOMM_EVENTSET__ARG_TRAITS_SS_)
#define _RTECEVENTCOMM_EVENTSET__ARG_TRAITS_SS_
  
  ACE_TEMPLATE_SPECIALIZATION
  class TAO_RTEventLog_Export Arg_Traits<RtecEventComm::EventSet>
    : public
        Var_Size_Arg_Traits_T<
            RtecEventComm::EventSet,
            RtecEventComm::EventSet_var,
            RtecEventComm::EventSet_out
          >
  {
  };

#endif /* end #if !defined */

#if !defined (_RTECEVENTCOMM_PUSHCONSUMER__ARG_TRAITS_SS_)
#define _RTECEVENTCOMM_PUSHCONSUMER__ARG_TRAITS_SS_
  
  ACE_TEMPLATE_SPECIALIZATION
  class TAO_RTEventLog_Export Arg_Traits<RtecEventComm::PushConsumer>
    : public
        Object_Arg_Traits_T<
            RtecEventComm::PushConsumer_ptr,
            RtecEventComm::PushConsumer_var,
            RtecEventComm::PushConsumer_out,
            TAO::Objref_Traits<RtecEventComm::PushConsumer>
          >
  {
  };

#endif /* end #if !defined */

#if !defined (_RTECEVENTCOMM_PUSHSUPPLIER__ARG_TRAITS_SS_)
#define _RTECEVENTCOMM_PUSHSUPPLIER__ARG_TRAITS_SS_
  
  ACE_TEMPLATE_SPECIALIZATION
  class TAO_RTEventLog_Export Arg_Traits<RtecEventComm::PushSupplier>
    : public
        Object_Arg_Traits_T<
            RtecEventComm::PushSupplier_ptr,
            RtecEventComm::PushSupplier_var,
            RtecEventComm::PushSupplier_out,
            TAO::Objref_Traits<RtecEventComm::PushSupplier>
          >
  {
  };

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

#if !defined (_RTECEVENTCHANNELADMIN_CONSUMERQOS__ARG_TRAITS_SS_)
#define _RTECEVENTCHANNELADMIN_CONSUMERQOS__ARG_TRAITS_SS_
  
  ACE_TEMPLATE_SPECIALIZATION
  class TAO_RTEventLog_Export Arg_Traits<RtecEventChannelAdmin::ConsumerQOS>
    : public
        Var_Size_Arg_Traits_T<
            RtecEventChannelAdmin::ConsumerQOS,
            RtecEventChannelAdmin::ConsumerQOS_var,
            RtecEventChannelAdmin::ConsumerQOS_out
          >
  {
  };

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

#if !defined (_RTECEVENTCHANNELADMIN_SUPPLIERQOS__ARG_TRAITS_SS_)
#define _RTECEVENTCHANNELADMIN_SUPPLIERQOS__ARG_TRAITS_SS_
  
  ACE_TEMPLATE_SPECIALIZATION
  class TAO_RTEventLog_Export Arg_Traits<RtecEventChannelAdmin::SupplierQOS>
    : public
        Var_Size_Arg_Traits_T<
            RtecEventChannelAdmin::SupplierQOS,
            RtecEventChannelAdmin::SupplierQOS_var,
            RtecEventChannelAdmin::SupplierQOS_out
          >
  {
  };

#endif /* end #if !defined */

#if !defined (_RTECEVENTCHANNELADMIN_OBSERVER__ARG_TRAITS_SS_)
#define _RTECEVENTCHANNELADMIN_OBSERVER__ARG_TRAITS_SS_
  
  ACE_TEMPLATE_SPECIALIZATION
  class TAO_RTEventLog_Export Arg_Traits<RtecEventChannelAdmin::Observer>
    : public
        Object_Arg_Traits_T<
            RtecEventChannelAdmin::Observer_ptr,
            RtecEventChannelAdmin::Observer_var,
            RtecEventChannelAdmin::Observer_out,
            TAO::Objref_Traits<RtecEventChannelAdmin::Observer>
          >
  {
  };

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

#if !defined (_DSLOGADMIN_RECORDIDLIST__ARG_TRAITS_SS_)
#define _DSLOGADMIN_RECORDIDLIST__ARG_TRAITS_SS_
  
  ACE_TEMPLATE_SPECIALIZATION
  class TAO_RTEventLog_Export Arg_Traits<DsLogAdmin::RecordIdList>
    : public
        Var_Size_Arg_Traits_T<
            DsLogAdmin::RecordIdList,
            DsLogAdmin::RecordIdList_var,
            DsLogAdmin::RecordIdList_out
          >
  {
  };

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

#if !defined (_DSLOGADMIN_NVLIST__ARG_TRAITS_SS_)
#define _DSLOGADMIN_NVLIST__ARG_TRAITS_SS_
  
  ACE_TEMPLATE_SPECIALIZATION
  class TAO_RTEventLog_Export Arg_Traits<DsLogAdmin::NVList>
    : public
        Var_Size_Arg_Traits_T<
            DsLogAdmin::NVList,
            DsLogAdmin::NVList_var,
            DsLogAdmin::NVList_out
          >
  {
  };

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

#if !defined (_DSLOGADMIN_TIMEINTERVAL__ARG_TRAITS_SS_)
#define _DSLOGADMIN_TIMEINTERVAL__ARG_TRAITS_SS_
  
  ACE_TEMPLATE_SPECIALIZATION
  class TAO_RTEventLog_Export Arg_Traits<DsLogAdmin::TimeInterval>
    : public
        Fixed_Size_Arg_Traits_T<
            DsLogAdmin::TimeInterval
          >
  {
  };

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

#if !defined (_DSLOGADMIN_RECORDLIST__ARG_TRAITS_SS_)
#define _DSLOGADMIN_RECORDLIST__ARG_TRAITS_SS_
  
  ACE_TEMPLATE_SPECIALIZATION
  class TAO_RTEventLog_Export Arg_Traits<DsLogAdmin::RecordList>
    : public
        Var_Size_Arg_Traits_T<
            DsLogAdmin::RecordList,
            DsLogAdmin::RecordList_var,
            DsLogAdmin::RecordList_out
          >
  {
  };

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

#if !defined (_DSLOGADMIN_ANYS__ARG_TRAITS_SS_)
#define _DSLOGADMIN_ANYS__ARG_TRAITS_SS_
  
  ACE_TEMPLATE_SPECIALIZATION
  class TAO_RTEventLog_Export Arg_Traits<DsLogAdmin::Anys>
    : public
        Var_Size_Arg_Traits_T<
            DsLogAdmin::Anys,
            DsLogAdmin::Anys_var,
            DsLogAdmin::Anys_out
          >
  {
  };

#endif /* end #if !defined */

#if !defined (_DSLOGADMIN_ITERATOR__ARG_TRAITS_SS_)
#define _DSLOGADMIN_ITERATOR__ARG_TRAITS_SS_
  
  ACE_TEMPLATE_SPECIALIZATION
  class TAO_RTEventLog_Export Arg_Traits<DsLogAdmin::Iterator>
    : public
        Object_Arg_Traits_T<
            DsLogAdmin::Iterator_ptr,
            DsLogAdmin::Iterator_var,
            DsLogAdmin::Iterator_out,
            TAO::Objref_Traits<DsLogAdmin::Iterator>
          >
  {
  };

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

#if !defined (_DSLOGADMIN_WEEKMASK__ARG_TRAITS_SS_)
#define _DSLOGADMIN_WEEKMASK__ARG_TRAITS_SS_
  
  ACE_TEMPLATE_SPECIALIZATION
  class TAO_RTEventLog_Export Arg_Traits<DsLogAdmin::WeekMask>
    : public
        Var_Size_Arg_Traits_T<
            DsLogAdmin::WeekMask,
            DsLogAdmin::WeekMask_var,
            DsLogAdmin::WeekMask_out
          >
  {
  };

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

#if !defined (_DSLOGADMIN_CAPACITYALARMTHRESHOLDLIST__ARG_TRAITS_SS_)
#define _DSLOGADMIN_CAPACITYALARMTHRESHOLDLIST__ARG_TRAITS_SS_
  
  ACE_TEMPLATE_SPECIALIZATION
  class TAO_RTEventLog_Export Arg_Traits<DsLogAdmin::CapacityAlarmThresholdList>
    : public
        Var_Size_Arg_Traits_T<
            DsLogAdmin::CapacityAlarmThresholdList,
            DsLogAdmin::CapacityAlarmThresholdList_var,
            DsLogAdmin::CapacityAlarmThresholdList_out
          >
  {
  };

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

#if !defined (_DSLOGADMIN_ADMINISTRATIVESTATE__ARG_TRAITS_SS_)
#define _DSLOGADMIN_ADMINISTRATIVESTATE__ARG_TRAITS_SS_
  
  ACE_TEMPLATE_SPECIALIZATION
  class TAO_RTEventLog_Export Arg_Traits<DsLogAdmin::AdministrativeState>
    : public
        Basic_Arg_Traits_T<
            DsLogAdmin::AdministrativeState
          >
  {
  };

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

#if !defined (_DSLOGADMIN_FORWARDINGSTATE__ARG_TRAITS_SS_)
#define _DSLOGADMIN_FORWARDINGSTATE__ARG_TRAITS_SS_
  
  ACE_TEMPLATE_SPECIALIZATION
  class TAO_RTEventLog_Export Arg_Traits<DsLogAdmin::ForwardingState>
    : public
        Basic_Arg_Traits_T<
            DsLogAdmin::ForwardingState
          >
  {
  };

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

#if !defined (_DSLOGADMIN_QOSLIST__ARG_TRAITS_SS_)
#define _DSLOGADMIN_QOSLIST__ARG_TRAITS_SS_
  
  ACE_TEMPLATE_SPECIALIZATION
  class TAO_RTEventLog_Export Arg_Traits<DsLogAdmin::QoSList>
    : public
        Var_Size_Arg_Traits_T<
            DsLogAdmin::QoSList,
            DsLogAdmin::QoSList_var,
            DsLogAdmin::QoSList_out
          >
  {
  };

#endif /* end #if !defined */

#if !defined (_RTEVENTLOGADMIN_EVENTLOG__ARG_TRAITS_SS_)
#define _RTEVENTLOGADMIN_EVENTLOG__ARG_TRAITS_SS_
  
  ACE_TEMPLATE_SPECIALIZATION
  class TAO_RTEventLog_Export Arg_Traits<RTEventLogAdmin::EventLog>
    : public
        Object_Arg_Traits_T<
            RTEventLogAdmin::EventLog_ptr,
            RTEventLogAdmin::EventLog_var,
            RTEventLogAdmin::EventLog_out,
            TAO::Objref_Traits<RTEventLogAdmin::EventLog>
          >
  {
  };

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


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

class TAO_RTEventLogAdmin_EventLog_Perfect_Hash_OpTable
  : public TAO_Perfect_Hash_OpTable
{
private:
  unsigned int hash (const char *str, unsigned int len);

public:
  const TAO_operation_db_entry * lookup (const char *str, unsigned int len);
};

/* C++ code produced by gperf version 2.8 (ACE version) */
/* Command-line: /work/a/ports/devel/ace+tao/work/ACE_wrappers/bin/gperf -m -M -J -c -C -D -E -T -f 0 -F 0,0,0 -a -o -t -p -K opname_ -L C++ -Z TAO_RTEventLogAdmin_EventLog_Perfect_Hash_OpTable -N lookup  */
unsigned int
TAO_RTEventLogAdmin_EventLog_Perfect_Hash_OpTable::hash (const char *str, unsigned int len)
{
  static const unsigned char asso_values[] =
    {
#if defined (ACE_MVS)
     91, 91, 91, 91, 91, 91, 91, 91, 91, 91,
     91, 91, 91, 91, 91, 91, 91, 91, 91, 91,
     91, 91, 91, 91, 91, 91, 91, 91, 91, 91,
     91, 91, 91, 91, 91, 91, 91, 91, 91, 91,
     91, 91, 91, 91, 91, 91, 91, 91, 91, 91,
     91, 91, 91, 91, 91, 91, 91, 91, 91, 91,
     91, 91, 91, 91, 91, 91, 91, 91, 91, 91,
     91, 91, 91, 91, 91, 91, 91, 91, 91, 91,
     91, 91, 91, 91, 91, 91, 91, 91, 91, 91,
     91, 91, 91, 91, 91, 91, 91, 91, 91, 91,
     91, 91, 91, 91, 91, 91, 91, 91, 91,  0,
     91, 91, 91, 91, 91, 91, 91, 91, 91, 91,
     91, 91, 91, 91, 91, 91, 91, 91, 91, 25,
     91,  0, 35,  0, 30, 15, 30,  0, 91, 91,
     91, 91, 91, 91, 91, 91,  5,  5, 15, 35,
     91, 91,  0,  0, 91, 91, 91, 91, 91, 91,
     91, 91,  0, 35, 91, 91, 10, 91,  0, 91,
     91, 91, 91, 91, 91, 91, 91, 91, 91, 91,
     91, 91, 91, 91, 91, 91, 91, 91, 91, 91,
     91, 91, 91, 91, 91, 91, 91, 91, 91, 91,
     91, 91, 91, 91, 91, 91, 91, 91, 91, 91,
     91, 91, 91, 91, 91, 91, 91, 91, 91, 91,
     91, 91, 91, 91, 91, 91, 91, 91, 91, 91,
     91, 91, 91, 91, 91, 91, 91, 91, 91, 91,
     91, 91, 91, 91, 91, 91, 91, 91, 91, 91,
     91, 91, 91, 91, 91, 91,
#else
     91, 91, 91, 91, 91, 91, 91, 91, 91, 91,
     91, 91, 91, 91, 91, 91, 91, 91, 91, 91,
     91, 91, 91, 91, 91, 91, 91, 91, 91, 91,
     91, 91, 91, 91, 91, 91, 91, 91, 91, 91,
     91, 91, 91, 91, 91, 91, 91, 91, 91, 91,
     91, 91, 91, 91, 91, 91, 91, 91, 91, 91,
     91, 91, 91, 91, 91, 91, 91, 91, 91, 91,
     91, 91, 91, 91, 91, 91, 91, 91, 91, 91,
     91, 91, 91, 91, 91, 91, 91, 91, 91, 91,
     91, 91, 91, 91, 91,  0, 91, 25, 91,  0,
     35,  0, 30, 15, 30,  0, 91,  5,  5, 15,
     35, 91, 91,  0,  0,  0, 35, 91, 91, 10,
     91,  0, 91, 91, 91, 91, 91, 91,
#endif /* ACE_MVS */
    };
  return len + asso_values[(int) str[len - 1]] + asso_values[(int) str[0]];
}

const class TAO_operation_db_entry *
TAO_RTEventLogAdmin_EventLog_Perfect_Hash_OpTable::lookup (const char *str, unsigned int len)
{
  enum
    {
      TOTAL_KEYWORDS = 46,
      MIN_WORD_LENGTH = 2,
      MAX_WORD_LENGTH = 29,
      MIN_HASH_VALUE = 4,
      MAX_HASH_VALUE = 90,
      HASH_VALUE_RANGE = 87,
      DUPLICATES = 4,
      WORDLIST_SIZE = 50
    };

  static const class TAO_operation_db_entry  wordlist[] =
    {
      {"",0,0,0},{"",0,0,0},{"",0,0,0},{"",0,0,0},
      {"copy", &POA_RTEventLogAdmin::EventLog::copy_skel, &POA_RTEventLogAdmin::_TAO_EventLog_ThruPOA_Proxy_Impl::copy, 0},
      {"query", &POA_RTEventLogAdmin::EventLog::query_skel, &POA_RTEventLogAdmin::_TAO_EventLog_ThruPOA_Proxy_Impl::query, 0},
      {"retrieve", &POA_RTEventLogAdmin::EventLog::retrieve_skel, &POA_RTEventLogAdmin::_TAO_EventLog_ThruPOA_Proxy_Impl::retrieve, 0},
      {"_interface", &POA_RTEventLogAdmin::EventLog::_interface_skel, 0, 0},
      {"set_log_qos", &POA_RTEventLogAdmin::EventLog::set_log_qos_skel, &POA_RTEventLogAdmin::_TAO_EventLog_ThruPOA_Proxy_Impl::set_log_qos, 0},
      {"set_max_size", &POA_RTEventLogAdmin::EventLog::set_max_size_skel, &POA_RTEventLogAdmin::_TAO_EventLog_ThruPOA_Proxy_Impl::set_max_size, 0},
      {"remove_observer", &POA_RTEventLogAdmin::EventLog::remove_observer_skel, &POA_RTEventLogAdmin::_TAO_EventLog_ThruPOA_Proxy_Impl::remove_observer, 0},
      {"set_interval", &POA_RTEventLogAdmin::EventLog::set_interval_skel, &POA_RTEventLogAdmin::_TAO_EventLog_ThruPOA_Proxy_Impl::set_interval, 0},
      {"set_week_mask", &POA_RTEventLogAdmin::EventLog::set_week_mask_skel, &POA_RTEventLogAdmin::_TAO_EventLog_ThruPOA_Proxy_Impl::set_week_mask, 0},
      {"set_max_record_life", &POA_RTEventLogAdmin::EventLog::set_max_record_life_skel, &POA_RTEventLogAdmin::_TAO_EventLog_ThruPOA_Proxy_Impl::set_max_record_life, 0},
      {"set_forwarding_state", &POA_RTEventLogAdmin::EventLog::set_forwarding_state_skel, &POA_RTEventLogAdmin::_TAO_EventLog_ThruPOA_Proxy_Impl::set_forwarding_state, 0},
      {"set_record_attribute", &POA_RTEventLogAdmin::EventLog::set_record_attribute_skel, &POA_RTEventLogAdmin::_TAO_EventLog_ThruPOA_Proxy_Impl::set_record_attribute, 0},
      {"set_records_attribute", &POA_RTEventLogAdmin::EventLog::set_records_attribute_skel, &POA_RTEventLogAdmin::_TAO_EventLog_ThruPOA_Proxy_Impl::set_records_attribute, 0},
      {"write_records", &POA_RTEventLogAdmin::EventLog::write_records_skel, &POA_RTEventLogAdmin::_TAO_EventLog_ThruPOA_Proxy_Impl::write_records, 0},
      {"set_administrative_state", &POA_RTEventLogAdmin::EventLog::set_administrative_state_skel, &POA_RTEventLogAdmin::_TAO_EventLog_ThruPOA_Proxy_Impl::set_administrative_state, 0},
      {"my_factory", &POA_RTEventLogAdmin::EventLog::my_factory_skel, &POA_RTEventLogAdmin::_TAO_EventLog_ThruPOA_Proxy_Impl::my_factory, 0},
      {"get_log_qos", &POA_RTEventLogAdmin::EventLog::get_log_qos_skel, &POA_RTEventLogAdmin::_TAO_EventLog_ThruPOA_Proxy_Impl::get_log_qos, 0},
      {"get_max_size", &POA_RTEventLogAdmin::EventLog::get_max_size_skel, &POA_RTEventLogAdmin::_TAO_EventLog_ThruPOA_Proxy_Impl::get_max_size, 0},
      {"get_n_records", &POA_RTEventLogAdmin::EventLog::get_n_records_skel, &POA_RTEventLogAdmin::_TAO_EventLog_ThruPOA_Proxy_Impl::get_n_records, 0},
      {"set_capacity_alarm_thresholds", &POA_RTEventLogAdmin::EventLog::set_capacity_alarm_thresholds_skel, &POA_RTEventLogAdmin::_TAO_EventLog_ThruPOA_Proxy_Impl::set_capacity_alarm_thresholds, 0},
      {"_is_a", &POA_RTEventLogAdmin::EventLog::_is_a_skel, 0, 0},
      {"get_current_size", &POA_RTEventLogAdmin::EventLog::get_current_size_skel, &POA_RTEventLogAdmin::_TAO_EventLog_ThruPOA_Proxy_Impl::get_current_size, 0},
      {"get_interval", &POA_RTEventLogAdmin::EventLog::get_interval_skel, &POA_RTEventLogAdmin::_TAO_EventLog_ThruPOA_Proxy_Impl::get_interval, 0},
      {"get_week_mask", &POA_RTEventLogAdmin::EventLog::get_week_mask_skel, &POA_RTEventLogAdmin::_TAO_EventLog_ThruPOA_Proxy_Impl::get_week_mask, 0},
      {"get_max_record_life", &POA_RTEventLogAdmin::EventLog::get_max_record_life_skel, &POA_RTEventLogAdmin::_TAO_EventLog_ThruPOA_Proxy_Impl::get_max_record_life, 0},
      {"get_forwarding_state", &POA_RTEventLogAdmin::EventLog::get_forwarding_state_skel, &POA_RTEventLogAdmin::_TAO_EventLog_ThruPOA_Proxy_Impl::get_forwarding_state, 0},
      {"get_record_attribute", &POA_RTEventLogAdmin::EventLog::get_record_attribute_skel, &POA_RTEventLogAdmin::_TAO_EventLog_ThruPOA_Proxy_Impl::get_record_attribute, 0},
      {"get_operational_state", &POA_RTEventLogAdmin::EventLog::get_operational_state_skel, &POA_RTEventLogAdmin::_TAO_EventLog_ThruPOA_Proxy_Impl::get_operational_state, 0},
      {"id", &POA_RTEventLogAdmin::EventLog::id_skel, &POA_RTEventLogAdmin::_TAO_EventLog_ThruPOA_Proxy_Impl::id, 0},
      {"get_availability_status", &POA_RTEventLogAdmin::EventLog::get_availability_status_skel, &POA_RTEventLogAdmin::_TAO_EventLog_ThruPOA_Proxy_Impl::get_availability_status, 0},
      {"get_administrative_state", &POA_RTEventLogAdmin::EventLog::get_administrative_state_skel, &POA_RTEventLogAdmin::_TAO_EventLog_ThruPOA_Proxy_Impl::get_administrative_state, 0},
      {"append_observer", &POA_RTEventLogAdmin::EventLog::append_observer_skel, &POA_RTEventLogAdmin::_TAO_EventLog_ThruPOA_Proxy_Impl::append_observer, 0},
      {"destroy", &POA_RTEventLogAdmin::EventLog::destroy_skel, &POA_RTEventLogAdmin::_TAO_EventLog_ThruPOA_Proxy_Impl::destroy, 0},
      {"for_consumers", &POA_RTEventLogAdmin::EventLog::for_consumers_skel, &POA_RTEventLogAdmin::_TAO_EventLog_ThruPOA_Proxy_Impl::for_consumers, 0},
      {"for_suppliers", &POA_RTEventLogAdmin::EventLog::for_suppliers_skel, &POA_RTEventLogAdmin::_TAO_EventLog_ThruPOA_Proxy_Impl::for_suppliers, 0},
      {"get_capacity_alarm_thresholds", &POA_RTEventLogAdmin::EventLog::get_capacity_alarm_thresholds_skel, &POA_RTEventLogAdmin::_TAO_EventLog_ThruPOA_Proxy_Impl::get_capacity_alarm_thresholds, 0},
      {"_component", &POA_RTEventLogAdmin::EventLog::_component_skel, 0, 0},
      {"copy_with_id", &POA_RTEventLogAdmin::EventLog::copy_with_id_skel, &POA_RTEventLogAdmin::_TAO_EventLog_ThruPOA_Proxy_Impl::copy_with_id, 0},
      {"_non_existent", &POA_RTEventLogAdmin::EventLog::_non_existent_skel, 0, 0},
      {"delete_records", &POA_RTEventLogAdmin::EventLog::delete_records_skel, &POA_RTEventLogAdmin::_TAO_EventLog_ThruPOA_Proxy_Impl::delete_records, 0},
      {"match", &POA_RTEventLogAdmin::EventLog::match_skel, &POA_RTEventLogAdmin::_TAO_EventLog_ThruPOA_Proxy_Impl::match, 0},
      {"set_log_full_action", &POA_RTEventLogAdmin::EventLog::set_log_full_action_skel, &POA_RTEventLogAdmin::_TAO_EventLog_ThruPOA_Proxy_Impl::set_log_full_action, 0},
      {"write_recordlist", &POA_RTEventLogAdmin::EventLog::write_recordlist_skel, &POA_RTEventLogAdmin::_TAO_EventLog_ThruPOA_Proxy_Impl::write_recordlist, 0},
      {"flush", &POA_RTEventLogAdmin::EventLog::flush_skel, &POA_RTEventLogAdmin::_TAO_EventLog_ThruPOA_Proxy_Impl::flush, 0},
      {"get_log_full_action", &POA_RTEventLogAdmin::EventLog::get_log_full_action_skel, &POA_RTEventLogAdmin::_TAO_EventLog_ThruPOA_Proxy_Impl::get_log_full_action, 0},
      {"delete_records_by_id", &POA_RTEventLogAdmin::EventLog::delete_records_by_id_skel, &POA_RTEventLogAdmin::_TAO_EventLog_ThruPOA_Proxy_Impl::delete_records_by_id, 0},
    };

  static const signed char lookup[] =
    {
        -1,   -1,  -14,   -2,    4,    5,  -29,   -2,    6,   -1,    7,    8,    9,  -37, 
        -2,   10,   -1,   11,   12,   13, -108,   16,   -1,   17,   18,   19,   20,   21, 
        22,   23,   24,   25,   26,   27,   28, -119,   31,   32,   33,   34,   35,   -1, 
        36, -120,   39,   40,   -1,   41,   42,   43,   44,   -1,   -1,   -1,   45,   -1, 
        -1,   -1,   -1,   -1,   -1,   46,   -1,   -1,   -1,   47,   -1,   -1,   -1,   48, 
        -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1, 
        -1,   -1,   -1,   -1,   -1,   -1,   49, 
    };

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

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

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

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

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

static TAO_RTEventLogAdmin_EventLog_Perfect_Hash_OpTable tao_RTEventLogAdmin_EventLog_optable;

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

#if (TAO_HAS_INTERCEPTORS == 1)

#endif /* TAO_HAS_INTERCEPTORS */

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

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

// Factory function Implementation.
POA_RTEventLogAdmin::_TAO_EventLog_Strategized_Proxy_Broker *
POA_RTEventLogAdmin::_TAO_EventLog_Strategized_Proxy_Broker::the_TAO_EventLog_Strategized_Proxy_Broker (void)
{
  static POA_RTEventLogAdmin::_TAO_EventLog_Strategized_Proxy_Broker
  strategized_proxy_broker;
  
  return &strategized_proxy_broker;
}

POA_RTEventLogAdmin::_TAO_EventLog_Strategized_Proxy_Broker::_TAO_EventLog_Strategized_Proxy_Broker (void)
{
}

POA_RTEventLogAdmin::_TAO_EventLog_Strategized_Proxy_Broker::~_TAO_EventLog_Strategized_Proxy_Broker (void)
{
}

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

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

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

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

TAO::Collocation_Proxy_Broker *
RTEventLogAdmin__TAO_EventLog_Proxy_Broker_Factory_function (CORBA::Object_ptr)
{
  return
    ::POA_RTEventLogAdmin::_TAO_EventLog_Strategized_Proxy_Broker::the_TAO_EventLog_Strategized_Proxy_Broker ();
}

int
RTEventLogAdmin__TAO_EventLog_Proxy_Broker_Factory_Initializer (size_t)
{
  RTEventLogAdmin__TAO_EventLog_Proxy_Broker_Factory_function_pointer = 
    RTEventLogAdmin__TAO_EventLog_Proxy_Broker_Factory_function;
  
  return 0;
}

static int
RTEventLogAdmin__TAO_EventLog_Proxy_Broker_Stub_Factory_Initializer_Scarecrow =
  RTEventLogAdmin__TAO_EventLog_Proxy_Broker_Factory_Initializer (
      reinterpret_cast<
          size_t> (
          RTEventLogAdmin__TAO_EventLog_Proxy_Broker_Factory_Initializer
        )
    );


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

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

POA_RTEventLogAdmin::_TAO_EventLog_ThruPOA_Proxy_Impl::_TAO_EventLog_ThruPOA_Proxy_Impl (void)
{}

// ThruPOA Implementation of the IDL interface methods

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

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

POA_RTEventLogAdmin::EventLog::EventLog (void)
{
  this->optable_ = &tao_RTEventLogAdmin_EventLog_optable;
}

POA_RTEventLogAdmin::EventLog::EventLog (const EventLog& rhs)
  : TAO_Abstract_ServantBase (rhs),
    TAO_ServantBase (rhs),
    ACE_NESTED_CLASS (POA_DsLogAdmin, Log) (rhs),
    ACE_NESTED_CLASS (POA_RtecEventChannelAdmin, EventChannel) (rhs)
{
}

POA_RTEventLogAdmin::EventLog::~EventLog (void)
{
}

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

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

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

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

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

CORBA::Boolean POA_RTEventLogAdmin::EventLog::_is_a (
    const char* value
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  if (
      !ACE_OS::strcmp (
          (char *)value,
          "IDL:omg.org/DsLogAdmin/Log:1.0"
        ) ||
      !ACE_OS::strcmp (
          (char *)value,
          "IDL:RtecEventChannelAdmin/EventChannel:1.0"
        ) ||
      !ACE_OS::strcmp (
          (char *)value,
          "IDL:omg.org/RTEventLogAdmin/EventLog:1.0"
        ) ||
      !ACE_OS::strcmp (
          (char *)value,
          "IDL:omg.org/CORBA/Object:1.0"
        )
     )
    {
      return 1;
    }
  else
    {
      return 0;
    }
}

void* POA_RTEventLogAdmin::EventLog::_downcast (
    const char* logical_type_id
  )
{
  if (ACE_OS::strcmp (logical_type_id,
                      "IDL:omg.org/DsLogAdmin/Log:1.0") == 0)
    {
      return static_cast<POA_DsLogAdmin::Log_ptr> (this);
    }
  
  if (ACE_OS::strcmp (logical_type_id,
                      "IDL:RtecEventChannelAdmin/EventChannel:1.0") == 0)
    {
      return static_cast<POA_RtecEventChannelAdmin::EventChannel_ptr> (this);
    }
  
  if (ACE_OS::strcmp (logical_type_id,
                      "IDL:omg.org/RTEventLogAdmin/EventLog:1.0") == 0)
    {
      return static_cast<POA_RTEventLogAdmin::EventLog_ptr> (this);
    }
  
  if (ACE_OS::strcmp (logical_type_id,
                      "IDL:omg.org/CORBA/Object:1.0") == 0)
    {
      return static_cast<PortableServer::Servant> (this);
    }
  
  return 0;
}

const char* POA_RTEventLogAdmin::EventLog::_interface_repository_id (void) const
{
  return "IDL:omg.org/RTEventLogAdmin/EventLog:1.0";
}

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

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

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

RTEventLogAdmin::EventLog *
POA_RTEventLogAdmin::EventLog::_this (ACE_ENV_SINGLE_ARG_DECL)
{
  TAO_Stub *stub = this->_create_stub (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  TAO_Stub_Auto_Ptr safe_stub (stub);
  CORBA::Object_ptr tmp = CORBA::Object::_nil ();
  
  if (stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects ())
    {
      ACE_NEW_RETURN (
          tmp,
          CORBA::Object (stub, 1, this),
          0
        );
    }
  else
    {
      ACE_NEW_RETURN (
          tmp,
          CORBA::Object (stub, 0, this),
          0
        );
    }
  
  CORBA::Object_var obj = tmp;
  (void) safe_stub.release ();
  
  typedef ::RTEventLogAdmin::EventLog STUB_SCOPED_NAME;
  return
    TAO::Narrow_Utils<STUB_SCOPED_NAME>::unchecked_narrow (
        obj.in (),
        RTEventLogAdmin__TAO_EventLog_Proxy_Broker_Factory_function_pointer
      );
}

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

class TAO_RTEventLogAdmin_EventLogFactory_Perfect_Hash_OpTable
  : public TAO_Perfect_Hash_OpTable
{
private:
  unsigned int hash (const char *str, unsigned int len);

public:
  const TAO_operation_db_entry * lookup (const char *str, unsigned int len);
};

/* C++ code produced by gperf version 2.8 (ACE version) */
/* Command-line: /work/a/ports/devel/ace+tao/work/ACE_wrappers/bin/gperf -m -M -J -c -C -D -E -T -f 0 -F 0,0,0 -a -o -t -p -K opname_ -L C++ -Z TAO_RTEventLogAdmin_EventLogFactory_Perfect_Hash_OpTable -N lookup  */
unsigned int
TAO_RTEventLogAdmin_EventLogFactory_Perfect_Hash_OpTable::hash (const char *str, unsigned int len)
{
  static const unsigned char asso_values[] =
    {
#if defined (ACE_MVS)
     26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
     26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
     26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
     26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
     26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
     26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
     26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
     26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
     26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
     26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
     26, 26, 26, 26, 26, 26, 26, 26, 26,  0,
     26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
     26, 26, 26, 26, 26, 26, 26, 26, 26,  0,
     26,  0,  5,  5,  0,  0, 26, 26, 26, 26,
     26, 26, 26, 26, 26, 26, 26,  0, 26, 26,
      5, 26, 26,  0, 26, 26, 26, 26, 26, 26,
     26, 26,  0,  0, 26, 26, 26, 26, 26, 26,
     26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
     26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
     26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
     26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
     26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
     26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
     26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
     26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
     26, 26, 26, 26, 26, 26,
#else
     26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
     26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
     26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
     26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
     26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
     26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
     26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
     26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
     26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
     26, 26, 26, 26, 26,  0, 26,  0, 26,  0,
      5,  5,  0,  0, 26, 26, 26, 26,  0, 26,
     26,  5, 26, 26,  0,  0,  0, 26, 26, 26,
     26, 26, 26, 26, 26, 26, 26, 26,
#endif /* ACE_MVS */
    };
  return len + asso_values[(int) str[len - 1]] + asso_values[(int) str[0]];
}

const class TAO_operation_db_entry *
TAO_RTEventLogAdmin_EventLogFactory_Perfect_Hash_OpTable::lookup (const char *str, unsigned int len)
{
  enum
    {
      TOTAL_KEYWORDS = 10,
      MIN_WORD_LENGTH = 5,
      MAX_WORD_LENGTH = 20,
      MIN_HASH_VALUE = 5,
      MAX_HASH_VALUE = 25,
      HASH_VALUE_RANGE = 21,
      DUPLICATES = 0,
      WORDLIST_SIZE = 15
    };

  static const class TAO_operation_db_entry  wordlist[] =
    {
      {"",0,0,0},{"",0,0,0},{"",0,0,0},{"",0,0,0},{"",0,0,0},
      {"_is_a", &POA_RTEventLogAdmin::EventLogFactory::_is_a_skel, 0, 0},
      {"",0,0,0},{"",0,0,0},
      {"find_log", &POA_RTEventLogAdmin::EventLogFactory::find_log_skel, &POA_RTEventLogAdmin::_TAO_EventLogFactory_ThruPOA_Proxy_Impl::find_log, 0},
      {"list_logs", &POA_RTEventLogAdmin::EventLogFactory::list_logs_skel, &POA_RTEventLogAdmin::_TAO_EventLogFactory_ThruPOA_Proxy_Impl::list_logs, 0},
      {"_component", &POA_RTEventLogAdmin::EventLogFactory::_component_skel, 0, 0},
      {"create", &POA_RTEventLogAdmin::EventLogFactory::create_skel, &POA_RTEventLogAdmin::_TAO_EventLogFactory_ThruPOA_Proxy_Impl::create, 0},
      {"",0,0,0},
      {"_non_existent", &POA_RTEventLogAdmin::EventLogFactory::_non_existent_skel, 0, 0},
      {"",0,0,0},
      {"_interface", &POA_RTEventLogAdmin::EventLogFactory::_interface_skel, 0, 0},
      {"",0,0,0},{"",0,0,0},{"",0,0,0},
      {"create_with_id", &POA_RTEventLogAdmin::EventLogFactory::create_with_id_skel, &POA_RTEventLogAdmin::_TAO_EventLogFactory_ThruPOA_Proxy_Impl::create_with_id, 0},
      {"list_logs_by_id", &POA_RTEventLogAdmin::EventLogFactory::list_logs_by_id_skel, &POA_RTEventLogAdmin::_TAO_EventLogFactory_ThruPOA_Proxy_Impl::list_logs_by_id, 0},
      {"",0,0,0},{"",0,0,0},{"",0,0,0},{"",0,0,0},
      {"obtain_push_supplier", &POA_RTEventLogAdmin::EventLogFactory::obtain_push_supplier_skel, &POA_RTEventLogAdmin::_TAO_EventLogFactory_ThruPOA_Proxy_Impl::obtain_push_supplier, 0},
    };

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

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

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

static TAO_RTEventLogAdmin_EventLogFactory_Perfect_Hash_OpTable tao_RTEventLogAdmin_EventLogFactory_optable;

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

#if (TAO_HAS_INTERCEPTORS == 1)

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

class TAO_ServerRequestInfo_RTEventLogAdmin_EventLogFactory_create : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_RTEventLogAdmin_EventLogFactory_create (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_RTEventLogAdmin::EventLogFactory *tao_impl,
      const ::DsLogAdmin::LogFullActionType & full_action,
      const ::CORBA::ULongLong & max_size,
      const ::DsLogAdmin::CapacityAlarmThresholdList & thresholds
      ACE_ENV_ARG_DECL_WITH_DEFAULTS
    );
  
  virtual Dynamic::ParameterList * arguments (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual Dynamic::ExceptionList * exceptions (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual CORBA::Any * result (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual char * target_most_derived_interface (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual CORBA::Boolean target_is_a (
      const char * id
      ACE_ENV_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  void result (::RTEventLogAdmin::EventLog_ptr result);

private:
  TAO_ServerRequestInfo_RTEventLogAdmin_EventLogFactory_create (
      const TAO_ServerRequestInfo_RTEventLogAdmin_EventLogFactory_create &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_RTEventLogAdmin_EventLogFactory_create &
    );
  
private:
  POA_RTEventLogAdmin::EventLogFactory *_tao_impl;
  
  const ::DsLogAdmin::LogFullActionType & full_action_;
  const ::CORBA::ULongLong & max_size_;
  const ::DsLogAdmin::CapacityAlarmThresholdList & thresholds_;
  ::RTEventLogAdmin::EventLog_ptr _result;
};

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

TAO_ServerRequestInfo_RTEventLogAdmin_EventLogFactory_create::TAO_ServerRequestInfo_RTEventLogAdmin_EventLogFactory_create (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_RTEventLogAdmin::EventLogFactory *tao_impl,
    const ::DsLogAdmin::LogFullActionType & full_action,
    const ::CORBA::ULongLong & max_size,
    const ::DsLogAdmin::CapacityAlarmThresholdList & thresholds
    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl),
    full_action_ (full_action),
    max_size_ (max_size),
    thresholds_ (thresholds)
{}

Dynamic::ParameterList *
TAO_ServerRequestInfo_RTEventLogAdmin_EventLogFactory_create::arguments (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the argument list on demand.
  Dynamic::ParameterList *parameter_list =
    TAO_RequestInfo_Util::make_parameter_list (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
  parameter_list->length (3);
  CORBA::ULong len = 0;
  
  (*parameter_list)[len].argument <<= full_action_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
  
  (*parameter_list)[len].argument <<= max_size_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
  
  (*parameter_list)[len].argument <<=  this->thresholds_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
  
  return safe_parameter_list._retn ();
}

Dynamic::ExceptionList *
TAO_ServerRequestInfo_RTEventLogAdmin_EventLogFactory_create::exceptions (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the exception list on demand.
  Dynamic::ExceptionList *exception_list =
    TAO_RequestInfo_Util::make_exception_list (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  Dynamic::ExceptionList_var safe_exception_list = exception_list;
    
  static CORBA::TypeCode_ptr _tao_RTEventLogAdmin_EventLogFactory_create_exceptiondata[] = 
  {
    DsLogAdmin::_tc_InvalidLogFullAction,
    DsLogAdmin::_tc_InvalidThreshold
  };
  
  exception_list->length (2);
  for (CORBA::ULong i = 0; i < 2; ++i)
    {
      CORBA::TypeCode_ptr tcp = _tao_RTEventLogAdmin_EventLogFactory_create_exceptiondata[i];
      TAO_Pseudo_Object_Manager<CORBA::TypeCode> tcp_object (&tcp, 1);
      (*exception_list)[i] = tcp_object;
    }

  return safe_exception_list._retn ();
}

CORBA::Any * 
TAO_ServerRequestInfo_RTEventLogAdmin_EventLogFactory_create::result (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the result on demand.
  CORBA::Boolean tk_void_any = 0;
  CORBA::Any *result_any =
    TAO_RequestInfo_Util::make_any (tk_void_any ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  CORBA::Any_var safe_result_any = result_any;
  
  (*result_any) <<= this->_result;
  
  return safe_result_any._retn ();
}

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

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

void 
TAO_ServerRequestInfo_RTEventLogAdmin_EventLogFactory_create::result (::RTEventLogAdmin::EventLog_ptr result)
{
  // Update the result.
   this->_result = result;
}

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

class TAO_ServerRequestInfo_RTEventLogAdmin_EventLogFactory_create_with_id : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_RTEventLogAdmin_EventLogFactory_create_with_id (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_RTEventLogAdmin::EventLogFactory *tao_impl,
      const ::DsLogAdmin::LogId & id,
      const ::DsLogAdmin::LogFullActionType & full_action,
      const ::CORBA::ULongLong & max_size,
      const ::DsLogAdmin::CapacityAlarmThresholdList & thresholds
      ACE_ENV_ARG_DECL_WITH_DEFAULTS
    );
  
  virtual Dynamic::ParameterList * arguments (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual Dynamic::ExceptionList * exceptions (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual CORBA::Any * result (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual char * target_most_derived_interface (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual CORBA::Boolean target_is_a (
      const char * id
      ACE_ENV_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  void result (::RTEventLogAdmin::EventLog_ptr result);

private:
  TAO_ServerRequestInfo_RTEventLogAdmin_EventLogFactory_create_with_id (
      const TAO_ServerRequestInfo_RTEventLogAdmin_EventLogFactory_create_with_id &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_RTEventLogAdmin_EventLogFactory_create_with_id &
    );
  
private:
  POA_RTEventLogAdmin::EventLogFactory *_tao_impl;
  
  const ::DsLogAdmin::LogId & id_;
  const ::DsLogAdmin::LogFullActionType & full_action_;
  const ::CORBA::ULongLong & max_size_;
  const ::DsLogAdmin::CapacityAlarmThresholdList & thresholds_;
  ::RTEventLogAdmin::EventLog_ptr _result;
};

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

TAO_ServerRequestInfo_RTEventLogAdmin_EventLogFactory_create_with_id::TAO_ServerRequestInfo_RTEventLogAdmin_EventLogFactory_create_with_id (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_RTEventLogAdmin::EventLogFactory *tao_impl,
    const ::DsLogAdmin::LogId & id,
    const ::DsLogAdmin::LogFullActionType & full_action,
    const ::CORBA::ULongLong & max_size,
    const ::DsLogAdmin::CapacityAlarmThresholdList & thresholds
    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl),
    id_ (id),
    full_action_ (full_action),
    max_size_ (max_size),
    thresholds_ (thresholds)
{}

Dynamic::ParameterList *
TAO_ServerRequestInfo_RTEventLogAdmin_EventLogFactory_create_with_id::arguments (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the argument list on demand.
  Dynamic::ParameterList *parameter_list =
    TAO_RequestInfo_Util::make_parameter_list (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
  parameter_list->length (4);
  CORBA::ULong len = 0;
  
  (*parameter_list)[len].argument <<= id_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
  
  (*parameter_list)[len].argument <<= full_action_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
  
  (*parameter_list)[len].argument <<= max_size_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
  
  (*parameter_list)[len].argument <<=  this->thresholds_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
  
  return safe_parameter_list._retn ();
}

Dynamic::ExceptionList *
TAO_ServerRequestInfo_RTEventLogAdmin_EventLogFactory_create_with_id::exceptions (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the exception list on demand.
  Dynamic::ExceptionList *exception_list =
    TAO_RequestInfo_Util::make_exception_list (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  Dynamic::ExceptionList_var safe_exception_list = exception_list;
    
  static CORBA::TypeCode_ptr _tao_RTEventLogAdmin_EventLogFactory_create_with_id_exceptiondata[] = 
  {
    DsLogAdmin::_tc_LogIdAlreadyExists,
    DsLogAdmin::_tc_InvalidLogFullAction,
    DsLogAdmin::_tc_InvalidThreshold
  };
  
  exception_list->length (3);
  for (CORBA::ULong i = 0; i < 3; ++i)
    {
      CORBA::TypeCode_ptr tcp = _tao_RTEventLogAdmin_EventLogFactory_create_with_id_exceptiondata[i];
      TAO_Pseudo_Object_Manager<CORBA::TypeCode> tcp_object (&tcp, 1);
      (*exception_list)[i] = tcp_object;
    }

  return safe_exception_list._retn ();
}

CORBA::Any * 
TAO_ServerRequestInfo_RTEventLogAdmin_EventLogFactory_create_with_id::result (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the result on demand.
  CORBA::Boolean tk_void_any = 0;
  CORBA::Any *result_any =
    TAO_RequestInfo_Util::make_any (tk_void_any ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  CORBA::Any_var safe_result_any = result_any;
  
  (*result_any) <<= this->_result;
  
  return safe_result_any._retn ();
}

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

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

void 
TAO_ServerRequestInfo_RTEventLogAdmin_EventLogFactory_create_with_id::result (::RTEventLogAdmin::EventLog_ptr result)
{
  // Update the result.
   this->_result = result;
}

#endif /* TAO_HAS_INTERCEPTORS */

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

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

// Factory function Implementation.
POA_RTEventLogAdmin::_TAO_EventLogFactory_Strategized_Proxy_Broker *
POA_RTEventLogAdmin::_TAO_EventLogFactory_Strategized_Proxy_Broker::the_TAO_EventLogFactory_Strategized_Proxy_Broker (void)
{
  static POA_RTEventLogAdmin::_TAO_EventLogFactory_Strategized_Proxy_Broker
  strategized_proxy_broker;
  
  return &strategized_proxy_broker;
}

POA_RTEventLogAdmin::_TAO_EventLogFactory_Strategized_Proxy_Broker::_TAO_EventLogFactory_Strategized_Proxy_Broker (void)
{
}

POA_RTEventLogAdmin::_TAO_EventLogFactory_Strategized_Proxy_Broker::~_TAO_EventLogFactory_Strategized_Proxy_Broker (void)
{
}

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

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

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

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

TAO::Collocation_Proxy_Broker *
RTEventLogAdmin__TAO_EventLogFactory_Proxy_Broker_Factory_function (CORBA::Object_ptr)
{
  return
    ::POA_RTEventLogAdmin::_TAO_EventLogFactory_Strategized_Proxy_Broker::the_TAO_EventLogFactory_Strategized_Proxy_Broker ();
}

int
RTEventLogAdmin__TAO_EventLogFactory_Proxy_Broker_Factory_Initializer (size_t)
{
  RTEventLogAdmin__TAO_EventLogFactory_Proxy_Broker_Factory_function_pointer = 
    RTEventLogAdmin__TAO_EventLogFactory_Proxy_Broker_Factory_function;
  
  return 0;
}

static int
RTEventLogAdmin__TAO_EventLogFactory_Proxy_Broker_Stub_Factory_Initializer_Scarecrow =
  RTEventLogAdmin__TAO_EventLogFactory_Proxy_Broker_Factory_Initializer (
      reinterpret_cast<
          size_t> (
          RTEventLogAdmin__TAO_EventLogFactory_Proxy_Broker_Factory_Initializer
        )
    );


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

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

POA_RTEventLogAdmin::_TAO_EventLogFactory_ThruPOA_Proxy_Impl::_TAO_EventLogFactory_ThruPOA_Proxy_Impl (void)
{}

// ThruPOA Implementation of the IDL interface methods

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

void
POA_RTEventLogAdmin::_TAO_EventLogFactory_ThruPOA_Proxy_Impl::create (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument ** args,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException,
    ::DsLogAdmin::InvalidLogFullAction,
    ::DsLogAdmin::InvalidThreshold
  ))
{
  ((TAO::Arg_Traits< ::RTEventLogAdmin::EventLog>::ret_val *) args[0])->arg () =
    reinterpret_cast<
        POA_RTEventLogAdmin::EventLogFactory_ptr> (
        servant->_downcast (
            "IDL:omg.org/RTEventLogAdmin/EventLogFactory:1.0"
          )
      )->create (
          ((TAO::Arg_Traits< DsLogAdmin::LogFullActionType>::in_arg_val *) args[1])->arg (),
          ((TAO::Arg_Traits< CORBA::ULongLong>::in_arg_val *) args[2])->arg (),
          ((TAO::Arg_Traits< ::DsLogAdmin::CapacityAlarmThresholdList>::in_arg_val *) args[3])->arg (),
          ((TAO::Arg_Traits< DsLogAdmin::LogId>::out_arg_val *) args[4])->arg ()
          ACE_ENV_ARG_PARAMETER
        );
  ACE_CHECK;
}

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

void
POA_RTEventLogAdmin::_TAO_EventLogFactory_ThruPOA_Proxy_Impl::create_with_id (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument ** args,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException,
    ::DsLogAdmin::LogIdAlreadyExists,
    ::DsLogAdmin::InvalidLogFullAction,
    ::DsLogAdmin::InvalidThreshold
  ))
{
  ((TAO::Arg_Traits< ::RTEventLogAdmin::EventLog>::ret_val *) args[0])->arg () =
    reinterpret_cast<
        POA_RTEventLogAdmin::EventLogFactory_ptr> (
        servant->_downcast (
            "IDL:omg.org/RTEventLogAdmin/EventLogFactory:1.0"
          )
      )->create_with_id (
          ((TAO::Arg_Traits< DsLogAdmin::LogId>::in_arg_val *) args[1])->arg (),
          ((TAO::Arg_Traits< DsLogAdmin::LogFullActionType>::in_arg_val *) args[2])->arg (),
          ((TAO::Arg_Traits< CORBA::ULongLong>::in_arg_val *) args[3])->arg (),
          ((TAO::Arg_Traits< ::DsLogAdmin::CapacityAlarmThresholdList>::in_arg_val *) args[4])->arg ()
          ACE_ENV_ARG_PARAMETER
        );
  ACE_CHECK;
}

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

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

POA_RTEventLogAdmin::EventLogFactory::EventLogFactory (void)
{
  this->optable_ = &tao_RTEventLogAdmin_EventLogFactory_optable;
}

POA_RTEventLogAdmin::EventLogFactory::EventLogFactory (const EventLogFactory& rhs)
  : TAO_Abstract_ServantBase (rhs),
    TAO_ServantBase (rhs),
    ACE_NESTED_CLASS (POA_DsLogAdmin, LogMgr) (rhs),
    ACE_NESTED_CLASS (POA_RtecEventChannelAdmin, ConsumerAdmin) (rhs)
{
}

POA_RTEventLogAdmin::EventLogFactory::~EventLogFactory (void)
{
}

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

void POA_RTEventLogAdmin::EventLogFactory::create_skel (
    TAO_ServerRequest &_tao_server_request,
    void *_tao_servant,
    void *_tao_servant_upcall
    ACE_ENV_ARG_DECL
  )
{
    TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
POA_RTEventLogAdmin::EventLogFactory *_tao_impl =
    static_cast<
        POA_RTEventLogAdmin::EventLogFactory *> (
        _tao_servant
      );
  ::RTEventLogAdmin::EventLog_var _tao_retval;
  ::DsLogAdmin::LogFullActionType full_action;
  ::CORBA::ULongLong max_size;
  ::DsLogAdmin::CapacityAlarmThresholdList thresholds;
  ::DsLogAdmin::LogId id = 0;
  
  if (!(
      (_tao_in >> full_action) &&
      (_tao_in >> max_size) &&
      (_tao_in >> thresholds)
      ))
    {
      TAO_InputCDR::throw_skel_exception (errno ACE_ENV_ARG_PARAMETER);
      ACE_CHECK;
    }
  
#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_Object_Adapter::Servant_Upcall *_tao_upcall =
    static_cast<
        TAO_Object_Adapter::Servant_Upcall *> (
        _tao_servant_upcall
      );
    
  TAO_ServerRequestInterceptor_Adapter _tao_vfr (
      _tao_server_request.orb_core ()->server_request_interceptors (),
      _tao_server_request.interceptor_count ()
    );
  
  TAO_ServerRequestInfo_RTEventLogAdmin_EventLogFactory_create _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl,
      
      full_action,
      
      max_size,
      
      thresholds
      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* Copy TSC to RSC */);
        
        _tao_vfr.receive_request (&_tao_ri ACE_ENV_ARG_PARAMETER);
        ACE_TRY_CHECK;
        
        if (!_tao_vfr.location_forwarded ())
          {
#endif /* TAO_HAS_INTERCEPTORS */
            _tao_retval = 
              _tao_impl->create (
                  full_action,
                  
                  max_size,
                  
                  thresholds,
                  
                  id
                  ACE_ENV_ARG_PARAMETER
                );
            TAO_INTERCEPTOR_CHECK;
#if (TAO_HAS_INTERCEPTORS == 1)
          }
      }
      
      if (!_tao_vfr.location_forwarded ())
        {
          ::RTEventLogAdmin::EventLog_ptr _tao_retval_info = _tao_retval._retn ();
          _tao_ri.result (_tao_retval_info);
          _tao_retval = _tao_retval_info;
          _tao_ri.reply_status (PortableInterceptor::SUCCESSFUL);
          _tao_vfr.send_reply (&_tao_ri ACE_ENV_ARG_PARAMETER);
          ACE_TRY_CHECK;
        }
    }
  ACE_CATCHANY
    {
      _tao_ri.exception (&ACE_ANY_EXCEPTION);
      _tao_vfr.send_exception (
          &_tao_ri
          ACE_ENV_ARG_PARAMETER
        );
      ACE_TRY_CHECK;
      
      PortableInterceptor::ReplyStatus _tao_status =
        _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_TRY_CHECK;
      
      if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION
          || _tao_status == PortableInterceptor::USER_EXCEPTION)
        {
          ACE_RE_THROW;
        }
    }
  
# if defined (ACE_HAS_EXCEPTIONS) \
  && defined (ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS)
  ACE_CATCHALL
    {
      CORBA::UNKNOWN ex;
      
      _tao_ri.exception (&ex);
      _tao_vfr.send_exception (
          &_tao_ri
          ACE_ENV_ARG_PARAMETER
        );
      ACE_TRY_CHECK;
      
      PortableInterceptor::ReplyStatus _tao_status =
        _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_TRY_CHECK;
      
      if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION)
        ACE_TRY_THROW (ex);
    }
# endif  /* ACE_HAS_EXCEPTIONS && ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS */
  ACE_ENDTRY;
  ACE_CHECK;
#endif /* TAO_HAS_INTERCEPTORS */
  
  _tao_server_request.init_reply ();
#if (TAO_HAS_INTERCEPTORS == 1)
  if (!_tao_vfr.location_forwarded ())
    {
#endif /* TAO_HAS_INTERCEPTORS */
      TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
      
      if (!(
          (_tao_out << _tao_retval.in ()) &&
          (_tao_out << id)
          ))
        {
          TAO_OutputCDR::throw_skel_exception (errno ACE_ENV_ARG_PARAMETER);
          ACE_CHECK;
        }
#if (TAO_HAS_INTERCEPTORS == 1)
    }
#endif /* TAO_HAS_INTERCEPTORS */
  
  
  // In case _tao_servant_upcall is not used in this function
  ACE_UNUSED_ARG (_tao_servant_upcall);
}

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

void POA_RTEventLogAdmin::EventLogFactory::create_with_id_skel (
    TAO_ServerRequest &_tao_server_request,
    void *_tao_servant,
    void *_tao_servant_upcall
    ACE_ENV_ARG_DECL
  )
{
    TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
POA_RTEventLogAdmin::EventLogFactory *_tao_impl =
    static_cast<
        POA_RTEventLogAdmin::EventLogFactory *> (
        _tao_servant
      );
  ::RTEventLogAdmin::EventLog_var _tao_retval;
  ::DsLogAdmin::LogId id;
  ::DsLogAdmin::LogFullActionType full_action;
  ::CORBA::ULongLong max_size;
  ::DsLogAdmin::CapacityAlarmThresholdList thresholds;
  
  if (!(
      (_tao_in >> id) &&
      (_tao_in >> full_action) &&
      (_tao_in >> max_size) &&
      (_tao_in >> thresholds)
      ))
    {
      TAO_InputCDR::throw_skel_exception (errno ACE_ENV_ARG_PARAMETER);
      ACE_CHECK;
    }
  
#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_Object_Adapter::Servant_Upcall *_tao_upcall =
    static_cast<
        TAO_Object_Adapter::Servant_Upcall *> (
        _tao_servant_upcall
      );
    
  TAO_ServerRequestInterceptor_Adapter _tao_vfr (
      _tao_server_request.orb_core ()->server_request_interceptors (),
      _tao_server_request.interceptor_count ()
    );
  
  TAO_ServerRequestInfo_RTEventLogAdmin_EventLogFactory_create_with_id _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl,
      
      id,
      
      full_action,
      
      max_size,
      
      thresholds
      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* Copy TSC to RSC */);
        
        _tao_vfr.receive_request (&_tao_ri ACE_ENV_ARG_PARAMETER);
        ACE_TRY_CHECK;
        
        if (!_tao_vfr.location_forwarded ())
          {
#endif /* TAO_HAS_INTERCEPTORS */
            _tao_retval = 
              _tao_impl->create_with_id (
                  id,
                  
                  full_action,
                  
                  max_size,
                  
                  thresholds
                  ACE_ENV_ARG_PARAMETER
                );
            TAO_INTERCEPTOR_CHECK;
#if (TAO_HAS_INTERCEPTORS == 1)
          }
      }
      
      if (!_tao_vfr.location_forwarded ())
        {
          ::RTEventLogAdmin::EventLog_ptr _tao_retval_info = _tao_retval._retn ();
          _tao_ri.result (_tao_retval_info);
          _tao_retval = _tao_retval_info;
          _tao_ri.reply_status (PortableInterceptor::SUCCESSFUL);
          _tao_vfr.send_reply (&_tao_ri ACE_ENV_ARG_PARAMETER);
          ACE_TRY_CHECK;
        }
    }
  ACE_CATCHANY
    {
      _tao_ri.exception (&ACE_ANY_EXCEPTION);
      _tao_vfr.send_exception (
          &_tao_ri
          ACE_ENV_ARG_PARAMETER
        );
      ACE_TRY_CHECK;
      
      PortableInterceptor::ReplyStatus _tao_status =
        _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_TRY_CHECK;
      
      if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION
          || _tao_status == PortableInterceptor::USER_EXCEPTION)
        {
          ACE_RE_THROW;
        }
    }
  
# if defined (ACE_HAS_EXCEPTIONS) \
  && defined (ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS)
  ACE_CATCHALL
    {
      CORBA::UNKNOWN ex;
      
      _tao_ri.exception (&ex);
      _tao_vfr.send_exception (
          &_tao_ri
          ACE_ENV_ARG_PARAMETER
        );
      ACE_TRY_CHECK;
      
      PortableInterceptor::ReplyStatus _tao_status =
        _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_TRY_CHECK;
      
      if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION)
        ACE_TRY_THROW (ex);
    }
# endif  /* ACE_HAS_EXCEPTIONS && ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS */
  ACE_ENDTRY;
  ACE_CHECK;
#endif /* TAO_HAS_INTERCEPTORS */
  
  _tao_server_request.init_reply ();
#if (TAO_HAS_INTERCEPTORS == 1)
  if (!_tao_vfr.location_forwarded ())
    {
#endif /* TAO_HAS_INTERCEPTORS */
      TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
      
      if (!(
          (_tao_out << _tao_retval.in ())
          ))
        {
          TAO_OutputCDR::throw_skel_exception (errno ACE_ENV_ARG_PARAMETER);
          ACE_CHECK;
        }
#if (TAO_HAS_INTERCEPTORS == 1)
    }
#endif /* TAO_HAS_INTERCEPTORS */
  
  
  // In case _tao_servant_upcall is not used in this function
  ACE_UNUSED_ARG (_tao_servant_upcall);
}

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

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

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

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

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

CORBA::Boolean POA_RTEventLogAdmin::EventLogFactory::_is_a (
    const char* value
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  if (
      !ACE_OS::strcmp (
          (char *)value,
          "IDL:omg.org/DsLogAdmin/LogMgr:1.0"
        ) ||
      !ACE_OS::strcmp (
          (char *)value,
          "IDL:RtecEventChannelAdmin/ConsumerAdmin:1.0"
        ) ||
      !ACE_OS::strcmp (
          (char *)value,
          "IDL:omg.org/RTEventLogAdmin/EventLogFactory:1.0"
        ) ||
      !ACE_OS::strcmp (
          (char *)value,
          "IDL:omg.org/CORBA/Object:1.0"
        )
     )
    {
      return 1;
    }
  else
    {
      return 0;
    }
}

void* POA_RTEventLogAdmin::EventLogFactory::_downcast (
    const char* logical_type_id
  )
{
  if (ACE_OS::strcmp (logical_type_id,
                      "IDL:omg.org/DsLogAdmin/LogMgr:1.0") == 0)
    {
      return static_cast<POA_DsLogAdmin::LogMgr_ptr> (this);
    }
  
  if (ACE_OS::strcmp (logical_type_id,
                      "IDL:RtecEventChannelAdmin/ConsumerAdmin:1.0") == 0)
    {
      return static_cast<POA_RtecEventChannelAdmin::ConsumerAdmin_ptr> (this);
    }
  
  if (ACE_OS::strcmp (logical_type_id,
                      "IDL:omg.org/RTEventLogAdmin/EventLogFactory:1.0") == 0)
    {
      return static_cast<POA_RTEventLogAdmin::EventLogFactory_ptr> (this);
    }
  
  if (ACE_OS::strcmp (logical_type_id,
                      "IDL:omg.org/CORBA/Object:1.0") == 0)
    {
      return static_cast<PortableServer::Servant> (this);
    }
  
  return 0;
}

const char* POA_RTEventLogAdmin::EventLogFactory::_interface_repository_id (void) const
{
  return "IDL:omg.org/RTEventLogAdmin/EventLogFactory:1.0";
}

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

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

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

RTEventLogAdmin::EventLogFactory *
POA_RTEventLogAdmin::EventLogFactory::_this (ACE_ENV_SINGLE_ARG_DECL)
{
  TAO_Stub *stub = this->_create_stub (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  TAO_Stub_Auto_Ptr safe_stub (stub);
  CORBA::Object_ptr tmp = CORBA::Object::_nil ();
  
  if (stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects ())
    {
      ACE_NEW_RETURN (
          tmp,
          CORBA::Object (stub, 1, this),
          0
        );
    }
  else
    {
      ACE_NEW_RETURN (
          tmp,
          CORBA::Object (stub, 0, this),
          0
        );
    }
  
  CORBA::Object_var obj = tmp;
  (void) safe_stub.release ();
  
  typedef ::RTEventLogAdmin::EventLogFactory STUB_SCOPED_NAME;
  return
    TAO::Narrow_Utils<STUB_SCOPED_NAME>::unchecked_narrow (
        obj.in (),
        RTEventLogAdmin__TAO_EventLogFactory_Proxy_Broker_Factory_function_pointer
      );
}

#endif /* ifndef */
