// -*- 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_RTECSCHEDULERS_CPP_
#define _TAO_IDL_RTECSCHEDULERS_CPP_


#include "RtecSchedulerS.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/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 "RtecSchedulerS.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:537

#if !defined (_RTECBASE_DEPENDENCY_TYPE_T__ARG_TRAITS_SS_)
#define _RTECBASE_DEPENDENCY_TYPE_T__ARG_TRAITS_SS_
  
  ACE_TEMPLATE_SPECIALIZATION
  class TAO_RTSched_Export Arg_Traits<RtecBase::Dependency_Type_t>
    : public
        Basic_Arg_Traits_T<
            RtecBase::Dependency_Type_t
          >
  {
  };

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

#if !defined (_RTECBASE_DEPENDENCY_ENABLED_TYPE_T__ARG_TRAITS_SS_)
#define _RTECBASE_DEPENDENCY_ENABLED_TYPE_T__ARG_TRAITS_SS_
  
  ACE_TEMPLATE_SPECIALIZATION
  class TAO_RTSched_Export Arg_Traits<RtecBase::Dependency_Enabled_Type_t>
    : public
        Basic_Arg_Traits_T<
            RtecBase::Dependency_Enabled_Type_t
          >
  {
  };

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

#if !defined (_RTECSCHEDULER_CRITICALITY_T__ARG_TRAITS_SS_)
#define _RTECSCHEDULER_CRITICALITY_T__ARG_TRAITS_SS_
  
  ACE_TEMPLATE_SPECIALIZATION
  class TAO_RTSched_Export Arg_Traits<RtecScheduler::Criticality_t>
    : public
        Basic_Arg_Traits_T<
            RtecScheduler::Criticality_t
          >
  {
  };

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

#if !defined (_RTECSCHEDULER_IMPORTANCE_T__ARG_TRAITS_SS_)
#define _RTECSCHEDULER_IMPORTANCE_T__ARG_TRAITS_SS_
  
  ACE_TEMPLATE_SPECIALIZATION
  class TAO_RTSched_Export Arg_Traits<RtecScheduler::Importance_t>
    : public
        Basic_Arg_Traits_T<
            RtecScheduler::Importance_t
          >
  {
  };

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

#if !defined (_RTECSCHEDULER_INFO_TYPE_T__ARG_TRAITS_SS_)
#define _RTECSCHEDULER_INFO_TYPE_T__ARG_TRAITS_SS_
  
  ACE_TEMPLATE_SPECIALIZATION
  class TAO_RTSched_Export Arg_Traits<RtecScheduler::Info_Type_t>
    : public
        Basic_Arg_Traits_T<
            RtecScheduler::Info_Type_t
          >
  {
  };

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

#if !defined (_RTECSCHEDULER_RT_INFO_ENABLED_TYPE_T__ARG_TRAITS_SS_)
#define _RTECSCHEDULER_RT_INFO_ENABLED_TYPE_T__ARG_TRAITS_SS_
  
  ACE_TEMPLATE_SPECIALIZATION
  class TAO_RTSched_Export Arg_Traits<RtecScheduler::RT_Info_Enabled_Type_t>
    : public
        Basic_Arg_Traits_T<
            RtecScheduler::RT_Info_Enabled_Type_t
          >
  {
  };

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

#if !defined (_RTECSCHEDULER_RT_INFO_ENABLE_STATE_PAIR_SET__ARG_TRAITS_SS_)
#define _RTECSCHEDULER_RT_INFO_ENABLE_STATE_PAIR_SET__ARG_TRAITS_SS_
  
  ACE_TEMPLATE_SPECIALIZATION
  class TAO_RTSched_Export Arg_Traits<RtecScheduler::RT_Info_Enable_State_Pair_Set>
    : public
        Var_Size_Arg_Traits_T<
            RtecScheduler::RT_Info_Enable_State_Pair_Set,
            RtecScheduler::RT_Info_Enable_State_Pair_Set_var,
            RtecScheduler::RT_Info_Enable_State_Pair_Set_out
          >
  {
  };

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

#if !defined (_RTECSCHEDULER_DEPENDENCY_SET__ARG_TRAITS_SS_)
#define _RTECSCHEDULER_DEPENDENCY_SET__ARG_TRAITS_SS_
  
  ACE_TEMPLATE_SPECIALIZATION
  class TAO_RTSched_Export Arg_Traits<RtecScheduler::Dependency_Set>
    : public
        Var_Size_Arg_Traits_T<
            RtecScheduler::Dependency_Set,
            RtecScheduler::Dependency_Set_var,
            RtecScheduler::Dependency_Set_out
          >
  {
  };

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

#if !defined (_RTECSCHEDULER_RT_INFO__ARG_TRAITS_SS_)
#define _RTECSCHEDULER_RT_INFO__ARG_TRAITS_SS_
  
  ACE_TEMPLATE_SPECIALIZATION
  class TAO_RTSched_Export Arg_Traits<RtecScheduler::RT_Info>
    : public
        Var_Size_Arg_Traits_T<
            RtecScheduler::RT_Info,
            RtecScheduler::RT_Info_var,
            RtecScheduler::RT_Info_out
          >
  {
  };

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

#if !defined (_RTECSCHEDULER_DISPATCHING_TYPE_T__ARG_TRAITS_SS_)
#define _RTECSCHEDULER_DISPATCHING_TYPE_T__ARG_TRAITS_SS_
  
  ACE_TEMPLATE_SPECIALIZATION
  class TAO_RTSched_Export Arg_Traits<RtecScheduler::Dispatching_Type_t>
    : public
        Basic_Arg_Traits_T<
            RtecScheduler::Dispatching_Type_t
          >
  {
  };

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

#if !defined (_RTECSCHEDULER_CONFIG_INFO_SET__ARG_TRAITS_SS_)
#define _RTECSCHEDULER_CONFIG_INFO_SET__ARG_TRAITS_SS_
  
  ACE_TEMPLATE_SPECIALIZATION
  class TAO_RTSched_Export Arg_Traits<RtecScheduler::Config_Info_Set>
    : public
        Var_Size_Arg_Traits_T<
            RtecScheduler::Config_Info_Set,
            RtecScheduler::Config_Info_Set_var,
            RtecScheduler::Config_Info_Set_out
          >
  {
  };

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

#if !defined (_RTECSCHEDULER_SCHEDULING_ANOMALY_SET__ARG_TRAITS_SS_)
#define _RTECSCHEDULER_SCHEDULING_ANOMALY_SET__ARG_TRAITS_SS_
  
  ACE_TEMPLATE_SPECIALIZATION
  class TAO_RTSched_Export Arg_Traits<RtecScheduler::Scheduling_Anomaly_Set>
    : public
        Var_Size_Arg_Traits_T<
            RtecScheduler::Scheduling_Anomaly_Set,
            RtecScheduler::Scheduling_Anomaly_Set_var,
            RtecScheduler::Scheduling_Anomaly_Set_out
          >
  {
  };

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

#if !defined (_RTECSCHEDULER_RT_INFO_SET__ARG_TRAITS_SS_)
#define _RTECSCHEDULER_RT_INFO_SET__ARG_TRAITS_SS_
  
  ACE_TEMPLATE_SPECIALIZATION
  class TAO_RTSched_Export Arg_Traits<RtecScheduler::RT_Info_Set>
    : public
        Var_Size_Arg_Traits_T<
            RtecScheduler::RT_Info_Set,
            RtecScheduler::RT_Info_Set_var,
            RtecScheduler::RT_Info_Set_out
          >
  {
  };

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


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

class TAO_RtecScheduler_Scheduler_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_RtecScheduler_Scheduler_Perfect_Hash_OpTable -N lookup  */
unsigned int
TAO_RtecScheduler_Scheduler_Perfect_Hash_OpTable::hash (const char *str, unsigned int len)
{
  static const unsigned char asso_values[] =
    {
#if defined (ACE_MVS)
     49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
     49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
     49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
     49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
     49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
     49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
     49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
     49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
     49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
     49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
     49, 49, 49, 49, 49, 49, 49, 49, 49,  0,
     49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
     49, 49, 49, 49, 49, 49, 49, 49, 49,  1,
     49, 10,  0, 20, 49,  5, 49, 49, 49, 49,
     49, 49, 49, 49, 49, 49, 49, 25, 49,  0,
     49, 10,  0,  0, 49, 49, 49, 49, 49, 49,
     49, 49,  0,  0, 49, 49, 49, 49,  0, 49,
     49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
     49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
     49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
     49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
     49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
     49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
     49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
     49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
     49, 49, 49, 49, 49, 49,
#else
     49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
     49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
     49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
     49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
     49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
     49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
     49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
     49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
     49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
     49, 49, 49, 49, 49,  0, 49,  1, 49, 10,
      0, 20, 49,  5, 49, 49, 49, 49, 25, 49,
      0, 49, 10,  0,  0,  0,  0, 49, 49, 49,
     49,  0, 49, 49, 49, 49, 49, 49,
#endif /* ACE_MVS */
    };
  return len + asso_values[(int) str[len - 1]] + asso_values[(int) str[0]];
}

const class TAO_operation_db_entry *
TAO_RtecScheduler_Scheduler_Perfect_Hash_OpTable::lookup (const char *str, unsigned int len)
{
  enum
    {
      TOTAL_KEYWORDS = 28,
      MIN_WORD_LENGTH = 3,
      MAX_WORD_LENGTH = 31,
      MIN_HASH_VALUE = 3,
      MAX_HASH_VALUE = 48,
      HASH_VALUE_RANGE = 46,
      DUPLICATES = 0,
      WORDLIST_SIZE = 31
    };

  static const class TAO_operation_db_entry  wordlist[] =
    {
      {"",0,0,0},{"",0,0,0},{"",0,0,0},
      {"set", &POA_RtecScheduler::Scheduler::set_skel, &POA_RtecScheduler::_TAO_Scheduler_ThruPOA_Proxy_Impl::set, 0},
      {"",0,0,0},
      {"reset", &POA_RtecScheduler::Scheduler::reset_skel, &POA_RtecScheduler::_TAO_Scheduler_ThruPOA_Proxy_Impl::reset, 0},
      {"_is_a", &POA_RtecScheduler::Scheduler::_is_a_skel, 0, 0},
      {"set_seq", &POA_RtecScheduler::Scheduler::set_seq_skel, &POA_RtecScheduler::_TAO_Scheduler_ThruPOA_Proxy_Impl::set_seq, 0},
      {"get", &POA_RtecScheduler::Scheduler::get_skel, &POA_RtecScheduler::_TAO_Scheduler_ThruPOA_Proxy_Impl::get, 0},
      {"reset_seq", &POA_RtecScheduler::Scheduler::reset_seq_skel, &POA_RtecScheduler::_TAO_Scheduler_ThruPOA_Proxy_Impl::reset_seq, 0},
      {"_component", &POA_RtecScheduler::Scheduler::_component_skel, 0, 0},
      {"replace_seq", &POA_RtecScheduler::Scheduler::replace_seq_skel, &POA_RtecScheduler::_TAO_Scheduler_ThruPOA_Proxy_Impl::replace_seq, 0},
      {"",0,0,0},
      {"_non_existent", &POA_RtecScheduler::Scheduler::_non_existent_skel, 0, 0},
      {"",0,0,0},
      {"add_dependency", &POA_RtecScheduler::Scheduler::add_dependency_skel, &POA_RtecScheduler::_TAO_Scheduler_ThruPOA_Proxy_Impl::add_dependency, 0},
      {"",0,0,0},
      {"remove_dependency", &POA_RtecScheduler::Scheduler::remove_dependency_skel, &POA_RtecScheduler::_TAO_Scheduler_ThruPOA_Proxy_Impl::remove_dependency, 0},
      {"priority", &POA_RtecScheduler::Scheduler::priority_skel, &POA_RtecScheduler::_TAO_Scheduler_ThruPOA_Proxy_Impl::priority, 0},
      {"",0,0,0},
      {"get_rt_info_set", &POA_RtecScheduler::Scheduler::get_rt_info_set_skel, &POA_RtecScheduler::_TAO_Scheduler_ThruPOA_Proxy_Impl::get_rt_info_set, 0},
      {"get_config_infos", &POA_RtecScheduler::Scheduler::get_config_infos_skel, &POA_RtecScheduler::_TAO_Scheduler_ThruPOA_Proxy_Impl::get_config_infos, 0},
      {"dispatch_configuration", &POA_RtecScheduler::Scheduler::dispatch_configuration_skel, &POA_RtecScheduler::_TAO_Scheduler_ThruPOA_Proxy_Impl::dispatch_configuration, 0},
      {"get_dependency_set", &POA_RtecScheduler::Scheduler::get_dependency_set_skel, &POA_RtecScheduler::_TAO_Scheduler_ThruPOA_Proxy_Impl::get_dependency_set, 0},
      {"get_config_info_set", &POA_RtecScheduler::Scheduler::get_config_info_set_skel, &POA_RtecScheduler::_TAO_Scheduler_ThruPOA_Proxy_Impl::get_config_info_set, 0},
      {"recompute_scheduling", &POA_RtecScheduler::Scheduler::recompute_scheduling_skel, &POA_RtecScheduler::_TAO_Scheduler_ThruPOA_Proxy_Impl::recompute_scheduling, 0},
      {"",0,0,0},{"",0,0,0},
      {"set_rt_info_enable_state_seq", &POA_RtecScheduler::Scheduler::set_rt_info_enable_state_seq_skel, &POA_RtecScheduler::_TAO_Scheduler_ThruPOA_Proxy_Impl::set_rt_info_enable_state_seq, 0},
      {"",0,0,0},
      {"_interface", &POA_RtecScheduler::Scheduler::_interface_skel, 0, 0},
      {"set_dependency_enable_state_seq", &POA_RtecScheduler::Scheduler::set_dependency_enable_state_seq_skel, &POA_RtecScheduler::_TAO_Scheduler_ThruPOA_Proxy_Impl::set_dependency_enable_state_seq, 0},
      {"",0,0,0},
      {"compute_scheduling", &POA_RtecScheduler::Scheduler::compute_scheduling_skel, &POA_RtecScheduler::_TAO_Scheduler_ThruPOA_Proxy_Impl::compute_scheduling, 0},
      {"",0,0,0},{"",0,0,0},
      {"create", &POA_RtecScheduler::Scheduler::create_skel, &POA_RtecScheduler::_TAO_Scheduler_ThruPOA_Proxy_Impl::create, 0},
      {"",0,0,0},{"",0,0,0},{"",0,0,0},
      {"entry_point_priority", &POA_RtecScheduler::Scheduler::entry_point_priority_skel, &POA_RtecScheduler::_TAO_Scheduler_ThruPOA_Proxy_Impl::entry_point_priority, 0},
      {"lookup", &POA_RtecScheduler::Scheduler::lookup_skel, &POA_RtecScheduler::_TAO_Scheduler_ThruPOA_Proxy_Impl::lookup, 0},
      {"",0,0,0},{"",0,0,0},
      {"set_rt_info_enable_state", &POA_RtecScheduler::Scheduler::set_rt_info_enable_state_skel, &POA_RtecScheduler::_TAO_Scheduler_ThruPOA_Proxy_Impl::set_rt_info_enable_state, 0},
      {"",0,0,0},{"",0,0,0},
      {"set_dependency_enable_state", &POA_RtecScheduler::Scheduler::set_dependency_enable_state_skel, &POA_RtecScheduler::_TAO_Scheduler_ThruPOA_Proxy_Impl::set_dependency_enable_state, 0},
      {"last_scheduled_priority", &POA_RtecScheduler::Scheduler::last_scheduled_priority_skel, &POA_RtecScheduler::_TAO_Scheduler_ThruPOA_Proxy_Impl::last_scheduled_priority, 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_RtecScheduler_Scheduler_Perfect_Hash_OpTable tao_RtecScheduler_Scheduler_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_RtecScheduler_Scheduler_create : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_RtecScheduler_Scheduler_create (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_RtecScheduler::Scheduler *tao_impl,
      const char * entry_point
      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 (RtecScheduler::handle_t result);

private:
  TAO_ServerRequestInfo_RtecScheduler_Scheduler_create (
      const TAO_ServerRequestInfo_RtecScheduler_Scheduler_create &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_RtecScheduler_Scheduler_create &
    );
  
private:
  POA_RtecScheduler::Scheduler *_tao_impl;
  
  const char * entry_point_;
  RtecScheduler::handle_t _result;
};

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

TAO_ServerRequestInfo_RtecScheduler_Scheduler_create::TAO_ServerRequestInfo_RtecScheduler_Scheduler_create (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_RtecScheduler::Scheduler *tao_impl,
    const char * entry_point
    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl),
    entry_point_ (entry_point)
{}

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

Dynamic::ExceptionList *
TAO_ServerRequestInfo_RtecScheduler_Scheduler_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_RtecScheduler_Scheduler_create_exceptiondata[] = 
  {
    RtecScheduler::_tc_DUPLICATE_NAME,
    RtecScheduler::_tc_INTERNAL,
    RtecScheduler::_tc_SYNCHRONIZATION_FAILURE
  };
  
  exception_list->length (3);
  for (CORBA::ULong i = 0; i < 3; ++i)
    {
      CORBA::TypeCode_ptr tcp = _tao_RtecScheduler_Scheduler_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_RtecScheduler_Scheduler_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_RtecScheduler_Scheduler_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_RtecScheduler_Scheduler_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_RtecScheduler_Scheduler_create::result (RtecScheduler::handle_t result)
{
  // Update the result.
   this->_result = result;
}

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

class TAO_ServerRequestInfo_RtecScheduler_Scheduler_lookup : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_RtecScheduler_Scheduler_lookup (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_RtecScheduler::Scheduler *tao_impl,
      const char * entry_point
      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 (RtecScheduler::handle_t result);

private:
  TAO_ServerRequestInfo_RtecScheduler_Scheduler_lookup (
      const TAO_ServerRequestInfo_RtecScheduler_Scheduler_lookup &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_RtecScheduler_Scheduler_lookup &
    );
  
private:
  POA_RtecScheduler::Scheduler *_tao_impl;
  
  const char * entry_point_;
  RtecScheduler::handle_t _result;
};

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

TAO_ServerRequestInfo_RtecScheduler_Scheduler_lookup::TAO_ServerRequestInfo_RtecScheduler_Scheduler_lookup (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_RtecScheduler::Scheduler *tao_impl,
    const char * entry_point
    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl),
    entry_point_ (entry_point)
{}

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

Dynamic::ExceptionList *
TAO_ServerRequestInfo_RtecScheduler_Scheduler_lookup::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_RtecScheduler_Scheduler_lookup_exceptiondata[] = 
  {
    RtecScheduler::_tc_UNKNOWN_TASK,
    RtecScheduler::_tc_SYNCHRONIZATION_FAILURE
  };
  
  exception_list->length (2);
  for (CORBA::ULong i = 0; i < 2; ++i)
    {
      CORBA::TypeCode_ptr tcp = _tao_RtecScheduler_Scheduler_lookup_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_RtecScheduler_Scheduler_lookup::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_RtecScheduler_Scheduler_lookup::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_RtecScheduler_Scheduler_lookup::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_RtecScheduler_Scheduler_lookup::result (RtecScheduler::handle_t result)
{
  // Update the result.
   this->_result = result;
}

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

class TAO_ServerRequestInfo_RtecScheduler_Scheduler_get : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_RtecScheduler_Scheduler_get (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_RtecScheduler::Scheduler *tao_impl,
      const ::RtecScheduler::handle_t & handle
      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 (::RtecScheduler::RT_Info * result);

private:
  TAO_ServerRequestInfo_RtecScheduler_Scheduler_get (
      const TAO_ServerRequestInfo_RtecScheduler_Scheduler_get &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_RtecScheduler_Scheduler_get &
    );
  
private:
  POA_RtecScheduler::Scheduler *_tao_impl;
  
  const ::RtecScheduler::handle_t & handle_;
  ::RtecScheduler::RT_Info * _result;
};

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

TAO_ServerRequestInfo_RtecScheduler_Scheduler_get::TAO_ServerRequestInfo_RtecScheduler_Scheduler_get (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_RtecScheduler::Scheduler *tao_impl,
    const ::RtecScheduler::handle_t & handle
    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl),
    handle_ (handle)
{}

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

Dynamic::ExceptionList *
TAO_ServerRequestInfo_RtecScheduler_Scheduler_get::exceptions (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the exception list on demand.
  Dynamic::ExceptionList *exception_list =
    TAO_RequestInfo_Util::make_exception_list (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  Dynamic::ExceptionList_var safe_exception_list = exception_list;
    
  static CORBA::TypeCode_ptr _tao_RtecScheduler_Scheduler_get_exceptiondata[] = 
  {
    RtecScheduler::_tc_UNKNOWN_TASK,
    RtecScheduler::_tc_SYNCHRONIZATION_FAILURE
  };
  
  exception_list->length (2);
  for (CORBA::ULong i = 0; i < 2; ++i)
    {
      CORBA::TypeCode_ptr tcp = _tao_RtecScheduler_Scheduler_get_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_RtecScheduler_Scheduler_get::result (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the result on demand.
  CORBA::Boolean tk_void_any = 0;
  CORBA::Any *result_any =
    TAO_RequestInfo_Util::make_any (tk_void_any ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  CORBA::Any_var safe_result_any = result_any;
  
  (*result_any) <<= *this->_result;
  
  return safe_result_any._retn ();
}

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

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

void 
TAO_ServerRequestInfo_RtecScheduler_Scheduler_get::result (::RtecScheduler::RT_Info * result)
{
  // Update the result.
   this->_result = result;
}

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

class TAO_ServerRequestInfo_RtecScheduler_Scheduler_set : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_RtecScheduler_Scheduler_set (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_RtecScheduler::Scheduler *tao_impl,
      const ::RtecScheduler::handle_t & handle,
      ::RtecScheduler::Criticality_t & criticality,
      const ::RtecScheduler::Time & wc_time,
      const ::RtecScheduler::Time & typical_time,
      const ::RtecScheduler::Time & cached_time,
      const ::RtecScheduler::Period_t & period,
      ::RtecScheduler::Importance_t & importance,
      const ::RtecScheduler::Quantum_t & quantum,
      const ::RtecScheduler::Threads_t & threads,
      ::RtecScheduler::Info_Type_t & info_type
      ACE_ENV_ARG_DECL_WITH_DEFAULTS
    );
  
  virtual Dynamic::ParameterList * arguments (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual Dynamic::ExceptionList * exceptions (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual CORBA::Any * result (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual char * target_most_derived_interface (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual CORBA::Boolean target_is_a (
      const char * id
      ACE_ENV_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
private:
  TAO_ServerRequestInfo_RtecScheduler_Scheduler_set (
      const TAO_ServerRequestInfo_RtecScheduler_Scheduler_set &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_RtecScheduler_Scheduler_set &
    );
  
private:
  POA_RtecScheduler::Scheduler *_tao_impl;
  
  const ::RtecScheduler::handle_t & handle_;
  const ::RtecScheduler::Criticality_t & criticality_;
  const ::RtecScheduler::Time & wc_time_;
  const ::RtecScheduler::Time & typical_time_;
  const ::RtecScheduler::Time & cached_time_;
  const ::RtecScheduler::Period_t & period_;
  const ::RtecScheduler::Importance_t & importance_;
  const ::RtecScheduler::Quantum_t & quantum_;
  const ::RtecScheduler::Threads_t & threads_;
  const ::RtecScheduler::Info_Type_t & info_type_;
};

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

TAO_ServerRequestInfo_RtecScheduler_Scheduler_set::TAO_ServerRequestInfo_RtecScheduler_Scheduler_set (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_RtecScheduler::Scheduler *tao_impl,
    const ::RtecScheduler::handle_t & handle,
    ::RtecScheduler::Criticality_t & criticality,
    const ::RtecScheduler::Time & wc_time,
    const ::RtecScheduler::Time & typical_time,
    const ::RtecScheduler::Time & cached_time,
    const ::RtecScheduler::Period_t & period,
    ::RtecScheduler::Importance_t & importance,
    const ::RtecScheduler::Quantum_t & quantum,
    const ::RtecScheduler::Threads_t & threads,
    ::RtecScheduler::Info_Type_t & info_type
    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl),
    handle_ (handle),
    criticality_ (criticality),
    wc_time_ (wc_time),
    typical_time_ (typical_time),
    cached_time_ (cached_time),
    period_ (period),
    importance_ (importance),
    quantum_ (quantum),
    threads_ (threads),
    info_type_ (info_type)
{}

Dynamic::ParameterList *
TAO_ServerRequestInfo_RtecScheduler_Scheduler_set::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 (10);
  CORBA::ULong len = 0;
  
  (*parameter_list)[len].argument <<= handle_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
  
  (*parameter_list)[len].argument <<=  this->criticality_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
  
  (*parameter_list)[len].argument <<= wc_time_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
  
  (*parameter_list)[len].argument <<= typical_time_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
  
  (*parameter_list)[len].argument <<= cached_time_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
  
  (*parameter_list)[len].argument <<= period_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
  
  (*parameter_list)[len].argument <<=  this->importance_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
  
  (*parameter_list)[len].argument <<= quantum_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
  
  (*parameter_list)[len].argument <<= threads_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
  
  (*parameter_list)[len].argument <<=  this->info_type_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
  
  return safe_parameter_list._retn ();
}

Dynamic::ExceptionList *
TAO_ServerRequestInfo_RtecScheduler_Scheduler_set::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_RtecScheduler_Scheduler_set_exceptiondata[] = 
  {
    RtecScheduler::_tc_UNKNOWN_TASK,
    RtecScheduler::_tc_INTERNAL,
    RtecScheduler::_tc_SYNCHRONIZATION_FAILURE
  };
  
  exception_list->length (3);
  for (CORBA::ULong i = 0; i < 3; ++i)
    {
      CORBA::TypeCode_ptr tcp = _tao_RtecScheduler_Scheduler_set_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_RtecScheduler_Scheduler_set::result (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the result on demand.
  CORBA::Boolean tk_void_any = 1;
  CORBA::Any *result_any =
    TAO_RequestInfo_Util::make_any (tk_void_any ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  return result_any;
}

char *
TAO_ServerRequestInfo_RtecScheduler_Scheduler_set::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_RtecScheduler_Scheduler_set::target_is_a (
    const char * id
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  return this->_tao_impl->_is_a (id ACE_ENV_ARG_PARAMETER);
}

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

class TAO_ServerRequestInfo_RtecScheduler_Scheduler_reset : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_RtecScheduler_Scheduler_reset (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_RtecScheduler::Scheduler *tao_impl,
      const ::RtecScheduler::handle_t & handle,
      ::RtecScheduler::Criticality_t & criticality,
      const ::RtecScheduler::Time & wc_time,
      const ::RtecScheduler::Time & typical_time,
      const ::RtecScheduler::Time & cached_time,
      const ::RtecScheduler::Period_t & period,
      ::RtecScheduler::Importance_t & importance,
      const ::RtecScheduler::Quantum_t & quantum,
      const ::RtecScheduler::Threads_t & threads,
      ::RtecScheduler::Info_Type_t & info_type
      ACE_ENV_ARG_DECL_WITH_DEFAULTS
    );
  
  virtual Dynamic::ParameterList * arguments (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual Dynamic::ExceptionList * exceptions (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual CORBA::Any * result (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual char * target_most_derived_interface (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual CORBA::Boolean target_is_a (
      const char * id
      ACE_ENV_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
private:
  TAO_ServerRequestInfo_RtecScheduler_Scheduler_reset (
      const TAO_ServerRequestInfo_RtecScheduler_Scheduler_reset &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_RtecScheduler_Scheduler_reset &
    );
  
private:
  POA_RtecScheduler::Scheduler *_tao_impl;
  
  const ::RtecScheduler::handle_t & handle_;
  const ::RtecScheduler::Criticality_t & criticality_;
  const ::RtecScheduler::Time & wc_time_;
  const ::RtecScheduler::Time & typical_time_;
  const ::RtecScheduler::Time & cached_time_;
  const ::RtecScheduler::Period_t & period_;
  const ::RtecScheduler::Importance_t & importance_;
  const ::RtecScheduler::Quantum_t & quantum_;
  const ::RtecScheduler::Threads_t & threads_;
  const ::RtecScheduler::Info_Type_t & info_type_;
};

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

TAO_ServerRequestInfo_RtecScheduler_Scheduler_reset::TAO_ServerRequestInfo_RtecScheduler_Scheduler_reset (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_RtecScheduler::Scheduler *tao_impl,
    const ::RtecScheduler::handle_t & handle,
    ::RtecScheduler::Criticality_t & criticality,
    const ::RtecScheduler::Time & wc_time,
    const ::RtecScheduler::Time & typical_time,
    const ::RtecScheduler::Time & cached_time,
    const ::RtecScheduler::Period_t & period,
    ::RtecScheduler::Importance_t & importance,
    const ::RtecScheduler::Quantum_t & quantum,
    const ::RtecScheduler::Threads_t & threads,
    ::RtecScheduler::Info_Type_t & info_type
    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl),
    handle_ (handle),
    criticality_ (criticality),
    wc_time_ (wc_time),
    typical_time_ (typical_time),
    cached_time_ (cached_time),
    period_ (period),
    importance_ (importance),
    quantum_ (quantum),
    threads_ (threads),
    info_type_ (info_type)
{}

Dynamic::ParameterList *
TAO_ServerRequestInfo_RtecScheduler_Scheduler_reset::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 (10);
  CORBA::ULong len = 0;
  
  (*parameter_list)[len].argument <<= handle_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
  
  (*parameter_list)[len].argument <<=  this->criticality_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
  
  (*parameter_list)[len].argument <<= wc_time_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
  
  (*parameter_list)[len].argument <<= typical_time_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
  
  (*parameter_list)[len].argument <<= cached_time_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
  
  (*parameter_list)[len].argument <<= period_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
  
  (*parameter_list)[len].argument <<=  this->importance_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
  
  (*parameter_list)[len].argument <<= quantum_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
  
  (*parameter_list)[len].argument <<= threads_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
  
  (*parameter_list)[len].argument <<=  this->info_type_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
  
  return safe_parameter_list._retn ();
}

Dynamic::ExceptionList *
TAO_ServerRequestInfo_RtecScheduler_Scheduler_reset::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_RtecScheduler_Scheduler_reset_exceptiondata[] = 
  {
    RtecScheduler::_tc_UNKNOWN_TASK,
    RtecScheduler::_tc_INTERNAL,
    RtecScheduler::_tc_SYNCHRONIZATION_FAILURE
  };
  
  exception_list->length (3);
  for (CORBA::ULong i = 0; i < 3; ++i)
    {
      CORBA::TypeCode_ptr tcp = _tao_RtecScheduler_Scheduler_reset_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_RtecScheduler_Scheduler_reset::result (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the result on demand.
  CORBA::Boolean tk_void_any = 1;
  CORBA::Any *result_any =
    TAO_RequestInfo_Util::make_any (tk_void_any ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  return result_any;
}

char *
TAO_ServerRequestInfo_RtecScheduler_Scheduler_reset::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_RtecScheduler_Scheduler_reset::target_is_a (
    const char * id
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  return this->_tao_impl->_is_a (id ACE_ENV_ARG_PARAMETER);
}

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

class TAO_ServerRequestInfo_RtecScheduler_Scheduler_set_seq : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_RtecScheduler_Scheduler_set_seq (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_RtecScheduler::Scheduler *tao_impl,
      const ::RtecScheduler::RT_Info_Set & infos
      ACE_ENV_ARG_DECL_WITH_DEFAULTS
    );
  
  virtual Dynamic::ParameterList * arguments (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual Dynamic::ExceptionList * exceptions (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual CORBA::Any * result (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual char * target_most_derived_interface (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual CORBA::Boolean target_is_a (
      const char * id
      ACE_ENV_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
private:
  TAO_ServerRequestInfo_RtecScheduler_Scheduler_set_seq (
      const TAO_ServerRequestInfo_RtecScheduler_Scheduler_set_seq &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_RtecScheduler_Scheduler_set_seq &
    );
  
private:
  POA_RtecScheduler::Scheduler *_tao_impl;
  
  const ::RtecScheduler::RT_Info_Set & infos_;
};

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

TAO_ServerRequestInfo_RtecScheduler_Scheduler_set_seq::TAO_ServerRequestInfo_RtecScheduler_Scheduler_set_seq (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_RtecScheduler::Scheduler *tao_impl,
    const ::RtecScheduler::RT_Info_Set & infos
    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl),
    infos_ (infos)
{}

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

Dynamic::ExceptionList *
TAO_ServerRequestInfo_RtecScheduler_Scheduler_set_seq::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_RtecScheduler_Scheduler_set_seq_exceptiondata[] = 
  {
    RtecScheduler::_tc_UNKNOWN_TASK,
    RtecScheduler::_tc_INTERNAL,
    RtecScheduler::_tc_SYNCHRONIZATION_FAILURE
  };
  
  exception_list->length (3);
  for (CORBA::ULong i = 0; i < 3; ++i)
    {
      CORBA::TypeCode_ptr tcp = _tao_RtecScheduler_Scheduler_set_seq_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_RtecScheduler_Scheduler_set_seq::result (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the result on demand.
  CORBA::Boolean tk_void_any = 1;
  CORBA::Any *result_any =
    TAO_RequestInfo_Util::make_any (tk_void_any ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  return result_any;
}

char *
TAO_ServerRequestInfo_RtecScheduler_Scheduler_set_seq::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_RtecScheduler_Scheduler_set_seq::target_is_a (
    const char * id
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  return this->_tao_impl->_is_a (id ACE_ENV_ARG_PARAMETER);
}

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

class TAO_ServerRequestInfo_RtecScheduler_Scheduler_reset_seq : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_RtecScheduler_Scheduler_reset_seq (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_RtecScheduler::Scheduler *tao_impl,
      const ::RtecScheduler::RT_Info_Set & infos
      ACE_ENV_ARG_DECL_WITH_DEFAULTS
    );
  
  virtual Dynamic::ParameterList * arguments (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual Dynamic::ExceptionList * exceptions (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual CORBA::Any * result (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual char * target_most_derived_interface (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual CORBA::Boolean target_is_a (
      const char * id
      ACE_ENV_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
private:
  TAO_ServerRequestInfo_RtecScheduler_Scheduler_reset_seq (
      const TAO_ServerRequestInfo_RtecScheduler_Scheduler_reset_seq &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_RtecScheduler_Scheduler_reset_seq &
    );
  
private:
  POA_RtecScheduler::Scheduler *_tao_impl;
  
  const ::RtecScheduler::RT_Info_Set & infos_;
};

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

TAO_ServerRequestInfo_RtecScheduler_Scheduler_reset_seq::TAO_ServerRequestInfo_RtecScheduler_Scheduler_reset_seq (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_RtecScheduler::Scheduler *tao_impl,
    const ::RtecScheduler::RT_Info_Set & infos
    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl),
    infos_ (infos)
{}

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

Dynamic::ExceptionList *
TAO_ServerRequestInfo_RtecScheduler_Scheduler_reset_seq::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_RtecScheduler_Scheduler_reset_seq_exceptiondata[] = 
  {
    RtecScheduler::_tc_UNKNOWN_TASK,
    RtecScheduler::_tc_INTERNAL,
    RtecScheduler::_tc_SYNCHRONIZATION_FAILURE
  };
  
  exception_list->length (3);
  for (CORBA::ULong i = 0; i < 3; ++i)
    {
      CORBA::TypeCode_ptr tcp = _tao_RtecScheduler_Scheduler_reset_seq_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_RtecScheduler_Scheduler_reset_seq::result (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the result on demand.
  CORBA::Boolean tk_void_any = 1;
  CORBA::Any *result_any =
    TAO_RequestInfo_Util::make_any (tk_void_any ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  return result_any;
}

char *
TAO_ServerRequestInfo_RtecScheduler_Scheduler_reset_seq::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_RtecScheduler_Scheduler_reset_seq::target_is_a (
    const char * id
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  return this->_tao_impl->_is_a (id ACE_ENV_ARG_PARAMETER);
}

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

class TAO_ServerRequestInfo_RtecScheduler_Scheduler_replace_seq : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_RtecScheduler_Scheduler_replace_seq (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_RtecScheduler::Scheduler *tao_impl,
      const ::RtecScheduler::RT_Info_Set & infos
      ACE_ENV_ARG_DECL_WITH_DEFAULTS
    );
  
  virtual Dynamic::ParameterList * arguments (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual Dynamic::ExceptionList * exceptions (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual CORBA::Any * result (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual char * target_most_derived_interface (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual CORBA::Boolean target_is_a (
      const char * id
      ACE_ENV_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
private:
  TAO_ServerRequestInfo_RtecScheduler_Scheduler_replace_seq (
      const TAO_ServerRequestInfo_RtecScheduler_Scheduler_replace_seq &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_RtecScheduler_Scheduler_replace_seq &
    );
  
private:
  POA_RtecScheduler::Scheduler *_tao_impl;
  
  const ::RtecScheduler::RT_Info_Set & infos_;
};

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

TAO_ServerRequestInfo_RtecScheduler_Scheduler_replace_seq::TAO_ServerRequestInfo_RtecScheduler_Scheduler_replace_seq (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_RtecScheduler::Scheduler *tao_impl,
    const ::RtecScheduler::RT_Info_Set & infos
    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl),
    infos_ (infos)
{}

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

Dynamic::ExceptionList *
TAO_ServerRequestInfo_RtecScheduler_Scheduler_replace_seq::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_RtecScheduler_Scheduler_replace_seq_exceptiondata[] = 
  {
    RtecScheduler::_tc_UNKNOWN_TASK,
    RtecScheduler::_tc_INTERNAL,
    RtecScheduler::_tc_SYNCHRONIZATION_FAILURE
  };
  
  exception_list->length (3);
  for (CORBA::ULong i = 0; i < 3; ++i)
    {
      CORBA::TypeCode_ptr tcp = _tao_RtecScheduler_Scheduler_replace_seq_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_RtecScheduler_Scheduler_replace_seq::result (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the result on demand.
  CORBA::Boolean tk_void_any = 1;
  CORBA::Any *result_any =
    TAO_RequestInfo_Util::make_any (tk_void_any ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  return result_any;
}

char *
TAO_ServerRequestInfo_RtecScheduler_Scheduler_replace_seq::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_RtecScheduler_Scheduler_replace_seq::target_is_a (
    const char * id
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  return this->_tao_impl->_is_a (id ACE_ENV_ARG_PARAMETER);
}

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

class TAO_ServerRequestInfo_RtecScheduler_Scheduler_add_dependency : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_RtecScheduler_Scheduler_add_dependency (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_RtecScheduler::Scheduler *tao_impl,
      const ::RtecScheduler::handle_t & handle,
      const ::RtecScheduler::handle_t & dependency,
      const ::CORBA::Long & number_of_calls,
      ::RtecScheduler::Dependency_Type_t & dependency_type
      ACE_ENV_ARG_DECL_WITH_DEFAULTS
    );
  
  virtual Dynamic::ParameterList * arguments (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual Dynamic::ExceptionList * exceptions (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual CORBA::Any * result (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual char * target_most_derived_interface (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual CORBA::Boolean target_is_a (
      const char * id
      ACE_ENV_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
private:
  TAO_ServerRequestInfo_RtecScheduler_Scheduler_add_dependency (
      const TAO_ServerRequestInfo_RtecScheduler_Scheduler_add_dependency &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_RtecScheduler_Scheduler_add_dependency &
    );
  
private:
  POA_RtecScheduler::Scheduler *_tao_impl;
  
  const ::RtecScheduler::handle_t & handle_;
  const ::RtecScheduler::handle_t & dependency_;
  const ::CORBA::Long & number_of_calls_;
  const ::RtecScheduler::Dependency_Type_t & dependency_type_;
};

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

TAO_ServerRequestInfo_RtecScheduler_Scheduler_add_dependency::TAO_ServerRequestInfo_RtecScheduler_Scheduler_add_dependency (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_RtecScheduler::Scheduler *tao_impl,
    const ::RtecScheduler::handle_t & handle,
    const ::RtecScheduler::handle_t & dependency,
    const ::CORBA::Long & number_of_calls,
    ::RtecScheduler::Dependency_Type_t & dependency_type
    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl),
    handle_ (handle),
    dependency_ (dependency),
    number_of_calls_ (number_of_calls),
    dependency_type_ (dependency_type)
{}

Dynamic::ParameterList *
TAO_ServerRequestInfo_RtecScheduler_Scheduler_add_dependency::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 <<= handle_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
  
  (*parameter_list)[len].argument <<= dependency_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
  
  (*parameter_list)[len].argument <<= number_of_calls_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
  
  (*parameter_list)[len].argument <<=  this->dependency_type_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
  
  return safe_parameter_list._retn ();
}

Dynamic::ExceptionList *
TAO_ServerRequestInfo_RtecScheduler_Scheduler_add_dependency::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_RtecScheduler_Scheduler_add_dependency_exceptiondata[] = 
  {
    RtecScheduler::_tc_SYNCHRONIZATION_FAILURE,
    RtecScheduler::_tc_UNKNOWN_TASK
  };
  
  exception_list->length (2);
  for (CORBA::ULong i = 0; i < 2; ++i)
    {
      CORBA::TypeCode_ptr tcp = _tao_RtecScheduler_Scheduler_add_dependency_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_RtecScheduler_Scheduler_add_dependency::result (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the result on demand.
  CORBA::Boolean tk_void_any = 1;
  CORBA::Any *result_any =
    TAO_RequestInfo_Util::make_any (tk_void_any ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  return result_any;
}

char *
TAO_ServerRequestInfo_RtecScheduler_Scheduler_add_dependency::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_RtecScheduler_Scheduler_add_dependency::target_is_a (
    const char * id
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  return this->_tao_impl->_is_a (id ACE_ENV_ARG_PARAMETER);
}

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

class TAO_ServerRequestInfo_RtecScheduler_Scheduler_remove_dependency : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_RtecScheduler_Scheduler_remove_dependency (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_RtecScheduler::Scheduler *tao_impl,
      const ::RtecScheduler::handle_t & handle,
      const ::RtecScheduler::handle_t & dependency,
      const ::CORBA::Long & number_of_calls,
      ::RtecScheduler::Dependency_Type_t & dependency_type
      ACE_ENV_ARG_DECL_WITH_DEFAULTS
    );
  
  virtual Dynamic::ParameterList * arguments (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual Dynamic::ExceptionList * exceptions (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual CORBA::Any * result (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual char * target_most_derived_interface (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual CORBA::Boolean target_is_a (
      const char * id
      ACE_ENV_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
private:
  TAO_ServerRequestInfo_RtecScheduler_Scheduler_remove_dependency (
      const TAO_ServerRequestInfo_RtecScheduler_Scheduler_remove_dependency &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_RtecScheduler_Scheduler_remove_dependency &
    );
  
private:
  POA_RtecScheduler::Scheduler *_tao_impl;
  
  const ::RtecScheduler::handle_t & handle_;
  const ::RtecScheduler::handle_t & dependency_;
  const ::CORBA::Long & number_of_calls_;
  const ::RtecScheduler::Dependency_Type_t & dependency_type_;
};

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

TAO_ServerRequestInfo_RtecScheduler_Scheduler_remove_dependency::TAO_ServerRequestInfo_RtecScheduler_Scheduler_remove_dependency (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_RtecScheduler::Scheduler *tao_impl,
    const ::RtecScheduler::handle_t & handle,
    const ::RtecScheduler::handle_t & dependency,
    const ::CORBA::Long & number_of_calls,
    ::RtecScheduler::Dependency_Type_t & dependency_type
    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl),
    handle_ (handle),
    dependency_ (dependency),
    number_of_calls_ (number_of_calls),
    dependency_type_ (dependency_type)
{}

Dynamic::ParameterList *
TAO_ServerRequestInfo_RtecScheduler_Scheduler_remove_dependency::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 <<= handle_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
  
  (*parameter_list)[len].argument <<= dependency_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
  
  (*parameter_list)[len].argument <<= number_of_calls_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
  
  (*parameter_list)[len].argument <<=  this->dependency_type_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
  
  return safe_parameter_list._retn ();
}

Dynamic::ExceptionList *
TAO_ServerRequestInfo_RtecScheduler_Scheduler_remove_dependency::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_RtecScheduler_Scheduler_remove_dependency_exceptiondata[] = 
  {
    RtecScheduler::_tc_SYNCHRONIZATION_FAILURE,
    RtecScheduler::_tc_UNKNOWN_TASK
  };
  
  exception_list->length (2);
  for (CORBA::ULong i = 0; i < 2; ++i)
    {
      CORBA::TypeCode_ptr tcp = _tao_RtecScheduler_Scheduler_remove_dependency_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_RtecScheduler_Scheduler_remove_dependency::result (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the result on demand.
  CORBA::Boolean tk_void_any = 1;
  CORBA::Any *result_any =
    TAO_RequestInfo_Util::make_any (tk_void_any ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  return result_any;
}

char *
TAO_ServerRequestInfo_RtecScheduler_Scheduler_remove_dependency::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_RtecScheduler_Scheduler_remove_dependency::target_is_a (
    const char * id
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  return this->_tao_impl->_is_a (id ACE_ENV_ARG_PARAMETER);
}

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

class TAO_ServerRequestInfo_RtecScheduler_Scheduler_set_dependency_enable_state : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_RtecScheduler_Scheduler_set_dependency_enable_state (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_RtecScheduler::Scheduler *tao_impl,
      const ::RtecScheduler::handle_t & handle,
      const ::RtecScheduler::handle_t & dependency,
      const ::CORBA::Long & number_of_calls,
      ::RtecScheduler::Dependency_Type_t & dependency_type,
      ::RtecScheduler::Dependency_Enabled_Type_t & enabled
      ACE_ENV_ARG_DECL_WITH_DEFAULTS
    );
  
  virtual Dynamic::ParameterList * arguments (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual Dynamic::ExceptionList * exceptions (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual CORBA::Any * result (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual char * target_most_derived_interface (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual CORBA::Boolean target_is_a (
      const char * id
      ACE_ENV_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
private:
  TAO_ServerRequestInfo_RtecScheduler_Scheduler_set_dependency_enable_state (
      const TAO_ServerRequestInfo_RtecScheduler_Scheduler_set_dependency_enable_state &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_RtecScheduler_Scheduler_set_dependency_enable_state &
    );
  
private:
  POA_RtecScheduler::Scheduler *_tao_impl;
  
  const ::RtecScheduler::handle_t & handle_;
  const ::RtecScheduler::handle_t & dependency_;
  const ::CORBA::Long & number_of_calls_;
  const ::RtecScheduler::Dependency_Type_t & dependency_type_;
  const ::RtecScheduler::Dependency_Enabled_Type_t & enabled_;
};

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

TAO_ServerRequestInfo_RtecScheduler_Scheduler_set_dependency_enable_state::TAO_ServerRequestInfo_RtecScheduler_Scheduler_set_dependency_enable_state (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_RtecScheduler::Scheduler *tao_impl,
    const ::RtecScheduler::handle_t & handle,
    const ::RtecScheduler::handle_t & dependency,
    const ::CORBA::Long & number_of_calls,
    ::RtecScheduler::Dependency_Type_t & dependency_type,
    ::RtecScheduler::Dependency_Enabled_Type_t & enabled
    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl),
    handle_ (handle),
    dependency_ (dependency),
    number_of_calls_ (number_of_calls),
    dependency_type_ (dependency_type),
    enabled_ (enabled)
{}

Dynamic::ParameterList *
TAO_ServerRequestInfo_RtecScheduler_Scheduler_set_dependency_enable_state::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 (5);
  CORBA::ULong len = 0;
  
  (*parameter_list)[len].argument <<= handle_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
  
  (*parameter_list)[len].argument <<= dependency_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
  
  (*parameter_list)[len].argument <<= number_of_calls_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
  
  (*parameter_list)[len].argument <<=  this->dependency_type_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
  
  (*parameter_list)[len].argument <<=  this->enabled_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
  
  return safe_parameter_list._retn ();
}

Dynamic::ExceptionList *
TAO_ServerRequestInfo_RtecScheduler_Scheduler_set_dependency_enable_state::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_RtecScheduler_Scheduler_set_dependency_enable_state_exceptiondata[] = 
  {
    RtecScheduler::_tc_SYNCHRONIZATION_FAILURE,
    RtecScheduler::_tc_UNKNOWN_TASK
  };
  
  exception_list->length (2);
  for (CORBA::ULong i = 0; i < 2; ++i)
    {
      CORBA::TypeCode_ptr tcp = _tao_RtecScheduler_Scheduler_set_dependency_enable_state_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_RtecScheduler_Scheduler_set_dependency_enable_state::result (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the result on demand.
  CORBA::Boolean tk_void_any = 1;
  CORBA::Any *result_any =
    TAO_RequestInfo_Util::make_any (tk_void_any ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  return result_any;
}

char *
TAO_ServerRequestInfo_RtecScheduler_Scheduler_set_dependency_enable_state::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_RtecScheduler_Scheduler_set_dependency_enable_state::target_is_a (
    const char * id
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  return this->_tao_impl->_is_a (id ACE_ENV_ARG_PARAMETER);
}

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

class TAO_ServerRequestInfo_RtecScheduler_Scheduler_set_dependency_enable_state_seq : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_RtecScheduler_Scheduler_set_dependency_enable_state_seq (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_RtecScheduler::Scheduler *tao_impl,
      const ::RtecScheduler::Dependency_Set & dependencies
      ACE_ENV_ARG_DECL_WITH_DEFAULTS
    );
  
  virtual Dynamic::ParameterList * arguments (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual Dynamic::ExceptionList * exceptions (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual CORBA::Any * result (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual char * target_most_derived_interface (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual CORBA::Boolean target_is_a (
      const char * id
      ACE_ENV_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
private:
  TAO_ServerRequestInfo_RtecScheduler_Scheduler_set_dependency_enable_state_seq (
      const TAO_ServerRequestInfo_RtecScheduler_Scheduler_set_dependency_enable_state_seq &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_RtecScheduler_Scheduler_set_dependency_enable_state_seq &
    );
  
private:
  POA_RtecScheduler::Scheduler *_tao_impl;
  
  const ::RtecScheduler::Dependency_Set & dependencies_;
};

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

TAO_ServerRequestInfo_RtecScheduler_Scheduler_set_dependency_enable_state_seq::TAO_ServerRequestInfo_RtecScheduler_Scheduler_set_dependency_enable_state_seq (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_RtecScheduler::Scheduler *tao_impl,
    const ::RtecScheduler::Dependency_Set & dependencies
    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl),
    dependencies_ (dependencies)
{}

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

Dynamic::ExceptionList *
TAO_ServerRequestInfo_RtecScheduler_Scheduler_set_dependency_enable_state_seq::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_RtecScheduler_Scheduler_set_dependency_enable_state_seq_exceptiondata[] = 
  {
    RtecScheduler::_tc_SYNCHRONIZATION_FAILURE,
    RtecScheduler::_tc_UNKNOWN_TASK
  };
  
  exception_list->length (2);
  for (CORBA::ULong i = 0; i < 2; ++i)
    {
      CORBA::TypeCode_ptr tcp = _tao_RtecScheduler_Scheduler_set_dependency_enable_state_seq_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_RtecScheduler_Scheduler_set_dependency_enable_state_seq::result (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the result on demand.
  CORBA::Boolean tk_void_any = 1;
  CORBA::Any *result_any =
    TAO_RequestInfo_Util::make_any (tk_void_any ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  return result_any;
}

char *
TAO_ServerRequestInfo_RtecScheduler_Scheduler_set_dependency_enable_state_seq::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_RtecScheduler_Scheduler_set_dependency_enable_state_seq::target_is_a (
    const char * id
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  return this->_tao_impl->_is_a (id ACE_ENV_ARG_PARAMETER);
}

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

class TAO_ServerRequestInfo_RtecScheduler_Scheduler_set_rt_info_enable_state : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_RtecScheduler_Scheduler_set_rt_info_enable_state (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_RtecScheduler::Scheduler *tao_impl,
      const ::RtecScheduler::handle_t & handle,
      ::RtecScheduler::RT_Info_Enabled_Type_t & enabled
      ACE_ENV_ARG_DECL_WITH_DEFAULTS
    );
  
  virtual Dynamic::ParameterList * arguments (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual Dynamic::ExceptionList * exceptions (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual CORBA::Any * result (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual char * target_most_derived_interface (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual CORBA::Boolean target_is_a (
      const char * id
      ACE_ENV_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
private:
  TAO_ServerRequestInfo_RtecScheduler_Scheduler_set_rt_info_enable_state (
      const TAO_ServerRequestInfo_RtecScheduler_Scheduler_set_rt_info_enable_state &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_RtecScheduler_Scheduler_set_rt_info_enable_state &
    );
  
private:
  POA_RtecScheduler::Scheduler *_tao_impl;
  
  const ::RtecScheduler::handle_t & handle_;
  const ::RtecScheduler::RT_Info_Enabled_Type_t & enabled_;
};

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

TAO_ServerRequestInfo_RtecScheduler_Scheduler_set_rt_info_enable_state::TAO_ServerRequestInfo_RtecScheduler_Scheduler_set_rt_info_enable_state (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_RtecScheduler::Scheduler *tao_impl,
    const ::RtecScheduler::handle_t & handle,
    ::RtecScheduler::RT_Info_Enabled_Type_t & enabled
    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl),
    handle_ (handle),
    enabled_ (enabled)
{}

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

Dynamic::ExceptionList *
TAO_ServerRequestInfo_RtecScheduler_Scheduler_set_rt_info_enable_state::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_RtecScheduler_Scheduler_set_rt_info_enable_state_exceptiondata[] = 
  {
    RtecScheduler::_tc_SYNCHRONIZATION_FAILURE,
    RtecScheduler::_tc_INTERNAL,
    RtecScheduler::_tc_UNKNOWN_TASK
  };
  
  exception_list->length (3);
  for (CORBA::ULong i = 0; i < 3; ++i)
    {
      CORBA::TypeCode_ptr tcp = _tao_RtecScheduler_Scheduler_set_rt_info_enable_state_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_RtecScheduler_Scheduler_set_rt_info_enable_state::result (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the result on demand.
  CORBA::Boolean tk_void_any = 1;
  CORBA::Any *result_any =
    TAO_RequestInfo_Util::make_any (tk_void_any ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  return result_any;
}

char *
TAO_ServerRequestInfo_RtecScheduler_Scheduler_set_rt_info_enable_state::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_RtecScheduler_Scheduler_set_rt_info_enable_state::target_is_a (
    const char * id
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  return this->_tao_impl->_is_a (id ACE_ENV_ARG_PARAMETER);
}

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

class TAO_ServerRequestInfo_RtecScheduler_Scheduler_set_rt_info_enable_state_seq : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_RtecScheduler_Scheduler_set_rt_info_enable_state_seq (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_RtecScheduler::Scheduler *tao_impl,
      const ::RtecScheduler::RT_Info_Enable_State_Pair_Set & pair_set
      ACE_ENV_ARG_DECL_WITH_DEFAULTS
    );
  
  virtual Dynamic::ParameterList * arguments (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual Dynamic::ExceptionList * exceptions (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual CORBA::Any * result (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual char * target_most_derived_interface (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual CORBA::Boolean target_is_a (
      const char * id
      ACE_ENV_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
private:
  TAO_ServerRequestInfo_RtecScheduler_Scheduler_set_rt_info_enable_state_seq (
      const TAO_ServerRequestInfo_RtecScheduler_Scheduler_set_rt_info_enable_state_seq &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_RtecScheduler_Scheduler_set_rt_info_enable_state_seq &
    );
  
private:
  POA_RtecScheduler::Scheduler *_tao_impl;
  
  const ::RtecScheduler::RT_Info_Enable_State_Pair_Set & pair_set_;
};

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

TAO_ServerRequestInfo_RtecScheduler_Scheduler_set_rt_info_enable_state_seq::TAO_ServerRequestInfo_RtecScheduler_Scheduler_set_rt_info_enable_state_seq (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_RtecScheduler::Scheduler *tao_impl,
    const ::RtecScheduler::RT_Info_Enable_State_Pair_Set & pair_set
    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl),
    pair_set_ (pair_set)
{}

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

Dynamic::ExceptionList *
TAO_ServerRequestInfo_RtecScheduler_Scheduler_set_rt_info_enable_state_seq::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_RtecScheduler_Scheduler_set_rt_info_enable_state_seq_exceptiondata[] = 
  {
    RtecScheduler::_tc_SYNCHRONIZATION_FAILURE,
    RtecScheduler::_tc_INTERNAL,
    RtecScheduler::_tc_UNKNOWN_TASK
  };
  
  exception_list->length (3);
  for (CORBA::ULong i = 0; i < 3; ++i)
    {
      CORBA::TypeCode_ptr tcp = _tao_RtecScheduler_Scheduler_set_rt_info_enable_state_seq_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_RtecScheduler_Scheduler_set_rt_info_enable_state_seq::result (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the result on demand.
  CORBA::Boolean tk_void_any = 1;
  CORBA::Any *result_any =
    TAO_RequestInfo_Util::make_any (tk_void_any ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  return result_any;
}

char *
TAO_ServerRequestInfo_RtecScheduler_Scheduler_set_rt_info_enable_state_seq::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_RtecScheduler_Scheduler_set_rt_info_enable_state_seq::target_is_a (
    const char * id
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  return this->_tao_impl->_is_a (id ACE_ENV_ARG_PARAMETER);
}

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

class TAO_ServerRequestInfo_RtecScheduler_Scheduler_priority : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_RtecScheduler_Scheduler_priority (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_RtecScheduler::Scheduler *tao_impl,
      const ::RtecScheduler::handle_t & handle      
      

      ACE_ENV_ARG_DECL_WITH_DEFAULTS
    );
  
  virtual Dynamic::ParameterList * arguments (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual Dynamic::ExceptionList * exceptions (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual CORBA::Any * result (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual char * target_most_derived_interface (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual CORBA::Boolean target_is_a (
      const char * id
      ACE_ENV_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
private:
  TAO_ServerRequestInfo_RtecScheduler_Scheduler_priority (
      const TAO_ServerRequestInfo_RtecScheduler_Scheduler_priority &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_RtecScheduler_Scheduler_priority &
    );
  
private:
  POA_RtecScheduler::Scheduler *_tao_impl;
  
  const ::RtecScheduler::handle_t & handle_;  
  

};

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

TAO_ServerRequestInfo_RtecScheduler_Scheduler_priority::TAO_ServerRequestInfo_RtecScheduler_Scheduler_priority (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_RtecScheduler::Scheduler *tao_impl,
    const ::RtecScheduler::handle_t & handle    
    

    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl),
    handle_ (handle)  
  

{}

Dynamic::ParameterList *
TAO_ServerRequestInfo_RtecScheduler_Scheduler_priority::arguments (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the argument list on demand.
  Dynamic::ParameterList *parameter_list =
    TAO_RequestInfo_Util::make_parameter_list (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
  parameter_list->length (1);
  CORBA::ULong len = 0;
  
  (*parameter_list)[len].argument <<= handle_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
    
  

  return safe_parameter_list._retn ();
}

Dynamic::ExceptionList *
TAO_ServerRequestInfo_RtecScheduler_Scheduler_priority::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_RtecScheduler_Scheduler_priority_exceptiondata[] = 
  {
    RtecScheduler::_tc_UNKNOWN_TASK,
    RtecScheduler::_tc_SYNCHRONIZATION_FAILURE,
    RtecScheduler::_tc_NOT_SCHEDULED
  };
  
  exception_list->length (3);
  for (CORBA::ULong i = 0; i < 3; ++i)
    {
      CORBA::TypeCode_ptr tcp = _tao_RtecScheduler_Scheduler_priority_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_RtecScheduler_Scheduler_priority::result (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the result on demand.
  CORBA::Boolean tk_void_any = 1;
  CORBA::Any *result_any =
    TAO_RequestInfo_Util::make_any (tk_void_any ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  return result_any;
}

char *
TAO_ServerRequestInfo_RtecScheduler_Scheduler_priority::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_RtecScheduler_Scheduler_priority::target_is_a (
    const char * id
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  return this->_tao_impl->_is_a (id ACE_ENV_ARG_PARAMETER);
}

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

class TAO_ServerRequestInfo_RtecScheduler_Scheduler_entry_point_priority : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_RtecScheduler_Scheduler_entry_point_priority (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_RtecScheduler::Scheduler *tao_impl,
      const char * entry_point      
      

      ACE_ENV_ARG_DECL_WITH_DEFAULTS
    );
  
  virtual Dynamic::ParameterList * arguments (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual Dynamic::ExceptionList * exceptions (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual CORBA::Any * result (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual char * target_most_derived_interface (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual CORBA::Boolean target_is_a (
      const char * id
      ACE_ENV_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
private:
  TAO_ServerRequestInfo_RtecScheduler_Scheduler_entry_point_priority (
      const TAO_ServerRequestInfo_RtecScheduler_Scheduler_entry_point_priority &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_RtecScheduler_Scheduler_entry_point_priority &
    );
  
private:
  POA_RtecScheduler::Scheduler *_tao_impl;
  
  const char * entry_point_;  
  

};

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

TAO_ServerRequestInfo_RtecScheduler_Scheduler_entry_point_priority::TAO_ServerRequestInfo_RtecScheduler_Scheduler_entry_point_priority (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_RtecScheduler::Scheduler *tao_impl,
    const char * entry_point    
    

    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl),
    entry_point_ (entry_point)  
  

{}

Dynamic::ParameterList *
TAO_ServerRequestInfo_RtecScheduler_Scheduler_entry_point_priority::arguments (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the argument list on demand.
  Dynamic::ParameterList *parameter_list =
    TAO_RequestInfo_Util::make_parameter_list (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
  parameter_list->length (1);
  CORBA::ULong len = 0;
  
  (*parameter_list)[len].argument <<= entry_point_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
    
  

  return safe_parameter_list._retn ();
}

Dynamic::ExceptionList *
TAO_ServerRequestInfo_RtecScheduler_Scheduler_entry_point_priority::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_RtecScheduler_Scheduler_entry_point_priority_exceptiondata[] = 
  {
    RtecScheduler::_tc_UNKNOWN_TASK,
    RtecScheduler::_tc_SYNCHRONIZATION_FAILURE,
    RtecScheduler::_tc_NOT_SCHEDULED
  };
  
  exception_list->length (3);
  for (CORBA::ULong i = 0; i < 3; ++i)
    {
      CORBA::TypeCode_ptr tcp = _tao_RtecScheduler_Scheduler_entry_point_priority_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_RtecScheduler_Scheduler_entry_point_priority::result (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the result on demand.
  CORBA::Boolean tk_void_any = 1;
  CORBA::Any *result_any =
    TAO_RequestInfo_Util::make_any (tk_void_any ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  return result_any;
}

char *
TAO_ServerRequestInfo_RtecScheduler_Scheduler_entry_point_priority::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_RtecScheduler_Scheduler_entry_point_priority::target_is_a (
    const char * id
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  return this->_tao_impl->_is_a (id ACE_ENV_ARG_PARAMETER);
}

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

class TAO_ServerRequestInfo_RtecScheduler_Scheduler_compute_scheduling : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_RtecScheduler_Scheduler_compute_scheduling (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_RtecScheduler::Scheduler *tao_impl,
      const ::CORBA::Long & minimum_priority,
      const ::CORBA::Long & maximum_priority      
      
      

      ACE_ENV_ARG_DECL_WITH_DEFAULTS
    );
  
  virtual Dynamic::ParameterList * arguments (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual Dynamic::ExceptionList * exceptions (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual CORBA::Any * result (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual char * target_most_derived_interface (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual CORBA::Boolean target_is_a (
      const char * id
      ACE_ENV_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
private:
  TAO_ServerRequestInfo_RtecScheduler_Scheduler_compute_scheduling (
      const TAO_ServerRequestInfo_RtecScheduler_Scheduler_compute_scheduling &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_RtecScheduler_Scheduler_compute_scheduling &
    );
  
private:
  POA_RtecScheduler::Scheduler *_tao_impl;
  
  const ::CORBA::Long & minimum_priority_;
  const ::CORBA::Long & maximum_priority_;  
  
  

};

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

TAO_ServerRequestInfo_RtecScheduler_Scheduler_compute_scheduling::TAO_ServerRequestInfo_RtecScheduler_Scheduler_compute_scheduling (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_RtecScheduler::Scheduler *tao_impl,
    const ::CORBA::Long & minimum_priority,
    const ::CORBA::Long & maximum_priority    
    
    

    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl),
    minimum_priority_ (minimum_priority),
    maximum_priority_ (maximum_priority)  
  
  

{}

Dynamic::ParameterList *
TAO_ServerRequestInfo_RtecScheduler_Scheduler_compute_scheduling::arguments (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the argument list on demand.
  Dynamic::ParameterList *parameter_list =
    TAO_RequestInfo_Util::make_parameter_list (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
  parameter_list->length (2);
  CORBA::ULong len = 0;
  
  (*parameter_list)[len].argument <<= minimum_priority_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
  
  (*parameter_list)[len].argument <<= maximum_priority_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
    
  
  

  return safe_parameter_list._retn ();
}

Dynamic::ExceptionList *
TAO_ServerRequestInfo_RtecScheduler_Scheduler_compute_scheduling::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_RtecScheduler_Scheduler_compute_scheduling_exceptiondata[] = 
  {
    RtecScheduler::_tc_UTILIZATION_BOUND_EXCEEDED,
    RtecScheduler::_tc_SYNCHRONIZATION_FAILURE,
    RtecScheduler::_tc_INSUFFICIENT_THREAD_PRIORITY_LEVELS,
    RtecScheduler::_tc_TASK_COUNT_MISMATCH,
    RtecScheduler::_tc_INTERNAL,
    RtecScheduler::_tc_DUPLICATE_NAME
  };
  
  exception_list->length (6);
  for (CORBA::ULong i = 0; i < 6; ++i)
    {
      CORBA::TypeCode_ptr tcp = _tao_RtecScheduler_Scheduler_compute_scheduling_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_RtecScheduler_Scheduler_compute_scheduling::result (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the result on demand.
  CORBA::Boolean tk_void_any = 1;
  CORBA::Any *result_any =
    TAO_RequestInfo_Util::make_any (tk_void_any ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  return result_any;
}

char *
TAO_ServerRequestInfo_RtecScheduler_Scheduler_compute_scheduling::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_RtecScheduler_Scheduler_compute_scheduling::target_is_a (
    const char * id
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  return this->_tao_impl->_is_a (id ACE_ENV_ARG_PARAMETER);
}

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

class TAO_ServerRequestInfo_RtecScheduler_Scheduler_recompute_scheduling : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_RtecScheduler_Scheduler_recompute_scheduling (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_RtecScheduler::Scheduler *tao_impl,
      const ::CORBA::Long & minimum_priority,
      const ::CORBA::Long & maximum_priority
      ACE_ENV_ARG_DECL_WITH_DEFAULTS
    );
  
  virtual Dynamic::ParameterList * arguments (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual Dynamic::ExceptionList * exceptions (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual CORBA::Any * result (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual char * target_most_derived_interface (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual CORBA::Boolean target_is_a (
      const char * id
      ACE_ENV_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
private:
  TAO_ServerRequestInfo_RtecScheduler_Scheduler_recompute_scheduling (
      const TAO_ServerRequestInfo_RtecScheduler_Scheduler_recompute_scheduling &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_RtecScheduler_Scheduler_recompute_scheduling &
    );
  
private:
  POA_RtecScheduler::Scheduler *_tao_impl;
  
  const ::CORBA::Long & minimum_priority_;
  const ::CORBA::Long & maximum_priority_;
};

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

TAO_ServerRequestInfo_RtecScheduler_Scheduler_recompute_scheduling::TAO_ServerRequestInfo_RtecScheduler_Scheduler_recompute_scheduling (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_RtecScheduler::Scheduler *tao_impl,
    const ::CORBA::Long & minimum_priority,
    const ::CORBA::Long & maximum_priority
    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl),
    minimum_priority_ (minimum_priority),
    maximum_priority_ (maximum_priority)
{}

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

Dynamic::ExceptionList *
TAO_ServerRequestInfo_RtecScheduler_Scheduler_recompute_scheduling::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_RtecScheduler_Scheduler_recompute_scheduling_exceptiondata[] = 
  {
    RtecScheduler::_tc_UTILIZATION_BOUND_EXCEEDED,
    RtecScheduler::_tc_SYNCHRONIZATION_FAILURE,
    RtecScheduler::_tc_INSUFFICIENT_THREAD_PRIORITY_LEVELS,
    RtecScheduler::_tc_TASK_COUNT_MISMATCH,
    RtecScheduler::_tc_INTERNAL,
    RtecScheduler::_tc_DUPLICATE_NAME
  };
  
  exception_list->length (6);
  for (CORBA::ULong i = 0; i < 6; ++i)
    {
      CORBA::TypeCode_ptr tcp = _tao_RtecScheduler_Scheduler_recompute_scheduling_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_RtecScheduler_Scheduler_recompute_scheduling::result (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the result on demand.
  CORBA::Boolean tk_void_any = 1;
  CORBA::Any *result_any =
    TAO_RequestInfo_Util::make_any (tk_void_any ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  return result_any;
}

char *
TAO_ServerRequestInfo_RtecScheduler_Scheduler_recompute_scheduling::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_RtecScheduler_Scheduler_recompute_scheduling::target_is_a (
    const char * id
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  return this->_tao_impl->_is_a (id ACE_ENV_ARG_PARAMETER);
}

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

class TAO_ServerRequestInfo_RtecScheduler_Scheduler_get_rt_info_set : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_RtecScheduler_Scheduler_get_rt_info_set (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_RtecScheduler::Scheduler *tao_impl
      ACE_ENV_ARG_DECL_WITH_DEFAULTS
    );
  
  virtual Dynamic::ParameterList * arguments (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual Dynamic::ExceptionList * exceptions (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual CORBA::Any * result (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual char * target_most_derived_interface (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual CORBA::Boolean target_is_a (
      const char * id
      ACE_ENV_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
private:
  TAO_ServerRequestInfo_RtecScheduler_Scheduler_get_rt_info_set (
      const TAO_ServerRequestInfo_RtecScheduler_Scheduler_get_rt_info_set &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_RtecScheduler_Scheduler_get_rt_info_set &
    );
  
private:
  POA_RtecScheduler::Scheduler *_tao_impl;
  
};

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

TAO_ServerRequestInfo_RtecScheduler_Scheduler_get_rt_info_set::TAO_ServerRequestInfo_RtecScheduler_Scheduler_get_rt_info_set (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_RtecScheduler::Scheduler *tao_impl
    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl)
{}

Dynamic::ParameterList *
TAO_ServerRequestInfo_RtecScheduler_Scheduler_get_rt_info_set::arguments (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the argument list on demand.
  Dynamic::ParameterList *parameter_list =
    TAO_RequestInfo_Util::make_parameter_list (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  return parameter_list;
}

Dynamic::ExceptionList *
TAO_ServerRequestInfo_RtecScheduler_Scheduler_get_rt_info_set::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_RtecScheduler_Scheduler_get_rt_info_set_exceptiondata[] = 
  {
    RtecScheduler::_tc_SYNCHRONIZATION_FAILURE,
    RtecScheduler::_tc_INTERNAL
  };
  
  exception_list->length (2);
  for (CORBA::ULong i = 0; i < 2; ++i)
    {
      CORBA::TypeCode_ptr tcp = _tao_RtecScheduler_Scheduler_get_rt_info_set_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_RtecScheduler_Scheduler_get_rt_info_set::result (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the result on demand.
  CORBA::Boolean tk_void_any = 1;
  CORBA::Any *result_any =
    TAO_RequestInfo_Util::make_any (tk_void_any ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  return result_any;
}

char *
TAO_ServerRequestInfo_RtecScheduler_Scheduler_get_rt_info_set::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_RtecScheduler_Scheduler_get_rt_info_set::target_is_a (
    const char * id
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  return this->_tao_impl->_is_a (id ACE_ENV_ARG_PARAMETER);
}

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

class TAO_ServerRequestInfo_RtecScheduler_Scheduler_get_dependency_set : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_RtecScheduler_Scheduler_get_dependency_set (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_RtecScheduler::Scheduler *tao_impl
      ACE_ENV_ARG_DECL_WITH_DEFAULTS
    );
  
  virtual Dynamic::ParameterList * arguments (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual Dynamic::ExceptionList * exceptions (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual CORBA::Any * result (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual char * target_most_derived_interface (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual CORBA::Boolean target_is_a (
      const char * id
      ACE_ENV_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
private:
  TAO_ServerRequestInfo_RtecScheduler_Scheduler_get_dependency_set (
      const TAO_ServerRequestInfo_RtecScheduler_Scheduler_get_dependency_set &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_RtecScheduler_Scheduler_get_dependency_set &
    );
  
private:
  POA_RtecScheduler::Scheduler *_tao_impl;
  
};

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

TAO_ServerRequestInfo_RtecScheduler_Scheduler_get_dependency_set::TAO_ServerRequestInfo_RtecScheduler_Scheduler_get_dependency_set (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_RtecScheduler::Scheduler *tao_impl
    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl)
{}

Dynamic::ParameterList *
TAO_ServerRequestInfo_RtecScheduler_Scheduler_get_dependency_set::arguments (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the argument list on demand.
  Dynamic::ParameterList *parameter_list =
    TAO_RequestInfo_Util::make_parameter_list (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  return parameter_list;
}

Dynamic::ExceptionList *
TAO_ServerRequestInfo_RtecScheduler_Scheduler_get_dependency_set::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_RtecScheduler_Scheduler_get_dependency_set_exceptiondata[] = 
  {
    RtecScheduler::_tc_SYNCHRONIZATION_FAILURE,
    RtecScheduler::_tc_INTERNAL
  };
  
  exception_list->length (2);
  for (CORBA::ULong i = 0; i < 2; ++i)
    {
      CORBA::TypeCode_ptr tcp = _tao_RtecScheduler_Scheduler_get_dependency_set_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_RtecScheduler_Scheduler_get_dependency_set::result (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the result on demand.
  CORBA::Boolean tk_void_any = 1;
  CORBA::Any *result_any =
    TAO_RequestInfo_Util::make_any (tk_void_any ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  return result_any;
}

char *
TAO_ServerRequestInfo_RtecScheduler_Scheduler_get_dependency_set::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_RtecScheduler_Scheduler_get_dependency_set::target_is_a (
    const char * id
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  return this->_tao_impl->_is_a (id ACE_ENV_ARG_PARAMETER);
}

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

class TAO_ServerRequestInfo_RtecScheduler_Scheduler_get_config_info_set : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_RtecScheduler_Scheduler_get_config_info_set (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_RtecScheduler::Scheduler *tao_impl
      ACE_ENV_ARG_DECL_WITH_DEFAULTS
    );
  
  virtual Dynamic::ParameterList * arguments (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual Dynamic::ExceptionList * exceptions (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual CORBA::Any * result (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual char * target_most_derived_interface (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual CORBA::Boolean target_is_a (
      const char * id
      ACE_ENV_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
private:
  TAO_ServerRequestInfo_RtecScheduler_Scheduler_get_config_info_set (
      const TAO_ServerRequestInfo_RtecScheduler_Scheduler_get_config_info_set &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_RtecScheduler_Scheduler_get_config_info_set &
    );
  
private:
  POA_RtecScheduler::Scheduler *_tao_impl;
  
};

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

TAO_ServerRequestInfo_RtecScheduler_Scheduler_get_config_info_set::TAO_ServerRequestInfo_RtecScheduler_Scheduler_get_config_info_set (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_RtecScheduler::Scheduler *tao_impl
    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl)
{}

Dynamic::ParameterList *
TAO_ServerRequestInfo_RtecScheduler_Scheduler_get_config_info_set::arguments (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the argument list on demand.
  Dynamic::ParameterList *parameter_list =
    TAO_RequestInfo_Util::make_parameter_list (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  return parameter_list;
}

Dynamic::ExceptionList *
TAO_ServerRequestInfo_RtecScheduler_Scheduler_get_config_info_set::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_RtecScheduler_Scheduler_get_config_info_set_exceptiondata[] = 
  {
    RtecScheduler::_tc_SYNCHRONIZATION_FAILURE,
    RtecScheduler::_tc_INTERNAL
  };
  
  exception_list->length (2);
  for (CORBA::ULong i = 0; i < 2; ++i)
    {
      CORBA::TypeCode_ptr tcp = _tao_RtecScheduler_Scheduler_get_config_info_set_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_RtecScheduler_Scheduler_get_config_info_set::result (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the result on demand.
  CORBA::Boolean tk_void_any = 1;
  CORBA::Any *result_any =
    TAO_RequestInfo_Util::make_any (tk_void_any ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  return result_any;
}

char *
TAO_ServerRequestInfo_RtecScheduler_Scheduler_get_config_info_set::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_RtecScheduler_Scheduler_get_config_info_set::target_is_a (
    const char * id
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  return this->_tao_impl->_is_a (id ACE_ENV_ARG_PARAMETER);
}

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

class TAO_ServerRequestInfo_RtecScheduler_Scheduler_dispatch_configuration : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_RtecScheduler_Scheduler_dispatch_configuration (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_RtecScheduler::Scheduler *tao_impl,
      const ::RtecScheduler::Preemption_Priority_t & p_priority      

      ACE_ENV_ARG_DECL_WITH_DEFAULTS
    );
  
  virtual Dynamic::ParameterList * arguments (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual Dynamic::ExceptionList * exceptions (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual CORBA::Any * result (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual char * target_most_derived_interface (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual CORBA::Boolean target_is_a (
      const char * id
      ACE_ENV_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
private:
  TAO_ServerRequestInfo_RtecScheduler_Scheduler_dispatch_configuration (
      const TAO_ServerRequestInfo_RtecScheduler_Scheduler_dispatch_configuration &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_RtecScheduler_Scheduler_dispatch_configuration &
    );
  
private:
  POA_RtecScheduler::Scheduler *_tao_impl;
  
  const ::RtecScheduler::Preemption_Priority_t & p_priority_;  

};

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

TAO_ServerRequestInfo_RtecScheduler_Scheduler_dispatch_configuration::TAO_ServerRequestInfo_RtecScheduler_Scheduler_dispatch_configuration (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_RtecScheduler::Scheduler *tao_impl,
    const ::RtecScheduler::Preemption_Priority_t & p_priority    

    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl),
    p_priority_ (p_priority)  

{}

Dynamic::ParameterList *
TAO_ServerRequestInfo_RtecScheduler_Scheduler_dispatch_configuration::arguments (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the argument list on demand.
  Dynamic::ParameterList *parameter_list =
    TAO_RequestInfo_Util::make_parameter_list (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
  parameter_list->length (1);
  CORBA::ULong len = 0;
  
  (*parameter_list)[len].argument <<= p_priority_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
    

  return safe_parameter_list._retn ();
}

Dynamic::ExceptionList *
TAO_ServerRequestInfo_RtecScheduler_Scheduler_dispatch_configuration::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_RtecScheduler_Scheduler_dispatch_configuration_exceptiondata[] = 
  {
    RtecScheduler::_tc_NOT_SCHEDULED,
    RtecScheduler::_tc_SYNCHRONIZATION_FAILURE,
    RtecScheduler::_tc_UNKNOWN_PRIORITY_LEVEL
  };
  
  exception_list->length (3);
  for (CORBA::ULong i = 0; i < 3; ++i)
    {
      CORBA::TypeCode_ptr tcp = _tao_RtecScheduler_Scheduler_dispatch_configuration_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_RtecScheduler_Scheduler_dispatch_configuration::result (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the result on demand.
  CORBA::Boolean tk_void_any = 1;
  CORBA::Any *result_any =
    TAO_RequestInfo_Util::make_any (tk_void_any ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  return result_any;
}

char *
TAO_ServerRequestInfo_RtecScheduler_Scheduler_dispatch_configuration::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_RtecScheduler_Scheduler_dispatch_configuration::target_is_a (
    const char * id
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  return this->_tao_impl->_is_a (id ACE_ENV_ARG_PARAMETER);
}

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

class TAO_ServerRequestInfo_RtecScheduler_Scheduler_last_scheduled_priority : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_RtecScheduler_Scheduler_last_scheduled_priority (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_RtecScheduler::Scheduler *tao_impl
      ACE_ENV_ARG_DECL_WITH_DEFAULTS
    );
  
  virtual Dynamic::ParameterList * arguments (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual Dynamic::ExceptionList * exceptions (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual CORBA::Any * result (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual char * target_most_derived_interface (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual CORBA::Boolean target_is_a (
      const char * id
      ACE_ENV_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  void result (RtecScheduler::Preemption_Priority_t result);

private:
  TAO_ServerRequestInfo_RtecScheduler_Scheduler_last_scheduled_priority (
      const TAO_ServerRequestInfo_RtecScheduler_Scheduler_last_scheduled_priority &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_RtecScheduler_Scheduler_last_scheduled_priority &
    );
  
private:
  POA_RtecScheduler::Scheduler *_tao_impl;
  
  RtecScheduler::Preemption_Priority_t _result;
};

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

TAO_ServerRequestInfo_RtecScheduler_Scheduler_last_scheduled_priority::TAO_ServerRequestInfo_RtecScheduler_Scheduler_last_scheduled_priority (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_RtecScheduler::Scheduler *tao_impl
    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl)
{}

Dynamic::ParameterList *
TAO_ServerRequestInfo_RtecScheduler_Scheduler_last_scheduled_priority::arguments (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the argument list on demand.
  Dynamic::ParameterList *parameter_list =
    TAO_RequestInfo_Util::make_parameter_list (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  return parameter_list;
}

Dynamic::ExceptionList *
TAO_ServerRequestInfo_RtecScheduler_Scheduler_last_scheduled_priority::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_RtecScheduler_Scheduler_last_scheduled_priority_exceptiondata[] = 
  {
    RtecScheduler::_tc_SYNCHRONIZATION_FAILURE,
    RtecScheduler::_tc_NOT_SCHEDULED
  };
  
  exception_list->length (2);
  for (CORBA::ULong i = 0; i < 2; ++i)
    {
      CORBA::TypeCode_ptr tcp = _tao_RtecScheduler_Scheduler_last_scheduled_priority_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_RtecScheduler_Scheduler_last_scheduled_priority::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_RtecScheduler_Scheduler_last_scheduled_priority::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_RtecScheduler_Scheduler_last_scheduled_priority::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_RtecScheduler_Scheduler_last_scheduled_priority::result (RtecScheduler::Preemption_Priority_t result)
{
  // Update the result.
   this->_result = result;
}

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

class TAO_ServerRequestInfo_RtecScheduler_Scheduler_get_config_infos : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_RtecScheduler_Scheduler_get_config_infos (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_RtecScheduler::Scheduler *tao_impl
      ACE_ENV_ARG_DECL_WITH_DEFAULTS
    );
  
  virtual Dynamic::ParameterList * arguments (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual Dynamic::ExceptionList * exceptions (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual CORBA::Any * result (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual char * target_most_derived_interface (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual CORBA::Boolean target_is_a (
      const char * id
      ACE_ENV_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
private:
  TAO_ServerRequestInfo_RtecScheduler_Scheduler_get_config_infos (
      const TAO_ServerRequestInfo_RtecScheduler_Scheduler_get_config_infos &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_RtecScheduler_Scheduler_get_config_infos &
    );
  
private:
  POA_RtecScheduler::Scheduler *_tao_impl;
  
};

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

TAO_ServerRequestInfo_RtecScheduler_Scheduler_get_config_infos::TAO_ServerRequestInfo_RtecScheduler_Scheduler_get_config_infos (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_RtecScheduler::Scheduler *tao_impl
    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl)
{}

Dynamic::ParameterList *
TAO_ServerRequestInfo_RtecScheduler_Scheduler_get_config_infos::arguments (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the argument list on demand.
  Dynamic::ParameterList *parameter_list =
    TAO_RequestInfo_Util::make_parameter_list (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  return parameter_list;
}

Dynamic::ExceptionList *
TAO_ServerRequestInfo_RtecScheduler_Scheduler_get_config_infos::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_RtecScheduler_Scheduler_get_config_infos_exceptiondata[] = 
  {
    RtecScheduler::_tc_SYNCHRONIZATION_FAILURE,
    RtecScheduler::_tc_NOT_SCHEDULED
  };
  
  exception_list->length (2);
  for (CORBA::ULong i = 0; i < 2; ++i)
    {
      CORBA::TypeCode_ptr tcp = _tao_RtecScheduler_Scheduler_get_config_infos_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_RtecScheduler_Scheduler_get_config_infos::result (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the result on demand.
  CORBA::Boolean tk_void_any = 1;
  CORBA::Any *result_any =
    TAO_RequestInfo_Util::make_any (tk_void_any ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  return result_any;
}

char *
TAO_ServerRequestInfo_RtecScheduler_Scheduler_get_config_infos::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_RtecScheduler_Scheduler_get_config_infos::target_is_a (
    const char * id
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  return this->_tao_impl->_is_a (id ACE_ENV_ARG_PARAMETER);
}

#endif /* TAO_HAS_INTERCEPTORS */

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

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

// Factory function Implementation.
POA_RtecScheduler::_TAO_Scheduler_Strategized_Proxy_Broker *
POA_RtecScheduler::_TAO_Scheduler_Strategized_Proxy_Broker::the_TAO_Scheduler_Strategized_Proxy_Broker (void)
{
  static POA_RtecScheduler::_TAO_Scheduler_Strategized_Proxy_Broker
  strategized_proxy_broker;
  
  return &strategized_proxy_broker;
}

POA_RtecScheduler::_TAO_Scheduler_Strategized_Proxy_Broker::_TAO_Scheduler_Strategized_Proxy_Broker (void)
{
}

POA_RtecScheduler::_TAO_Scheduler_Strategized_Proxy_Broker::~_TAO_Scheduler_Strategized_Proxy_Broker (void)
{
}

TAO::Collocation_Strategy
POA_RtecScheduler::_TAO_Scheduler_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_RtecScheduler::_TAO_Scheduler_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 *
RtecScheduler__TAO_Scheduler_Proxy_Broker_Factory_function (CORBA::Object_ptr)
{
  return
    ::POA_RtecScheduler::_TAO_Scheduler_Strategized_Proxy_Broker::the_TAO_Scheduler_Strategized_Proxy_Broker ();
}

int
RtecScheduler__TAO_Scheduler_Proxy_Broker_Factory_Initializer (size_t)
{
  RtecScheduler__TAO_Scheduler_Proxy_Broker_Factory_function_pointer = 
    RtecScheduler__TAO_Scheduler_Proxy_Broker_Factory_function;
  
  return 0;
}

static int
RtecScheduler__TAO_Scheduler_Proxy_Broker_Stub_Factory_Initializer_Scarecrow =
  RtecScheduler__TAO_Scheduler_Proxy_Broker_Factory_Initializer (
      reinterpret_cast<
          size_t> (
          RtecScheduler__TAO_Scheduler_Proxy_Broker_Factory_Initializer
        )
    );


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

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

POA_RtecScheduler::_TAO_Scheduler_ThruPOA_Proxy_Impl::_TAO_Scheduler_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_RtecScheduler::_TAO_Scheduler_ThruPOA_Proxy_Impl::create (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument ** args,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException,
    ::RtecScheduler::DUPLICATE_NAME,
    ::RtecScheduler::INTERNAL,
    ::RtecScheduler::SYNCHRONIZATION_FAILURE
  ))
{
  ((TAO::Arg_Traits< RtecScheduler::handle_t>::ret_val *) args[0])->arg () =
    reinterpret_cast<
        POA_RtecScheduler::Scheduler_ptr> (
        servant->_downcast (
            "IDL:RtecScheduler/Scheduler:1.0"
          )
      )->create (
          ((TAO::Arg_Traits< ::CORBA::Char *>::in_arg_val *) args[1])->arg ()
          ACE_ENV_ARG_PARAMETER
        );
  ACE_CHECK;
}

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

void
POA_RtecScheduler::_TAO_Scheduler_ThruPOA_Proxy_Impl::lookup (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument ** args,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException,
    ::RtecScheduler::UNKNOWN_TASK,
    ::RtecScheduler::SYNCHRONIZATION_FAILURE
  ))
{
  ((TAO::Arg_Traits< RtecScheduler::handle_t>::ret_val *) args[0])->arg () =
    reinterpret_cast<
        POA_RtecScheduler::Scheduler_ptr> (
        servant->_downcast (
            "IDL:RtecScheduler/Scheduler:1.0"
          )
      )->lookup (
          ((TAO::Arg_Traits< ::CORBA::Char *>::in_arg_val *) args[1])->arg ()
          ACE_ENV_ARG_PARAMETER
        );
  ACE_CHECK;
}

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

void
POA_RtecScheduler::_TAO_Scheduler_ThruPOA_Proxy_Impl::get (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument ** args,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException,
    ::RtecScheduler::UNKNOWN_TASK,
    ::RtecScheduler::SYNCHRONIZATION_FAILURE
  ))
{
  ((TAO::Arg_Traits< ::RtecScheduler::RT_Info>::ret_val *) args[0])->arg () =
    reinterpret_cast<
        POA_RtecScheduler::Scheduler_ptr> (
        servant->_downcast (
            "IDL:RtecScheduler/Scheduler:1.0"
          )
      )->get (
          ((TAO::Arg_Traits< RtecScheduler::handle_t>::in_arg_val *) args[1])->arg ()
          ACE_ENV_ARG_PARAMETER
        );
  ACE_CHECK;
}

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

void
POA_RtecScheduler::_TAO_Scheduler_ThruPOA_Proxy_Impl::set (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument ** args,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException,
    ::RtecScheduler::UNKNOWN_TASK,
    ::RtecScheduler::INTERNAL,
    ::RtecScheduler::SYNCHRONIZATION_FAILURE
  ))
{
  reinterpret_cast<
      POA_RtecScheduler::Scheduler_ptr> (
      servant->_downcast (
          "IDL:RtecScheduler/Scheduler:1.0"
        )
    )->set (
        ((TAO::Arg_Traits< RtecScheduler::handle_t>::in_arg_val *) args[1])->arg (),
        ((TAO::Arg_Traits< ::RtecScheduler::Criticality_t>::in_arg_val *) args[2])->arg (),
        ((TAO::Arg_Traits< RtecScheduler::Time>::in_arg_val *) args[3])->arg (),
        ((TAO::Arg_Traits< RtecScheduler::Time>::in_arg_val *) args[4])->arg (),
        ((TAO::Arg_Traits< RtecScheduler::Time>::in_arg_val *) args[5])->arg (),
        ((TAO::Arg_Traits< RtecScheduler::Period_t>::in_arg_val *) args[6])->arg (),
        ((TAO::Arg_Traits< ::RtecScheduler::Importance_t>::in_arg_val *) args[7])->arg (),
        ((TAO::Arg_Traits< RtecScheduler::Quantum_t>::in_arg_val *) args[8])->arg (),
        ((TAO::Arg_Traits< RtecScheduler::Threads_t>::in_arg_val *) args[9])->arg (),
        ((TAO::Arg_Traits< ::RtecScheduler::Info_Type_t>::in_arg_val *) args[10])->arg ()
        ACE_ENV_ARG_PARAMETER
      );
  ACE_CHECK;
}

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

void
POA_RtecScheduler::_TAO_Scheduler_ThruPOA_Proxy_Impl::reset (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument ** args,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException,
    ::RtecScheduler::UNKNOWN_TASK,
    ::RtecScheduler::INTERNAL,
    ::RtecScheduler::SYNCHRONIZATION_FAILURE
  ))
{
  reinterpret_cast<
      POA_RtecScheduler::Scheduler_ptr> (
      servant->_downcast (
          "IDL:RtecScheduler/Scheduler:1.0"
        )
    )->reset (
        ((TAO::Arg_Traits< RtecScheduler::handle_t>::in_arg_val *) args[1])->arg (),
        ((TAO::Arg_Traits< ::RtecScheduler::Criticality_t>::in_arg_val *) args[2])->arg (),
        ((TAO::Arg_Traits< RtecScheduler::Time>::in_arg_val *) args[3])->arg (),
        ((TAO::Arg_Traits< RtecScheduler::Time>::in_arg_val *) args[4])->arg (),
        ((TAO::Arg_Traits< RtecScheduler::Time>::in_arg_val *) args[5])->arg (),
        ((TAO::Arg_Traits< RtecScheduler::Period_t>::in_arg_val *) args[6])->arg (),
        ((TAO::Arg_Traits< ::RtecScheduler::Importance_t>::in_arg_val *) args[7])->arg (),
        ((TAO::Arg_Traits< RtecScheduler::Quantum_t>::in_arg_val *) args[8])->arg (),
        ((TAO::Arg_Traits< RtecScheduler::Threads_t>::in_arg_val *) args[9])->arg (),
        ((TAO::Arg_Traits< ::RtecScheduler::Info_Type_t>::in_arg_val *) args[10])->arg ()
        ACE_ENV_ARG_PARAMETER
      );
  ACE_CHECK;
}

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

void
POA_RtecScheduler::_TAO_Scheduler_ThruPOA_Proxy_Impl::set_seq (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument ** args,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException,
    ::RtecScheduler::UNKNOWN_TASK,
    ::RtecScheduler::INTERNAL,
    ::RtecScheduler::SYNCHRONIZATION_FAILURE
  ))
{
  reinterpret_cast<
      POA_RtecScheduler::Scheduler_ptr> (
      servant->_downcast (
          "IDL:RtecScheduler/Scheduler:1.0"
        )
    )->set_seq (
        ((TAO::Arg_Traits< ::RtecScheduler::RT_Info_Set>::in_arg_val *) args[1])->arg ()
        ACE_ENV_ARG_PARAMETER
      );
  ACE_CHECK;
}

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

void
POA_RtecScheduler::_TAO_Scheduler_ThruPOA_Proxy_Impl::reset_seq (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument ** args,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException,
    ::RtecScheduler::UNKNOWN_TASK,
    ::RtecScheduler::INTERNAL,
    ::RtecScheduler::SYNCHRONIZATION_FAILURE
  ))
{
  reinterpret_cast<
      POA_RtecScheduler::Scheduler_ptr> (
      servant->_downcast (
          "IDL:RtecScheduler/Scheduler:1.0"
        )
    )->reset_seq (
        ((TAO::Arg_Traits< ::RtecScheduler::RT_Info_Set>::in_arg_val *) args[1])->arg ()
        ACE_ENV_ARG_PARAMETER
      );
  ACE_CHECK;
}

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

void
POA_RtecScheduler::_TAO_Scheduler_ThruPOA_Proxy_Impl::replace_seq (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument ** args,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException,
    ::RtecScheduler::UNKNOWN_TASK,
    ::RtecScheduler::INTERNAL,
    ::RtecScheduler::SYNCHRONIZATION_FAILURE
  ))
{
  reinterpret_cast<
      POA_RtecScheduler::Scheduler_ptr> (
      servant->_downcast (
          "IDL:RtecScheduler/Scheduler:1.0"
        )
    )->replace_seq (
        ((TAO::Arg_Traits< ::RtecScheduler::RT_Info_Set>::in_arg_val *) args[1])->arg ()
        ACE_ENV_ARG_PARAMETER
      );
  ACE_CHECK;
}

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

void
POA_RtecScheduler::_TAO_Scheduler_ThruPOA_Proxy_Impl::add_dependency (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument ** args,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException,
    ::RtecScheduler::SYNCHRONIZATION_FAILURE,
    ::RtecScheduler::UNKNOWN_TASK
  ))
{
  reinterpret_cast<
      POA_RtecScheduler::Scheduler_ptr> (
      servant->_downcast (
          "IDL:RtecScheduler/Scheduler:1.0"
        )
    )->add_dependency (
        ((TAO::Arg_Traits< RtecScheduler::handle_t>::in_arg_val *) args[1])->arg (),
        ((TAO::Arg_Traits< RtecScheduler::handle_t>::in_arg_val *) args[2])->arg (),
        ((TAO::Arg_Traits< CORBA::Long>::in_arg_val *) args[3])->arg (),
        ((TAO::Arg_Traits< ::RtecScheduler::Dependency_Type_t>::in_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_RtecScheduler::_TAO_Scheduler_ThruPOA_Proxy_Impl::remove_dependency (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument ** args,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException,
    ::RtecScheduler::SYNCHRONIZATION_FAILURE,
    ::RtecScheduler::UNKNOWN_TASK
  ))
{
  reinterpret_cast<
      POA_RtecScheduler::Scheduler_ptr> (
      servant->_downcast (
          "IDL:RtecScheduler/Scheduler:1.0"
        )
    )->remove_dependency (
        ((TAO::Arg_Traits< RtecScheduler::handle_t>::in_arg_val *) args[1])->arg (),
        ((TAO::Arg_Traits< RtecScheduler::handle_t>::in_arg_val *) args[2])->arg (),
        ((TAO::Arg_Traits< CORBA::Long>::in_arg_val *) args[3])->arg (),
        ((TAO::Arg_Traits< ::RtecScheduler::Dependency_Type_t>::in_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_RtecScheduler::_TAO_Scheduler_ThruPOA_Proxy_Impl::set_dependency_enable_state (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument ** args,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException,
    ::RtecScheduler::SYNCHRONIZATION_FAILURE,
    ::RtecScheduler::UNKNOWN_TASK
  ))
{
  reinterpret_cast<
      POA_RtecScheduler::Scheduler_ptr> (
      servant->_downcast (
          "IDL:RtecScheduler/Scheduler:1.0"
        )
    )->set_dependency_enable_state (
        ((TAO::Arg_Traits< RtecScheduler::handle_t>::in_arg_val *) args[1])->arg (),
        ((TAO::Arg_Traits< RtecScheduler::handle_t>::in_arg_val *) args[2])->arg (),
        ((TAO::Arg_Traits< CORBA::Long>::in_arg_val *) args[3])->arg (),
        ((TAO::Arg_Traits< ::RtecScheduler::Dependency_Type_t>::in_arg_val *) args[4])->arg (),
        ((TAO::Arg_Traits< ::RtecScheduler::Dependency_Enabled_Type_t>::in_arg_val *) args[5])->arg ()
        ACE_ENV_ARG_PARAMETER
      );
  ACE_CHECK;
}

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

void
POA_RtecScheduler::_TAO_Scheduler_ThruPOA_Proxy_Impl::set_dependency_enable_state_seq (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument ** args,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException,
    ::RtecScheduler::SYNCHRONIZATION_FAILURE,
    ::RtecScheduler::UNKNOWN_TASK
  ))
{
  reinterpret_cast<
      POA_RtecScheduler::Scheduler_ptr> (
      servant->_downcast (
          "IDL:RtecScheduler/Scheduler:1.0"
        )
    )->set_dependency_enable_state_seq (
        ((TAO::Arg_Traits< ::RtecScheduler::Dependency_Set>::in_arg_val *) args[1])->arg ()
        ACE_ENV_ARG_PARAMETER
      );
  ACE_CHECK;
}

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

void
POA_RtecScheduler::_TAO_Scheduler_ThruPOA_Proxy_Impl::set_rt_info_enable_state (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument ** args,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException,
    ::RtecScheduler::SYNCHRONIZATION_FAILURE,
    ::RtecScheduler::INTERNAL,
    ::RtecScheduler::UNKNOWN_TASK
  ))
{
  reinterpret_cast<
      POA_RtecScheduler::Scheduler_ptr> (
      servant->_downcast (
          "IDL:RtecScheduler/Scheduler:1.0"
        )
    )->set_rt_info_enable_state (
        ((TAO::Arg_Traits< RtecScheduler::handle_t>::in_arg_val *) args[1])->arg (),
        ((TAO::Arg_Traits< ::RtecScheduler::RT_Info_Enabled_Type_t>::in_arg_val *) args[2])->arg ()
        ACE_ENV_ARG_PARAMETER
      );
  ACE_CHECK;
}

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

void
POA_RtecScheduler::_TAO_Scheduler_ThruPOA_Proxy_Impl::set_rt_info_enable_state_seq (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument ** args,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException,
    ::RtecScheduler::SYNCHRONIZATION_FAILURE,
    ::RtecScheduler::INTERNAL,
    ::RtecScheduler::UNKNOWN_TASK
  ))
{
  reinterpret_cast<
      POA_RtecScheduler::Scheduler_ptr> (
      servant->_downcast (
          "IDL:RtecScheduler/Scheduler:1.0"
        )
    )->set_rt_info_enable_state_seq (
        ((TAO::Arg_Traits< ::RtecScheduler::RT_Info_Enable_State_Pair_Set>::in_arg_val *) args[1])->arg ()
        ACE_ENV_ARG_PARAMETER
      );
  ACE_CHECK;
}

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

void
POA_RtecScheduler::_TAO_Scheduler_ThruPOA_Proxy_Impl::priority (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument ** args,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException,
    ::RtecScheduler::UNKNOWN_TASK,
    ::RtecScheduler::SYNCHRONIZATION_FAILURE,
    ::RtecScheduler::NOT_SCHEDULED
  ))
{
  reinterpret_cast<
      POA_RtecScheduler::Scheduler_ptr> (
      servant->_downcast (
          "IDL:RtecScheduler/Scheduler:1.0"
        )
    )->priority (
        ((TAO::Arg_Traits< RtecScheduler::handle_t>::in_arg_val *) args[1])->arg (),
        ((TAO::Arg_Traits< RtecScheduler::OS_Priority>::out_arg_val *) args[2])->arg (),
        ((TAO::Arg_Traits< RtecScheduler::Preemption_Subpriority_t>::out_arg_val *) args[3])->arg (),
        ((TAO::Arg_Traits< RtecScheduler::Preemption_Priority_t>::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_RtecScheduler::_TAO_Scheduler_ThruPOA_Proxy_Impl::entry_point_priority (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument ** args,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException,
    ::RtecScheduler::UNKNOWN_TASK,
    ::RtecScheduler::SYNCHRONIZATION_FAILURE,
    ::RtecScheduler::NOT_SCHEDULED
  ))
{
  reinterpret_cast<
      POA_RtecScheduler::Scheduler_ptr> (
      servant->_downcast (
          "IDL:RtecScheduler/Scheduler:1.0"
        )
    )->entry_point_priority (
        ((TAO::Arg_Traits< ::CORBA::Char *>::in_arg_val *) args[1])->arg (),
        ((TAO::Arg_Traits< RtecScheduler::OS_Priority>::out_arg_val *) args[2])->arg (),
        ((TAO::Arg_Traits< RtecScheduler::Preemption_Subpriority_t>::out_arg_val *) args[3])->arg (),
        ((TAO::Arg_Traits< RtecScheduler::Preemption_Priority_t>::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_RtecScheduler::_TAO_Scheduler_ThruPOA_Proxy_Impl::compute_scheduling (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument ** args,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException,
    ::RtecScheduler::UTILIZATION_BOUND_EXCEEDED,
    ::RtecScheduler::SYNCHRONIZATION_FAILURE,
    ::RtecScheduler::INSUFFICIENT_THREAD_PRIORITY_LEVELS,
    ::RtecScheduler::TASK_COUNT_MISMATCH,
    ::RtecScheduler::INTERNAL,
    ::RtecScheduler::DUPLICATE_NAME
  ))
{
  reinterpret_cast<
      POA_RtecScheduler::Scheduler_ptr> (
      servant->_downcast (
          "IDL:RtecScheduler/Scheduler:1.0"
        )
    )->compute_scheduling (
        ((TAO::Arg_Traits< CORBA::Long>::in_arg_val *) args[1])->arg (),
        ((TAO::Arg_Traits< CORBA::Long>::in_arg_val *) args[2])->arg (),
        ((TAO::Arg_Traits< ::RtecScheduler::RT_Info_Set>::out_arg_val *) args[3])->arg (),
        ((TAO::Arg_Traits< ::RtecScheduler::Dependency_Set>::out_arg_val *) args[4])->arg (),
        ((TAO::Arg_Traits< ::RtecScheduler::Config_Info_Set>::out_arg_val *) args[5])->arg (),
        ((TAO::Arg_Traits< ::RtecScheduler::Scheduling_Anomaly_Set>::out_arg_val *) args[6])->arg ()
        ACE_ENV_ARG_PARAMETER
      );
  ACE_CHECK;
}

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

void
POA_RtecScheduler::_TAO_Scheduler_ThruPOA_Proxy_Impl::recompute_scheduling (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument ** args,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException,
    ::RtecScheduler::UTILIZATION_BOUND_EXCEEDED,
    ::RtecScheduler::SYNCHRONIZATION_FAILURE,
    ::RtecScheduler::INSUFFICIENT_THREAD_PRIORITY_LEVELS,
    ::RtecScheduler::TASK_COUNT_MISMATCH,
    ::RtecScheduler::INTERNAL,
    ::RtecScheduler::DUPLICATE_NAME
  ))
{
  reinterpret_cast<
      POA_RtecScheduler::Scheduler_ptr> (
      servant->_downcast (
          "IDL:RtecScheduler/Scheduler:1.0"
        )
    )->recompute_scheduling (
        ((TAO::Arg_Traits< CORBA::Long>::in_arg_val *) args[1])->arg (),
        ((TAO::Arg_Traits< CORBA::Long>::in_arg_val *) args[2])->arg (),
        ((TAO::Arg_Traits< ::RtecScheduler::Scheduling_Anomaly_Set>::out_arg_val *) args[3])->arg ()
        ACE_ENV_ARG_PARAMETER
      );
  ACE_CHECK;
}

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

void
POA_RtecScheduler::_TAO_Scheduler_ThruPOA_Proxy_Impl::get_rt_info_set (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument ** args,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException,
    ::RtecScheduler::SYNCHRONIZATION_FAILURE,
    ::RtecScheduler::INTERNAL
  ))
{
  reinterpret_cast<
      POA_RtecScheduler::Scheduler_ptr> (
      servant->_downcast (
          "IDL:RtecScheduler/Scheduler:1.0"
        )
    )->get_rt_info_set (
        ((TAO::Arg_Traits< ::RtecScheduler::RT_Info_Set>::out_arg_val *) args[1])->arg ()
        ACE_ENV_ARG_PARAMETER
      );
  ACE_CHECK;
}

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

void
POA_RtecScheduler::_TAO_Scheduler_ThruPOA_Proxy_Impl::get_dependency_set (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument ** args,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException,
    ::RtecScheduler::SYNCHRONIZATION_FAILURE,
    ::RtecScheduler::INTERNAL
  ))
{
  reinterpret_cast<
      POA_RtecScheduler::Scheduler_ptr> (
      servant->_downcast (
          "IDL:RtecScheduler/Scheduler:1.0"
        )
    )->get_dependency_set (
        ((TAO::Arg_Traits< ::RtecScheduler::Dependency_Set>::out_arg_val *) args[1])->arg ()
        ACE_ENV_ARG_PARAMETER
      );
  ACE_CHECK;
}

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

void
POA_RtecScheduler::_TAO_Scheduler_ThruPOA_Proxy_Impl::get_config_info_set (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument ** args,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException,
    ::RtecScheduler::SYNCHRONIZATION_FAILURE,
    ::RtecScheduler::INTERNAL
  ))
{
  reinterpret_cast<
      POA_RtecScheduler::Scheduler_ptr> (
      servant->_downcast (
          "IDL:RtecScheduler/Scheduler:1.0"
        )
    )->get_config_info_set (
        ((TAO::Arg_Traits< ::RtecScheduler::Config_Info_Set>::out_arg_val *) args[1])->arg ()
        ACE_ENV_ARG_PARAMETER
      );
  ACE_CHECK;
}

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

void
POA_RtecScheduler::_TAO_Scheduler_ThruPOA_Proxy_Impl::dispatch_configuration (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument ** args,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException,
    ::RtecScheduler::NOT_SCHEDULED,
    ::RtecScheduler::SYNCHRONIZATION_FAILURE,
    ::RtecScheduler::UNKNOWN_PRIORITY_LEVEL
  ))
{
  reinterpret_cast<
      POA_RtecScheduler::Scheduler_ptr> (
      servant->_downcast (
          "IDL:RtecScheduler/Scheduler:1.0"
        )
    )->dispatch_configuration (
        ((TAO::Arg_Traits< RtecScheduler::Preemption_Priority_t>::in_arg_val *) args[1])->arg (),
        ((TAO::Arg_Traits< RtecScheduler::OS_Priority>::out_arg_val *) args[2])->arg (),
        ((TAO::Arg_Traits< ::RtecScheduler::Dispatching_Type_t>::out_arg_val *) args[3])->arg ()
        ACE_ENV_ARG_PARAMETER
      );
  ACE_CHECK;
}

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

void
POA_RtecScheduler::_TAO_Scheduler_ThruPOA_Proxy_Impl::last_scheduled_priority (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument ** args,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException,
    ::RtecScheduler::SYNCHRONIZATION_FAILURE,
    ::RtecScheduler::NOT_SCHEDULED
  ))
{
  ((TAO::Arg_Traits< RtecScheduler::Preemption_Priority_t>::ret_val *) args[0])->arg () =
    reinterpret_cast<
        POA_RtecScheduler::Scheduler_ptr> (
        servant->_downcast (
            "IDL:RtecScheduler/Scheduler:1.0"
          )
      )->last_scheduled_priority (
          ACE_ENV_SINGLE_ARG_PARAMETER
        );
  ACE_CHECK;
}

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

void
POA_RtecScheduler::_TAO_Scheduler_ThruPOA_Proxy_Impl::get_config_infos (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument ** args,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException,
    ::RtecScheduler::SYNCHRONIZATION_FAILURE,
    ::RtecScheduler::NOT_SCHEDULED
  ))
{
  reinterpret_cast<
      POA_RtecScheduler::Scheduler_ptr> (
      servant->_downcast (
          "IDL:RtecScheduler/Scheduler:1.0"
        )
    )->get_config_infos (
        ((TAO::Arg_Traits< ::RtecScheduler::Config_Info_Set>::out_arg_val *) args[1])->arg ()
        ACE_ENV_ARG_PARAMETER
      );
  ACE_CHECK;
}

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

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

POA_RtecScheduler::Scheduler::Scheduler (void)
{
  this->optable_ = &tao_RtecScheduler_Scheduler_optable;
}

POA_RtecScheduler::Scheduler::Scheduler (const Scheduler& rhs)
  : TAO_Abstract_ServantBase (rhs),
    TAO_ServantBase (rhs)
{
}

POA_RtecScheduler::Scheduler::~Scheduler (void)
{
}

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

void POA_RtecScheduler::Scheduler::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_RtecScheduler::Scheduler *_tao_impl =
    static_cast<
        POA_RtecScheduler::Scheduler *> (
        _tao_servant
      );
  RtecScheduler::handle_t _tao_retval = 0;
  ::CORBA::String_var entry_point;
  
  if (!(
      (_tao_in >> entry_point.out ())
      ))
    {
      TAO_InputCDR::throw_skel_exception (errno ACE_ENV_ARG_PARAMETER);
      ACE_CHECK;
    }
  
#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_Object_Adapter::Servant_Upcall *_tao_upcall =
    static_cast<
        TAO_Object_Adapter::Servant_Upcall *> (
        _tao_servant_upcall
      );
    
  TAO_ServerRequestInterceptor_Adapter _tao_vfr (
      _tao_server_request.orb_core ()->server_request_interceptors (),
      _tao_server_request.interceptor_count ()
    );
  
  TAO_ServerRequestInfo_RtecScheduler_Scheduler_create _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl,
      
      entry_point.in ()
      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* Copy TSC to RSC */);
        
        _tao_vfr.receive_request (&_tao_ri ACE_ENV_ARG_PARAMETER);
        ACE_TRY_CHECK;
        
        if (!_tao_vfr.location_forwarded ())
          {
#endif /* TAO_HAS_INTERCEPTORS */
            _tao_retval = 
              _tao_impl->create (
                  entry_point.in ()
                  ACE_ENV_ARG_PARAMETER
                );
            TAO_INTERCEPTOR_CHECK;
#if (TAO_HAS_INTERCEPTORS == 1)
          }
      }
      
      if (!_tao_vfr.location_forwarded ())
        {
          RtecScheduler::handle_t _tao_retval_info = _tao_retval;
          _tao_ri.result (_tao_retval_info);
          _tao_ri.reply_status (PortableInterceptor::SUCCESSFUL);
          _tao_vfr.send_reply (&_tao_ri ACE_ENV_ARG_PARAMETER);
          ACE_TRY_CHECK;
        }
    }
  ACE_CATCHANY
    {
      _tao_ri.exception (&ACE_ANY_EXCEPTION);
      _tao_vfr.send_exception (
          &_tao_ri
          ACE_ENV_ARG_PARAMETER
        );
      ACE_TRY_CHECK;
      
      PortableInterceptor::ReplyStatus _tao_status =
        _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_TRY_CHECK;
      
      if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION
          || _tao_status == PortableInterceptor::USER_EXCEPTION)
        {
          ACE_RE_THROW;
        }
    }
  
# if defined (ACE_HAS_EXCEPTIONS) \
  && defined (ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS)
  ACE_CATCHALL
    {
      CORBA::UNKNOWN ex;
      
      _tao_ri.exception (&ex);
      _tao_vfr.send_exception (
          &_tao_ri
          ACE_ENV_ARG_PARAMETER
        );
      ACE_TRY_CHECK;
      
      PortableInterceptor::ReplyStatus _tao_status =
        _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_TRY_CHECK;
      
      if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION)
        ACE_TRY_THROW (ex);
    }
# endif  /* ACE_HAS_EXCEPTIONS && ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS */
  ACE_ENDTRY;
  ACE_CHECK;
#endif /* TAO_HAS_INTERCEPTORS */
  
  _tao_server_request.init_reply ();
#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)
          ))
        {
          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_RtecScheduler::Scheduler::lookup_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_RtecScheduler::Scheduler *_tao_impl =
    static_cast<
        POA_RtecScheduler::Scheduler *> (
        _tao_servant
      );
  RtecScheduler::handle_t _tao_retval = 0;
  ::CORBA::String_var entry_point;
  
  if (!(
      (_tao_in >> entry_point.out ())
      ))
    {
      TAO_InputCDR::throw_skel_exception (errno ACE_ENV_ARG_PARAMETER);
      ACE_CHECK;
    }
  
#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_Object_Adapter::Servant_Upcall *_tao_upcall =
    static_cast<
        TAO_Object_Adapter::Servant_Upcall *> (
        _tao_servant_upcall
      );
    
  TAO_ServerRequestInterceptor_Adapter _tao_vfr (
      _tao_server_request.orb_core ()->server_request_interceptors (),
      _tao_server_request.interceptor_count ()
    );
  
  TAO_ServerRequestInfo_RtecScheduler_Scheduler_lookup _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl,
      
      entry_point.in ()
      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* Copy TSC to RSC */);
        
        _tao_vfr.receive_request (&_tao_ri ACE_ENV_ARG_PARAMETER);
        ACE_TRY_CHECK;
        
        if (!_tao_vfr.location_forwarded ())
          {
#endif /* TAO_HAS_INTERCEPTORS */
            _tao_retval = 
              _tao_impl->lookup (
                  entry_point.in ()
                  ACE_ENV_ARG_PARAMETER
                );
            TAO_INTERCEPTOR_CHECK;
#if (TAO_HAS_INTERCEPTORS == 1)
          }
      }
      
      if (!_tao_vfr.location_forwarded ())
        {
          RtecScheduler::handle_t _tao_retval_info = _tao_retval;
          _tao_ri.result (_tao_retval_info);
          _tao_ri.reply_status (PortableInterceptor::SUCCESSFUL);
          _tao_vfr.send_reply (&_tao_ri ACE_ENV_ARG_PARAMETER);
          ACE_TRY_CHECK;
        }
    }
  ACE_CATCHANY
    {
      _tao_ri.exception (&ACE_ANY_EXCEPTION);
      _tao_vfr.send_exception (
          &_tao_ri
          ACE_ENV_ARG_PARAMETER
        );
      ACE_TRY_CHECK;
      
      PortableInterceptor::ReplyStatus _tao_status =
        _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_TRY_CHECK;
      
      if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION
          || _tao_status == PortableInterceptor::USER_EXCEPTION)
        {
          ACE_RE_THROW;
        }
    }
  
# if defined (ACE_HAS_EXCEPTIONS) \
  && defined (ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS)
  ACE_CATCHALL
    {
      CORBA::UNKNOWN ex;
      
      _tao_ri.exception (&ex);
      _tao_vfr.send_exception (
          &_tao_ri
          ACE_ENV_ARG_PARAMETER
        );
      ACE_TRY_CHECK;
      
      PortableInterceptor::ReplyStatus _tao_status =
        _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_TRY_CHECK;
      
      if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION)
        ACE_TRY_THROW (ex);
    }
# endif  /* ACE_HAS_EXCEPTIONS && ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS */
  ACE_ENDTRY;
  ACE_CHECK;
#endif /* TAO_HAS_INTERCEPTORS */
  
  _tao_server_request.init_reply ();
#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)
          ))
        {
          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_RtecScheduler::Scheduler::get_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_RtecScheduler::Scheduler *_tao_impl =
    static_cast<
        POA_RtecScheduler::Scheduler *> (
        _tao_servant
      );
  ::RtecScheduler::RT_Info_var _tao_retval;
  ::RtecScheduler::handle_t handle;
  
  if (!(
      (_tao_in >> handle)
      ))
    {
      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_RtecScheduler_Scheduler_get _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl,
      
      handle
      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* Copy TSC to RSC */);
        
        _tao_vfr.receive_request (&_tao_ri ACE_ENV_ARG_PARAMETER);
        ACE_TRY_CHECK;
        
        if (!_tao_vfr.location_forwarded ())
          {
#endif /* TAO_HAS_INTERCEPTORS */
            _tao_retval = 
              _tao_impl->get (
                  handle
                  ACE_ENV_ARG_PARAMETER
                );
            TAO_INTERCEPTOR_CHECK;
#if (TAO_HAS_INTERCEPTORS == 1)
          }
      }
      
      if (!_tao_vfr.location_forwarded ())
        {
          ::RtecScheduler::RT_Info * _tao_retval_info = _tao_retval._retn ();
          _tao_ri.result (_tao_retval_info);
          _tao_retval = _tao_retval_info;
          _tao_ri.reply_status (PortableInterceptor::SUCCESSFUL);
          _tao_vfr.send_reply (&_tao_ri ACE_ENV_ARG_PARAMETER);
          ACE_TRY_CHECK;
        }
    }
  ACE_CATCHANY
    {
      _tao_ri.exception (&ACE_ANY_EXCEPTION);
      _tao_vfr.send_exception (
          &_tao_ri
          ACE_ENV_ARG_PARAMETER
        );
      ACE_TRY_CHECK;
      
      PortableInterceptor::ReplyStatus _tao_status =
        _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_TRY_CHECK;
      
      if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION
          || _tao_status == PortableInterceptor::USER_EXCEPTION)
        {
          ACE_RE_THROW;
        }
    }
  
# if defined (ACE_HAS_EXCEPTIONS) \
  && defined (ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS)
  ACE_CATCHALL
    {
      CORBA::UNKNOWN ex;
      
      _tao_ri.exception (&ex);
      _tao_vfr.send_exception (
          &_tao_ri
          ACE_ENV_ARG_PARAMETER
        );
      ACE_TRY_CHECK;
      
      PortableInterceptor::ReplyStatus _tao_status =
        _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_TRY_CHECK;
      
      if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION)
        ACE_TRY_THROW (ex);
    }
# endif  /* ACE_HAS_EXCEPTIONS && ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS */
  ACE_ENDTRY;
  ACE_CHECK;
#endif /* TAO_HAS_INTERCEPTORS */
  
  _tao_server_request.init_reply ();
#if (TAO_HAS_INTERCEPTORS == 1)
  if (!_tao_vfr.location_forwarded ())
    {
#endif /* TAO_HAS_INTERCEPTORS */
      TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
      
      if (!(
          (_tao_out << _tao_retval.in ())
          ))
        {
          TAO_OutputCDR::throw_skel_exception (errno ACE_ENV_ARG_PARAMETER);
          ACE_CHECK;
        }
#if (TAO_HAS_INTERCEPTORS == 1)
    }
#endif /* TAO_HAS_INTERCEPTORS */
  
  
  // In case _tao_servant_upcall is not used in this function
  ACE_UNUSED_ARG (_tao_servant_upcall);
}

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

void POA_RtecScheduler::Scheduler::set_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_RtecScheduler::Scheduler *_tao_impl =
    static_cast<
        POA_RtecScheduler::Scheduler *> (
        _tao_servant
      );
  _tao_server_request.argument_flag (0);
  
  ::RtecScheduler::handle_t handle;
  ::RtecScheduler::Criticality_t criticality;
  ::RtecScheduler::Time wc_time;
  ::RtecScheduler::Time typical_time;
  ::RtecScheduler::Time cached_time;
  ::RtecScheduler::Period_t period;
  ::RtecScheduler::Importance_t importance;
  ::RtecScheduler::Quantum_t quantum;
  ::RtecScheduler::Threads_t threads;
  ::RtecScheduler::Info_Type_t info_type;
  
  if (!(
      (_tao_in >> handle) &&
      (_tao_in >> criticality) &&
      (_tao_in >> wc_time) &&
      (_tao_in >> typical_time) &&
      (_tao_in >> cached_time) &&
      (_tao_in >> period) &&
      (_tao_in >> importance) &&
      (_tao_in >> quantum) &&
      (_tao_in >> threads) &&
      (_tao_in >> info_type)
      ))
    {
      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_RtecScheduler_Scheduler_set _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl,
      
      handle,
      
      criticality,
      
      wc_time,
      
      typical_time,
      
      cached_time,
      
      period,
      
      importance,
      
      quantum,
      
      threads,
      
      info_type
      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* Copy TSC to RSC */);
        
        _tao_vfr.receive_request (&_tao_ri ACE_ENV_ARG_PARAMETER);
        ACE_TRY_CHECK;
        
        if (!_tao_vfr.location_forwarded ())
          {
#endif /* TAO_HAS_INTERCEPTORS */
            
              _tao_impl->set (
                  handle,
                  
                  criticality,
                  
                  wc_time,
                  
                  typical_time,
                  
                  cached_time,
                  
                  period,
                  
                  importance,
                  
                  quantum,
                  
                  threads,
                  
                  info_type
                  ACE_ENV_ARG_PARAMETER
                );
            TAO_INTERCEPTOR_CHECK;
#if (TAO_HAS_INTERCEPTORS == 1)
          }
      }
      
      if (!_tao_vfr.location_forwarded ())
        {
          _tao_ri.reply_status (PortableInterceptor::SUCCESSFUL);
          _tao_vfr.send_reply (&_tao_ri ACE_ENV_ARG_PARAMETER);
          ACE_TRY_CHECK;
        }
    }
  ACE_CATCHANY
    {
      _tao_ri.exception (&ACE_ANY_EXCEPTION);
      _tao_vfr.send_exception (
          &_tao_ri
          ACE_ENV_ARG_PARAMETER
        );
      ACE_TRY_CHECK;
      
      PortableInterceptor::ReplyStatus _tao_status =
        _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_TRY_CHECK;
      
      if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION
          || _tao_status == PortableInterceptor::USER_EXCEPTION)
        {
          ACE_RE_THROW;
        }
    }
  
# if defined (ACE_HAS_EXCEPTIONS) \
  && defined (ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS)
  ACE_CATCHALL
    {
      CORBA::UNKNOWN ex;
      
      _tao_ri.exception (&ex);
      _tao_vfr.send_exception (
          &_tao_ri
          ACE_ENV_ARG_PARAMETER
        );
      ACE_TRY_CHECK;
      
      PortableInterceptor::ReplyStatus _tao_status =
        _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_TRY_CHECK;
      
      if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION)
        ACE_TRY_THROW (ex);
    }
# endif  /* ACE_HAS_EXCEPTIONS && ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS */
  ACE_ENDTRY;
  ACE_CHECK;
#endif /* TAO_HAS_INTERCEPTORS */
  
  _tao_server_request.init_reply ();
  
  // In case _tao_servant_upcall is not used in this function
  ACE_UNUSED_ARG (_tao_servant_upcall);
}

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

void POA_RtecScheduler::Scheduler::reset_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_RtecScheduler::Scheduler *_tao_impl =
    static_cast<
        POA_RtecScheduler::Scheduler *> (
        _tao_servant
      );
  _tao_server_request.argument_flag (0);
  
  ::RtecScheduler::handle_t handle;
  ::RtecScheduler::Criticality_t criticality;
  ::RtecScheduler::Time wc_time;
  ::RtecScheduler::Time typical_time;
  ::RtecScheduler::Time cached_time;
  ::RtecScheduler::Period_t period;
  ::RtecScheduler::Importance_t importance;
  ::RtecScheduler::Quantum_t quantum;
  ::RtecScheduler::Threads_t threads;
  ::RtecScheduler::Info_Type_t info_type;
  
  if (!(
      (_tao_in >> handle) &&
      (_tao_in >> criticality) &&
      (_tao_in >> wc_time) &&
      (_tao_in >> typical_time) &&
      (_tao_in >> cached_time) &&
      (_tao_in >> period) &&
      (_tao_in >> importance) &&
      (_tao_in >> quantum) &&
      (_tao_in >> threads) &&
      (_tao_in >> info_type)
      ))
    {
      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_RtecScheduler_Scheduler_reset _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl,
      
      handle,
      
      criticality,
      
      wc_time,
      
      typical_time,
      
      cached_time,
      
      period,
      
      importance,
      
      quantum,
      
      threads,
      
      info_type
      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* Copy TSC to RSC */);
        
        _tao_vfr.receive_request (&_tao_ri ACE_ENV_ARG_PARAMETER);
        ACE_TRY_CHECK;
        
        if (!_tao_vfr.location_forwarded ())
          {
#endif /* TAO_HAS_INTERCEPTORS */
            
              _tao_impl->reset (
                  handle,
                  
                  criticality,
                  
                  wc_time,
                  
                  typical_time,
                  
                  cached_time,
                  
                  period,
                  
                  importance,
                  
                  quantum,
                  
                  threads,
                  
                  info_type
                  ACE_ENV_ARG_PARAMETER
                );
            TAO_INTERCEPTOR_CHECK;
#if (TAO_HAS_INTERCEPTORS == 1)
          }
      }
      
      if (!_tao_vfr.location_forwarded ())
        {
          _tao_ri.reply_status (PortableInterceptor::SUCCESSFUL);
          _tao_vfr.send_reply (&_tao_ri ACE_ENV_ARG_PARAMETER);
          ACE_TRY_CHECK;
        }
    }
  ACE_CATCHANY
    {
      _tao_ri.exception (&ACE_ANY_EXCEPTION);
      _tao_vfr.send_exception (
          &_tao_ri
          ACE_ENV_ARG_PARAMETER
        );
      ACE_TRY_CHECK;
      
      PortableInterceptor::ReplyStatus _tao_status =
        _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_TRY_CHECK;
      
      if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION
          || _tao_status == PortableInterceptor::USER_EXCEPTION)
        {
          ACE_RE_THROW;
        }
    }
  
# if defined (ACE_HAS_EXCEPTIONS) \
  && defined (ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS)
  ACE_CATCHALL
    {
      CORBA::UNKNOWN ex;
      
      _tao_ri.exception (&ex);
      _tao_vfr.send_exception (
          &_tao_ri
          ACE_ENV_ARG_PARAMETER
        );
      ACE_TRY_CHECK;
      
      PortableInterceptor::ReplyStatus _tao_status =
        _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_TRY_CHECK;
      
      if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION)
        ACE_TRY_THROW (ex);
    }
# endif  /* ACE_HAS_EXCEPTIONS && ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS */
  ACE_ENDTRY;
  ACE_CHECK;
#endif /* TAO_HAS_INTERCEPTORS */
  
  _tao_server_request.init_reply ();
  
  // In case _tao_servant_upcall is not used in this function
  ACE_UNUSED_ARG (_tao_servant_upcall);
}

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

void POA_RtecScheduler::Scheduler::set_seq_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_RtecScheduler::Scheduler *_tao_impl =
    static_cast<
        POA_RtecScheduler::Scheduler *> (
        _tao_servant
      );
  _tao_server_request.argument_flag (0);
  
  ::RtecScheduler::RT_Info_Set infos;
  
  if (!(
      (_tao_in >> infos)
      ))
    {
      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_RtecScheduler_Scheduler_set_seq _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl,
      
      infos
      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* Copy TSC to RSC */);
        
        _tao_vfr.receive_request (&_tao_ri ACE_ENV_ARG_PARAMETER);
        ACE_TRY_CHECK;
        
        if (!_tao_vfr.location_forwarded ())
          {
#endif /* TAO_HAS_INTERCEPTORS */
            
              _tao_impl->set_seq (
                  infos
                  ACE_ENV_ARG_PARAMETER
                );
            TAO_INTERCEPTOR_CHECK;
#if (TAO_HAS_INTERCEPTORS == 1)
          }
      }
      
      if (!_tao_vfr.location_forwarded ())
        {
          _tao_ri.reply_status (PortableInterceptor::SUCCESSFUL);
          _tao_vfr.send_reply (&_tao_ri ACE_ENV_ARG_PARAMETER);
          ACE_TRY_CHECK;
        }
    }
  ACE_CATCHANY
    {
      _tao_ri.exception (&ACE_ANY_EXCEPTION);
      _tao_vfr.send_exception (
          &_tao_ri
          ACE_ENV_ARG_PARAMETER
        );
      ACE_TRY_CHECK;
      
      PortableInterceptor::ReplyStatus _tao_status =
        _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_TRY_CHECK;
      
      if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION
          || _tao_status == PortableInterceptor::USER_EXCEPTION)
        {
          ACE_RE_THROW;
        }
    }
  
# if defined (ACE_HAS_EXCEPTIONS) \
  && defined (ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS)
  ACE_CATCHALL
    {
      CORBA::UNKNOWN ex;
      
      _tao_ri.exception (&ex);
      _tao_vfr.send_exception (
          &_tao_ri
          ACE_ENV_ARG_PARAMETER
        );
      ACE_TRY_CHECK;
      
      PortableInterceptor::ReplyStatus _tao_status =
        _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_TRY_CHECK;
      
      if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION)
        ACE_TRY_THROW (ex);
    }
# endif  /* ACE_HAS_EXCEPTIONS && ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS */
  ACE_ENDTRY;
  ACE_CHECK;
#endif /* TAO_HAS_INTERCEPTORS */
  
  _tao_server_request.init_reply ();
  
  // In case _tao_servant_upcall is not used in this function
  ACE_UNUSED_ARG (_tao_servant_upcall);
}

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

void POA_RtecScheduler::Scheduler::reset_seq_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_RtecScheduler::Scheduler *_tao_impl =
    static_cast<
        POA_RtecScheduler::Scheduler *> (
        _tao_servant
      );
  _tao_server_request.argument_flag (0);
  
  ::RtecScheduler::RT_Info_Set infos;
  
  if (!(
      (_tao_in >> infos)
      ))
    {
      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_RtecScheduler_Scheduler_reset_seq _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl,
      
      infos
      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* Copy TSC to RSC */);
        
        _tao_vfr.receive_request (&_tao_ri ACE_ENV_ARG_PARAMETER);
        ACE_TRY_CHECK;
        
        if (!_tao_vfr.location_forwarded ())
          {
#endif /* TAO_HAS_INTERCEPTORS */
            
              _tao_impl->reset_seq (
                  infos
                  ACE_ENV_ARG_PARAMETER
                );
            TAO_INTERCEPTOR_CHECK;
#if (TAO_HAS_INTERCEPTORS == 1)
          }
      }
      
      if (!_tao_vfr.location_forwarded ())
        {
          _tao_ri.reply_status (PortableInterceptor::SUCCESSFUL);
          _tao_vfr.send_reply (&_tao_ri ACE_ENV_ARG_PARAMETER);
          ACE_TRY_CHECK;
        }
    }
  ACE_CATCHANY
    {
      _tao_ri.exception (&ACE_ANY_EXCEPTION);
      _tao_vfr.send_exception (
          &_tao_ri
          ACE_ENV_ARG_PARAMETER
        );
      ACE_TRY_CHECK;
      
      PortableInterceptor::ReplyStatus _tao_status =
        _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_TRY_CHECK;
      
      if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION
          || _tao_status == PortableInterceptor::USER_EXCEPTION)
        {
          ACE_RE_THROW;
        }
    }
  
# if defined (ACE_HAS_EXCEPTIONS) \
  && defined (ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS)
  ACE_CATCHALL
    {
      CORBA::UNKNOWN ex;
      
      _tao_ri.exception (&ex);
      _tao_vfr.send_exception (
          &_tao_ri
          ACE_ENV_ARG_PARAMETER
        );
      ACE_TRY_CHECK;
      
      PortableInterceptor::ReplyStatus _tao_status =
        _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_TRY_CHECK;
      
      if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION)
        ACE_TRY_THROW (ex);
    }
# endif  /* ACE_HAS_EXCEPTIONS && ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS */
  ACE_ENDTRY;
  ACE_CHECK;
#endif /* TAO_HAS_INTERCEPTORS */
  
  _tao_server_request.init_reply ();
  
  // In case _tao_servant_upcall is not used in this function
  ACE_UNUSED_ARG (_tao_servant_upcall);
}

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

void POA_RtecScheduler::Scheduler::replace_seq_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_RtecScheduler::Scheduler *_tao_impl =
    static_cast<
        POA_RtecScheduler::Scheduler *> (
        _tao_servant
      );
  _tao_server_request.argument_flag (0);
  
  ::RtecScheduler::RT_Info_Set infos;
  
  if (!(
      (_tao_in >> infos)
      ))
    {
      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_RtecScheduler_Scheduler_replace_seq _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl,
      
      infos
      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* Copy TSC to RSC */);
        
        _tao_vfr.receive_request (&_tao_ri ACE_ENV_ARG_PARAMETER);
        ACE_TRY_CHECK;
        
        if (!_tao_vfr.location_forwarded ())
          {
#endif /* TAO_HAS_INTERCEPTORS */
            
              _tao_impl->replace_seq (
                  infos
                  ACE_ENV_ARG_PARAMETER
                );
            TAO_INTERCEPTOR_CHECK;
#if (TAO_HAS_INTERCEPTORS == 1)
          }
      }
      
      if (!_tao_vfr.location_forwarded ())
        {
          _tao_ri.reply_status (PortableInterceptor::SUCCESSFUL);
          _tao_vfr.send_reply (&_tao_ri ACE_ENV_ARG_PARAMETER);
          ACE_TRY_CHECK;
        }
    }
  ACE_CATCHANY
    {
      _tao_ri.exception (&ACE_ANY_EXCEPTION);
      _tao_vfr.send_exception (
          &_tao_ri
          ACE_ENV_ARG_PARAMETER
        );
      ACE_TRY_CHECK;
      
      PortableInterceptor::ReplyStatus _tao_status =
        _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_TRY_CHECK;
      
      if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION
          || _tao_status == PortableInterceptor::USER_EXCEPTION)
        {
          ACE_RE_THROW;
        }
    }
  
# if defined (ACE_HAS_EXCEPTIONS) \
  && defined (ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS)
  ACE_CATCHALL
    {
      CORBA::UNKNOWN ex;
      
      _tao_ri.exception (&ex);
      _tao_vfr.send_exception (
          &_tao_ri
          ACE_ENV_ARG_PARAMETER
        );
      ACE_TRY_CHECK;
      
      PortableInterceptor::ReplyStatus _tao_status =
        _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_TRY_CHECK;
      
      if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION)
        ACE_TRY_THROW (ex);
    }
# endif  /* ACE_HAS_EXCEPTIONS && ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS */
  ACE_ENDTRY;
  ACE_CHECK;
#endif /* TAO_HAS_INTERCEPTORS */
  
  _tao_server_request.init_reply ();
  
  // In case _tao_servant_upcall is not used in this function
  ACE_UNUSED_ARG (_tao_servant_upcall);
}

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

void POA_RtecScheduler::Scheduler::add_dependency_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_RtecScheduler::Scheduler *_tao_impl =
    static_cast<
        POA_RtecScheduler::Scheduler *> (
        _tao_servant
      );
  _tao_server_request.argument_flag (0);
  
  ::RtecScheduler::handle_t handle;
  ::RtecScheduler::handle_t dependency;
  ::CORBA::Long number_of_calls;
  ::RtecScheduler::Dependency_Type_t dependency_type;
  
  if (!(
      (_tao_in >> handle) &&
      (_tao_in >> dependency) &&
      (_tao_in >> number_of_calls) &&
      (_tao_in >> dependency_type)
      ))
    {
      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_RtecScheduler_Scheduler_add_dependency _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl,
      
      handle,
      
      dependency,
      
      number_of_calls,
      
      dependency_type
      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* Copy TSC to RSC */);
        
        _tao_vfr.receive_request (&_tao_ri ACE_ENV_ARG_PARAMETER);
        ACE_TRY_CHECK;
        
        if (!_tao_vfr.location_forwarded ())
          {
#endif /* TAO_HAS_INTERCEPTORS */
            
              _tao_impl->add_dependency (
                  handle,
                  
                  dependency,
                  
                  number_of_calls,
                  
                  dependency_type
                  ACE_ENV_ARG_PARAMETER
                );
            TAO_INTERCEPTOR_CHECK;
#if (TAO_HAS_INTERCEPTORS == 1)
          }
      }
      
      if (!_tao_vfr.location_forwarded ())
        {
          _tao_ri.reply_status (PortableInterceptor::SUCCESSFUL);
          _tao_vfr.send_reply (&_tao_ri ACE_ENV_ARG_PARAMETER);
          ACE_TRY_CHECK;
        }
    }
  ACE_CATCHANY
    {
      _tao_ri.exception (&ACE_ANY_EXCEPTION);
      _tao_vfr.send_exception (
          &_tao_ri
          ACE_ENV_ARG_PARAMETER
        );
      ACE_TRY_CHECK;
      
      PortableInterceptor::ReplyStatus _tao_status =
        _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_TRY_CHECK;
      
      if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION
          || _tao_status == PortableInterceptor::USER_EXCEPTION)
        {
          ACE_RE_THROW;
        }
    }
  
# if defined (ACE_HAS_EXCEPTIONS) \
  && defined (ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS)
  ACE_CATCHALL
    {
      CORBA::UNKNOWN ex;
      
      _tao_ri.exception (&ex);
      _tao_vfr.send_exception (
          &_tao_ri
          ACE_ENV_ARG_PARAMETER
        );
      ACE_TRY_CHECK;
      
      PortableInterceptor::ReplyStatus _tao_status =
        _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_TRY_CHECK;
      
      if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION)
        ACE_TRY_THROW (ex);
    }
# endif  /* ACE_HAS_EXCEPTIONS && ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS */
  ACE_ENDTRY;
  ACE_CHECK;
#endif /* TAO_HAS_INTERCEPTORS */
  
  _tao_server_request.init_reply ();
  
  // In case _tao_servant_upcall is not used in this function
  ACE_UNUSED_ARG (_tao_servant_upcall);
}

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

void POA_RtecScheduler::Scheduler::remove_dependency_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_RtecScheduler::Scheduler *_tao_impl =
    static_cast<
        POA_RtecScheduler::Scheduler *> (
        _tao_servant
      );
  _tao_server_request.argument_flag (0);
  
  ::RtecScheduler::handle_t handle;
  ::RtecScheduler::handle_t dependency;
  ::CORBA::Long number_of_calls;
  ::RtecScheduler::Dependency_Type_t dependency_type;
  
  if (!(
      (_tao_in >> handle) &&
      (_tao_in >> dependency) &&
      (_tao_in >> number_of_calls) &&
      (_tao_in >> dependency_type)
      ))
    {
      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_RtecScheduler_Scheduler_remove_dependency _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl,
      
      handle,
      
      dependency,
      
      number_of_calls,
      
      dependency_type
      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* Copy TSC to RSC */);
        
        _tao_vfr.receive_request (&_tao_ri ACE_ENV_ARG_PARAMETER);
        ACE_TRY_CHECK;
        
        if (!_tao_vfr.location_forwarded ())
          {
#endif /* TAO_HAS_INTERCEPTORS */
            
              _tao_impl->remove_dependency (
                  handle,
                  
                  dependency,
                  
                  number_of_calls,
                  
                  dependency_type
                  ACE_ENV_ARG_PARAMETER
                );
            TAO_INTERCEPTOR_CHECK;
#if (TAO_HAS_INTERCEPTORS == 1)
          }
      }
      
      if (!_tao_vfr.location_forwarded ())
        {
          _tao_ri.reply_status (PortableInterceptor::SUCCESSFUL);
          _tao_vfr.send_reply (&_tao_ri ACE_ENV_ARG_PARAMETER);
          ACE_TRY_CHECK;
        }
    }
  ACE_CATCHANY
    {
      _tao_ri.exception (&ACE_ANY_EXCEPTION);
      _tao_vfr.send_exception (
          &_tao_ri
          ACE_ENV_ARG_PARAMETER
        );
      ACE_TRY_CHECK;
      
      PortableInterceptor::ReplyStatus _tao_status =
        _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_TRY_CHECK;
      
      if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION
          || _tao_status == PortableInterceptor::USER_EXCEPTION)
        {
          ACE_RE_THROW;
        }
    }
  
# if defined (ACE_HAS_EXCEPTIONS) \
  && defined (ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS)
  ACE_CATCHALL
    {
      CORBA::UNKNOWN ex;
      
      _tao_ri.exception (&ex);
      _tao_vfr.send_exception (
          &_tao_ri
          ACE_ENV_ARG_PARAMETER
        );
      ACE_TRY_CHECK;
      
      PortableInterceptor::ReplyStatus _tao_status =
        _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_TRY_CHECK;
      
      if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION)
        ACE_TRY_THROW (ex);
    }
# endif  /* ACE_HAS_EXCEPTIONS && ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS */
  ACE_ENDTRY;
  ACE_CHECK;
#endif /* TAO_HAS_INTERCEPTORS */
  
  _tao_server_request.init_reply ();
  
  // In case _tao_servant_upcall is not used in this function
  ACE_UNUSED_ARG (_tao_servant_upcall);
}

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

void POA_RtecScheduler::Scheduler::set_dependency_enable_state_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_RtecScheduler::Scheduler *_tao_impl =
    static_cast<
        POA_RtecScheduler::Scheduler *> (
        _tao_servant
      );
  _tao_server_request.argument_flag (0);
  
  ::RtecScheduler::handle_t handle;
  ::RtecScheduler::handle_t dependency;
  ::CORBA::Long number_of_calls;
  ::RtecScheduler::Dependency_Type_t dependency_type;
  ::RtecScheduler::Dependency_Enabled_Type_t enabled;
  
  if (!(
      (_tao_in >> handle) &&
      (_tao_in >> dependency) &&
      (_tao_in >> number_of_calls) &&
      (_tao_in >> dependency_type) &&
      (_tao_in >> enabled)
      ))
    {
      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_RtecScheduler_Scheduler_set_dependency_enable_state _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl,
      
      handle,
      
      dependency,
      
      number_of_calls,
      
      dependency_type,
      
      enabled
      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* Copy TSC to RSC */);
        
        _tao_vfr.receive_request (&_tao_ri ACE_ENV_ARG_PARAMETER);
        ACE_TRY_CHECK;
        
        if (!_tao_vfr.location_forwarded ())
          {
#endif /* TAO_HAS_INTERCEPTORS */
            
              _tao_impl->set_dependency_enable_state (
                  handle,
                  
                  dependency,
                  
                  number_of_calls,
                  
                  dependency_type,
                  
                  enabled
                  ACE_ENV_ARG_PARAMETER
                );
            TAO_INTERCEPTOR_CHECK;
#if (TAO_HAS_INTERCEPTORS == 1)
          }
      }
      
      if (!_tao_vfr.location_forwarded ())
        {
          _tao_ri.reply_status (PortableInterceptor::SUCCESSFUL);
          _tao_vfr.send_reply (&_tao_ri ACE_ENV_ARG_PARAMETER);
          ACE_TRY_CHECK;
        }
    }
  ACE_CATCHANY
    {
      _tao_ri.exception (&ACE_ANY_EXCEPTION);
      _tao_vfr.send_exception (
          &_tao_ri
          ACE_ENV_ARG_PARAMETER
        );
      ACE_TRY_CHECK;
      
      PortableInterceptor::ReplyStatus _tao_status =
        _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_TRY_CHECK;
      
      if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION
          || _tao_status == PortableInterceptor::USER_EXCEPTION)
        {
          ACE_RE_THROW;
        }
    }
  
# if defined (ACE_HAS_EXCEPTIONS) \
  && defined (ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS)
  ACE_CATCHALL
    {
      CORBA::UNKNOWN ex;
      
      _tao_ri.exception (&ex);
      _tao_vfr.send_exception (
          &_tao_ri
          ACE_ENV_ARG_PARAMETER
        );
      ACE_TRY_CHECK;
      
      PortableInterceptor::ReplyStatus _tao_status =
        _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_TRY_CHECK;
      
      if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION)
        ACE_TRY_THROW (ex);
    }
# endif  /* ACE_HAS_EXCEPTIONS && ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS */
  ACE_ENDTRY;
  ACE_CHECK;
#endif /* TAO_HAS_INTERCEPTORS */
  
  _tao_server_request.init_reply ();
  
  // In case _tao_servant_upcall is not used in this function
  ACE_UNUSED_ARG (_tao_servant_upcall);
}

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

void POA_RtecScheduler::Scheduler::set_dependency_enable_state_seq_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_RtecScheduler::Scheduler *_tao_impl =
    static_cast<
        POA_RtecScheduler::Scheduler *> (
        _tao_servant
      );
  _tao_server_request.argument_flag (0);
  
  ::RtecScheduler::Dependency_Set dependencies;
  
  if (!(
      (_tao_in >> dependencies)
      ))
    {
      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_RtecScheduler_Scheduler_set_dependency_enable_state_seq _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl,
      
      dependencies
      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* Copy TSC to RSC */);
        
        _tao_vfr.receive_request (&_tao_ri ACE_ENV_ARG_PARAMETER);
        ACE_TRY_CHECK;
        
        if (!_tao_vfr.location_forwarded ())
          {
#endif /* TAO_HAS_INTERCEPTORS */
            
              _tao_impl->set_dependency_enable_state_seq (
                  dependencies
                  ACE_ENV_ARG_PARAMETER
                );
            TAO_INTERCEPTOR_CHECK;
#if (TAO_HAS_INTERCEPTORS == 1)
          }
      }
      
      if (!_tao_vfr.location_forwarded ())
        {
          _tao_ri.reply_status (PortableInterceptor::SUCCESSFUL);
          _tao_vfr.send_reply (&_tao_ri ACE_ENV_ARG_PARAMETER);
          ACE_TRY_CHECK;
        }
    }
  ACE_CATCHANY
    {
      _tao_ri.exception (&ACE_ANY_EXCEPTION);
      _tao_vfr.send_exception (
          &_tao_ri
          ACE_ENV_ARG_PARAMETER
        );
      ACE_TRY_CHECK;
      
      PortableInterceptor::ReplyStatus _tao_status =
        _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_TRY_CHECK;
      
      if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION
          || _tao_status == PortableInterceptor::USER_EXCEPTION)
        {
          ACE_RE_THROW;
        }
    }
  
# if defined (ACE_HAS_EXCEPTIONS) \
  && defined (ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS)
  ACE_CATCHALL
    {
      CORBA::UNKNOWN ex;
      
      _tao_ri.exception (&ex);
      _tao_vfr.send_exception (
          &_tao_ri
          ACE_ENV_ARG_PARAMETER
        );
      ACE_TRY_CHECK;
      
      PortableInterceptor::ReplyStatus _tao_status =
        _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_TRY_CHECK;
      
      if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION)
        ACE_TRY_THROW (ex);
    }
# endif  /* ACE_HAS_EXCEPTIONS && ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS */
  ACE_ENDTRY;
  ACE_CHECK;
#endif /* TAO_HAS_INTERCEPTORS */
  
  _tao_server_request.init_reply ();
  
  // In case _tao_servant_upcall is not used in this function
  ACE_UNUSED_ARG (_tao_servant_upcall);
}

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

void POA_RtecScheduler::Scheduler::set_rt_info_enable_state_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_RtecScheduler::Scheduler *_tao_impl =
    static_cast<
        POA_RtecScheduler::Scheduler *> (
        _tao_servant
      );
  _tao_server_request.argument_flag (0);
  
  ::RtecScheduler::handle_t handle;
  ::RtecScheduler::RT_Info_Enabled_Type_t enabled;
  
  if (!(
      (_tao_in >> handle) &&
      (_tao_in >> enabled)
      ))
    {
      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_RtecScheduler_Scheduler_set_rt_info_enable_state _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl,
      
      handle,
      
      enabled
      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* Copy TSC to RSC */);
        
        _tao_vfr.receive_request (&_tao_ri ACE_ENV_ARG_PARAMETER);
        ACE_TRY_CHECK;
        
        if (!_tao_vfr.location_forwarded ())
          {
#endif /* TAO_HAS_INTERCEPTORS */
            
              _tao_impl->set_rt_info_enable_state (
                  handle,
                  
                  enabled
                  ACE_ENV_ARG_PARAMETER
                );
            TAO_INTERCEPTOR_CHECK;
#if (TAO_HAS_INTERCEPTORS == 1)
          }
      }
      
      if (!_tao_vfr.location_forwarded ())
        {
          _tao_ri.reply_status (PortableInterceptor::SUCCESSFUL);
          _tao_vfr.send_reply (&_tao_ri ACE_ENV_ARG_PARAMETER);
          ACE_TRY_CHECK;
        }
    }
  ACE_CATCHANY
    {
      _tao_ri.exception (&ACE_ANY_EXCEPTION);
      _tao_vfr.send_exception (
          &_tao_ri
          ACE_ENV_ARG_PARAMETER
        );
      ACE_TRY_CHECK;
      
      PortableInterceptor::ReplyStatus _tao_status =
        _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_TRY_CHECK;
      
      if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION
          || _tao_status == PortableInterceptor::USER_EXCEPTION)
        {
          ACE_RE_THROW;
        }
    }
  
# if defined (ACE_HAS_EXCEPTIONS) \
  && defined (ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS)
  ACE_CATCHALL
    {
      CORBA::UNKNOWN ex;
      
      _tao_ri.exception (&ex);
      _tao_vfr.send_exception (
          &_tao_ri
          ACE_ENV_ARG_PARAMETER
        );
      ACE_TRY_CHECK;
      
      PortableInterceptor::ReplyStatus _tao_status =
        _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_TRY_CHECK;
      
      if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION)
        ACE_TRY_THROW (ex);
    }
# endif  /* ACE_HAS_EXCEPTIONS && ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS */
  ACE_ENDTRY;
  ACE_CHECK;
#endif /* TAO_HAS_INTERCEPTORS */
  
  _tao_server_request.init_reply ();
  
  // In case _tao_servant_upcall is not used in this function
  ACE_UNUSED_ARG (_tao_servant_upcall);
}

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

void POA_RtecScheduler::Scheduler::set_rt_info_enable_state_seq_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_RtecScheduler::Scheduler *_tao_impl =
    static_cast<
        POA_RtecScheduler::Scheduler *> (
        _tao_servant
      );
  _tao_server_request.argument_flag (0);
  
  ::RtecScheduler::RT_Info_Enable_State_Pair_Set pair_set;
  
  if (!(
      (_tao_in >> pair_set)
      ))
    {
      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_RtecScheduler_Scheduler_set_rt_info_enable_state_seq _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl,
      
      pair_set
      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* Copy TSC to RSC */);
        
        _tao_vfr.receive_request (&_tao_ri ACE_ENV_ARG_PARAMETER);
        ACE_TRY_CHECK;
        
        if (!_tao_vfr.location_forwarded ())
          {
#endif /* TAO_HAS_INTERCEPTORS */
            
              _tao_impl->set_rt_info_enable_state_seq (
                  pair_set
                  ACE_ENV_ARG_PARAMETER
                );
            TAO_INTERCEPTOR_CHECK;
#if (TAO_HAS_INTERCEPTORS == 1)
          }
      }
      
      if (!_tao_vfr.location_forwarded ())
        {
          _tao_ri.reply_status (PortableInterceptor::SUCCESSFUL);
          _tao_vfr.send_reply (&_tao_ri ACE_ENV_ARG_PARAMETER);
          ACE_TRY_CHECK;
        }
    }
  ACE_CATCHANY
    {
      _tao_ri.exception (&ACE_ANY_EXCEPTION);
      _tao_vfr.send_exception (
          &_tao_ri
          ACE_ENV_ARG_PARAMETER
        );
      ACE_TRY_CHECK;
      
      PortableInterceptor::ReplyStatus _tao_status =
        _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_TRY_CHECK;
      
      if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION
          || _tao_status == PortableInterceptor::USER_EXCEPTION)
        {
          ACE_RE_THROW;
        }
    }
  
# if defined (ACE_HAS_EXCEPTIONS) \
  && defined (ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS)
  ACE_CATCHALL
    {
      CORBA::UNKNOWN ex;
      
      _tao_ri.exception (&ex);
      _tao_vfr.send_exception (
          &_tao_ri
          ACE_ENV_ARG_PARAMETER
        );
      ACE_TRY_CHECK;
      
      PortableInterceptor::ReplyStatus _tao_status =
        _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_TRY_CHECK;
      
      if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION)
        ACE_TRY_THROW (ex);
    }
# endif  /* ACE_HAS_EXCEPTIONS && ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS */
  ACE_ENDTRY;
  ACE_CHECK;
#endif /* TAO_HAS_INTERCEPTORS */
  
  _tao_server_request.init_reply ();
  
  // In case _tao_servant_upcall is not used in this function
  ACE_UNUSED_ARG (_tao_servant_upcall);
}

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

void POA_RtecScheduler::Scheduler::priority_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_RtecScheduler::Scheduler *_tao_impl =
    static_cast<
        POA_RtecScheduler::Scheduler *> (
        _tao_servant
      );
  
  ::RtecScheduler::handle_t handle;
  ::RtecScheduler::OS_Priority o_priority = 0;
  ::RtecScheduler::Preemption_Subpriority_t p_subpriority = 0;
  ::RtecScheduler::Preemption_Priority_t p_priority = 0;
  
  if (!(
      (_tao_in >> handle)
      ))
    {
      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_RtecScheduler_Scheduler_priority _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl,
      
      handle      
      

      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* Copy TSC to RSC */);
        
        _tao_vfr.receive_request (&_tao_ri ACE_ENV_ARG_PARAMETER);
        ACE_TRY_CHECK;
        
        if (!_tao_vfr.location_forwarded ())
          {
#endif /* TAO_HAS_INTERCEPTORS */
            
              _tao_impl->priority (
                  handle,
                  
                  o_priority,
                  
                  p_subpriority,
                  
                  p_priority
                  ACE_ENV_ARG_PARAMETER
                );
            TAO_INTERCEPTOR_CHECK;
#if (TAO_HAS_INTERCEPTORS == 1)
          }
      }
      
      if (!_tao_vfr.location_forwarded ())
        {
          _tao_ri.reply_status (PortableInterceptor::SUCCESSFUL);
          _tao_vfr.send_reply (&_tao_ri ACE_ENV_ARG_PARAMETER);
          ACE_TRY_CHECK;
        }
    }
  ACE_CATCHANY
    {
      _tao_ri.exception (&ACE_ANY_EXCEPTION);
      _tao_vfr.send_exception (
          &_tao_ri
          ACE_ENV_ARG_PARAMETER
        );
      ACE_TRY_CHECK;
      
      PortableInterceptor::ReplyStatus _tao_status =
        _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_TRY_CHECK;
      
      if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION
          || _tao_status == PortableInterceptor::USER_EXCEPTION)
        {
          ACE_RE_THROW;
        }
    }
  
# if defined (ACE_HAS_EXCEPTIONS) \
  && defined (ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS)
  ACE_CATCHALL
    {
      CORBA::UNKNOWN ex;
      
      _tao_ri.exception (&ex);
      _tao_vfr.send_exception (
          &_tao_ri
          ACE_ENV_ARG_PARAMETER
        );
      ACE_TRY_CHECK;
      
      PortableInterceptor::ReplyStatus _tao_status =
        _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_TRY_CHECK;
      
      if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION)
        ACE_TRY_THROW (ex);
    }
# endif  /* ACE_HAS_EXCEPTIONS && ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS */
  ACE_ENDTRY;
  ACE_CHECK;
#endif /* TAO_HAS_INTERCEPTORS */
  
  _tao_server_request.init_reply ();
#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 << o_priority) &&
          (_tao_out << p_subpriority) &&
          (_tao_out << p_priority)
          ))
        {
          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_RtecScheduler::Scheduler::entry_point_priority_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_RtecScheduler::Scheduler *_tao_impl =
    static_cast<
        POA_RtecScheduler::Scheduler *> (
        _tao_servant
      );
  
  ::CORBA::String_var entry_point;
  ::RtecScheduler::OS_Priority o_priority = 0;
  ::RtecScheduler::Preemption_Subpriority_t p_subpriority = 0;
  ::RtecScheduler::Preemption_Priority_t p_priority = 0;
  
  if (!(
      (_tao_in >> entry_point.out ())
      ))
    {
      TAO_InputCDR::throw_skel_exception (errno ACE_ENV_ARG_PARAMETER);
      ACE_CHECK;
    }
  
#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_Object_Adapter::Servant_Upcall *_tao_upcall =
    static_cast<
        TAO_Object_Adapter::Servant_Upcall *> (
        _tao_servant_upcall
      );
    
  TAO_ServerRequestInterceptor_Adapter _tao_vfr (
      _tao_server_request.orb_core ()->server_request_interceptors (),
      _tao_server_request.interceptor_count ()
    );
  
  TAO_ServerRequestInfo_RtecScheduler_Scheduler_entry_point_priority _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl,
      
      entry_point.in ()      
      

      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* Copy TSC to RSC */);
        
        _tao_vfr.receive_request (&_tao_ri ACE_ENV_ARG_PARAMETER);
        ACE_TRY_CHECK;
        
        if (!_tao_vfr.location_forwarded ())
          {
#endif /* TAO_HAS_INTERCEPTORS */
            
              _tao_impl->entry_point_priority (
                  entry_point.in (),
                  
                  o_priority,
                  
                  p_subpriority,
                  
                  p_priority
                  ACE_ENV_ARG_PARAMETER
                );
            TAO_INTERCEPTOR_CHECK;
#if (TAO_HAS_INTERCEPTORS == 1)
          }
      }
      
      if (!_tao_vfr.location_forwarded ())
        {
          _tao_ri.reply_status (PortableInterceptor::SUCCESSFUL);
          _tao_vfr.send_reply (&_tao_ri ACE_ENV_ARG_PARAMETER);
          ACE_TRY_CHECK;
        }
    }
  ACE_CATCHANY
    {
      _tao_ri.exception (&ACE_ANY_EXCEPTION);
      _tao_vfr.send_exception (
          &_tao_ri
          ACE_ENV_ARG_PARAMETER
        );
      ACE_TRY_CHECK;
      
      PortableInterceptor::ReplyStatus _tao_status =
        _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_TRY_CHECK;
      
      if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION
          || _tao_status == PortableInterceptor::USER_EXCEPTION)
        {
          ACE_RE_THROW;
        }
    }
  
# if defined (ACE_HAS_EXCEPTIONS) \
  && defined (ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS)
  ACE_CATCHALL
    {
      CORBA::UNKNOWN ex;
      
      _tao_ri.exception (&ex);
      _tao_vfr.send_exception (
          &_tao_ri
          ACE_ENV_ARG_PARAMETER
        );
      ACE_TRY_CHECK;
      
      PortableInterceptor::ReplyStatus _tao_status =
        _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_TRY_CHECK;
      
      if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION)
        ACE_TRY_THROW (ex);
    }
# endif  /* ACE_HAS_EXCEPTIONS && ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS */
  ACE_ENDTRY;
  ACE_CHECK;
#endif /* TAO_HAS_INTERCEPTORS */
  
  _tao_server_request.init_reply ();
#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 << o_priority) &&
          (_tao_out << p_subpriority) &&
          (_tao_out << p_priority)
          ))
        {
          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_RtecScheduler::Scheduler::compute_scheduling_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_RtecScheduler::Scheduler *_tao_impl =
    static_cast<
        POA_RtecScheduler::Scheduler *> (
        _tao_servant
      );
  
  ::CORBA::Long minimum_priority;
  ::CORBA::Long maximum_priority;
  ::RtecScheduler::RT_Info_Set_var infos;
  
  ::RtecScheduler::Dependency_Set_var dependencies;
  
  ::RtecScheduler::Config_Info_Set_var configs;
  
  ::RtecScheduler::Scheduling_Anomaly_Set_var anomalies;
  
  
  if (!(
      (_tao_in >> minimum_priority) &&
      (_tao_in >> maximum_priority)
      ))
    {
      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_RtecScheduler_Scheduler_compute_scheduling _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl,
      
      minimum_priority,
      
      maximum_priority      
      
      

      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* Copy TSC to RSC */);
        
        _tao_vfr.receive_request (&_tao_ri ACE_ENV_ARG_PARAMETER);
        ACE_TRY_CHECK;
        
        if (!_tao_vfr.location_forwarded ())
          {
#endif /* TAO_HAS_INTERCEPTORS */
            
              _tao_impl->compute_scheduling (
                  minimum_priority,
                  
                  maximum_priority,
                  
                  infos.out (),
                  
                  dependencies.out (),
                  
                  configs.out (),
                  
                  anomalies.out ()
                  ACE_ENV_ARG_PARAMETER
                );
            TAO_INTERCEPTOR_CHECK;
#if (TAO_HAS_INTERCEPTORS == 1)
          }
      }
      
      if (!_tao_vfr.location_forwarded ())
        {
          _tao_ri.reply_status (PortableInterceptor::SUCCESSFUL);
          _tao_vfr.send_reply (&_tao_ri ACE_ENV_ARG_PARAMETER);
          ACE_TRY_CHECK;
        }
    }
  ACE_CATCHANY
    {
      _tao_ri.exception (&ACE_ANY_EXCEPTION);
      _tao_vfr.send_exception (
          &_tao_ri
          ACE_ENV_ARG_PARAMETER
        );
      ACE_TRY_CHECK;
      
      PortableInterceptor::ReplyStatus _tao_status =
        _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_TRY_CHECK;
      
      if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION
          || _tao_status == PortableInterceptor::USER_EXCEPTION)
        {
          ACE_RE_THROW;
        }
    }
  
# if defined (ACE_HAS_EXCEPTIONS) \
  && defined (ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS)
  ACE_CATCHALL
    {
      CORBA::UNKNOWN ex;
      
      _tao_ri.exception (&ex);
      _tao_vfr.send_exception (
          &_tao_ri
          ACE_ENV_ARG_PARAMETER
        );
      ACE_TRY_CHECK;
      
      PortableInterceptor::ReplyStatus _tao_status =
        _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_TRY_CHECK;
      
      if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION)
        ACE_TRY_THROW (ex);
    }
# endif  /* ACE_HAS_EXCEPTIONS && ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS */
  ACE_ENDTRY;
  ACE_CHECK;
#endif /* TAO_HAS_INTERCEPTORS */
  
  _tao_server_request.init_reply ();
#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 << infos.in ()) &&
          (_tao_out << dependencies.in ()) &&
          (_tao_out << configs.in ()) &&
          (_tao_out << anomalies.in ())
          ))
        {
          TAO_OutputCDR::throw_skel_exception (errno ACE_ENV_ARG_PARAMETER);
          ACE_CHECK;
        }
#if (TAO_HAS_INTERCEPTORS == 1)
    }
#endif /* TAO_HAS_INTERCEPTORS */
  
  
  // In case _tao_servant_upcall is not used in this function
  ACE_UNUSED_ARG (_tao_servant_upcall);
}

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

void POA_RtecScheduler::Scheduler::recompute_scheduling_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_RtecScheduler::Scheduler *_tao_impl =
    static_cast<
        POA_RtecScheduler::Scheduler *> (
        _tao_servant
      );
  
  ::CORBA::Long minimum_priority;
  ::CORBA::Long maximum_priority;
  ::RtecScheduler::Scheduling_Anomaly_Set_var anomalies;
  
  
  if (!(
      (_tao_in >> minimum_priority) &&
      (_tao_in >> maximum_priority)
      ))
    {
      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_RtecScheduler_Scheduler_recompute_scheduling _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl,
      
      minimum_priority,
      
      maximum_priority
      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* Copy TSC to RSC */);
        
        _tao_vfr.receive_request (&_tao_ri ACE_ENV_ARG_PARAMETER);
        ACE_TRY_CHECK;
        
        if (!_tao_vfr.location_forwarded ())
          {
#endif /* TAO_HAS_INTERCEPTORS */
            
              _tao_impl->recompute_scheduling (
                  minimum_priority,
                  
                  maximum_priority,
                  
                  anomalies.out ()
                  ACE_ENV_ARG_PARAMETER
                );
            TAO_INTERCEPTOR_CHECK;
#if (TAO_HAS_INTERCEPTORS == 1)
          }
      }
      
      if (!_tao_vfr.location_forwarded ())
        {
          _tao_ri.reply_status (PortableInterceptor::SUCCESSFUL);
          _tao_vfr.send_reply (&_tao_ri ACE_ENV_ARG_PARAMETER);
          ACE_TRY_CHECK;
        }
    }
  ACE_CATCHANY
    {
      _tao_ri.exception (&ACE_ANY_EXCEPTION);
      _tao_vfr.send_exception (
          &_tao_ri
          ACE_ENV_ARG_PARAMETER
        );
      ACE_TRY_CHECK;
      
      PortableInterceptor::ReplyStatus _tao_status =
        _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_TRY_CHECK;
      
      if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION
          || _tao_status == PortableInterceptor::USER_EXCEPTION)
        {
          ACE_RE_THROW;
        }
    }
  
# if defined (ACE_HAS_EXCEPTIONS) \
  && defined (ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS)
  ACE_CATCHALL
    {
      CORBA::UNKNOWN ex;
      
      _tao_ri.exception (&ex);
      _tao_vfr.send_exception (
          &_tao_ri
          ACE_ENV_ARG_PARAMETER
        );
      ACE_TRY_CHECK;
      
      PortableInterceptor::ReplyStatus _tao_status =
        _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_TRY_CHECK;
      
      if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION)
        ACE_TRY_THROW (ex);
    }
# endif  /* ACE_HAS_EXCEPTIONS && ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS */
  ACE_ENDTRY;
  ACE_CHECK;
#endif /* TAO_HAS_INTERCEPTORS */
  
  _tao_server_request.init_reply ();
#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 << anomalies.in ())
          ))
        {
          TAO_OutputCDR::throw_skel_exception (errno ACE_ENV_ARG_PARAMETER);
          ACE_CHECK;
        }
#if (TAO_HAS_INTERCEPTORS == 1)
    }
#endif /* TAO_HAS_INTERCEPTORS */
  
  
  // In case _tao_servant_upcall is not used in this function
  ACE_UNUSED_ARG (_tao_servant_upcall);
}

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

void POA_RtecScheduler::Scheduler::get_rt_info_set_skel (
    TAO_ServerRequest &_tao_server_request,
    void *_tao_servant,
    void *_tao_servant_upcall
    ACE_ENV_ARG_DECL
  )
{
  POA_RtecScheduler::Scheduler *_tao_impl =
    static_cast<
        POA_RtecScheduler::Scheduler *> (
        _tao_servant
      );
  
  ::RtecScheduler::RT_Info_Set_var infos;
  
  
#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_RtecScheduler_Scheduler_get_rt_info_set _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl
      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* Copy TSC to RSC */);
        
        _tao_vfr.receive_request (&_tao_ri ACE_ENV_ARG_PARAMETER);
        ACE_TRY_CHECK;
        
        if (!_tao_vfr.location_forwarded ())
          {
#endif /* TAO_HAS_INTERCEPTORS */
            
              _tao_impl->get_rt_info_set (
                  infos.out ()
                  ACE_ENV_ARG_PARAMETER
                );
            TAO_INTERCEPTOR_CHECK;
#if (TAO_HAS_INTERCEPTORS == 1)
          }
      }
      
      if (!_tao_vfr.location_forwarded ())
        {
          _tao_ri.reply_status (PortableInterceptor::SUCCESSFUL);
          _tao_vfr.send_reply (&_tao_ri ACE_ENV_ARG_PARAMETER);
          ACE_TRY_CHECK;
        }
    }
  ACE_CATCHANY
    {
      _tao_ri.exception (&ACE_ANY_EXCEPTION);
      _tao_vfr.send_exception (
          &_tao_ri
          ACE_ENV_ARG_PARAMETER
        );
      ACE_TRY_CHECK;
      
      PortableInterceptor::ReplyStatus _tao_status =
        _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_TRY_CHECK;
      
      if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION
          || _tao_status == PortableInterceptor::USER_EXCEPTION)
        {
          ACE_RE_THROW;
        }
    }
  
# if defined (ACE_HAS_EXCEPTIONS) \
  && defined (ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS)
  ACE_CATCHALL
    {
      CORBA::UNKNOWN ex;
      
      _tao_ri.exception (&ex);
      _tao_vfr.send_exception (
          &_tao_ri
          ACE_ENV_ARG_PARAMETER
        );
      ACE_TRY_CHECK;
      
      PortableInterceptor::ReplyStatus _tao_status =
        _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_TRY_CHECK;
      
      if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION)
        ACE_TRY_THROW (ex);
    }
# endif  /* ACE_HAS_EXCEPTIONS && ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS */
  ACE_ENDTRY;
  ACE_CHECK;
#endif /* TAO_HAS_INTERCEPTORS */
  
  _tao_server_request.init_reply ();
#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 << infos.in ())
          ))
        {
          TAO_OutputCDR::throw_skel_exception (errno ACE_ENV_ARG_PARAMETER);
          ACE_CHECK;
        }
#if (TAO_HAS_INTERCEPTORS == 1)
    }
#endif /* TAO_HAS_INTERCEPTORS */
  
  
  // In case _tao_servant_upcall is not used in this function
  ACE_UNUSED_ARG (_tao_servant_upcall);
}

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

void POA_RtecScheduler::Scheduler::get_dependency_set_skel (
    TAO_ServerRequest &_tao_server_request,
    void *_tao_servant,
    void *_tao_servant_upcall
    ACE_ENV_ARG_DECL
  )
{
  POA_RtecScheduler::Scheduler *_tao_impl =
    static_cast<
        POA_RtecScheduler::Scheduler *> (
        _tao_servant
      );
  
  ::RtecScheduler::Dependency_Set_var dependencies;
  
  
#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_RtecScheduler_Scheduler_get_dependency_set _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl
      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* Copy TSC to RSC */);
        
        _tao_vfr.receive_request (&_tao_ri ACE_ENV_ARG_PARAMETER);
        ACE_TRY_CHECK;
        
        if (!_tao_vfr.location_forwarded ())
          {
#endif /* TAO_HAS_INTERCEPTORS */
            
              _tao_impl->get_dependency_set (
                  dependencies.out ()
                  ACE_ENV_ARG_PARAMETER
                );
            TAO_INTERCEPTOR_CHECK;
#if (TAO_HAS_INTERCEPTORS == 1)
          }
      }
      
      if (!_tao_vfr.location_forwarded ())
        {
          _tao_ri.reply_status (PortableInterceptor::SUCCESSFUL);
          _tao_vfr.send_reply (&_tao_ri ACE_ENV_ARG_PARAMETER);
          ACE_TRY_CHECK;
        }
    }
  ACE_CATCHANY
    {
      _tao_ri.exception (&ACE_ANY_EXCEPTION);
      _tao_vfr.send_exception (
          &_tao_ri
          ACE_ENV_ARG_PARAMETER
        );
      ACE_TRY_CHECK;
      
      PortableInterceptor::ReplyStatus _tao_status =
        _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_TRY_CHECK;
      
      if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION
          || _tao_status == PortableInterceptor::USER_EXCEPTION)
        {
          ACE_RE_THROW;
        }
    }
  
# if defined (ACE_HAS_EXCEPTIONS) \
  && defined (ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS)
  ACE_CATCHALL
    {
      CORBA::UNKNOWN ex;
      
      _tao_ri.exception (&ex);
      _tao_vfr.send_exception (
          &_tao_ri
          ACE_ENV_ARG_PARAMETER
        );
      ACE_TRY_CHECK;
      
      PortableInterceptor::ReplyStatus _tao_status =
        _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_TRY_CHECK;
      
      if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION)
        ACE_TRY_THROW (ex);
    }
# endif  /* ACE_HAS_EXCEPTIONS && ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS */
  ACE_ENDTRY;
  ACE_CHECK;
#endif /* TAO_HAS_INTERCEPTORS */
  
  _tao_server_request.init_reply ();
#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 << dependencies.in ())
          ))
        {
          TAO_OutputCDR::throw_skel_exception (errno ACE_ENV_ARG_PARAMETER);
          ACE_CHECK;
        }
#if (TAO_HAS_INTERCEPTORS == 1)
    }
#endif /* TAO_HAS_INTERCEPTORS */
  
  
  // In case _tao_servant_upcall is not used in this function
  ACE_UNUSED_ARG (_tao_servant_upcall);
}

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

void POA_RtecScheduler::Scheduler::get_config_info_set_skel (
    TAO_ServerRequest &_tao_server_request,
    void *_tao_servant,
    void *_tao_servant_upcall
    ACE_ENV_ARG_DECL
  )
{
  POA_RtecScheduler::Scheduler *_tao_impl =
    static_cast<
        POA_RtecScheduler::Scheduler *> (
        _tao_servant
      );
  
  ::RtecScheduler::Config_Info_Set_var configs;
  
  
#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_RtecScheduler_Scheduler_get_config_info_set _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl
      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* Copy TSC to RSC */);
        
        _tao_vfr.receive_request (&_tao_ri ACE_ENV_ARG_PARAMETER);
        ACE_TRY_CHECK;
        
        if (!_tao_vfr.location_forwarded ())
          {
#endif /* TAO_HAS_INTERCEPTORS */
            
              _tao_impl->get_config_info_set (
                  configs.out ()
                  ACE_ENV_ARG_PARAMETER
                );
            TAO_INTERCEPTOR_CHECK;
#if (TAO_HAS_INTERCEPTORS == 1)
          }
      }
      
      if (!_tao_vfr.location_forwarded ())
        {
          _tao_ri.reply_status (PortableInterceptor::SUCCESSFUL);
          _tao_vfr.send_reply (&_tao_ri ACE_ENV_ARG_PARAMETER);
          ACE_TRY_CHECK;
        }
    }
  ACE_CATCHANY
    {
      _tao_ri.exception (&ACE_ANY_EXCEPTION);
      _tao_vfr.send_exception (
          &_tao_ri
          ACE_ENV_ARG_PARAMETER
        );
      ACE_TRY_CHECK;
      
      PortableInterceptor::ReplyStatus _tao_status =
        _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_TRY_CHECK;
      
      if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION
          || _tao_status == PortableInterceptor::USER_EXCEPTION)
        {
          ACE_RE_THROW;
        }
    }
  
# if defined (ACE_HAS_EXCEPTIONS) \
  && defined (ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS)
  ACE_CATCHALL
    {
      CORBA::UNKNOWN ex;
      
      _tao_ri.exception (&ex);
      _tao_vfr.send_exception (
          &_tao_ri
          ACE_ENV_ARG_PARAMETER
        );
      ACE_TRY_CHECK;
      
      PortableInterceptor::ReplyStatus _tao_status =
        _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_TRY_CHECK;
      
      if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION)
        ACE_TRY_THROW (ex);
    }
# endif  /* ACE_HAS_EXCEPTIONS && ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS */
  ACE_ENDTRY;
  ACE_CHECK;
#endif /* TAO_HAS_INTERCEPTORS */
  
  _tao_server_request.init_reply ();
#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 << configs.in ())
          ))
        {
          TAO_OutputCDR::throw_skel_exception (errno ACE_ENV_ARG_PARAMETER);
          ACE_CHECK;
        }
#if (TAO_HAS_INTERCEPTORS == 1)
    }
#endif /* TAO_HAS_INTERCEPTORS */
  
  
  // In case _tao_servant_upcall is not used in this function
  ACE_UNUSED_ARG (_tao_servant_upcall);
}

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

void POA_RtecScheduler::Scheduler::dispatch_configuration_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_RtecScheduler::Scheduler *_tao_impl =
    static_cast<
        POA_RtecScheduler::Scheduler *> (
        _tao_servant
      );
  
  ::RtecScheduler::Preemption_Priority_t p_priority;
  ::RtecScheduler::OS_Priority o_priority = 0;
  ::RtecScheduler::Dispatching_Type_t d_type;
  
  if (!(
      (_tao_in >> p_priority)
      ))
    {
      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_RtecScheduler_Scheduler_dispatch_configuration _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl,
      
      p_priority      

      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* Copy TSC to RSC */);
        
        _tao_vfr.receive_request (&_tao_ri ACE_ENV_ARG_PARAMETER);
        ACE_TRY_CHECK;
        
        if (!_tao_vfr.location_forwarded ())
          {
#endif /* TAO_HAS_INTERCEPTORS */
            
              _tao_impl->dispatch_configuration (
                  p_priority,
                  
                  o_priority,
                  
                  d_type
                  ACE_ENV_ARG_PARAMETER
                );
            TAO_INTERCEPTOR_CHECK;
#if (TAO_HAS_INTERCEPTORS == 1)
          }
      }
      
      if (!_tao_vfr.location_forwarded ())
        {
          _tao_ri.reply_status (PortableInterceptor::SUCCESSFUL);
          _tao_vfr.send_reply (&_tao_ri ACE_ENV_ARG_PARAMETER);
          ACE_TRY_CHECK;
        }
    }
  ACE_CATCHANY
    {
      _tao_ri.exception (&ACE_ANY_EXCEPTION);
      _tao_vfr.send_exception (
          &_tao_ri
          ACE_ENV_ARG_PARAMETER
        );
      ACE_TRY_CHECK;
      
      PortableInterceptor::ReplyStatus _tao_status =
        _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_TRY_CHECK;
      
      if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION
          || _tao_status == PortableInterceptor::USER_EXCEPTION)
        {
          ACE_RE_THROW;
        }
    }
  
# if defined (ACE_HAS_EXCEPTIONS) \
  && defined (ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS)
  ACE_CATCHALL
    {
      CORBA::UNKNOWN ex;
      
      _tao_ri.exception (&ex);
      _tao_vfr.send_exception (
          &_tao_ri
          ACE_ENV_ARG_PARAMETER
        );
      ACE_TRY_CHECK;
      
      PortableInterceptor::ReplyStatus _tao_status =
        _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_TRY_CHECK;
      
      if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION)
        ACE_TRY_THROW (ex);
    }
# endif  /* ACE_HAS_EXCEPTIONS && ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS */
  ACE_ENDTRY;
  ACE_CHECK;
#endif /* TAO_HAS_INTERCEPTORS */
  
  _tao_server_request.init_reply ();
#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 << o_priority) &&
          (_tao_out << d_type)
          ))
        {
          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_RtecScheduler::Scheduler::last_scheduled_priority_skel (
    TAO_ServerRequest &_tao_server_request,
    void *_tao_servant,
    void *_tao_servant_upcall
    ACE_ENV_ARG_DECL
  )
{
  POA_RtecScheduler::Scheduler *_tao_impl =
    static_cast<
        POA_RtecScheduler::Scheduler *> (
        _tao_servant
      );
  RtecScheduler::Preemption_Priority_t _tao_retval = 0;
  
#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_Object_Adapter::Servant_Upcall *_tao_upcall =
    static_cast<
        TAO_Object_Adapter::Servant_Upcall *> (
        _tao_servant_upcall
      );
    
  TAO_ServerRequestInterceptor_Adapter _tao_vfr (
      _tao_server_request.orb_core ()->server_request_interceptors (),
      _tao_server_request.interceptor_count ()
    );
  
  TAO_ServerRequestInfo_RtecScheduler_Scheduler_last_scheduled_priority _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl
      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* Copy TSC to RSC */);
        
        _tao_vfr.receive_request (&_tao_ri ACE_ENV_ARG_PARAMETER);
        ACE_TRY_CHECK;
        
        if (!_tao_vfr.location_forwarded ())
          {
#endif /* TAO_HAS_INTERCEPTORS */
            _tao_retval = 
              _tao_impl->last_scheduled_priority (
                  ACE_ENV_SINGLE_ARG_PARAMETER
                );
            TAO_INTERCEPTOR_CHECK;
#if (TAO_HAS_INTERCEPTORS == 1)
          }
      }
      
      if (!_tao_vfr.location_forwarded ())
        {
          RtecScheduler::Preemption_Priority_t _tao_retval_info = _tao_retval;
          _tao_ri.result (_tao_retval_info);
          _tao_ri.reply_status (PortableInterceptor::SUCCESSFUL);
          _tao_vfr.send_reply (&_tao_ri ACE_ENV_ARG_PARAMETER);
          ACE_TRY_CHECK;
        }
    }
  ACE_CATCHANY
    {
      _tao_ri.exception (&ACE_ANY_EXCEPTION);
      _tao_vfr.send_exception (
          &_tao_ri
          ACE_ENV_ARG_PARAMETER
        );
      ACE_TRY_CHECK;
      
      PortableInterceptor::ReplyStatus _tao_status =
        _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_TRY_CHECK;
      
      if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION
          || _tao_status == PortableInterceptor::USER_EXCEPTION)
        {
          ACE_RE_THROW;
        }
    }
  
# if defined (ACE_HAS_EXCEPTIONS) \
  && defined (ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS)
  ACE_CATCHALL
    {
      CORBA::UNKNOWN ex;
      
      _tao_ri.exception (&ex);
      _tao_vfr.send_exception (
          &_tao_ri
          ACE_ENV_ARG_PARAMETER
        );
      ACE_TRY_CHECK;
      
      PortableInterceptor::ReplyStatus _tao_status =
        _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_TRY_CHECK;
      
      if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION)
        ACE_TRY_THROW (ex);
    }
# endif  /* ACE_HAS_EXCEPTIONS && ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS */
  ACE_ENDTRY;
  ACE_CHECK;
#endif /* TAO_HAS_INTERCEPTORS */
  
  _tao_server_request.init_reply ();
#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)
          ))
        {
          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_RtecScheduler::Scheduler::get_config_infos_skel (
    TAO_ServerRequest &_tao_server_request,
    void *_tao_servant,
    void *_tao_servant_upcall
    ACE_ENV_ARG_DECL
  )
{
  POA_RtecScheduler::Scheduler *_tao_impl =
    static_cast<
        POA_RtecScheduler::Scheduler *> (
        _tao_servant
      );
  
  ::RtecScheduler::Config_Info_Set_var configs;
  
  
#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_RtecScheduler_Scheduler_get_config_infos _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl
      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* Copy TSC to RSC */);
        
        _tao_vfr.receive_request (&_tao_ri ACE_ENV_ARG_PARAMETER);
        ACE_TRY_CHECK;
        
        if (!_tao_vfr.location_forwarded ())
          {
#endif /* TAO_HAS_INTERCEPTORS */
            
              _tao_impl->get_config_infos (
                  configs.out ()
                  ACE_ENV_ARG_PARAMETER
                );
            TAO_INTERCEPTOR_CHECK;
#if (TAO_HAS_INTERCEPTORS == 1)
          }
      }
      
      if (!_tao_vfr.location_forwarded ())
        {
          _tao_ri.reply_status (PortableInterceptor::SUCCESSFUL);
          _tao_vfr.send_reply (&_tao_ri ACE_ENV_ARG_PARAMETER);
          ACE_TRY_CHECK;
        }
    }
  ACE_CATCHANY
    {
      _tao_ri.exception (&ACE_ANY_EXCEPTION);
      _tao_vfr.send_exception (
          &_tao_ri
          ACE_ENV_ARG_PARAMETER
        );
      ACE_TRY_CHECK;
      
      PortableInterceptor::ReplyStatus _tao_status =
        _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_TRY_CHECK;
      
      if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION
          || _tao_status == PortableInterceptor::USER_EXCEPTION)
        {
          ACE_RE_THROW;
        }
    }
  
# if defined (ACE_HAS_EXCEPTIONS) \
  && defined (ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS)
  ACE_CATCHALL
    {
      CORBA::UNKNOWN ex;
      
      _tao_ri.exception (&ex);
      _tao_vfr.send_exception (
          &_tao_ri
          ACE_ENV_ARG_PARAMETER
        );
      ACE_TRY_CHECK;
      
      PortableInterceptor::ReplyStatus _tao_status =
        _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_TRY_CHECK;
      
      if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION)
        ACE_TRY_THROW (ex);
    }
# endif  /* ACE_HAS_EXCEPTIONS && ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS */
  ACE_ENDTRY;
  ACE_CHECK;
#endif /* TAO_HAS_INTERCEPTORS */
  
  _tao_server_request.init_reply ();
#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 << configs.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_RtecScheduler::Scheduler::_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_RtecScheduler::Scheduler *_tao_impl =
    (POA_RtecScheduler::Scheduler *) _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_RtecScheduler::Scheduler::_non_existent_skel (
    TAO_ServerRequest &_tao_server_request, 
    void * _tao_servant,
    void * /* Servant_Upcall */
    ACE_ENV_ARG_DECL
  )
{
  POA_RtecScheduler::Scheduler *_tao_impl =
    (POA_RtecScheduler::Scheduler *) _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_RtecScheduler::Scheduler::_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_RtecScheduler::Scheduler *_tao_impl =
    (POA_RtecScheduler::Scheduler *) _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_RtecScheduler::Scheduler::_component_skel (
    TAO_ServerRequest &_tao_server_request, 
    void * _tao_object_reference,
    void * /* Servant_Upcall */
    ACE_ENV_ARG_DECL
  )
{
  POA_RtecScheduler::Scheduler *_tao_impl =
    (POA_RtecScheduler::Scheduler *) _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_RtecScheduler::Scheduler::_is_a (
    const char* value
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  if (
      !ACE_OS::strcmp (
          (char *)value,
          "IDL:RtecScheduler/Scheduler:1.0"
        ) ||
      !ACE_OS::strcmp (
          (char *)value,
          "IDL:omg.org/CORBA/Object:1.0"
        )
     )
    {
      return 1;
    }
  else
    {
      return 0;
    }
}

void* POA_RtecScheduler::Scheduler::_downcast (
    const char* logical_type_id
  )
{
  if (ACE_OS::strcmp (logical_type_id,
                      "IDL:RtecScheduler/Scheduler:1.0") == 0)
    {
      return static_cast<POA_RtecScheduler::Scheduler_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_RtecScheduler::Scheduler::_interface_repository_id (void) const
{
  return "IDL:RtecScheduler/Scheduler:1.0";
}

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

void POA_RtecScheduler::Scheduler::_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

RtecScheduler::Scheduler *
POA_RtecScheduler::Scheduler::_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 ::RtecScheduler::Scheduler STUB_SCOPED_NAME;
  return
    TAO::Narrow_Utils<STUB_SCOPED_NAME>::unchecked_narrow (
        obj.in (),
        RtecScheduler__TAO_Scheduler_Proxy_Broker_Factory_function_pointer
      );
}

#endif /* ifndef */
