From 2e1a499e45b33662fd3b898776aa786c84441373 Mon Sep 17 00:00:00 2001 From: venkita Date: Tue, 12 Aug 2003 21:10:23 +0000 Subject: . --- .../Kokyu_dsrt_schedulers/FP_SchedulingC.cpp | 811 ++++++++++++++++++++ .../Kokyu_dsrt_schedulers/FP_SchedulingC.h | 405 ++++++++++ .../Kokyu_dsrt_schedulers/FP_SchedulingC.i | 121 +++ .../Kokyu_dsrt_schedulers/MIF_SchedulingC.cpp | 784 +++++++++++++++++++ .../Kokyu_dsrt_schedulers/MIF_SchedulingC.h | 405 ++++++++++ .../Kokyu_dsrt_schedulers/MIF_SchedulingC.i | 121 +++ .../Kokyu_dsrt_schedulers/MUF_SchedulingC.cpp | 834 +++++++++++++++++++++ .../Kokyu_dsrt_schedulers/MUF_SchedulingC.h | 407 ++++++++++ .../Kokyu_dsrt_schedulers/MUF_SchedulingC.i | 125 +++ 9 files changed, 4013 insertions(+) create mode 100644 TAO/examples/Kokyu_dsrt_schedulers/FP_SchedulingC.cpp create mode 100644 TAO/examples/Kokyu_dsrt_schedulers/FP_SchedulingC.h create mode 100644 TAO/examples/Kokyu_dsrt_schedulers/FP_SchedulingC.i create mode 100644 TAO/examples/Kokyu_dsrt_schedulers/MIF_SchedulingC.cpp create mode 100644 TAO/examples/Kokyu_dsrt_schedulers/MIF_SchedulingC.h create mode 100644 TAO/examples/Kokyu_dsrt_schedulers/MIF_SchedulingC.i create mode 100644 TAO/examples/Kokyu_dsrt_schedulers/MUF_SchedulingC.cpp create mode 100644 TAO/examples/Kokyu_dsrt_schedulers/MUF_SchedulingC.h create mode 100644 TAO/examples/Kokyu_dsrt_schedulers/MUF_SchedulingC.i diff --git a/TAO/examples/Kokyu_dsrt_schedulers/FP_SchedulingC.cpp b/TAO/examples/Kokyu_dsrt_schedulers/FP_SchedulingC.cpp new file mode 100644 index 00000000000..c8bd8d595c8 --- /dev/null +++ b/TAO/examples/Kokyu_dsrt_schedulers/FP_SchedulingC.cpp @@ -0,0 +1,811 @@ +// -*- 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:351 + + +#include "FP_SchedulingC.h" +#include "tao/Stub.h" +#include "tao/Invocation.h" +#include "tao/PortableInterceptor.h" + +#if TAO_HAS_INTERCEPTORS == 1 +#include "tao/RequestInfo_Util.h" +#include "tao/ClientRequestInfo_i.h" +#include "tao/ClientInterceptorAdapter.h" +#endif /* TAO_HAS_INTERCEPTORS == 1 */ + + +#if defined (__BORLANDC__) +#pragma option -w-rvl -w-rch -w-ccc -w-aus -w-sig +#endif /* __BORLANDC__ */ + +#if !defined (__ACE_INLINE__) +#include "FP_SchedulingC.i" +#endif /* !defined INLINE */ + +// TAO_IDL - Generated from +// be/be_visitor_typecode/typecode_defn.cpp:284 + +static const CORBA::Long _oc_FP_Scheduling_SegmentSchedulingParameter[] = +{ + TAO_ENCAP_BYTE_ORDER, // byte order + 49, + ACE_NTOHL (0x49444c3a), + ACE_NTOHL (0x46505f53), + ACE_NTOHL (0x63686564), + ACE_NTOHL (0x756c696e), + ACE_NTOHL (0x672f5365), + ACE_NTOHL (0x676d656e), + ACE_NTOHL (0x74536368), + ACE_NTOHL (0x6564756c), + ACE_NTOHL (0x696e6750), + ACE_NTOHL (0x6172616d), + ACE_NTOHL (0x65746572), + ACE_NTOHL (0x3a312e30), + ACE_NTOHL (0x0), // repository ID = IDL:FP_Scheduling/SegmentSchedulingParameter:1.0 + 27, + ACE_NTOHL (0x5365676d), + ACE_NTOHL (0x656e7453), + ACE_NTOHL (0x63686564), + ACE_NTOHL (0x756c696e), + ACE_NTOHL (0x67506172), + ACE_NTOHL (0x616d6574), + ACE_NTOHL (0x65720000), // name = SegmentSchedulingParameter + 1, // member count + 14, + ACE_NTOHL (0x62617365), + ACE_NTOHL (0x5f707269), + ACE_NTOHL (0x6f726974), + ACE_NTOHL (0x79000000), // name = base_priority + CORBA::tk_alias, // typecode kind for typedefs + 64, // encapsulation length + TAO_ENCAP_BYTE_ORDER, // byte order + 33, + ACE_NTOHL (0x49444c3a), + ACE_NTOHL (0x6f6d672e), + ACE_NTOHL (0x6f72672f), + ACE_NTOHL (0x5254434f), + ACE_NTOHL (0x5242412f), + ACE_NTOHL (0x5072696f), + ACE_NTOHL (0x72697479), + ACE_NTOHL (0x3a312e30), + ACE_NTOHL (0x0), // repository ID = IDL:omg.org/RTCORBA/Priority:1.0 + 9, + ACE_NTOHL (0x5072696f), + ACE_NTOHL (0x72697479), + ACE_NTOHL (0x0), // name = Priority + CORBA::tk_short, + + +}; + +static CORBA::TypeCode _tc_TAO_tc_FP_Scheduling_SegmentSchedulingParameter ( + CORBA::tk_struct, + sizeof (_oc_FP_Scheduling_SegmentSchedulingParameter), + (char *) &_oc_FP_Scheduling_SegmentSchedulingParameter, + 0, + sizeof (FP_Scheduling::SegmentSchedulingParameter) + ); + +TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) +TAO_NAMESPACE_BEGIN (FP_Scheduling) +TAO_NAMESPACE_DEFINE ( + ::CORBA::TypeCode_ptr, + _tc_SegmentSchedulingParameter, + &_tc_TAO_tc_FP_Scheduling_SegmentSchedulingParameter + ) +TAO_NAMESPACE_END + +// TAO_IDL - Generated from +// be/be_visitor_structure/structure_cs.cpp:66 + +void FP_Scheduling::SegmentSchedulingParameter::_tao_any_destructor (void *_tao_void_pointer) +{ + SegmentSchedulingParameter *tmp = ACE_static_cast (SegmentSchedulingParameter*, _tao_void_pointer); + delete tmp; +} + +// TAO_IDL - Generated from +// be/be_type.cpp:297 + +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) + +template class + TAO_Fixed_Var_T< + FP_Scheduling::SegmentSchedulingParameter + >; + +template class TAO_Var_Base_T< + FP_Scheduling::SegmentSchedulingParameter + >; + +#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) + +# pragma instantiate \ + TAO_Fixed_Var_T< \ + FP_Scheduling::SegmentSchedulingParameter \ + > + +#pragma instantiate TAO_Var_Base_T< + FP_Scheduling::SegmentSchedulingParameter + > + +#endif /* !ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ + +// TAO_IDL - Generated from +// be/be_visitor_interface/interface_cs.cpp:63 + +int FP_Scheduling::SegmentSchedulingParameterPolicy::_tao_class_id = 0; + +FP_Scheduling::SegmentSchedulingParameterPolicy_ptr +FP_Scheduling::tao_SegmentSchedulingParameterPolicy_life::tao_duplicate ( + SegmentSchedulingParameterPolicy_ptr p + ) +{ + return SegmentSchedulingParameterPolicy::_duplicate (p); +} + +void +FP_Scheduling::tao_SegmentSchedulingParameterPolicy_life::tao_release ( + SegmentSchedulingParameterPolicy_ptr p + ) +{ + CORBA::release (p); +} + +FP_Scheduling::SegmentSchedulingParameterPolicy_ptr +FP_Scheduling::tao_SegmentSchedulingParameterPolicy_life::tao_nil ( + void + ) +{ + return SegmentSchedulingParameterPolicy::_nil (); +} + +CORBA::Boolean +FP_Scheduling::tao_SegmentSchedulingParameterPolicy_life::tao_marshal ( + SegmentSchedulingParameterPolicy_ptr p, + TAO_OutputCDR &cdr + ) +{ + return p->marshal (cdr); +} + +FP_Scheduling::SegmentSchedulingParameterPolicy_ptr +FP_Scheduling::tao_SegmentSchedulingParameterPolicy_cast::tao_narrow ( + CORBA::Object *p + ACE_ENV_ARG_DECL + ) +{ + return SegmentSchedulingParameterPolicy::_narrow (p ACE_ENV_ARG_PARAMETER); +} + +CORBA::Object * +FP_Scheduling::tao_SegmentSchedulingParameterPolicy_cast::tao_upcast ( + void *src + ) +{ + SegmentSchedulingParameterPolicy **tmp = + ACE_static_cast (SegmentSchedulingParameterPolicy **, src); + return *tmp; +} + +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) + template class + TAO_Objref_Var_T< + FP_Scheduling::SegmentSchedulingParameterPolicy, + FP_Scheduling::tao_SegmentSchedulingParameterPolicy_life + >; + template class + TAO_Objref_Out_T< + FP_Scheduling::SegmentSchedulingParameterPolicy, + FP_Scheduling::tao_SegmentSchedulingParameterPolicy_life + >; +#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) +# pragma instantiate \ + TAO_Objref_Var_T< \ + FP_Scheduling::SegmentSchedulingParameterPolicy, \ + FP_Scheduling::tao_SegmentSchedulingParameterPolicy_life \ + > +# pragma instantiate \ + TAO_Objref_Out_T< \ + FP_Scheduling::SegmentSchedulingParameterPolicy, \ + FP_Scheduling::tao_SegmentSchedulingParameterPolicy_life \ + > +#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ + +// TAO_IDL - Generated from +// be/be_visitor_interface/interface_cs.cpp:245 + +FP_Scheduling::SegmentSchedulingParameterPolicy::SegmentSchedulingParameterPolicy (void) +{} + +FP_Scheduling::SegmentSchedulingParameterPolicy::~SegmentSchedulingParameterPolicy (void) +{} + +void +FP_Scheduling::SegmentSchedulingParameterPolicy::_tao_any_destructor (void *_tao_void_pointer) +{ + SegmentSchedulingParameterPolicy *tmp = ACE_static_cast (SegmentSchedulingParameterPolicy *, _tao_void_pointer); + CORBA::release (tmp); +} + +FP_Scheduling::SegmentSchedulingParameterPolicy_ptr +FP_Scheduling::SegmentSchedulingParameterPolicy::_narrow ( + CORBA::Object_ptr obj + ACE_ENV_ARG_DECL + ) +{ + return SegmentSchedulingParameterPolicy::_unchecked_narrow (obj ACE_ENV_ARG_PARAMETER); +} + +FP_Scheduling::SegmentSchedulingParameterPolicy_ptr +FP_Scheduling::SegmentSchedulingParameterPolicy::_unchecked_narrow ( + CORBA::Object_ptr obj + ACE_ENV_ARG_DECL_NOT_USED + ) +{ + if (CORBA::is_nil (obj)) + { + return SegmentSchedulingParameterPolicy::_nil (); + } + + return + ACE_reinterpret_cast ( + SegmentSchedulingParameterPolicy_ptr, + obj->_tao_QueryInterface ( + ACE_reinterpret_cast ( + ptrdiff_t, + &SegmentSchedulingParameterPolicy::_tao_class_id + ) + ) + ); +} + +FP_Scheduling::SegmentSchedulingParameterPolicy_ptr +FP_Scheduling::SegmentSchedulingParameterPolicy::_duplicate (SegmentSchedulingParameterPolicy_ptr obj) +{ + if (! CORBA::is_nil (obj)) + { + obj->_add_ref (); + } + + return obj; +} + +void *FP_Scheduling::SegmentSchedulingParameterPolicy::_tao_QueryInterface (ptrdiff_t type) +{ + void *retv = 0; + + if (type == ACE_reinterpret_cast ( + ptrdiff_t, + &::CORBA::Policy::_tao_class_id) + ) + { + retv = + ACE_reinterpret_cast ( + void *, + ACE_static_cast ( + CORBA::Policy_ptr, + this + ) + ); + } + else if (type == ACE_reinterpret_cast ( + ptrdiff_t, + &ACE_NESTED_CLASS (::FP_Scheduling, SegmentSchedulingParameterPolicy)::_tao_class_id) + ) + { + retv = ACE_reinterpret_cast (void*, this); + } + else if (type == ACE_reinterpret_cast ( + ptrdiff_t, + &CORBA::Object::_tao_class_id) + ) + { + retv = + ACE_reinterpret_cast ( + void *, + ACE_static_cast (CORBA::Object_ptr, this) + ); + } + + if (retv != 0) + { + this->_add_ref (); + } + + return retv; +} + +const char* FP_Scheduling::SegmentSchedulingParameterPolicy::_interface_repository_id (void) const +{ + return "IDL:FP_Scheduling/SegmentSchedulingParameterPolicy:1.0"; +} + +CORBA::Boolean +FP_Scheduling::SegmentSchedulingParameterPolicy::marshal (TAO_OutputCDR &) +{ + return 0; +} + +// TAO_IDL - Generated from +// be/be_visitor_typecode/typecode_defn.cpp:284 + +static const CORBA::Long _oc_FP_Scheduling_SegmentSchedulingParameterPolicy[] = +{ + TAO_ENCAP_BYTE_ORDER, // byte order + 55, + ACE_NTOHL (0x49444c3a), + ACE_NTOHL (0x46505f53), + ACE_NTOHL (0x63686564), + ACE_NTOHL (0x756c696e), + ACE_NTOHL (0x672f5365), + ACE_NTOHL (0x676d656e), + ACE_NTOHL (0x74536368), + ACE_NTOHL (0x6564756c), + ACE_NTOHL (0x696e6750), + ACE_NTOHL (0x6172616d), + ACE_NTOHL (0x65746572), + ACE_NTOHL (0x506f6c69), + ACE_NTOHL (0x63793a31), + ACE_NTOHL (0x2e300000), // repository ID = IDL:FP_Scheduling/SegmentSchedulingParameterPolicy:1.0 + 33, + ACE_NTOHL (0x5365676d), + ACE_NTOHL (0x656e7453), + ACE_NTOHL (0x63686564), + ACE_NTOHL (0x756c696e), + ACE_NTOHL (0x67506172), + ACE_NTOHL (0x616d6574), + ACE_NTOHL (0x6572506f), + ACE_NTOHL (0x6c696379), + ACE_NTOHL (0x0), // name = SegmentSchedulingParameterPolicy + }; + +static CORBA::TypeCode _tc_TAO_tc_FP_Scheduling_SegmentSchedulingParameterPolicy ( + CORBA::tk_objref, + sizeof (_oc_FP_Scheduling_SegmentSchedulingParameterPolicy), + (char *) &_oc_FP_Scheduling_SegmentSchedulingParameterPolicy, + 0, + sizeof (FP_Scheduling::SegmentSchedulingParameterPolicy) + ); + +TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) +TAO_NAMESPACE_BEGIN (FP_Scheduling) +TAO_NAMESPACE_DEFINE ( + ::CORBA::TypeCode_ptr, + _tc_SegmentSchedulingParameterPolicy, + &_tc_TAO_tc_FP_Scheduling_SegmentSchedulingParameterPolicy + ) +TAO_NAMESPACE_END + +// TAO_IDL - Generated from +// be/be_visitor_interface/interface_cs.cpp:63 + +int FP_Scheduling::FP_Scheduler::_tao_class_id = 0; + +FP_Scheduling::FP_Scheduler_ptr +FP_Scheduling::tao_FP_Scheduler_life::tao_duplicate ( + FP_Scheduler_ptr p + ) +{ + return FP_Scheduler::_duplicate (p); +} + +void +FP_Scheduling::tao_FP_Scheduler_life::tao_release ( + FP_Scheduler_ptr p + ) +{ + CORBA::release (p); +} + +FP_Scheduling::FP_Scheduler_ptr +FP_Scheduling::tao_FP_Scheduler_life::tao_nil ( + void + ) +{ + return FP_Scheduler::_nil (); +} + +CORBA::Boolean +FP_Scheduling::tao_FP_Scheduler_life::tao_marshal ( + FP_Scheduler_ptr p, + TAO_OutputCDR &cdr + ) +{ + return p->marshal (cdr); +} + +FP_Scheduling::FP_Scheduler_ptr +FP_Scheduling::tao_FP_Scheduler_cast::tao_narrow ( + CORBA::Object *p + ACE_ENV_ARG_DECL + ) +{ + return FP_Scheduler::_narrow (p ACE_ENV_ARG_PARAMETER); +} + +CORBA::Object * +FP_Scheduling::tao_FP_Scheduler_cast::tao_upcast ( + void *src + ) +{ + FP_Scheduler **tmp = + ACE_static_cast (FP_Scheduler **, src); + return *tmp; +} + +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) + template class + TAO_Objref_Var_T< + FP_Scheduling::FP_Scheduler, + FP_Scheduling::tao_FP_Scheduler_life + >; + template class + TAO_Objref_Out_T< + FP_Scheduling::FP_Scheduler, + FP_Scheduling::tao_FP_Scheduler_life + >; +#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) +# pragma instantiate \ + TAO_Objref_Var_T< \ + FP_Scheduling::FP_Scheduler, \ + FP_Scheduling::tao_FP_Scheduler_life \ + > +# pragma instantiate \ + TAO_Objref_Out_T< \ + FP_Scheduling::FP_Scheduler, \ + FP_Scheduling::tao_FP_Scheduler_life \ + > +#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ + +// TAO_IDL - Generated from +// be/be_visitor_interface/interface_cs.cpp:245 + +FP_Scheduling::FP_Scheduler::FP_Scheduler (void) +{} + +FP_Scheduling::FP_Scheduler::~FP_Scheduler (void) +{} + +void +FP_Scheduling::FP_Scheduler::_tao_any_destructor (void *_tao_void_pointer) +{ + FP_Scheduler *tmp = ACE_static_cast (FP_Scheduler *, _tao_void_pointer); + CORBA::release (tmp); +} + +FP_Scheduling::FP_Scheduler_ptr +FP_Scheduling::FP_Scheduler::_narrow ( + CORBA::Object_ptr obj + ACE_ENV_ARG_DECL + ) +{ + return FP_Scheduler::_unchecked_narrow (obj ACE_ENV_ARG_PARAMETER); +} + +FP_Scheduling::FP_Scheduler_ptr +FP_Scheduling::FP_Scheduler::_unchecked_narrow ( + CORBA::Object_ptr obj + ACE_ENV_ARG_DECL_NOT_USED + ) +{ + if (CORBA::is_nil (obj)) + { + return FP_Scheduler::_nil (); + } + + return + ACE_reinterpret_cast ( + FP_Scheduler_ptr, + obj->_tao_QueryInterface ( + ACE_reinterpret_cast ( + ptrdiff_t, + &FP_Scheduler::_tao_class_id + ) + ) + ); +} + +FP_Scheduling::FP_Scheduler_ptr +FP_Scheduling::FP_Scheduler::_duplicate (FP_Scheduler_ptr obj) +{ + if (! CORBA::is_nil (obj)) + { + obj->_add_ref (); + } + + return obj; +} + +void *FP_Scheduling::FP_Scheduler::_tao_QueryInterface (ptrdiff_t type) +{ + void *retv = 0; + + if (type == ACE_reinterpret_cast ( + ptrdiff_t, + &::RTScheduling::Scheduler::_tao_class_id) + ) + { + retv = + ACE_reinterpret_cast ( + void *, + ACE_static_cast ( + RTScheduling::Scheduler_ptr, + this + ) + ); + } + else if (type == ACE_reinterpret_cast ( + ptrdiff_t, + &ACE_NESTED_CLASS (::FP_Scheduling, FP_Scheduler)::_tao_class_id) + ) + { + retv = ACE_reinterpret_cast (void*, this); + } + else if (type == ACE_reinterpret_cast ( + ptrdiff_t, + &CORBA::Object::_tao_class_id) + ) + { + retv = + ACE_reinterpret_cast ( + void *, + ACE_static_cast (CORBA::Object_ptr, this) + ); + } + + if (retv != 0) + { + this->_add_ref (); + } + + return retv; +} + +const char* FP_Scheduling::FP_Scheduler::_interface_repository_id (void) const +{ + return "IDL:FP_Scheduling/FP_Scheduler:1.0"; +} + +CORBA::Boolean +FP_Scheduling::FP_Scheduler::marshal (TAO_OutputCDR &) +{ + return 0; +} + +// TAO_IDL - Generated from +// be/be_visitor_typecode/typecode_defn.cpp:284 + +static const CORBA::Long _oc_FP_Scheduling_FP_Scheduler[] = +{ + TAO_ENCAP_BYTE_ORDER, // byte order + 35, + ACE_NTOHL (0x49444c3a), + ACE_NTOHL (0x46505f53), + ACE_NTOHL (0x63686564), + ACE_NTOHL (0x756c696e), + ACE_NTOHL (0x672f4650), + ACE_NTOHL (0x5f536368), + ACE_NTOHL (0x6564756c), + ACE_NTOHL (0x65723a31), + ACE_NTOHL (0x2e300000), // repository ID = IDL:FP_Scheduling/FP_Scheduler:1.0 + 13, + ACE_NTOHL (0x46505f53), + ACE_NTOHL (0x63686564), + ACE_NTOHL (0x756c6572), + ACE_NTOHL (0x0), // name = FP_Scheduler + }; + +static CORBA::TypeCode _tc_TAO_tc_FP_Scheduling_FP_Scheduler ( + CORBA::tk_objref, + sizeof (_oc_FP_Scheduling_FP_Scheduler), + (char *) &_oc_FP_Scheduling_FP_Scheduler, + 0, + sizeof (FP_Scheduling::FP_Scheduler) + ); + +TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) +TAO_NAMESPACE_BEGIN (FP_Scheduling) +TAO_NAMESPACE_DEFINE ( + ::CORBA::TypeCode_ptr, + _tc_FP_Scheduler, + &_tc_TAO_tc_FP_Scheduling_FP_Scheduler + ) +TAO_NAMESPACE_END + +// TAO_IDL - Generated from +// be/be_visitor_structure/any_op_cs.cpp:54 + +// Copying insertion. +void operator<<= ( + CORBA::Any &_tao_any, + const FP_Scheduling::SegmentSchedulingParameter &_tao_elem + ) +{ + TAO::Any_Dual_Impl_T::insert_copy ( + _tao_any, + FP_Scheduling::SegmentSchedulingParameter::_tao_any_destructor, + FP_Scheduling::_tc_SegmentSchedulingParameter, + _tao_elem + ); +} + +// Non-copying insertion. +void operator<<= ( + CORBA::Any &_tao_any, + FP_Scheduling::SegmentSchedulingParameter *_tao_elem + ) +{ + TAO::Any_Dual_Impl_T::insert ( + _tao_any, + FP_Scheduling::SegmentSchedulingParameter::_tao_any_destructor, + FP_Scheduling::_tc_SegmentSchedulingParameter, + _tao_elem + ); +} + +// Extraction to non-const pointer (deprecated). +CORBA::Boolean operator>>= ( + const CORBA::Any &_tao_any, + FP_Scheduling::SegmentSchedulingParameter *&_tao_elem + ) +{ + return _tao_any >>= ACE_const_cast ( + const FP_Scheduling::SegmentSchedulingParameter *&, + _tao_elem + ); +} + +// Extraction to const pointer. +CORBA::Boolean operator>>= ( + const CORBA::Any &_tao_any, + const FP_Scheduling::SegmentSchedulingParameter *&_tao_elem + ) +{ + return + TAO::Any_Dual_Impl_T::extract ( + _tao_any, + FP_Scheduling::SegmentSchedulingParameter::_tao_any_destructor, + FP_Scheduling::_tc_SegmentSchedulingParameter, + _tao_elem + ); +} + +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \ + defined (ACE_HAS_GNU_REPO) + template class TAO::Any_Dual_Impl_T; +#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) +# pragma instantiate TAO::Any_Dual_Impl_T +#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ + +// TAO_IDL - Generated from +// be/be_visitor_interface/any_op_cs.cpp:50 + +// Copying insertion. +void +operator<<= ( + CORBA::Any &_tao_any, + FP_Scheduling::SegmentSchedulingParameterPolicy_ptr _tao_elem + ) +{ + FP_Scheduling::SegmentSchedulingParameterPolicy_ptr _tao_objptr = + FP_Scheduling::SegmentSchedulingParameterPolicy::_duplicate (_tao_elem); + _tao_any <<= &_tao_objptr; +} + +// Non-copying insertion. +void +operator<<= ( + CORBA::Any &_tao_any, + FP_Scheduling::SegmentSchedulingParameterPolicy_ptr *_tao_elem + ) +{ + TAO::Any_Impl_T::insert ( + _tao_any, + FP_Scheduling::SegmentSchedulingParameterPolicy::_tao_any_destructor, + FP_Scheduling::_tc_SegmentSchedulingParameterPolicy, + *_tao_elem + ); +} + +CORBA::Boolean +operator>>= ( + const CORBA::Any &_tao_any, + FP_Scheduling::SegmentSchedulingParameterPolicy_ptr &_tao_elem + ) +{ + return + TAO::Any_Impl_T::extract ( + _tao_any, + FP_Scheduling::SegmentSchedulingParameterPolicy::_tao_any_destructor, + FP_Scheduling::_tc_SegmentSchedulingParameterPolicy, + _tao_elem + ); +} + +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \ + defined (ACE_HAS_GNU_REPO) + template class TAO::Any_Impl_T; +#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) +# pragma instantiate TAO::Any_Impl_T +#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ + +// TAO_IDL - Generated from +// be/be_visitor_interface/any_op_cs.cpp:50 + +// Copying insertion. +void +operator<<= ( + CORBA::Any &_tao_any, + FP_Scheduling::FP_Scheduler_ptr _tao_elem + ) +{ + FP_Scheduling::FP_Scheduler_ptr _tao_objptr = + FP_Scheduling::FP_Scheduler::_duplicate (_tao_elem); + _tao_any <<= &_tao_objptr; +} + +// Non-copying insertion. +void +operator<<= ( + CORBA::Any &_tao_any, + FP_Scheduling::FP_Scheduler_ptr *_tao_elem + ) +{ + TAO::Any_Impl_T::insert ( + _tao_any, + FP_Scheduling::FP_Scheduler::_tao_any_destructor, + FP_Scheduling::_tc_FP_Scheduler, + *_tao_elem + ); +} + +CORBA::Boolean +operator>>= ( + const CORBA::Any &_tao_any, + FP_Scheduling::FP_Scheduler_ptr &_tao_elem + ) +{ + return + TAO::Any_Impl_T::extract ( + _tao_any, + FP_Scheduling::FP_Scheduler::_tao_any_destructor, + FP_Scheduling::_tc_FP_Scheduler, + _tao_elem + ); +} + +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \ + defined (ACE_HAS_GNU_REPO) + template class TAO::Any_Impl_T; +#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) +# pragma instantiate TAO::Any_Impl_T +#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ + diff --git a/TAO/examples/Kokyu_dsrt_schedulers/FP_SchedulingC.h b/TAO/examples/Kokyu_dsrt_schedulers/FP_SchedulingC.h new file mode 100644 index 00000000000..af0f64eac8b --- /dev/null +++ b/TAO/examples/Kokyu_dsrt_schedulers/FP_SchedulingC.h @@ -0,0 +1,405 @@ +// -*- 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:151 + +#ifndef _TAO_IDL_FP_SCHEDULINGC_H_ +#define _TAO_IDL_FP_SCHEDULINGC_H_ + + +#include "tao/corba.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + + +#include "tao/RTScheduling/RTScheduler.h" +#include "tao/RTCORBA/RTCORBA.h" + +#if defined (TAO_EXPORT_MACRO) +#undef TAO_EXPORT_MACRO +#endif +#define TAO_EXPORT_MACRO + +#if defined (TAO_EXPORT_NESTED_CLASSES) +# if defined (TAO_EXPORT_NESTED_MACRO) +# undef TAO_EXPORT_NESTED_MACRO +# endif /* defined (TAO_EXPORT_NESTED_MACRO) */ +# define TAO_EXPORT_NESTED_MACRO +#endif /* TAO_EXPORT_NESTED_CLASSES */ + +#if defined(_MSC_VER) +#if (_MSC_VER >= 1200) +#pragma warning(push) +#endif /* _MSC_VER >= 1200 */ +#pragma warning(disable:4250) +#endif /* _MSC_VER */ + +#if defined (__BORLANDC__) +#pragma option push -w-rvl -w-rch -w-ccc -w-inl +#endif /* __BORLANDC__ */ + +// TAO_IDL - Generated from +// be/be_visitor_module/module_ch.cpp:48 + +TAO_NAMESPACE FP_Scheduling +{ + + // TAO_IDL - Generated from + // be/be_type.cpp:254 + + struct SegmentSchedulingParameter; + + typedef + TAO_Fixed_Var_T< + SegmentSchedulingParameter + > + SegmentSchedulingParameter_var; + + typedef + SegmentSchedulingParameter & + SegmentSchedulingParameter_out; + + // TAO_IDL - Generated from + // be/be_visitor_structure/structure_ch.cpp:52 + + struct SegmentSchedulingParameter + { + typedef SegmentSchedulingParameter_var _var_type; + + static void _tao_any_destructor (void *); + RTCORBA::Priority base_priority; + }; + + // TAO_IDL - Generated from + // be/be_visitor_typecode/typecode_decl.cpp:44 + + TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_SegmentSchedulingParameter; + + // TAO_IDL - Generated from + // be/be_interface.cpp:584 + +#if !defined (_FP_SCHEDULING_SEGMENTSCHEDULINGPARAMETERPOLICY__ODDS_N_ENDS_CH_) +#define _FP_SCHEDULING_SEGMENTSCHEDULINGPARAMETERPOLICY__ODDS_N_ENDS_CH_ + + class SegmentSchedulingParameterPolicy; + typedef SegmentSchedulingParameterPolicy *SegmentSchedulingParameterPolicy_ptr; + struct tao_SegmentSchedulingParameterPolicy_life; + + typedef + TAO_Objref_Var_T< + SegmentSchedulingParameterPolicy, + tao_SegmentSchedulingParameterPolicy_life + > + SegmentSchedulingParameterPolicy_var; + + typedef + TAO_Objref_Out_T< + SegmentSchedulingParameterPolicy, + tao_SegmentSchedulingParameterPolicy_life + > + SegmentSchedulingParameterPolicy_out; + + struct tao_SegmentSchedulingParameterPolicy_life + { + static SegmentSchedulingParameterPolicy_ptr tao_duplicate (SegmentSchedulingParameterPolicy_ptr); + static void tao_release (SegmentSchedulingParameterPolicy_ptr); + static SegmentSchedulingParameterPolicy_ptr tao_nil (void); + static CORBA::Boolean tao_marshal ( + SegmentSchedulingParameterPolicy_ptr, + TAO_OutputCDR & + ); + }; + + struct tao_SegmentSchedulingParameterPolicy_cast + { + static SegmentSchedulingParameterPolicy_ptr tao_narrow ( + CORBA::Object_ptr + ACE_ENV_ARG_DECL + ); + static CORBA::Object_ptr tao_upcast (void *); + }; + +#endif /* end #if !defined */ + + // TAO_IDL - Generated from + // be/be_visitor_interface/interface_ch.cpp:53 + +#if !defined (_FP_SCHEDULING_SEGMENTSCHEDULINGPARAMETERPOLICY_CH_) +#define _FP_SCHEDULING_SEGMENTSCHEDULINGPARAMETERPOLICY_CH_ + + class SegmentSchedulingParameterPolicy + : public virtual CORBA::Policy + { + public: + typedef SegmentSchedulingParameterPolicy_ptr _ptr_type; + typedef SegmentSchedulingParameterPolicy_var _var_type; + static int _tao_class_id; + + // The static operations. + static SegmentSchedulingParameterPolicy_ptr _duplicate (SegmentSchedulingParameterPolicy_ptr obj); + + static SegmentSchedulingParameterPolicy_ptr _narrow ( + CORBA::Object_ptr obj + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ); + + static SegmentSchedulingParameterPolicy_ptr _unchecked_narrow ( + CORBA::Object_ptr obj + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ); + + static SegmentSchedulingParameterPolicy_ptr _nil (void) + { + return (SegmentSchedulingParameterPolicy_ptr)0; + } + + static void _tao_any_destructor (void *); + + // TAO_IDL - Generated from + // be/be_visitor_operation/operation_ch.cpp:46 + + virtual ::FP_Scheduling::SegmentSchedulingParameter value ( + ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + + // TAO_IDL - Generated from + // be/be_visitor_operation/operation_ch.cpp:46 + + virtual void value ( + const FP_Scheduling::SegmentSchedulingParameter & value + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + + // TAO_IDL - Generated from + // be/be_visitor_interface/interface_ch.cpp:210 + + virtual void *_tao_QueryInterface (ptrdiff_t type); + + virtual const char* _interface_repository_id (void) const; + virtual CORBA::Boolean marshal (TAO_OutputCDR &cdr); + + protected: + SegmentSchedulingParameterPolicy (void); + virtual ~SegmentSchedulingParameterPolicy (void); + + private: + SegmentSchedulingParameterPolicy (const SegmentSchedulingParameterPolicy &); + void operator= (const SegmentSchedulingParameterPolicy &); + }; + +#endif /* end #if !defined */ + + // TAO_IDL - Generated from + // be/be_visitor_typecode/typecode_decl.cpp:44 + + TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_SegmentSchedulingParameterPolicy; + + // TAO_IDL - Generated from + // be/be_interface.cpp:584 + +#if !defined (_FP_SCHEDULING_FP_SCHEDULER__ODDS_N_ENDS_CH_) +#define _FP_SCHEDULING_FP_SCHEDULER__ODDS_N_ENDS_CH_ + + class FP_Scheduler; + typedef FP_Scheduler *FP_Scheduler_ptr; + struct tao_FP_Scheduler_life; + + typedef + TAO_Objref_Var_T< + FP_Scheduler, + tao_FP_Scheduler_life + > + FP_Scheduler_var; + + typedef + TAO_Objref_Out_T< + FP_Scheduler, + tao_FP_Scheduler_life + > + FP_Scheduler_out; + + struct tao_FP_Scheduler_life + { + static FP_Scheduler_ptr tao_duplicate (FP_Scheduler_ptr); + static void tao_release (FP_Scheduler_ptr); + static FP_Scheduler_ptr tao_nil (void); + static CORBA::Boolean tao_marshal ( + FP_Scheduler_ptr, + TAO_OutputCDR & + ); + }; + + struct tao_FP_Scheduler_cast + { + static FP_Scheduler_ptr tao_narrow ( + CORBA::Object_ptr + ACE_ENV_ARG_DECL + ); + static CORBA::Object_ptr tao_upcast (void *); + }; + +#endif /* end #if !defined */ + + // TAO_IDL - Generated from + // be/be_visitor_interface/interface_ch.cpp:53 + +#if !defined (_FP_SCHEDULING_FP_SCHEDULER_CH_) +#define _FP_SCHEDULING_FP_SCHEDULER_CH_ + + class FP_Scheduler + : public virtual RTScheduling::Scheduler + { + public: + typedef FP_Scheduler_ptr _ptr_type; + typedef FP_Scheduler_var _var_type; + static int _tao_class_id; + + // The static operations. + static FP_Scheduler_ptr _duplicate (FP_Scheduler_ptr obj); + + static FP_Scheduler_ptr _narrow ( + CORBA::Object_ptr obj + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ); + + static FP_Scheduler_ptr _unchecked_narrow ( + CORBA::Object_ptr obj + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ); + + static FP_Scheduler_ptr _nil (void) + { + return (FP_Scheduler_ptr)0; + } + + static void _tao_any_destructor (void *); + + // TAO_IDL - Generated from + // be/be_visitor_operation/operation_ch.cpp:46 + + virtual ::FP_Scheduling::SegmentSchedulingParameterPolicy_ptr create_segment_scheduling_parameter ( + const FP_Scheduling::SegmentSchedulingParameter & value + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + + // TAO_IDL - Generated from + // be/be_visitor_interface/interface_ch.cpp:210 + + virtual void *_tao_QueryInterface (ptrdiff_t type); + + virtual const char* _interface_repository_id (void) const; + virtual CORBA::Boolean marshal (TAO_OutputCDR &cdr); + + protected: + FP_Scheduler (void); + virtual ~FP_Scheduler (void); + + private: + FP_Scheduler (const FP_Scheduler &); + void operator= (const FP_Scheduler &); + }; + +#endif /* end #if !defined */ + + // TAO_IDL - Generated from + // be/be_visitor_typecode/typecode_decl.cpp:44 + + TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_FP_Scheduler; + +// TAO_IDL - Generated from +// be/be_visitor_module/module_ch.cpp:67 + +} +TAO_NAMESPACE_CLOSE // module FP_Scheduling + +// TAO_IDL - Generated from +// be/be_visitor_structure/any_op_ch.cpp:52 + + void operator<<= (CORBA::Any &, const FP_Scheduling::SegmentSchedulingParameter &); // copying version + void operator<<= (CORBA::Any &, FP_Scheduling::SegmentSchedulingParameter*); // noncopying version + CORBA::Boolean operator>>= (const CORBA::Any &, FP_Scheduling::SegmentSchedulingParameter *&); // deprecated + CORBA::Boolean operator>>= (const CORBA::Any &, const FP_Scheduling::SegmentSchedulingParameter *&); + +// TAO_IDL - Generated from +// be/be_visitor_interface/any_op_ch.cpp:52 + + void operator<<= (CORBA::Any &, FP_Scheduling::SegmentSchedulingParameterPolicy_ptr); // copying + void operator<<= (CORBA::Any &, FP_Scheduling::SegmentSchedulingParameterPolicy_ptr *); // non-copying + CORBA::Boolean operator>>= (const CORBA::Any &, FP_Scheduling::SegmentSchedulingParameterPolicy_ptr &); + +// TAO_IDL - Generated from +// be/be_visitor_interface/any_op_ch.cpp:52 + + void operator<<= (CORBA::Any &, FP_Scheduling::FP_Scheduler_ptr); // copying + void operator<<= (CORBA::Any &, FP_Scheduling::FP_Scheduler_ptr *); // non-copying + CORBA::Boolean operator>>= (const CORBA::Any &, FP_Scheduling::FP_Scheduler_ptr &); + +// TAO_IDL - Generated from +// be/be_visitor_root/cdr_op.cpp:48 + +#ifndef __ACE_INLINE__ + +// TAO_IDL - Generated from +// be/be_visitor_structure/cdr_op_ch.cpp:53 + + CORBA::Boolean operator<< (TAO_OutputCDR &, const FP_Scheduling::SegmentSchedulingParameter &); + CORBA::Boolean operator>> (TAO_InputCDR &, FP_Scheduling::SegmentSchedulingParameter &); + +// TAO_IDL - Generated from +// be/be_visitor_root/cdr_op.cpp:64 + +#endif /* __ACE_INLINE__ */ + +// TAO_IDL - Generated from +// be/be_codegen.cpp:1059 + +#if defined (__ACE_INLINE__) +#include "FP_SchedulingC.i" +#endif /* defined INLINE */ + +#if defined(_MSC_VER) && (_MSC_VER >= 1200) +#pragma warning(pop) +#endif /* _MSC_VER */ + +#if defined (__BORLANDC__) +#pragma option pop +#endif /* __BORLANDC__ */ + +#endif /* ifndef */ + diff --git a/TAO/examples/Kokyu_dsrt_schedulers/FP_SchedulingC.i b/TAO/examples/Kokyu_dsrt_schedulers/FP_SchedulingC.i new file mode 100644 index 00000000000..9ca1ba7b10f --- /dev/null +++ b/TAO/examples/Kokyu_dsrt_schedulers/FP_SchedulingC.i @@ -0,0 +1,121 @@ +// -*- 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_visitor_interface/interface_ci.cpp:63 + +#if !defined (_FP_SCHEDULING_SEGMENTSCHEDULINGPARAMETERPOLICY___CI_) +#define _FP_SCHEDULING_SEGMENTSCHEDULINGPARAMETERPOLICY___CI_ + +template<> +ACE_INLINE +CORBA::Boolean +TAO::Any_Impl_T::to_object ( + CORBA::Object_ptr &_tao_elem + ) const +{ + _tao_elem = CORBA::Object::_duplicate (this->value_); + return 1; +} + +template<> +ACE_INLINE +CORBA::Boolean +TAO::Any_Impl_T::marshal_value (TAO_OutputCDR &) +{ + return 0; +} + +template<> +ACE_INLINE +CORBA::Boolean +TAO::Any_Impl_T::demarshal_value (TAO_InputCDR &) +{ + return 0; +} + +#endif /* end #if !defined */ + +// TAO_IDL - Generated from +// be/be_visitor_interface/interface_ci.cpp:63 + +#if !defined (_FP_SCHEDULING_FP_SCHEDULER___CI_) +#define _FP_SCHEDULING_FP_SCHEDULER___CI_ + +template<> +ACE_INLINE +CORBA::Boolean +TAO::Any_Impl_T::to_object ( + CORBA::Object_ptr &_tao_elem + ) const +{ + _tao_elem = CORBA::Object::_duplicate (this->value_); + return 1; +} + +template<> +ACE_INLINE +CORBA::Boolean +TAO::Any_Impl_T::marshal_value (TAO_OutputCDR &) +{ + return 0; +} + +template<> +ACE_INLINE +CORBA::Boolean +TAO::Any_Impl_T::demarshal_value (TAO_InputCDR &) +{ + return 0; +} + +#endif /* end #if !defined */ + +// TAO_IDL - Generated from +// be/be_visitor_structure/cdr_op_ci.cpp:70 + +ACE_INLINE +CORBA::Boolean operator<< ( + TAO_OutputCDR &strm, + const FP_Scheduling::SegmentSchedulingParameter &_tao_aggregate + ) +{ + return + (strm << _tao_aggregate.base_priority); +} + +ACE_INLINE +CORBA::Boolean operator>> ( + TAO_InputCDR &strm, + FP_Scheduling::SegmentSchedulingParameter &_tao_aggregate + ) +{ + return + (strm >> _tao_aggregate.base_priority); +} + diff --git a/TAO/examples/Kokyu_dsrt_schedulers/MIF_SchedulingC.cpp b/TAO/examples/Kokyu_dsrt_schedulers/MIF_SchedulingC.cpp new file mode 100644 index 00000000000..7d7f62eaa55 --- /dev/null +++ b/TAO/examples/Kokyu_dsrt_schedulers/MIF_SchedulingC.cpp @@ -0,0 +1,784 @@ +// -*- 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:351 + + +#include "MIF_SchedulingC.h" +#include "tao/Stub.h" +#include "tao/Invocation.h" +#include "tao/PortableInterceptor.h" + +#if TAO_HAS_INTERCEPTORS == 1 +#include "tao/RequestInfo_Util.h" +#include "tao/ClientRequestInfo_i.h" +#include "tao/ClientInterceptorAdapter.h" +#endif /* TAO_HAS_INTERCEPTORS == 1 */ + + +#if defined (__BORLANDC__) +#pragma option -w-rvl -w-rch -w-ccc -w-aus -w-sig +#endif /* __BORLANDC__ */ + +#if !defined (__ACE_INLINE__) +#include "MIF_SchedulingC.i" +#endif /* !defined INLINE */ + +// TAO_IDL - Generated from +// be/be_visitor_typecode/typecode_defn.cpp:284 + +static const CORBA::Long _oc_MIF_Scheduling_SchedulingParameter[] = +{ + TAO_ENCAP_BYTE_ORDER, // byte order + 43, + ACE_NTOHL (0x49444c3a), + ACE_NTOHL (0x4d49465f), + ACE_NTOHL (0x53636865), + ACE_NTOHL (0x64756c69), + ACE_NTOHL (0x6e672f53), + ACE_NTOHL (0x63686564), + ACE_NTOHL (0x756c696e), + ACE_NTOHL (0x67506172), + ACE_NTOHL (0x616d6574), + ACE_NTOHL (0x65723a31), + ACE_NTOHL (0x2e300000), // repository ID = IDL:MIF_Scheduling/SchedulingParameter:1.0 + 20, + ACE_NTOHL (0x53636865), + ACE_NTOHL (0x64756c69), + ACE_NTOHL (0x6e675061), + ACE_NTOHL (0x72616d65), + ACE_NTOHL (0x74657200), // name = SchedulingParameter + 1, // member count + 11, + ACE_NTOHL (0x696d706f), + ACE_NTOHL (0x7274616e), + ACE_NTOHL (0x63650000), // name = importance + CORBA::tk_long, + +}; + +static CORBA::TypeCode _tc_TAO_tc_MIF_Scheduling_SchedulingParameter ( + CORBA::tk_struct, + sizeof (_oc_MIF_Scheduling_SchedulingParameter), + (char *) &_oc_MIF_Scheduling_SchedulingParameter, + 0, + sizeof (MIF_Scheduling::SchedulingParameter) + ); + +TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) +TAO_NAMESPACE_BEGIN (MIF_Scheduling) +TAO_NAMESPACE_DEFINE ( + ::CORBA::TypeCode_ptr, + _tc_SchedulingParameter, + &_tc_TAO_tc_MIF_Scheduling_SchedulingParameter + ) +TAO_NAMESPACE_END + +// TAO_IDL - Generated from +// be/be_visitor_structure/structure_cs.cpp:66 + +void MIF_Scheduling::SchedulingParameter::_tao_any_destructor (void *_tao_void_pointer) +{ + SchedulingParameter *tmp = ACE_static_cast (SchedulingParameter*, _tao_void_pointer); + delete tmp; +} + +// TAO_IDL - Generated from +// be/be_type.cpp:297 + +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) + +template class + TAO_Fixed_Var_T< + MIF_Scheduling::SchedulingParameter + >; + +template class TAO_Var_Base_T< + MIF_Scheduling::SchedulingParameter + >; + +#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) + +# pragma instantiate \ + TAO_Fixed_Var_T< \ + MIF_Scheduling::SchedulingParameter \ + > + +#pragma instantiate TAO_Var_Base_T< + MIF_Scheduling::SchedulingParameter + > + +#endif /* !ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ + +// TAO_IDL - Generated from +// be/be_visitor_interface/interface_cs.cpp:63 + +int MIF_Scheduling::SchedulingParameterPolicy::_tao_class_id = 0; + +MIF_Scheduling::SchedulingParameterPolicy_ptr +MIF_Scheduling::tao_SchedulingParameterPolicy_life::tao_duplicate ( + SchedulingParameterPolicy_ptr p + ) +{ + return SchedulingParameterPolicy::_duplicate (p); +} + +void +MIF_Scheduling::tao_SchedulingParameterPolicy_life::tao_release ( + SchedulingParameterPolicy_ptr p + ) +{ + CORBA::release (p); +} + +MIF_Scheduling::SchedulingParameterPolicy_ptr +MIF_Scheduling::tao_SchedulingParameterPolicy_life::tao_nil ( + void + ) +{ + return SchedulingParameterPolicy::_nil (); +} + +CORBA::Boolean +MIF_Scheduling::tao_SchedulingParameterPolicy_life::tao_marshal ( + SchedulingParameterPolicy_ptr p, + TAO_OutputCDR &cdr + ) +{ + return p->marshal (cdr); +} + +MIF_Scheduling::SchedulingParameterPolicy_ptr +MIF_Scheduling::tao_SchedulingParameterPolicy_cast::tao_narrow ( + CORBA::Object *p + ACE_ENV_ARG_DECL + ) +{ + return SchedulingParameterPolicy::_narrow (p ACE_ENV_ARG_PARAMETER); +} + +CORBA::Object * +MIF_Scheduling::tao_SchedulingParameterPolicy_cast::tao_upcast ( + void *src + ) +{ + SchedulingParameterPolicy **tmp = + ACE_static_cast (SchedulingParameterPolicy **, src); + return *tmp; +} + +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) + template class + TAO_Objref_Var_T< + MIF_Scheduling::SchedulingParameterPolicy, + MIF_Scheduling::tao_SchedulingParameterPolicy_life + >; + template class + TAO_Objref_Out_T< + MIF_Scheduling::SchedulingParameterPolicy, + MIF_Scheduling::tao_SchedulingParameterPolicy_life + >; +#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) +# pragma instantiate \ + TAO_Objref_Var_T< \ + MIF_Scheduling::SchedulingParameterPolicy, \ + MIF_Scheduling::tao_SchedulingParameterPolicy_life \ + > +# pragma instantiate \ + TAO_Objref_Out_T< \ + MIF_Scheduling::SchedulingParameterPolicy, \ + MIF_Scheduling::tao_SchedulingParameterPolicy_life \ + > +#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ + +// TAO_IDL - Generated from +// be/be_visitor_interface/interface_cs.cpp:245 + +MIF_Scheduling::SchedulingParameterPolicy::SchedulingParameterPolicy (void) +{} + +MIF_Scheduling::SchedulingParameterPolicy::~SchedulingParameterPolicy (void) +{} + +void +MIF_Scheduling::SchedulingParameterPolicy::_tao_any_destructor (void *_tao_void_pointer) +{ + SchedulingParameterPolicy *tmp = ACE_static_cast (SchedulingParameterPolicy *, _tao_void_pointer); + CORBA::release (tmp); +} + +MIF_Scheduling::SchedulingParameterPolicy_ptr +MIF_Scheduling::SchedulingParameterPolicy::_narrow ( + CORBA::Object_ptr obj + ACE_ENV_ARG_DECL + ) +{ + return SchedulingParameterPolicy::_unchecked_narrow (obj ACE_ENV_ARG_PARAMETER); +} + +MIF_Scheduling::SchedulingParameterPolicy_ptr +MIF_Scheduling::SchedulingParameterPolicy::_unchecked_narrow ( + CORBA::Object_ptr obj + ACE_ENV_ARG_DECL_NOT_USED + ) +{ + if (CORBA::is_nil (obj)) + { + return SchedulingParameterPolicy::_nil (); + } + + return + ACE_reinterpret_cast ( + SchedulingParameterPolicy_ptr, + obj->_tao_QueryInterface ( + ACE_reinterpret_cast ( + ptrdiff_t, + &SchedulingParameterPolicy::_tao_class_id + ) + ) + ); +} + +MIF_Scheduling::SchedulingParameterPolicy_ptr +MIF_Scheduling::SchedulingParameterPolicy::_duplicate (SchedulingParameterPolicy_ptr obj) +{ + if (! CORBA::is_nil (obj)) + { + obj->_add_ref (); + } + + return obj; +} + +void *MIF_Scheduling::SchedulingParameterPolicy::_tao_QueryInterface (ptrdiff_t type) +{ + void *retv = 0; + + if (type == ACE_reinterpret_cast ( + ptrdiff_t, + &::CORBA::Policy::_tao_class_id) + ) + { + retv = + ACE_reinterpret_cast ( + void *, + ACE_static_cast ( + CORBA::Policy_ptr, + this + ) + ); + } + else if (type == ACE_reinterpret_cast ( + ptrdiff_t, + &ACE_NESTED_CLASS (::MIF_Scheduling, SchedulingParameterPolicy)::_tao_class_id) + ) + { + retv = ACE_reinterpret_cast (void*, this); + } + else if (type == ACE_reinterpret_cast ( + ptrdiff_t, + &CORBA::Object::_tao_class_id) + ) + { + retv = + ACE_reinterpret_cast ( + void *, + ACE_static_cast (CORBA::Object_ptr, this) + ); + } + + if (retv != 0) + { + this->_add_ref (); + } + + return retv; +} + +const char* MIF_Scheduling::SchedulingParameterPolicy::_interface_repository_id (void) const +{ + return "IDL:MIF_Scheduling/SchedulingParameterPolicy:1.0"; +} + +CORBA::Boolean +MIF_Scheduling::SchedulingParameterPolicy::marshal (TAO_OutputCDR &) +{ + return 0; +} + +// TAO_IDL - Generated from +// be/be_visitor_typecode/typecode_defn.cpp:284 + +static const CORBA::Long _oc_MIF_Scheduling_SchedulingParameterPolicy[] = +{ + TAO_ENCAP_BYTE_ORDER, // byte order + 49, + ACE_NTOHL (0x49444c3a), + ACE_NTOHL (0x4d49465f), + ACE_NTOHL (0x53636865), + ACE_NTOHL (0x64756c69), + ACE_NTOHL (0x6e672f53), + ACE_NTOHL (0x63686564), + ACE_NTOHL (0x756c696e), + ACE_NTOHL (0x67506172), + ACE_NTOHL (0x616d6574), + ACE_NTOHL (0x6572506f), + ACE_NTOHL (0x6c696379), + ACE_NTOHL (0x3a312e30), + ACE_NTOHL (0x0), // repository ID = IDL:MIF_Scheduling/SchedulingParameterPolicy:1.0 + 26, + ACE_NTOHL (0x53636865), + ACE_NTOHL (0x64756c69), + ACE_NTOHL (0x6e675061), + ACE_NTOHL (0x72616d65), + ACE_NTOHL (0x74657250), + ACE_NTOHL (0x6f6c6963), + ACE_NTOHL (0x79000000), // name = SchedulingParameterPolicy + }; + +static CORBA::TypeCode _tc_TAO_tc_MIF_Scheduling_SchedulingParameterPolicy ( + CORBA::tk_objref, + sizeof (_oc_MIF_Scheduling_SchedulingParameterPolicy), + (char *) &_oc_MIF_Scheduling_SchedulingParameterPolicy, + 0, + sizeof (MIF_Scheduling::SchedulingParameterPolicy) + ); + +TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) +TAO_NAMESPACE_BEGIN (MIF_Scheduling) +TAO_NAMESPACE_DEFINE ( + ::CORBA::TypeCode_ptr, + _tc_SchedulingParameterPolicy, + &_tc_TAO_tc_MIF_Scheduling_SchedulingParameterPolicy + ) +TAO_NAMESPACE_END + +// TAO_IDL - Generated from +// be/be_visitor_interface/interface_cs.cpp:63 + +int MIF_Scheduling::Scheduler::_tao_class_id = 0; + +MIF_Scheduling::Scheduler_ptr +MIF_Scheduling::tao_Scheduler_life::tao_duplicate ( + Scheduler_ptr p + ) +{ + return Scheduler::_duplicate (p); +} + +void +MIF_Scheduling::tao_Scheduler_life::tao_release ( + Scheduler_ptr p + ) +{ + CORBA::release (p); +} + +MIF_Scheduling::Scheduler_ptr +MIF_Scheduling::tao_Scheduler_life::tao_nil ( + void + ) +{ + return Scheduler::_nil (); +} + +CORBA::Boolean +MIF_Scheduling::tao_Scheduler_life::tao_marshal ( + Scheduler_ptr p, + TAO_OutputCDR &cdr + ) +{ + return p->marshal (cdr); +} + +MIF_Scheduling::Scheduler_ptr +MIF_Scheduling::tao_Scheduler_cast::tao_narrow ( + CORBA::Object *p + ACE_ENV_ARG_DECL + ) +{ + return Scheduler::_narrow (p ACE_ENV_ARG_PARAMETER); +} + +CORBA::Object * +MIF_Scheduling::tao_Scheduler_cast::tao_upcast ( + void *src + ) +{ + Scheduler **tmp = + ACE_static_cast (Scheduler **, src); + return *tmp; +} + +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) + template class + TAO_Objref_Var_T< + MIF_Scheduling::Scheduler, + MIF_Scheduling::tao_Scheduler_life + >; + template class + TAO_Objref_Out_T< + MIF_Scheduling::Scheduler, + MIF_Scheduling::tao_Scheduler_life + >; +#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) +# pragma instantiate \ + TAO_Objref_Var_T< \ + MIF_Scheduling::Scheduler, \ + MIF_Scheduling::tao_Scheduler_life \ + > +# pragma instantiate \ + TAO_Objref_Out_T< \ + MIF_Scheduling::Scheduler, \ + MIF_Scheduling::tao_Scheduler_life \ + > +#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ + +// TAO_IDL - Generated from +// be/be_visitor_interface/interface_cs.cpp:245 + +MIF_Scheduling::Scheduler::Scheduler (void) +{} + +MIF_Scheduling::Scheduler::~Scheduler (void) +{} + +void +MIF_Scheduling::Scheduler::_tao_any_destructor (void *_tao_void_pointer) +{ + Scheduler *tmp = ACE_static_cast (Scheduler *, _tao_void_pointer); + CORBA::release (tmp); +} + +MIF_Scheduling::Scheduler_ptr +MIF_Scheduling::Scheduler::_narrow ( + CORBA::Object_ptr obj + ACE_ENV_ARG_DECL + ) +{ + return Scheduler::_unchecked_narrow (obj ACE_ENV_ARG_PARAMETER); +} + +MIF_Scheduling::Scheduler_ptr +MIF_Scheduling::Scheduler::_unchecked_narrow ( + CORBA::Object_ptr obj + ACE_ENV_ARG_DECL_NOT_USED + ) +{ + if (CORBA::is_nil (obj)) + { + return Scheduler::_nil (); + } + + return + ACE_reinterpret_cast ( + Scheduler_ptr, + obj->_tao_QueryInterface ( + ACE_reinterpret_cast ( + ptrdiff_t, + &Scheduler::_tao_class_id + ) + ) + ); +} + +MIF_Scheduling::Scheduler_ptr +MIF_Scheduling::Scheduler::_duplicate (Scheduler_ptr obj) +{ + if (! CORBA::is_nil (obj)) + { + obj->_add_ref (); + } + + return obj; +} + +void *MIF_Scheduling::Scheduler::_tao_QueryInterface (ptrdiff_t type) +{ + void *retv = 0; + + if (type == ACE_reinterpret_cast ( + ptrdiff_t, + &::RTScheduling::Scheduler::_tao_class_id) + ) + { + retv = + ACE_reinterpret_cast ( + void *, + ACE_static_cast ( + RTScheduling::Scheduler_ptr, + this + ) + ); + } + else if (type == ACE_reinterpret_cast ( + ptrdiff_t, + &ACE_NESTED_CLASS (::MIF_Scheduling, Scheduler)::_tao_class_id) + ) + { + retv = ACE_reinterpret_cast (void*, this); + } + else if (type == ACE_reinterpret_cast ( + ptrdiff_t, + &CORBA::Object::_tao_class_id) + ) + { + retv = + ACE_reinterpret_cast ( + void *, + ACE_static_cast (CORBA::Object_ptr, this) + ); + } + + if (retv != 0) + { + this->_add_ref (); + } + + return retv; +} + +const char* MIF_Scheduling::Scheduler::_interface_repository_id (void) const +{ + return "IDL:MIF_Scheduling/Scheduler:1.0"; +} + +CORBA::Boolean +MIF_Scheduling::Scheduler::marshal (TAO_OutputCDR &) +{ + return 0; +} + +// TAO_IDL - Generated from +// be/be_visitor_typecode/typecode_defn.cpp:284 + +static const CORBA::Long _oc_MIF_Scheduling_Scheduler[] = +{ + TAO_ENCAP_BYTE_ORDER, // byte order + 33, + ACE_NTOHL (0x49444c3a), + ACE_NTOHL (0x4d49465f), + ACE_NTOHL (0x53636865), + ACE_NTOHL (0x64756c69), + ACE_NTOHL (0x6e672f53), + ACE_NTOHL (0x63686564), + ACE_NTOHL (0x756c6572), + ACE_NTOHL (0x3a312e30), + ACE_NTOHL (0x0), // repository ID = IDL:MIF_Scheduling/Scheduler:1.0 + 10, + ACE_NTOHL (0x53636865), + ACE_NTOHL (0x64756c65), + ACE_NTOHL (0x72000000), // name = Scheduler + }; + +static CORBA::TypeCode _tc_TAO_tc_MIF_Scheduling_Scheduler ( + CORBA::tk_objref, + sizeof (_oc_MIF_Scheduling_Scheduler), + (char *) &_oc_MIF_Scheduling_Scheduler, + 0, + sizeof (MIF_Scheduling::Scheduler) + ); + +TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) +TAO_NAMESPACE_BEGIN (MIF_Scheduling) +TAO_NAMESPACE_DEFINE ( + ::CORBA::TypeCode_ptr, + _tc_Scheduler, + &_tc_TAO_tc_MIF_Scheduling_Scheduler + ) +TAO_NAMESPACE_END + +// TAO_IDL - Generated from +// be/be_visitor_structure/any_op_cs.cpp:54 + +// Copying insertion. +void operator<<= ( + CORBA::Any &_tao_any, + const MIF_Scheduling::SchedulingParameter &_tao_elem + ) +{ + TAO::Any_Dual_Impl_T::insert_copy ( + _tao_any, + MIF_Scheduling::SchedulingParameter::_tao_any_destructor, + MIF_Scheduling::_tc_SchedulingParameter, + _tao_elem + ); +} + +// Non-copying insertion. +void operator<<= ( + CORBA::Any &_tao_any, + MIF_Scheduling::SchedulingParameter *_tao_elem + ) +{ + TAO::Any_Dual_Impl_T::insert ( + _tao_any, + MIF_Scheduling::SchedulingParameter::_tao_any_destructor, + MIF_Scheduling::_tc_SchedulingParameter, + _tao_elem + ); +} + +// Extraction to non-const pointer (deprecated). +CORBA::Boolean operator>>= ( + const CORBA::Any &_tao_any, + MIF_Scheduling::SchedulingParameter *&_tao_elem + ) +{ + return _tao_any >>= ACE_const_cast ( + const MIF_Scheduling::SchedulingParameter *&, + _tao_elem + ); +} + +// Extraction to const pointer. +CORBA::Boolean operator>>= ( + const CORBA::Any &_tao_any, + const MIF_Scheduling::SchedulingParameter *&_tao_elem + ) +{ + return + TAO::Any_Dual_Impl_T::extract ( + _tao_any, + MIF_Scheduling::SchedulingParameter::_tao_any_destructor, + MIF_Scheduling::_tc_SchedulingParameter, + _tao_elem + ); +} + +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \ + defined (ACE_HAS_GNU_REPO) + template class TAO::Any_Dual_Impl_T; +#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) +# pragma instantiate TAO::Any_Dual_Impl_T +#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ + +// TAO_IDL - Generated from +// be/be_visitor_interface/any_op_cs.cpp:50 + +// Copying insertion. +void +operator<<= ( + CORBA::Any &_tao_any, + MIF_Scheduling::SchedulingParameterPolicy_ptr _tao_elem + ) +{ + MIF_Scheduling::SchedulingParameterPolicy_ptr _tao_objptr = + MIF_Scheduling::SchedulingParameterPolicy::_duplicate (_tao_elem); + _tao_any <<= &_tao_objptr; +} + +// Non-copying insertion. +void +operator<<= ( + CORBA::Any &_tao_any, + MIF_Scheduling::SchedulingParameterPolicy_ptr *_tao_elem + ) +{ + TAO::Any_Impl_T::insert ( + _tao_any, + MIF_Scheduling::SchedulingParameterPolicy::_tao_any_destructor, + MIF_Scheduling::_tc_SchedulingParameterPolicy, + *_tao_elem + ); +} + +CORBA::Boolean +operator>>= ( + const CORBA::Any &_tao_any, + MIF_Scheduling::SchedulingParameterPolicy_ptr &_tao_elem + ) +{ + return + TAO::Any_Impl_T::extract ( + _tao_any, + MIF_Scheduling::SchedulingParameterPolicy::_tao_any_destructor, + MIF_Scheduling::_tc_SchedulingParameterPolicy, + _tao_elem + ); +} + +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \ + defined (ACE_HAS_GNU_REPO) + template class TAO::Any_Impl_T; +#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) +# pragma instantiate TAO::Any_Impl_T +#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ + +// TAO_IDL - Generated from +// be/be_visitor_interface/any_op_cs.cpp:50 + +// Copying insertion. +void +operator<<= ( + CORBA::Any &_tao_any, + MIF_Scheduling::Scheduler_ptr _tao_elem + ) +{ + MIF_Scheduling::Scheduler_ptr _tao_objptr = + MIF_Scheduling::Scheduler::_duplicate (_tao_elem); + _tao_any <<= &_tao_objptr; +} + +// Non-copying insertion. +void +operator<<= ( + CORBA::Any &_tao_any, + MIF_Scheduling::Scheduler_ptr *_tao_elem + ) +{ + TAO::Any_Impl_T::insert ( + _tao_any, + MIF_Scheduling::Scheduler::_tao_any_destructor, + MIF_Scheduling::_tc_Scheduler, + *_tao_elem + ); +} + +CORBA::Boolean +operator>>= ( + const CORBA::Any &_tao_any, + MIF_Scheduling::Scheduler_ptr &_tao_elem + ) +{ + return + TAO::Any_Impl_T::extract ( + _tao_any, + MIF_Scheduling::Scheduler::_tao_any_destructor, + MIF_Scheduling::_tc_Scheduler, + _tao_elem + ); +} + +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \ + defined (ACE_HAS_GNU_REPO) + template class TAO::Any_Impl_T; +#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) +# pragma instantiate TAO::Any_Impl_T +#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ + diff --git a/TAO/examples/Kokyu_dsrt_schedulers/MIF_SchedulingC.h b/TAO/examples/Kokyu_dsrt_schedulers/MIF_SchedulingC.h new file mode 100644 index 00000000000..e4a9adfa182 --- /dev/null +++ b/TAO/examples/Kokyu_dsrt_schedulers/MIF_SchedulingC.h @@ -0,0 +1,405 @@ +// -*- 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:151 + +#ifndef _TAO_IDL_MIF_SCHEDULINGC_H_ +#define _TAO_IDL_MIF_SCHEDULINGC_H_ + + +#include "tao/corba.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + + +#include "tao/RTScheduling/RTScheduler.h" +#include "tao/RTCORBA/RTCORBA.h" + +#if defined (TAO_EXPORT_MACRO) +#undef TAO_EXPORT_MACRO +#endif +#define TAO_EXPORT_MACRO + +#if defined (TAO_EXPORT_NESTED_CLASSES) +# if defined (TAO_EXPORT_NESTED_MACRO) +# undef TAO_EXPORT_NESTED_MACRO +# endif /* defined (TAO_EXPORT_NESTED_MACRO) */ +# define TAO_EXPORT_NESTED_MACRO +#endif /* TAO_EXPORT_NESTED_CLASSES */ + +#if defined(_MSC_VER) +#if (_MSC_VER >= 1200) +#pragma warning(push) +#endif /* _MSC_VER >= 1200 */ +#pragma warning(disable:4250) +#endif /* _MSC_VER */ + +#if defined (__BORLANDC__) +#pragma option push -w-rvl -w-rch -w-ccc -w-inl +#endif /* __BORLANDC__ */ + +// TAO_IDL - Generated from +// be/be_visitor_module/module_ch.cpp:48 + +TAO_NAMESPACE MIF_Scheduling +{ + + // TAO_IDL - Generated from + // be/be_type.cpp:254 + + struct SchedulingParameter; + + typedef + TAO_Fixed_Var_T< + SchedulingParameter + > + SchedulingParameter_var; + + typedef + SchedulingParameter & + SchedulingParameter_out; + + // TAO_IDL - Generated from + // be/be_visitor_structure/structure_ch.cpp:52 + + struct SchedulingParameter + { + typedef SchedulingParameter_var _var_type; + + static void _tao_any_destructor (void *); + CORBA::Long importance; + }; + + // TAO_IDL - Generated from + // be/be_visitor_typecode/typecode_decl.cpp:44 + + TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_SchedulingParameter; + + // TAO_IDL - Generated from + // be/be_interface.cpp:584 + +#if !defined (_MIF_SCHEDULING_SCHEDULINGPARAMETERPOLICY__ODDS_N_ENDS_CH_) +#define _MIF_SCHEDULING_SCHEDULINGPARAMETERPOLICY__ODDS_N_ENDS_CH_ + + class SchedulingParameterPolicy; + typedef SchedulingParameterPolicy *SchedulingParameterPolicy_ptr; + struct tao_SchedulingParameterPolicy_life; + + typedef + TAO_Objref_Var_T< + SchedulingParameterPolicy, + tao_SchedulingParameterPolicy_life + > + SchedulingParameterPolicy_var; + + typedef + TAO_Objref_Out_T< + SchedulingParameterPolicy, + tao_SchedulingParameterPolicy_life + > + SchedulingParameterPolicy_out; + + struct tao_SchedulingParameterPolicy_life + { + static SchedulingParameterPolicy_ptr tao_duplicate (SchedulingParameterPolicy_ptr); + static void tao_release (SchedulingParameterPolicy_ptr); + static SchedulingParameterPolicy_ptr tao_nil (void); + static CORBA::Boolean tao_marshal ( + SchedulingParameterPolicy_ptr, + TAO_OutputCDR & + ); + }; + + struct tao_SchedulingParameterPolicy_cast + { + static SchedulingParameterPolicy_ptr tao_narrow ( + CORBA::Object_ptr + ACE_ENV_ARG_DECL + ); + static CORBA::Object_ptr tao_upcast (void *); + }; + +#endif /* end #if !defined */ + + // TAO_IDL - Generated from + // be/be_visitor_interface/interface_ch.cpp:53 + +#if !defined (_MIF_SCHEDULING_SCHEDULINGPARAMETERPOLICY_CH_) +#define _MIF_SCHEDULING_SCHEDULINGPARAMETERPOLICY_CH_ + + class SchedulingParameterPolicy + : public virtual CORBA::Policy + { + public: + typedef SchedulingParameterPolicy_ptr _ptr_type; + typedef SchedulingParameterPolicy_var _var_type; + static int _tao_class_id; + + // The static operations. + static SchedulingParameterPolicy_ptr _duplicate (SchedulingParameterPolicy_ptr obj); + + static SchedulingParameterPolicy_ptr _narrow ( + CORBA::Object_ptr obj + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ); + + static SchedulingParameterPolicy_ptr _unchecked_narrow ( + CORBA::Object_ptr obj + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ); + + static SchedulingParameterPolicy_ptr _nil (void) + { + return (SchedulingParameterPolicy_ptr)0; + } + + static void _tao_any_destructor (void *); + + // TAO_IDL - Generated from + // be/be_visitor_operation/operation_ch.cpp:46 + + virtual ::MIF_Scheduling::SchedulingParameter value ( + ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + + // TAO_IDL - Generated from + // be/be_visitor_operation/operation_ch.cpp:46 + + virtual void value ( + const MIF_Scheduling::SchedulingParameter & value + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + + // TAO_IDL - Generated from + // be/be_visitor_interface/interface_ch.cpp:210 + + virtual void *_tao_QueryInterface (ptrdiff_t type); + + virtual const char* _interface_repository_id (void) const; + virtual CORBA::Boolean marshal (TAO_OutputCDR &cdr); + + protected: + SchedulingParameterPolicy (void); + virtual ~SchedulingParameterPolicy (void); + + private: + SchedulingParameterPolicy (const SchedulingParameterPolicy &); + void operator= (const SchedulingParameterPolicy &); + }; + +#endif /* end #if !defined */ + + // TAO_IDL - Generated from + // be/be_visitor_typecode/typecode_decl.cpp:44 + + TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_SchedulingParameterPolicy; + + // TAO_IDL - Generated from + // be/be_interface.cpp:584 + +#if !defined (_MIF_SCHEDULING_SCHEDULER__ODDS_N_ENDS_CH_) +#define _MIF_SCHEDULING_SCHEDULER__ODDS_N_ENDS_CH_ + + class Scheduler; + typedef Scheduler *Scheduler_ptr; + struct tao_Scheduler_life; + + typedef + TAO_Objref_Var_T< + Scheduler, + tao_Scheduler_life + > + Scheduler_var; + + typedef + TAO_Objref_Out_T< + Scheduler, + tao_Scheduler_life + > + Scheduler_out; + + struct tao_Scheduler_life + { + static Scheduler_ptr tao_duplicate (Scheduler_ptr); + static void tao_release (Scheduler_ptr); + static Scheduler_ptr tao_nil (void); + static CORBA::Boolean tao_marshal ( + Scheduler_ptr, + TAO_OutputCDR & + ); + }; + + struct tao_Scheduler_cast + { + static Scheduler_ptr tao_narrow ( + CORBA::Object_ptr + ACE_ENV_ARG_DECL + ); + static CORBA::Object_ptr tao_upcast (void *); + }; + +#endif /* end #if !defined */ + + // TAO_IDL - Generated from + // be/be_visitor_interface/interface_ch.cpp:53 + +#if !defined (_MIF_SCHEDULING_SCHEDULER_CH_) +#define _MIF_SCHEDULING_SCHEDULER_CH_ + + class Scheduler + : public virtual RTScheduling::Scheduler + { + public: + typedef Scheduler_ptr _ptr_type; + typedef Scheduler_var _var_type; + static int _tao_class_id; + + // The static operations. + static Scheduler_ptr _duplicate (Scheduler_ptr obj); + + static Scheduler_ptr _narrow ( + CORBA::Object_ptr obj + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ); + + static Scheduler_ptr _unchecked_narrow ( + CORBA::Object_ptr obj + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ); + + static Scheduler_ptr _nil (void) + { + return (Scheduler_ptr)0; + } + + static void _tao_any_destructor (void *); + + // TAO_IDL - Generated from + // be/be_visitor_operation/operation_ch.cpp:46 + + virtual ::MIF_Scheduling::SchedulingParameterPolicy_ptr create_scheduling_parameter ( + const MIF_Scheduling::SchedulingParameter & value + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + + // TAO_IDL - Generated from + // be/be_visitor_interface/interface_ch.cpp:210 + + virtual void *_tao_QueryInterface (ptrdiff_t type); + + virtual const char* _interface_repository_id (void) const; + virtual CORBA::Boolean marshal (TAO_OutputCDR &cdr); + + protected: + Scheduler (void); + virtual ~Scheduler (void); + + private: + Scheduler (const Scheduler &); + void operator= (const Scheduler &); + }; + +#endif /* end #if !defined */ + + // TAO_IDL - Generated from + // be/be_visitor_typecode/typecode_decl.cpp:44 + + TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_Scheduler; + +// TAO_IDL - Generated from +// be/be_visitor_module/module_ch.cpp:67 + +} +TAO_NAMESPACE_CLOSE // module MIF_Scheduling + +// TAO_IDL - Generated from +// be/be_visitor_structure/any_op_ch.cpp:52 + + void operator<<= (CORBA::Any &, const MIF_Scheduling::SchedulingParameter &); // copying version + void operator<<= (CORBA::Any &, MIF_Scheduling::SchedulingParameter*); // noncopying version + CORBA::Boolean operator>>= (const CORBA::Any &, MIF_Scheduling::SchedulingParameter *&); // deprecated + CORBA::Boolean operator>>= (const CORBA::Any &, const MIF_Scheduling::SchedulingParameter *&); + +// TAO_IDL - Generated from +// be/be_visitor_interface/any_op_ch.cpp:52 + + void operator<<= (CORBA::Any &, MIF_Scheduling::SchedulingParameterPolicy_ptr); // copying + void operator<<= (CORBA::Any &, MIF_Scheduling::SchedulingParameterPolicy_ptr *); // non-copying + CORBA::Boolean operator>>= (const CORBA::Any &, MIF_Scheduling::SchedulingParameterPolicy_ptr &); + +// TAO_IDL - Generated from +// be/be_visitor_interface/any_op_ch.cpp:52 + + void operator<<= (CORBA::Any &, MIF_Scheduling::Scheduler_ptr); // copying + void operator<<= (CORBA::Any &, MIF_Scheduling::Scheduler_ptr *); // non-copying + CORBA::Boolean operator>>= (const CORBA::Any &, MIF_Scheduling::Scheduler_ptr &); + +// TAO_IDL - Generated from +// be/be_visitor_root/cdr_op.cpp:48 + +#ifndef __ACE_INLINE__ + +// TAO_IDL - Generated from +// be/be_visitor_structure/cdr_op_ch.cpp:53 + + CORBA::Boolean operator<< (TAO_OutputCDR &, const MIF_Scheduling::SchedulingParameter &); + CORBA::Boolean operator>> (TAO_InputCDR &, MIF_Scheduling::SchedulingParameter &); + +// TAO_IDL - Generated from +// be/be_visitor_root/cdr_op.cpp:64 + +#endif /* __ACE_INLINE__ */ + +// TAO_IDL - Generated from +// be/be_codegen.cpp:1059 + +#if defined (__ACE_INLINE__) +#include "MIF_SchedulingC.i" +#endif /* defined INLINE */ + +#if defined(_MSC_VER) && (_MSC_VER >= 1200) +#pragma warning(pop) +#endif /* _MSC_VER */ + +#if defined (__BORLANDC__) +#pragma option pop +#endif /* __BORLANDC__ */ + +#endif /* ifndef */ + diff --git a/TAO/examples/Kokyu_dsrt_schedulers/MIF_SchedulingC.i b/TAO/examples/Kokyu_dsrt_schedulers/MIF_SchedulingC.i new file mode 100644 index 00000000000..dd75ec080f8 --- /dev/null +++ b/TAO/examples/Kokyu_dsrt_schedulers/MIF_SchedulingC.i @@ -0,0 +1,121 @@ +// -*- 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_visitor_interface/interface_ci.cpp:63 + +#if !defined (_MIF_SCHEDULING_SCHEDULINGPARAMETERPOLICY___CI_) +#define _MIF_SCHEDULING_SCHEDULINGPARAMETERPOLICY___CI_ + +template<> +ACE_INLINE +CORBA::Boolean +TAO::Any_Impl_T::to_object ( + CORBA::Object_ptr &_tao_elem + ) const +{ + _tao_elem = CORBA::Object::_duplicate (this->value_); + return 1; +} + +template<> +ACE_INLINE +CORBA::Boolean +TAO::Any_Impl_T::marshal_value (TAO_OutputCDR &) +{ + return 0; +} + +template<> +ACE_INLINE +CORBA::Boolean +TAO::Any_Impl_T::demarshal_value (TAO_InputCDR &) +{ + return 0; +} + +#endif /* end #if !defined */ + +// TAO_IDL - Generated from +// be/be_visitor_interface/interface_ci.cpp:63 + +#if !defined (_MIF_SCHEDULING_SCHEDULER___CI_) +#define _MIF_SCHEDULING_SCHEDULER___CI_ + +template<> +ACE_INLINE +CORBA::Boolean +TAO::Any_Impl_T::to_object ( + CORBA::Object_ptr &_tao_elem + ) const +{ + _tao_elem = CORBA::Object::_duplicate (this->value_); + return 1; +} + +template<> +ACE_INLINE +CORBA::Boolean +TAO::Any_Impl_T::marshal_value (TAO_OutputCDR &) +{ + return 0; +} + +template<> +ACE_INLINE +CORBA::Boolean +TAO::Any_Impl_T::demarshal_value (TAO_InputCDR &) +{ + return 0; +} + +#endif /* end #if !defined */ + +// TAO_IDL - Generated from +// be/be_visitor_structure/cdr_op_ci.cpp:70 + +ACE_INLINE +CORBA::Boolean operator<< ( + TAO_OutputCDR &strm, + const MIF_Scheduling::SchedulingParameter &_tao_aggregate + ) +{ + return + (strm << _tao_aggregate.importance); +} + +ACE_INLINE +CORBA::Boolean operator>> ( + TAO_InputCDR &strm, + MIF_Scheduling::SchedulingParameter &_tao_aggregate + ) +{ + return + (strm >> _tao_aggregate.importance); +} + diff --git a/TAO/examples/Kokyu_dsrt_schedulers/MUF_SchedulingC.cpp b/TAO/examples/Kokyu_dsrt_schedulers/MUF_SchedulingC.cpp new file mode 100644 index 00000000000..7da16b2f24d --- /dev/null +++ b/TAO/examples/Kokyu_dsrt_schedulers/MUF_SchedulingC.cpp @@ -0,0 +1,834 @@ +// -*- 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:351 + + +#include "MUF_SchedulingC.h" +#include "tao/Stub.h" +#include "tao/Invocation.h" +#include "tao/PortableInterceptor.h" + +#if TAO_HAS_INTERCEPTORS == 1 +#include "tao/RequestInfo_Util.h" +#include "tao/ClientRequestInfo_i.h" +#include "tao/ClientInterceptorAdapter.h" +#endif /* TAO_HAS_INTERCEPTORS == 1 */ + + +#if defined (__BORLANDC__) +#pragma option -w-rvl -w-rch -w-ccc -w-aus -w-sig +#endif /* __BORLANDC__ */ + +#if !defined (__ACE_INLINE__) +#include "MUF_SchedulingC.i" +#endif /* !defined INLINE */ + +// TAO_IDL - Generated from +// be/be_visitor_typecode/typecode_defn.cpp:284 + +static const CORBA::Long _oc_MUF_Scheduling_SchedulingParameter[] = +{ + TAO_ENCAP_BYTE_ORDER, // byte order + 43, + ACE_NTOHL (0x49444c3a), + ACE_NTOHL (0x4d55465f), + ACE_NTOHL (0x53636865), + ACE_NTOHL (0x64756c69), + ACE_NTOHL (0x6e672f53), + ACE_NTOHL (0x63686564), + ACE_NTOHL (0x756c696e), + ACE_NTOHL (0x67506172), + ACE_NTOHL (0x616d6574), + ACE_NTOHL (0x65723a31), + ACE_NTOHL (0x2e300000), // repository ID = IDL:MUF_Scheduling/SchedulingParameter:1.0 + 20, + ACE_NTOHL (0x53636865), + ACE_NTOHL (0x64756c69), + ACE_NTOHL (0x6e675061), + ACE_NTOHL (0x72616d65), + ACE_NTOHL (0x74657200), // name = SchedulingParameter + 3, // member count + 9, + ACE_NTOHL (0x64656164), + ACE_NTOHL (0x6c696e65), + ACE_NTOHL (0x0), // name = deadline + CORBA::tk_alias, // typecode kind for typedefs + 56, // encapsulation length + TAO_ENCAP_BYTE_ORDER, // byte order + 31, + ACE_NTOHL (0x49444c3a), + ACE_NTOHL (0x6f6d672e), + ACE_NTOHL (0x6f72672f), + ACE_NTOHL (0x54696d65), + ACE_NTOHL (0x42617365), + ACE_NTOHL (0x2f54696d), + ACE_NTOHL (0x65543a31), + ACE_NTOHL (0x2e300000), // repository ID = IDL:omg.org/TimeBase/TimeT:1.0 + 6, + ACE_NTOHL (0x54696d65), + ACE_NTOHL (0x54000000), // name = TimeT + CORBA::tk_ulonglong, + + + 33, + ACE_NTOHL (0x65737469), + ACE_NTOHL (0x6d617465), + ACE_NTOHL (0x645f696e), + ACE_NTOHL (0x69746961), + ACE_NTOHL (0x6c5f6578), + ACE_NTOHL (0x65637574), + ACE_NTOHL (0x696f6e5f), + ACE_NTOHL (0x74696d65), + ACE_NTOHL (0x0), // name = estimated_initial_execution_time + CORBA::tk_alias, // typecode kind for typedefs + 56, // encapsulation length + TAO_ENCAP_BYTE_ORDER, // byte order + 31, + ACE_NTOHL (0x49444c3a), + ACE_NTOHL (0x6f6d672e), + ACE_NTOHL (0x6f72672f), + ACE_NTOHL (0x54696d65), + ACE_NTOHL (0x42617365), + ACE_NTOHL (0x2f54696d), + ACE_NTOHL (0x65543a31), + ACE_NTOHL (0x2e300000), // repository ID = IDL:omg.org/TimeBase/TimeT:1.0 + 6, + ACE_NTOHL (0x54696d65), + ACE_NTOHL (0x54000000), // name = TimeT + CORBA::tk_ulonglong, + + + 12, + ACE_NTOHL (0x63726974), + ACE_NTOHL (0x6963616c), + ACE_NTOHL (0x69747900), // name = criticality + CORBA::tk_long, + +}; + +static CORBA::TypeCode _tc_TAO_tc_MUF_Scheduling_SchedulingParameter ( + CORBA::tk_struct, + sizeof (_oc_MUF_Scheduling_SchedulingParameter), + (char *) &_oc_MUF_Scheduling_SchedulingParameter, + 0, + sizeof (MUF_Scheduling::SchedulingParameter) + ); + +TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) +TAO_NAMESPACE_BEGIN (MUF_Scheduling) +TAO_NAMESPACE_DEFINE ( + ::CORBA::TypeCode_ptr, + _tc_SchedulingParameter, + &_tc_TAO_tc_MUF_Scheduling_SchedulingParameter + ) +TAO_NAMESPACE_END + +// TAO_IDL - Generated from +// be/be_visitor_structure/structure_cs.cpp:66 + +void MUF_Scheduling::SchedulingParameter::_tao_any_destructor (void *_tao_void_pointer) +{ + SchedulingParameter *tmp = ACE_static_cast (SchedulingParameter*, _tao_void_pointer); + delete tmp; +} + +// TAO_IDL - Generated from +// be/be_type.cpp:297 + +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) + +template class + TAO_Fixed_Var_T< + MUF_Scheduling::SchedulingParameter + >; + +template class TAO_Var_Base_T< + MUF_Scheduling::SchedulingParameter + >; + +#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) + +# pragma instantiate \ + TAO_Fixed_Var_T< \ + MUF_Scheduling::SchedulingParameter \ + > + +#pragma instantiate TAO_Var_Base_T< + MUF_Scheduling::SchedulingParameter + > + +#endif /* !ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ + +// TAO_IDL - Generated from +// be/be_visitor_interface/interface_cs.cpp:63 + +int MUF_Scheduling::SchedulingParameterPolicy::_tao_class_id = 0; + +MUF_Scheduling::SchedulingParameterPolicy_ptr +MUF_Scheduling::tao_SchedulingParameterPolicy_life::tao_duplicate ( + SchedulingParameterPolicy_ptr p + ) +{ + return SchedulingParameterPolicy::_duplicate (p); +} + +void +MUF_Scheduling::tao_SchedulingParameterPolicy_life::tao_release ( + SchedulingParameterPolicy_ptr p + ) +{ + CORBA::release (p); +} + +MUF_Scheduling::SchedulingParameterPolicy_ptr +MUF_Scheduling::tao_SchedulingParameterPolicy_life::tao_nil ( + void + ) +{ + return SchedulingParameterPolicy::_nil (); +} + +CORBA::Boolean +MUF_Scheduling::tao_SchedulingParameterPolicy_life::tao_marshal ( + SchedulingParameterPolicy_ptr p, + TAO_OutputCDR &cdr + ) +{ + return p->marshal (cdr); +} + +MUF_Scheduling::SchedulingParameterPolicy_ptr +MUF_Scheduling::tao_SchedulingParameterPolicy_cast::tao_narrow ( + CORBA::Object *p + ACE_ENV_ARG_DECL + ) +{ + return SchedulingParameterPolicy::_narrow (p ACE_ENV_ARG_PARAMETER); +} + +CORBA::Object * +MUF_Scheduling::tao_SchedulingParameterPolicy_cast::tao_upcast ( + void *src + ) +{ + SchedulingParameterPolicy **tmp = + ACE_static_cast (SchedulingParameterPolicy **, src); + return *tmp; +} + +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) + template class + TAO_Objref_Var_T< + MUF_Scheduling::SchedulingParameterPolicy, + MUF_Scheduling::tao_SchedulingParameterPolicy_life + >; + template class + TAO_Objref_Out_T< + MUF_Scheduling::SchedulingParameterPolicy, + MUF_Scheduling::tao_SchedulingParameterPolicy_life + >; +#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) +# pragma instantiate \ + TAO_Objref_Var_T< \ + MUF_Scheduling::SchedulingParameterPolicy, \ + MUF_Scheduling::tao_SchedulingParameterPolicy_life \ + > +# pragma instantiate \ + TAO_Objref_Out_T< \ + MUF_Scheduling::SchedulingParameterPolicy, \ + MUF_Scheduling::tao_SchedulingParameterPolicy_life \ + > +#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ + +// TAO_IDL - Generated from +// be/be_visitor_interface/interface_cs.cpp:245 + +MUF_Scheduling::SchedulingParameterPolicy::SchedulingParameterPolicy (void) +{} + +MUF_Scheduling::SchedulingParameterPolicy::~SchedulingParameterPolicy (void) +{} + +void +MUF_Scheduling::SchedulingParameterPolicy::_tao_any_destructor (void *_tao_void_pointer) +{ + SchedulingParameterPolicy *tmp = ACE_static_cast (SchedulingParameterPolicy *, _tao_void_pointer); + CORBA::release (tmp); +} + +MUF_Scheduling::SchedulingParameterPolicy_ptr +MUF_Scheduling::SchedulingParameterPolicy::_narrow ( + CORBA::Object_ptr obj + ACE_ENV_ARG_DECL + ) +{ + return SchedulingParameterPolicy::_unchecked_narrow (obj ACE_ENV_ARG_PARAMETER); +} + +MUF_Scheduling::SchedulingParameterPolicy_ptr +MUF_Scheduling::SchedulingParameterPolicy::_unchecked_narrow ( + CORBA::Object_ptr obj + ACE_ENV_ARG_DECL_NOT_USED + ) +{ + if (CORBA::is_nil (obj)) + { + return SchedulingParameterPolicy::_nil (); + } + + return + ACE_reinterpret_cast ( + SchedulingParameterPolicy_ptr, + obj->_tao_QueryInterface ( + ACE_reinterpret_cast ( + ptrdiff_t, + &SchedulingParameterPolicy::_tao_class_id + ) + ) + ); +} + +MUF_Scheduling::SchedulingParameterPolicy_ptr +MUF_Scheduling::SchedulingParameterPolicy::_duplicate (SchedulingParameterPolicy_ptr obj) +{ + if (! CORBA::is_nil (obj)) + { + obj->_add_ref (); + } + + return obj; +} + +void *MUF_Scheduling::SchedulingParameterPolicy::_tao_QueryInterface (ptrdiff_t type) +{ + void *retv = 0; + + if (type == ACE_reinterpret_cast ( + ptrdiff_t, + &::CORBA::Policy::_tao_class_id) + ) + { + retv = + ACE_reinterpret_cast ( + void *, + ACE_static_cast ( + CORBA::Policy_ptr, + this + ) + ); + } + else if (type == ACE_reinterpret_cast ( + ptrdiff_t, + &ACE_NESTED_CLASS (::MUF_Scheduling, SchedulingParameterPolicy)::_tao_class_id) + ) + { + retv = ACE_reinterpret_cast (void*, this); + } + else if (type == ACE_reinterpret_cast ( + ptrdiff_t, + &CORBA::Object::_tao_class_id) + ) + { + retv = + ACE_reinterpret_cast ( + void *, + ACE_static_cast (CORBA::Object_ptr, this) + ); + } + + if (retv != 0) + { + this->_add_ref (); + } + + return retv; +} + +const char* MUF_Scheduling::SchedulingParameterPolicy::_interface_repository_id (void) const +{ + return "IDL:MUF_Scheduling/SchedulingParameterPolicy:1.0"; +} + +CORBA::Boolean +MUF_Scheduling::SchedulingParameterPolicy::marshal (TAO_OutputCDR &) +{ + return 0; +} + +// TAO_IDL - Generated from +// be/be_visitor_typecode/typecode_defn.cpp:284 + +static const CORBA::Long _oc_MUF_Scheduling_SchedulingParameterPolicy[] = +{ + TAO_ENCAP_BYTE_ORDER, // byte order + 49, + ACE_NTOHL (0x49444c3a), + ACE_NTOHL (0x4d55465f), + ACE_NTOHL (0x53636865), + ACE_NTOHL (0x64756c69), + ACE_NTOHL (0x6e672f53), + ACE_NTOHL (0x63686564), + ACE_NTOHL (0x756c696e), + ACE_NTOHL (0x67506172), + ACE_NTOHL (0x616d6574), + ACE_NTOHL (0x6572506f), + ACE_NTOHL (0x6c696379), + ACE_NTOHL (0x3a312e30), + ACE_NTOHL (0x0), // repository ID = IDL:MUF_Scheduling/SchedulingParameterPolicy:1.0 + 26, + ACE_NTOHL (0x53636865), + ACE_NTOHL (0x64756c69), + ACE_NTOHL (0x6e675061), + ACE_NTOHL (0x72616d65), + ACE_NTOHL (0x74657250), + ACE_NTOHL (0x6f6c6963), + ACE_NTOHL (0x79000000), // name = SchedulingParameterPolicy + }; + +static CORBA::TypeCode _tc_TAO_tc_MUF_Scheduling_SchedulingParameterPolicy ( + CORBA::tk_objref, + sizeof (_oc_MUF_Scheduling_SchedulingParameterPolicy), + (char *) &_oc_MUF_Scheduling_SchedulingParameterPolicy, + 0, + sizeof (MUF_Scheduling::SchedulingParameterPolicy) + ); + +TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) +TAO_NAMESPACE_BEGIN (MUF_Scheduling) +TAO_NAMESPACE_DEFINE ( + ::CORBA::TypeCode_ptr, + _tc_SchedulingParameterPolicy, + &_tc_TAO_tc_MUF_Scheduling_SchedulingParameterPolicy + ) +TAO_NAMESPACE_END + +// TAO_IDL - Generated from +// be/be_visitor_interface/interface_cs.cpp:63 + +int MUF_Scheduling::Scheduler::_tao_class_id = 0; + +MUF_Scheduling::Scheduler_ptr +MUF_Scheduling::tao_Scheduler_life::tao_duplicate ( + Scheduler_ptr p + ) +{ + return Scheduler::_duplicate (p); +} + +void +MUF_Scheduling::tao_Scheduler_life::tao_release ( + Scheduler_ptr p + ) +{ + CORBA::release (p); +} + +MUF_Scheduling::Scheduler_ptr +MUF_Scheduling::tao_Scheduler_life::tao_nil ( + void + ) +{ + return Scheduler::_nil (); +} + +CORBA::Boolean +MUF_Scheduling::tao_Scheduler_life::tao_marshal ( + Scheduler_ptr p, + TAO_OutputCDR &cdr + ) +{ + return p->marshal (cdr); +} + +MUF_Scheduling::Scheduler_ptr +MUF_Scheduling::tao_Scheduler_cast::tao_narrow ( + CORBA::Object *p + ACE_ENV_ARG_DECL + ) +{ + return Scheduler::_narrow (p ACE_ENV_ARG_PARAMETER); +} + +CORBA::Object * +MUF_Scheduling::tao_Scheduler_cast::tao_upcast ( + void *src + ) +{ + Scheduler **tmp = + ACE_static_cast (Scheduler **, src); + return *tmp; +} + +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) + template class + TAO_Objref_Var_T< + MUF_Scheduling::Scheduler, + MUF_Scheduling::tao_Scheduler_life + >; + template class + TAO_Objref_Out_T< + MUF_Scheduling::Scheduler, + MUF_Scheduling::tao_Scheduler_life + >; +#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) +# pragma instantiate \ + TAO_Objref_Var_T< \ + MUF_Scheduling::Scheduler, \ + MUF_Scheduling::tao_Scheduler_life \ + > +# pragma instantiate \ + TAO_Objref_Out_T< \ + MUF_Scheduling::Scheduler, \ + MUF_Scheduling::tao_Scheduler_life \ + > +#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ + +// TAO_IDL - Generated from +// be/be_visitor_interface/interface_cs.cpp:245 + +MUF_Scheduling::Scheduler::Scheduler (void) +{} + +MUF_Scheduling::Scheduler::~Scheduler (void) +{} + +void +MUF_Scheduling::Scheduler::_tao_any_destructor (void *_tao_void_pointer) +{ + Scheduler *tmp = ACE_static_cast (Scheduler *, _tao_void_pointer); + CORBA::release (tmp); +} + +MUF_Scheduling::Scheduler_ptr +MUF_Scheduling::Scheduler::_narrow ( + CORBA::Object_ptr obj + ACE_ENV_ARG_DECL + ) +{ + return Scheduler::_unchecked_narrow (obj ACE_ENV_ARG_PARAMETER); +} + +MUF_Scheduling::Scheduler_ptr +MUF_Scheduling::Scheduler::_unchecked_narrow ( + CORBA::Object_ptr obj + ACE_ENV_ARG_DECL_NOT_USED + ) +{ + if (CORBA::is_nil (obj)) + { + return Scheduler::_nil (); + } + + return + ACE_reinterpret_cast ( + Scheduler_ptr, + obj->_tao_QueryInterface ( + ACE_reinterpret_cast ( + ptrdiff_t, + &Scheduler::_tao_class_id + ) + ) + ); +} + +MUF_Scheduling::Scheduler_ptr +MUF_Scheduling::Scheduler::_duplicate (Scheduler_ptr obj) +{ + if (! CORBA::is_nil (obj)) + { + obj->_add_ref (); + } + + return obj; +} + +void *MUF_Scheduling::Scheduler::_tao_QueryInterface (ptrdiff_t type) +{ + void *retv = 0; + + if (type == ACE_reinterpret_cast ( + ptrdiff_t, + &::RTScheduling::Scheduler::_tao_class_id) + ) + { + retv = + ACE_reinterpret_cast ( + void *, + ACE_static_cast ( + RTScheduling::Scheduler_ptr, + this + ) + ); + } + else if (type == ACE_reinterpret_cast ( + ptrdiff_t, + &ACE_NESTED_CLASS (::MUF_Scheduling, Scheduler)::_tao_class_id) + ) + { + retv = ACE_reinterpret_cast (void*, this); + } + else if (type == ACE_reinterpret_cast ( + ptrdiff_t, + &CORBA::Object::_tao_class_id) + ) + { + retv = + ACE_reinterpret_cast ( + void *, + ACE_static_cast (CORBA::Object_ptr, this) + ); + } + + if (retv != 0) + { + this->_add_ref (); + } + + return retv; +} + +const char* MUF_Scheduling::Scheduler::_interface_repository_id (void) const +{ + return "IDL:MUF_Scheduling/Scheduler:1.0"; +} + +CORBA::Boolean +MUF_Scheduling::Scheduler::marshal (TAO_OutputCDR &) +{ + return 0; +} + +// TAO_IDL - Generated from +// be/be_visitor_typecode/typecode_defn.cpp:284 + +static const CORBA::Long _oc_MUF_Scheduling_Scheduler[] = +{ + TAO_ENCAP_BYTE_ORDER, // byte order + 33, + ACE_NTOHL (0x49444c3a), + ACE_NTOHL (0x4d55465f), + ACE_NTOHL (0x53636865), + ACE_NTOHL (0x64756c69), + ACE_NTOHL (0x6e672f53), + ACE_NTOHL (0x63686564), + ACE_NTOHL (0x756c6572), + ACE_NTOHL (0x3a312e30), + ACE_NTOHL (0x0), // repository ID = IDL:MUF_Scheduling/Scheduler:1.0 + 10, + ACE_NTOHL (0x53636865), + ACE_NTOHL (0x64756c65), + ACE_NTOHL (0x72000000), // name = Scheduler + }; + +static CORBA::TypeCode _tc_TAO_tc_MUF_Scheduling_Scheduler ( + CORBA::tk_objref, + sizeof (_oc_MUF_Scheduling_Scheduler), + (char *) &_oc_MUF_Scheduling_Scheduler, + 0, + sizeof (MUF_Scheduling::Scheduler) + ); + +TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) +TAO_NAMESPACE_BEGIN (MUF_Scheduling) +TAO_NAMESPACE_DEFINE ( + ::CORBA::TypeCode_ptr, + _tc_Scheduler, + &_tc_TAO_tc_MUF_Scheduling_Scheduler + ) +TAO_NAMESPACE_END + +// TAO_IDL - Generated from +// be/be_visitor_structure/any_op_cs.cpp:54 + +// Copying insertion. +void operator<<= ( + CORBA::Any &_tao_any, + const MUF_Scheduling::SchedulingParameter &_tao_elem + ) +{ + TAO::Any_Dual_Impl_T::insert_copy ( + _tao_any, + MUF_Scheduling::SchedulingParameter::_tao_any_destructor, + MUF_Scheduling::_tc_SchedulingParameter, + _tao_elem + ); +} + +// Non-copying insertion. +void operator<<= ( + CORBA::Any &_tao_any, + MUF_Scheduling::SchedulingParameter *_tao_elem + ) +{ + TAO::Any_Dual_Impl_T::insert ( + _tao_any, + MUF_Scheduling::SchedulingParameter::_tao_any_destructor, + MUF_Scheduling::_tc_SchedulingParameter, + _tao_elem + ); +} + +// Extraction to non-const pointer (deprecated). +CORBA::Boolean operator>>= ( + const CORBA::Any &_tao_any, + MUF_Scheduling::SchedulingParameter *&_tao_elem + ) +{ + return _tao_any >>= ACE_const_cast ( + const MUF_Scheduling::SchedulingParameter *&, + _tao_elem + ); +} + +// Extraction to const pointer. +CORBA::Boolean operator>>= ( + const CORBA::Any &_tao_any, + const MUF_Scheduling::SchedulingParameter *&_tao_elem + ) +{ + return + TAO::Any_Dual_Impl_T::extract ( + _tao_any, + MUF_Scheduling::SchedulingParameter::_tao_any_destructor, + MUF_Scheduling::_tc_SchedulingParameter, + _tao_elem + ); +} + +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \ + defined (ACE_HAS_GNU_REPO) + template class TAO::Any_Dual_Impl_T; +#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) +# pragma instantiate TAO::Any_Dual_Impl_T +#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ + +// TAO_IDL - Generated from +// be/be_visitor_interface/any_op_cs.cpp:50 + +// Copying insertion. +void +operator<<= ( + CORBA::Any &_tao_any, + MUF_Scheduling::SchedulingParameterPolicy_ptr _tao_elem + ) +{ + MUF_Scheduling::SchedulingParameterPolicy_ptr _tao_objptr = + MUF_Scheduling::SchedulingParameterPolicy::_duplicate (_tao_elem); + _tao_any <<= &_tao_objptr; +} + +// Non-copying insertion. +void +operator<<= ( + CORBA::Any &_tao_any, + MUF_Scheduling::SchedulingParameterPolicy_ptr *_tao_elem + ) +{ + TAO::Any_Impl_T::insert ( + _tao_any, + MUF_Scheduling::SchedulingParameterPolicy::_tao_any_destructor, + MUF_Scheduling::_tc_SchedulingParameterPolicy, + *_tao_elem + ); +} + +CORBA::Boolean +operator>>= ( + const CORBA::Any &_tao_any, + MUF_Scheduling::SchedulingParameterPolicy_ptr &_tao_elem + ) +{ + return + TAO::Any_Impl_T::extract ( + _tao_any, + MUF_Scheduling::SchedulingParameterPolicy::_tao_any_destructor, + MUF_Scheduling::_tc_SchedulingParameterPolicy, + _tao_elem + ); +} + +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \ + defined (ACE_HAS_GNU_REPO) + template class TAO::Any_Impl_T; +#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) +# pragma instantiate TAO::Any_Impl_T +#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ + +// TAO_IDL - Generated from +// be/be_visitor_interface/any_op_cs.cpp:50 + +// Copying insertion. +void +operator<<= ( + CORBA::Any &_tao_any, + MUF_Scheduling::Scheduler_ptr _tao_elem + ) +{ + MUF_Scheduling::Scheduler_ptr _tao_objptr = + MUF_Scheduling::Scheduler::_duplicate (_tao_elem); + _tao_any <<= &_tao_objptr; +} + +// Non-copying insertion. +void +operator<<= ( + CORBA::Any &_tao_any, + MUF_Scheduling::Scheduler_ptr *_tao_elem + ) +{ + TAO::Any_Impl_T::insert ( + _tao_any, + MUF_Scheduling::Scheduler::_tao_any_destructor, + MUF_Scheduling::_tc_Scheduler, + *_tao_elem + ); +} + +CORBA::Boolean +operator>>= ( + const CORBA::Any &_tao_any, + MUF_Scheduling::Scheduler_ptr &_tao_elem + ) +{ + return + TAO::Any_Impl_T::extract ( + _tao_any, + MUF_Scheduling::Scheduler::_tao_any_destructor, + MUF_Scheduling::_tc_Scheduler, + _tao_elem + ); +} + +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \ + defined (ACE_HAS_GNU_REPO) + template class TAO::Any_Impl_T; +#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) +# pragma instantiate TAO::Any_Impl_T +#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ + diff --git a/TAO/examples/Kokyu_dsrt_schedulers/MUF_SchedulingC.h b/TAO/examples/Kokyu_dsrt_schedulers/MUF_SchedulingC.h new file mode 100644 index 00000000000..163e248ce0e --- /dev/null +++ b/TAO/examples/Kokyu_dsrt_schedulers/MUF_SchedulingC.h @@ -0,0 +1,407 @@ +// -*- 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:151 + +#ifndef _TAO_IDL_MUF_SCHEDULINGC_H_ +#define _TAO_IDL_MUF_SCHEDULINGC_H_ + + +#include "tao/corba.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + + +#include "tao/RTScheduling/RTScheduler.h" +#include "tao/RTCORBA/RTCORBAC.h" + +#if defined (TAO_EXPORT_MACRO) +#undef TAO_EXPORT_MACRO +#endif +#define TAO_EXPORT_MACRO + +#if defined (TAO_EXPORT_NESTED_CLASSES) +# if defined (TAO_EXPORT_NESTED_MACRO) +# undef TAO_EXPORT_NESTED_MACRO +# endif /* defined (TAO_EXPORT_NESTED_MACRO) */ +# define TAO_EXPORT_NESTED_MACRO +#endif /* TAO_EXPORT_NESTED_CLASSES */ + +#if defined(_MSC_VER) +#if (_MSC_VER >= 1200) +#pragma warning(push) +#endif /* _MSC_VER >= 1200 */ +#pragma warning(disable:4250) +#endif /* _MSC_VER */ + +#if defined (__BORLANDC__) +#pragma option push -w-rvl -w-rch -w-ccc -w-inl +#endif /* __BORLANDC__ */ + +// TAO_IDL - Generated from +// be/be_visitor_module/module_ch.cpp:48 + +TAO_NAMESPACE MUF_Scheduling +{ + + // TAO_IDL - Generated from + // be/be_type.cpp:254 + + struct SchedulingParameter; + + typedef + TAO_Fixed_Var_T< + SchedulingParameter + > + SchedulingParameter_var; + + typedef + SchedulingParameter & + SchedulingParameter_out; + + // TAO_IDL - Generated from + // be/be_visitor_structure/structure_ch.cpp:52 + + struct SchedulingParameter + { + typedef SchedulingParameter_var _var_type; + + static void _tao_any_destructor (void *); + TimeBase::TimeT deadline; + TimeBase::TimeT estimated_initial_execution_time; + CORBA::Long criticality; + }; + + // TAO_IDL - Generated from + // be/be_visitor_typecode/typecode_decl.cpp:44 + + TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_SchedulingParameter; + + // TAO_IDL - Generated from + // be/be_interface.cpp:584 + +#if !defined (_MUF_SCHEDULING_SCHEDULINGPARAMETERPOLICY__ODDS_N_ENDS_CH_) +#define _MUF_SCHEDULING_SCHEDULINGPARAMETERPOLICY__ODDS_N_ENDS_CH_ + + class SchedulingParameterPolicy; + typedef SchedulingParameterPolicy *SchedulingParameterPolicy_ptr; + struct tao_SchedulingParameterPolicy_life; + + typedef + TAO_Objref_Var_T< + SchedulingParameterPolicy, + tao_SchedulingParameterPolicy_life + > + SchedulingParameterPolicy_var; + + typedef + TAO_Objref_Out_T< + SchedulingParameterPolicy, + tao_SchedulingParameterPolicy_life + > + SchedulingParameterPolicy_out; + + struct tao_SchedulingParameterPolicy_life + { + static SchedulingParameterPolicy_ptr tao_duplicate (SchedulingParameterPolicy_ptr); + static void tao_release (SchedulingParameterPolicy_ptr); + static SchedulingParameterPolicy_ptr tao_nil (void); + static CORBA::Boolean tao_marshal ( + SchedulingParameterPolicy_ptr, + TAO_OutputCDR & + ); + }; + + struct tao_SchedulingParameterPolicy_cast + { + static SchedulingParameterPolicy_ptr tao_narrow ( + CORBA::Object_ptr + ACE_ENV_ARG_DECL + ); + static CORBA::Object_ptr tao_upcast (void *); + }; + +#endif /* end #if !defined */ + + // TAO_IDL - Generated from + // be/be_visitor_interface/interface_ch.cpp:53 + +#if !defined (_MUF_SCHEDULING_SCHEDULINGPARAMETERPOLICY_CH_) +#define _MUF_SCHEDULING_SCHEDULINGPARAMETERPOLICY_CH_ + + class SchedulingParameterPolicy + : public virtual CORBA::Policy + { + public: + typedef SchedulingParameterPolicy_ptr _ptr_type; + typedef SchedulingParameterPolicy_var _var_type; + static int _tao_class_id; + + // The static operations. + static SchedulingParameterPolicy_ptr _duplicate (SchedulingParameterPolicy_ptr obj); + + static SchedulingParameterPolicy_ptr _narrow ( + CORBA::Object_ptr obj + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ); + + static SchedulingParameterPolicy_ptr _unchecked_narrow ( + CORBA::Object_ptr obj + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ); + + static SchedulingParameterPolicy_ptr _nil (void) + { + return (SchedulingParameterPolicy_ptr)0; + } + + static void _tao_any_destructor (void *); + + // TAO_IDL - Generated from + // be/be_visitor_operation/operation_ch.cpp:46 + + virtual ::MUF_Scheduling::SchedulingParameter value ( + ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + + // TAO_IDL - Generated from + // be/be_visitor_operation/operation_ch.cpp:46 + + virtual void value ( + const MUF_Scheduling::SchedulingParameter & value + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + + // TAO_IDL - Generated from + // be/be_visitor_interface/interface_ch.cpp:210 + + virtual void *_tao_QueryInterface (ptrdiff_t type); + + virtual const char* _interface_repository_id (void) const; + virtual CORBA::Boolean marshal (TAO_OutputCDR &cdr); + + protected: + SchedulingParameterPolicy (void); + virtual ~SchedulingParameterPolicy (void); + + private: + SchedulingParameterPolicy (const SchedulingParameterPolicy &); + void operator= (const SchedulingParameterPolicy &); + }; + +#endif /* end #if !defined */ + + // TAO_IDL - Generated from + // be/be_visitor_typecode/typecode_decl.cpp:44 + + TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_SchedulingParameterPolicy; + + // TAO_IDL - Generated from + // be/be_interface.cpp:584 + +#if !defined (_MUF_SCHEDULING_SCHEDULER__ODDS_N_ENDS_CH_) +#define _MUF_SCHEDULING_SCHEDULER__ODDS_N_ENDS_CH_ + + class Scheduler; + typedef Scheduler *Scheduler_ptr; + struct tao_Scheduler_life; + + typedef + TAO_Objref_Var_T< + Scheduler, + tao_Scheduler_life + > + Scheduler_var; + + typedef + TAO_Objref_Out_T< + Scheduler, + tao_Scheduler_life + > + Scheduler_out; + + struct tao_Scheduler_life + { + static Scheduler_ptr tao_duplicate (Scheduler_ptr); + static void tao_release (Scheduler_ptr); + static Scheduler_ptr tao_nil (void); + static CORBA::Boolean tao_marshal ( + Scheduler_ptr, + TAO_OutputCDR & + ); + }; + + struct tao_Scheduler_cast + { + static Scheduler_ptr tao_narrow ( + CORBA::Object_ptr + ACE_ENV_ARG_DECL + ); + static CORBA::Object_ptr tao_upcast (void *); + }; + +#endif /* end #if !defined */ + + // TAO_IDL - Generated from + // be/be_visitor_interface/interface_ch.cpp:53 + +#if !defined (_MUF_SCHEDULING_SCHEDULER_CH_) +#define _MUF_SCHEDULING_SCHEDULER_CH_ + + class Scheduler + : public virtual RTScheduling::Scheduler + { + public: + typedef Scheduler_ptr _ptr_type; + typedef Scheduler_var _var_type; + static int _tao_class_id; + + // The static operations. + static Scheduler_ptr _duplicate (Scheduler_ptr obj); + + static Scheduler_ptr _narrow ( + CORBA::Object_ptr obj + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ); + + static Scheduler_ptr _unchecked_narrow ( + CORBA::Object_ptr obj + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ); + + static Scheduler_ptr _nil (void) + { + return (Scheduler_ptr)0; + } + + static void _tao_any_destructor (void *); + + // TAO_IDL - Generated from + // be/be_visitor_operation/operation_ch.cpp:46 + + virtual ::MUF_Scheduling::SchedulingParameterPolicy_ptr create_scheduling_parameter ( + const MUF_Scheduling::SchedulingParameter & value + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + + // TAO_IDL - Generated from + // be/be_visitor_interface/interface_ch.cpp:210 + + virtual void *_tao_QueryInterface (ptrdiff_t type); + + virtual const char* _interface_repository_id (void) const; + virtual CORBA::Boolean marshal (TAO_OutputCDR &cdr); + + protected: + Scheduler (void); + virtual ~Scheduler (void); + + private: + Scheduler (const Scheduler &); + void operator= (const Scheduler &); + }; + +#endif /* end #if !defined */ + + // TAO_IDL - Generated from + // be/be_visitor_typecode/typecode_decl.cpp:44 + + TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_Scheduler; + +// TAO_IDL - Generated from +// be/be_visitor_module/module_ch.cpp:67 + +} +TAO_NAMESPACE_CLOSE // module MUF_Scheduling + +// TAO_IDL - Generated from +// be/be_visitor_structure/any_op_ch.cpp:52 + + void operator<<= (CORBA::Any &, const MUF_Scheduling::SchedulingParameter &); // copying version + void operator<<= (CORBA::Any &, MUF_Scheduling::SchedulingParameter*); // noncopying version + CORBA::Boolean operator>>= (const CORBA::Any &, MUF_Scheduling::SchedulingParameter *&); // deprecated + CORBA::Boolean operator>>= (const CORBA::Any &, const MUF_Scheduling::SchedulingParameter *&); + +// TAO_IDL - Generated from +// be/be_visitor_interface/any_op_ch.cpp:52 + + void operator<<= (CORBA::Any &, MUF_Scheduling::SchedulingParameterPolicy_ptr); // copying + void operator<<= (CORBA::Any &, MUF_Scheduling::SchedulingParameterPolicy_ptr *); // non-copying + CORBA::Boolean operator>>= (const CORBA::Any &, MUF_Scheduling::SchedulingParameterPolicy_ptr &); + +// TAO_IDL - Generated from +// be/be_visitor_interface/any_op_ch.cpp:52 + + void operator<<= (CORBA::Any &, MUF_Scheduling::Scheduler_ptr); // copying + void operator<<= (CORBA::Any &, MUF_Scheduling::Scheduler_ptr *); // non-copying + CORBA::Boolean operator>>= (const CORBA::Any &, MUF_Scheduling::Scheduler_ptr &); + +// TAO_IDL - Generated from +// be/be_visitor_root/cdr_op.cpp:48 + +#ifndef __ACE_INLINE__ + +// TAO_IDL - Generated from +// be/be_visitor_structure/cdr_op_ch.cpp:53 + + CORBA::Boolean operator<< (TAO_OutputCDR &, const MUF_Scheduling::SchedulingParameter &); + CORBA::Boolean operator>> (TAO_InputCDR &, MUF_Scheduling::SchedulingParameter &); + +// TAO_IDL - Generated from +// be/be_visitor_root/cdr_op.cpp:64 + +#endif /* __ACE_INLINE__ */ + +// TAO_IDL - Generated from +// be/be_codegen.cpp:1059 + +#if defined (__ACE_INLINE__) +#include "MUF_SchedulingC.i" +#endif /* defined INLINE */ + +#if defined(_MSC_VER) && (_MSC_VER >= 1200) +#pragma warning(pop) +#endif /* _MSC_VER */ + +#if defined (__BORLANDC__) +#pragma option pop +#endif /* __BORLANDC__ */ + +#endif /* ifndef */ + diff --git a/TAO/examples/Kokyu_dsrt_schedulers/MUF_SchedulingC.i b/TAO/examples/Kokyu_dsrt_schedulers/MUF_SchedulingC.i new file mode 100644 index 00000000000..e7157fb718b --- /dev/null +++ b/TAO/examples/Kokyu_dsrt_schedulers/MUF_SchedulingC.i @@ -0,0 +1,125 @@ +// -*- 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_visitor_interface/interface_ci.cpp:63 + +#if !defined (_MUF_SCHEDULING_SCHEDULINGPARAMETERPOLICY___CI_) +#define _MUF_SCHEDULING_SCHEDULINGPARAMETERPOLICY___CI_ + +template<> +ACE_INLINE +CORBA::Boolean +TAO::Any_Impl_T::to_object ( + CORBA::Object_ptr &_tao_elem + ) const +{ + _tao_elem = CORBA::Object::_duplicate (this->value_); + return 1; +} + +template<> +ACE_INLINE +CORBA::Boolean +TAO::Any_Impl_T::marshal_value (TAO_OutputCDR &) +{ + return 0; +} + +template<> +ACE_INLINE +CORBA::Boolean +TAO::Any_Impl_T::demarshal_value (TAO_InputCDR &) +{ + return 0; +} + +#endif /* end #if !defined */ + +// TAO_IDL - Generated from +// be/be_visitor_interface/interface_ci.cpp:63 + +#if !defined (_MUF_SCHEDULING_SCHEDULER___CI_) +#define _MUF_SCHEDULING_SCHEDULER___CI_ + +template<> +ACE_INLINE +CORBA::Boolean +TAO::Any_Impl_T::to_object ( + CORBA::Object_ptr &_tao_elem + ) const +{ + _tao_elem = CORBA::Object::_duplicate (this->value_); + return 1; +} + +template<> +ACE_INLINE +CORBA::Boolean +TAO::Any_Impl_T::marshal_value (TAO_OutputCDR &) +{ + return 0; +} + +template<> +ACE_INLINE +CORBA::Boolean +TAO::Any_Impl_T::demarshal_value (TAO_InputCDR &) +{ + return 0; +} + +#endif /* end #if !defined */ + +// TAO_IDL - Generated from +// be/be_visitor_structure/cdr_op_ci.cpp:70 + +ACE_INLINE +CORBA::Boolean operator<< ( + TAO_OutputCDR &strm, + const MUF_Scheduling::SchedulingParameter &_tao_aggregate + ) +{ + return + (strm << _tao_aggregate.deadline) && + (strm << _tao_aggregate.estimated_initial_execution_time) && + (strm << _tao_aggregate.criticality); +} + +ACE_INLINE +CORBA::Boolean operator>> ( + TAO_InputCDR &strm, + MUF_Scheduling::SchedulingParameter &_tao_aggregate + ) +{ + return + (strm >> _tao_aggregate.deadline) && + (strm >> _tao_aggregate.estimated_initial_execution_time) && + (strm >> _tao_aggregate.criticality); +} + -- cgit v1.2.1