From 5c597a85abcc50838eeb7d727aaced881538c793 Mon Sep 17 00:00:00 2001 From: yamuna Date: Fri, 27 Jun 2003 16:40:32 +0000 Subject: ChangelogTag: Thu Jun 26 22:34:10 2003 Yamuna Krishnamurthy --- TAO/tao/RTScheduling/RTScheduler_Manager.cpp | 75 +++++++++ TAO/tao/RTScheduling/RTScheduler_Manager.h | 153 ++++++++++++++++++ TAO/tao/RTScheduling/RTScheduler_Manager.i | 227 +++++++++++++++++++++++++++ 3 files changed, 455 insertions(+) create mode 100644 TAO/tao/RTScheduling/RTScheduler_Manager.cpp create mode 100644 TAO/tao/RTScheduling/RTScheduler_Manager.h create mode 100644 TAO/tao/RTScheduling/RTScheduler_Manager.i diff --git a/TAO/tao/RTScheduling/RTScheduler_Manager.cpp b/TAO/tao/RTScheduling/RTScheduler_Manager.cpp new file mode 100644 index 00000000000..5225b37a61e --- /dev/null +++ b/TAO/tao/RTScheduling/RTScheduler_Manager.cpp @@ -0,0 +1,75 @@ +// $Id$ + +#include "RTScheduler_Manager.h" + +#if ! defined (__ACE_INLINE__) +#include "RTScheduler_Manager.i" +#endif /* __ACE_INLINE__ */ + +ACE_RCSID(TAO, RT_ORB, "$Id$") + +TAO_RTScheduler_Manager::TAO_RTScheduler_Manager (void) +{ + +} + +TAO_RTScheduler_Manager::~TAO_RTScheduler_Manager (void) +{ +} + +TAO_RTScheduler_Manager_ptr +TAO_RTScheduler_Manager::_narrow (CORBA::Object_ptr obj + ACE_ENV_ARG_DECL) +{ + return TAO_RTScheduler_Manager::_unchecked_narrow (obj ACE_ENV_ARG_PARAMETER); +} + +TAO_RTScheduler_Manager_ptr +TAO_RTScheduler_Manager::_unchecked_narrow (CORBA::Object_ptr obj + ACE_ENV_ARG_DECL_NOT_USED) +{ + if (CORBA::is_nil (obj)) + return TAO_RTScheduler_Manager::_nil (); + return + ACE_reinterpret_cast + ( + TAO_RTScheduler_Manager_ptr, + obj->_tao_QueryInterface + ( + ACE_reinterpret_cast (ptr_arith_t, + &TAO_RTScheduler_Manager::_narrow) + ) + ); +} + +TAO_RTScheduler_Manager_ptr +TAO_RTScheduler_Manager::_duplicate (TAO_RTScheduler_Manager_ptr obj) +{ + if (!CORBA::is_nil (obj)) + obj->_add_ref (); + return obj; +} + +void * +TAO_RTScheduler_Manager::_tao_QueryInterface (ptr_arith_t type) +{ + void *retv = 0; + if (type == ACE_reinterpret_cast + (ptr_arith_t, + &TAO_RTScheduler_Manager::_narrow)) + retv = ACE_reinterpret_cast (void*, this); + else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow)) + retv = ACE_reinterpret_cast (void *, + ACE_static_cast (CORBA::Object_ptr, this)); + + if (retv) + this->_add_ref (); + return retv; +} + +const char* +TAO_RTScheduler_Manager::_interface_repository_id (void) const +{ + return "IDL:RTScheduler_Manager:1.0"; +} + diff --git a/TAO/tao/RTScheduling/RTScheduler_Manager.h b/TAO/tao/RTScheduling/RTScheduler_Manager.h new file mode 100644 index 00000000000..af6831950e6 --- /dev/null +++ b/TAO/tao/RTScheduling/RTScheduler_Manager.h @@ -0,0 +1,153 @@ +/* -*- C++ -*- */ +//============================================================================= +/** + * @file RTScheduler_Manager.h + * + * $Id$ + * + * @author Yamuna Krishnmaurthy + */ +//============================================================================= + + +#ifndef TAO_PRIORITY_MAPPING_MANAGER_H +#define TAO_PRIORITY_MAPPING_MANAGER_H + + +#if defined(_MSC_VER) +#if (_MSC_VER >= 1200) +#pragma warning(push) +#endif /* _MSC_VER >= 1200 */ +#pragma warning(disable:4250) +#endif /* _MSC_VER */ + +#include "RTSchedulerC.h" +//#include "tao/LocalObject.h" + +class TAO_RTScheduler_Manager; +class TAO_RTScheduler_Manager_var; +typedef TAO_RTScheduler_Manager *TAO_RTScheduler_Manager_ptr; + + +/** + * @class TAO_RTScheduler_Manager + * + * @brief RTScheduler_Manager pseudo-objref. + * + * Allows setting of user-defined RTScheduler at run-time. + */ +class TAO_RTScheduler_Export TAO_RTScheduler_Manager : + public virtual TAO_Local_RefCounted_Object +{ +public: + + TAO_RTScheduler_Manager (void); + /// Constructor. + TAO_RTScheduler_Manager (TAO_ORB_Core*); + + /// + void rtscheduler (RTScheduling::Scheduler_ptr rtscheduler + ACE_ENV_ARG_DECL_WITH_DEFAULTS); + + /// + RTScheduling::Scheduler_ptr rtscheduler (void); + +public: +#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) + typedef TAO_RTScheduler_Manager_ptr _ptr_type; + typedef TAO_RTScheduler_Manager_var _var_type; +#endif /* ! __GNUC__ || g++ >= 2.8 */ + + // the static operations + static TAO_RTScheduler_Manager_ptr _duplicate (TAO_RTScheduler_Manager_ptr obj); + static TAO_RTScheduler_Manager_ptr _narrow ( + CORBA::Object_ptr obj + ACE_ENV_ARG_DECL_WITH_DEFAULTS); + + static TAO_RTScheduler_Manager_ptr _unchecked_narrow ( + CORBA::Object_ptr obj + ACE_ENV_ARG_DECL_WITH_DEFAULTS); + + static TAO_RTScheduler_Manager_ptr _nil (void) + { + return (TAO_RTScheduler_Manager_ptr)0; + } + + virtual void *_tao_QueryInterface (ptr_arith_t type); + + virtual const char* _interface_repository_id (void) const; + +protected: + + /// Protected destructor to enforce proper memory management of this + /// reference counted object. + ~TAO_RTScheduler_Manager (void); + +private: + + TAO_RTScheduler_Manager (const TAO_RTScheduler_Manager &); + void operator= (const TAO_RTScheduler_Manager &); + TAO_ORB_Core* orb_; + +private: + RTScheduling::Scheduler_var rtscheduler_; +}; + +class TAO_RTScheduler_Export TAO_RTScheduler_Manager_var : public TAO_Base_var +{ +public: + TAO_RTScheduler_Manager_var (void); // default constructor + TAO_RTScheduler_Manager_var (TAO_RTScheduler_Manager_ptr); + TAO_RTScheduler_Manager_var (const TAO_RTScheduler_Manager_var &); // copy constructor + ~TAO_RTScheduler_Manager_var (void); // destructor + + TAO_RTScheduler_Manager_var &operator= (TAO_RTScheduler_Manager_ptr); + TAO_RTScheduler_Manager_var &operator= (const TAO_RTScheduler_Manager_var &); + TAO_RTScheduler_Manager_ptr operator-> (void) const; + + /// in, inout, out, _retn + operator const TAO_RTScheduler_Manager_ptr &() const; + operator TAO_RTScheduler_Manager_ptr &(); + TAO_RTScheduler_Manager_ptr in (void) const; + TAO_RTScheduler_Manager_ptr &inout (void); + TAO_RTScheduler_Manager_ptr &out (void); + TAO_RTScheduler_Manager_ptr _retn (void); + TAO_RTScheduler_Manager_ptr ptr (void) const; + + // Hooks used by template sequence and object manager classes + // for non-defined forward declared interfaces. + static TAO_RTScheduler_Manager_ptr duplicate (TAO_RTScheduler_Manager_ptr); + static void release (TAO_RTScheduler_Manager_ptr); + static TAO_RTScheduler_Manager_ptr nil (void); + static TAO_RTScheduler_Manager_ptr narrow (CORBA::Object * ACE_ENV_ARG_DECL_NOT_USED); + static CORBA::Object * upcast (void *); + +private: + /// Unimplemented - prevents widening assignment. + TAO_RTScheduler_Manager_ptr ptr_; + TAO_RTScheduler_Manager_var (const TAO_Base_var &rhs); + TAO_RTScheduler_Manager_var &operator= (const TAO_Base_var &rhs); +}; + +class TAO_RTScheduler_Export TAO_RTScheduler_Manager_out +{ +public: + TAO_RTScheduler_Manager_out (TAO_RTScheduler_Manager_ptr &); + TAO_RTScheduler_Manager_out (TAO_RTScheduler_Manager_var &); + TAO_RTScheduler_Manager_out (const TAO_RTScheduler_Manager_out &); + TAO_RTScheduler_Manager_out &operator= (const TAO_RTScheduler_Manager_out &); + TAO_RTScheduler_Manager_out &operator= (const TAO_RTScheduler_Manager_var &); + TAO_RTScheduler_Manager_out &operator= (TAO_RTScheduler_Manager_ptr); + operator TAO_RTScheduler_Manager_ptr &(); + TAO_RTScheduler_Manager_ptr &ptr (void); + TAO_RTScheduler_Manager_ptr operator-> (void); + +private: + TAO_RTScheduler_Manager_ptr &ptr_; +}; + +#if defined (__ACE_INLINE__) +#include "RTScheduler_Manager.i" +#endif /* __ACE_INLINE__ */ + +#endif /* TAO_PRIORITY_MAPPING_MANAGER_H */ diff --git a/TAO/tao/RTScheduling/RTScheduler_Manager.i b/TAO/tao/RTScheduling/RTScheduler_Manager.i new file mode 100644 index 00000000000..509027f2112 --- /dev/null +++ b/TAO/tao/RTScheduling/RTScheduler_Manager.i @@ -0,0 +1,227 @@ +// $Id$ + +// ************************************************************* +// Inline operations for class TAO_RTScheduler_Manager_var +// ************************************************************* + +#include "tao/ORB_Core.h" + +ACE_INLINE +TAO_RTScheduler_Manager_var::TAO_RTScheduler_Manager_var (void) // default constructor + : ptr_ (TAO_RTScheduler_Manager::_nil ()) +{} + +ACE_INLINE +TAO_RTScheduler_Manager_var::TAO_RTScheduler_Manager_var (TAO_RTScheduler_Manager_ptr p) + : ptr_ (p) +{} + +ACE_INLINE ::TAO_RTScheduler_Manager_ptr +TAO_RTScheduler_Manager_var::ptr (void) const +{ + return this->ptr_; +} + +ACE_INLINE +TAO_RTScheduler_Manager_var::TAO_RTScheduler_Manager_var (const ::TAO_RTScheduler_Manager_var &p) // copy constructor + : TAO_Base_var (), + ptr_ (TAO_RTScheduler_Manager::_duplicate (p.ptr ())) +{} + +ACE_INLINE +TAO_RTScheduler_Manager_var::~TAO_RTScheduler_Manager_var (void) // destructor +{ + CORBA::release (this->ptr_); +} + +ACE_INLINE TAO_RTScheduler_Manager_var & +TAO_RTScheduler_Manager_var::operator= (TAO_RTScheduler_Manager_ptr p) +{ + CORBA::release (this->ptr_); + this->ptr_ = p; + return *this; +} + +ACE_INLINE TAO_RTScheduler_Manager_var & +TAO_RTScheduler_Manager_var::operator= (const ::TAO_RTScheduler_Manager_var &p) +{ + if (this != &p) + { + CORBA::release (this->ptr_); + this->ptr_ = ::TAO_RTScheduler_Manager::_duplicate (p.ptr ()); + } + return *this; +} + +ACE_INLINE +TAO_RTScheduler_Manager_var::operator const ::TAO_RTScheduler_Manager_ptr &() const // cast +{ + return this->ptr_; +} + +ACE_INLINE +TAO_RTScheduler_Manager_var::operator ::TAO_RTScheduler_Manager_ptr &() // cast +{ + return this->ptr_; +} + +ACE_INLINE ::TAO_RTScheduler_Manager_ptr +TAO_RTScheduler_Manager_var::operator-> (void) const +{ + return this->ptr_; +} + +ACE_INLINE ::TAO_RTScheduler_Manager_ptr +TAO_RTScheduler_Manager_var::in (void) const +{ + return this->ptr_; +} + +ACE_INLINE ::TAO_RTScheduler_Manager_ptr & +TAO_RTScheduler_Manager_var::inout (void) +{ + return this->ptr_; +} + +ACE_INLINE ::TAO_RTScheduler_Manager_ptr & +TAO_RTScheduler_Manager_var::out (void) +{ + CORBA::release (this->ptr_); + this->ptr_ = ::TAO_RTScheduler_Manager::_nil (); + return this->ptr_; +} + +ACE_INLINE ::TAO_RTScheduler_Manager_ptr +TAO_RTScheduler_Manager_var::_retn (void) +{ + // yield ownership of managed obj reference + ::TAO_RTScheduler_Manager_ptr val = this->ptr_; + this->ptr_ = ::TAO_RTScheduler_Manager::_nil (); + return val; +} + +ACE_INLINE ::TAO_RTScheduler_Manager_ptr +TAO_RTScheduler_Manager_var::duplicate (TAO_RTScheduler_Manager_ptr p) +{ + return ::TAO_RTScheduler_Manager::_duplicate (p); +} + +ACE_INLINE void +TAO_RTScheduler_Manager_var::release (TAO_RTScheduler_Manager_ptr p) +{ + CORBA::release (p); +} + +ACE_INLINE ::TAO_RTScheduler_Manager_ptr +TAO_RTScheduler_Manager_var::nil (void) +{ + return ::TAO_RTScheduler_Manager::_nil (); +} + +ACE_INLINE ::TAO_RTScheduler_Manager_ptr +TAO_RTScheduler_Manager_var::narrow ( + CORBA::Object *p + ACE_ENV_ARG_DECL + ) +{ + return ::TAO_RTScheduler_Manager::_narrow (p ACE_ENV_ARG_PARAMETER); +} + +ACE_INLINE CORBA::Object * +TAO_RTScheduler_Manager_var::upcast (void *src) +{ + TAO_RTScheduler_Manager **tmp = + ACE_static_cast (TAO_RTScheduler_Manager **, src); + return *tmp; +} + + +// ************************************************************* +// Inline operations for class TAO_RTScheduler_Manager_out +// ************************************************************* + +ACE_INLINE +TAO_RTScheduler_Manager_out::TAO_RTScheduler_Manager_out (TAO_RTScheduler_Manager_ptr &p) + : ptr_ (p) +{ + this->ptr_ = ::TAO_RTScheduler_Manager::_nil (); +} + +ACE_INLINE +TAO_RTScheduler_Manager_out::TAO_RTScheduler_Manager_out (TAO_RTScheduler_Manager_var &p) // constructor from _var + : ptr_ (p.out ()) +{ + CORBA::release (this->ptr_); + this->ptr_ = ::TAO_RTScheduler_Manager::_nil (); +} + +ACE_INLINE +TAO_RTScheduler_Manager_out::TAO_RTScheduler_Manager_out (const ::TAO_RTScheduler_Manager_out &p) // copy constructor + : ptr_ (ACE_const_cast (TAO_RTScheduler_Manager_out &, p).ptr_) +{} + +ACE_INLINE ::TAO_RTScheduler_Manager_out & +TAO_RTScheduler_Manager_out::operator= (const ::TAO_RTScheduler_Manager_out &p) +{ + this->ptr_ = ACE_const_cast (TAO_RTScheduler_Manager_out&, p).ptr_; + return *this; +} + +ACE_INLINE TAO_RTScheduler_Manager_out & +TAO_RTScheduler_Manager_out::operator= (const ::TAO_RTScheduler_Manager_var &p) +{ + this->ptr_ = ::TAO_RTScheduler_Manager::_duplicate (p.ptr ()); + return *this; +} + +ACE_INLINE TAO_RTScheduler_Manager_out & +TAO_RTScheduler_Manager_out::operator= (TAO_RTScheduler_Manager_ptr p) +{ + this->ptr_ = p; + return *this; +} + +ACE_INLINE +TAO_RTScheduler_Manager_out::operator ::TAO_RTScheduler_Manager_ptr &() // cast +{ + return this->ptr_; +} + +ACE_INLINE ::TAO_RTScheduler_Manager_ptr & +TAO_RTScheduler_Manager_out::ptr (void) // ptr +{ + return this->ptr_; +} + +ACE_INLINE ::TAO_RTScheduler_Manager_ptr +TAO_RTScheduler_Manager_out::operator-> (void) +{ + return this->ptr_; +} + +/////////////////////////////////////////////////////////////////////////// +ACE_INLINE +TAO_RTScheduler_Manager::TAO_RTScheduler_Manager (TAO_ORB_Core* orb) + : orb_ (orb) +{ +} + +ACE_INLINE RTScheduling::Scheduler_ptr +TAO_RTScheduler_Manager::rtscheduler (void) +{ + return RTScheduling::Scheduler::_duplicate (this->rtscheduler_.in()); +} + +ACE_INLINE void +TAO_RTScheduler_Manager::rtscheduler (RTScheduling::Scheduler_ptr rtscheduler + ACE_ENV_ARG_DECL) +{ + rtscheduler_ = RTScheduling::Scheduler::_duplicate (rtscheduler); + this->orb_->object_ref_table ().register_initial_reference ("RTScheduler", + RTScheduling::Scheduler::_duplicate (this->rtscheduler_.in ()) + ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + +} + + -- cgit v1.2.1