TAO_CosNotification: TAO_Notify_Object class Reference

00036 {
00037   if (TAO_debug_level > 2 )
00038     ACE_DEBUG ((LM_DEBUG,"object:%x  destroyed\n", this ));
00039 
00040   this->destroy_proxy_poa ();
00041   this->destroy_object_poa ();
00042   this->destroy_poa ();
00043 }

00022 : poa_ (0)
00023 , proxy_poa_ (0)
00024 , own_proxy_poa_ (false)
00025 , object_poa_ (0)
00026 , own_object_poa_ (false)
00027 , id_ (0)
00028 , own_worker_task_ (false)
00029 , shutdown_ (false)
00030 {
00031   if (TAO_debug_level > 2 )
00032     ACE_DEBUG ((LM_DEBUG,"object:%x  created\n", this ));
00033 }

00081 {
00082   this->id_ = id;
00083   return this->poa_->activate_with_id (servant, this->id_);
00084 }

00072 {
00073   return this->poa_->activate (servant, this->id_);
00074 }

00092 {
00093   ACE_ASSERT( this->admin_properties_.get() != 0 );
00094   return *this->admin_properties_;
00095 }

00037 {
00038   ACE_ASSERT( single != 0 );
00039   this->set_proxy_poa( single );
00040   this->set_object_poa( single );
00041   this->set_poa( single );
00042 
00043   // Maintain ownership of the poa
00044 }

00089 {
00090   try
00091   {
00092     this->poa_->deactivate (this->id_);
00093   }
00094   catch (const CORBA::Exception& ex)
00095   {
00096     // Do not propagate any exceptions
00097     if (TAO_debug_level > 2)
00098     {
00099       ex._tao_print_exception ("(%P|%t)\n");
00100       ACE_DEBUG ((LM_DEBUG, "Could not deactivate object %d\n", this->id_));
00101     }
00102   }
00103 }

00173 {
00174   if (this->object_poa_ != 0)
00175   {
00176     try
00177     {
00178       if ( this->object_poa_ == this->proxy_poa_ ) this->proxy_poa_ = 0;
00179       if ( this->object_poa_ == this->poa_ ) this->poa_ = 0;
00180 
00181       if ( this->own_object_poa_ == true )
00182       {
00183         this->own_object_poa_ = false;
00184         ACE_Auto_Ptr< TAO_Notify_POA_Helper > aop( object_poa_ );
00185         this->object_poa_->destroy ();
00186       }
00187       this->object_poa_ = 0;
00188     }
00189     catch (const CORBA::Exception& ex)
00190     {
00191       if (TAO_debug_level > 2)
00192         ex._tao_print_exception ("Proxy shutdown error (%P|%t)\n");
00193     }
00194   }
00195 }

00199 {
00200   this->poa_ = 0;
00201 }

00147 {
00148   if (this->proxy_poa_ != 0)
00149   {
00150     try
00151     {
00152       if ( this->proxy_poa_ == this->object_poa_ ) this->object_poa_ = 0;
00153       if ( this->proxy_poa_ == this->poa_ ) this->poa_ = 0;
00154 
00155       if ( this->own_proxy_poa_ == true )
00156       {
00157         this->own_proxy_poa_ = false;
00158         ACE_Auto_Ptr< TAO_Notify_POA_Helper > app( proxy_poa_ );
00159         this->proxy_poa_->destroy ();
00160       }
00161       this->proxy_poa_ = 0;
00162     }
00163     catch (const CORBA::Exception& ex)
00164     {
00165       if (TAO_debug_level > 2)
00166         ex._tao_print_exception ("Proxy shutdown error (%P|%t)\n");
00167     }
00168   }
00169 }

00085 {
00086   ACE_ASSERT( this->event_manager_.get() != 0 );
00087   return *this->event_manager_;
00088 }

00015 {
00016   TAO_Notify_Worker_Task::Ptr task( this->worker_task_ );
00017   if ( task.isSet() )
00018   {
00019     task->execute( method_request );
00020   }
00021 }

00303 {
00304   // qos_properties_ is essentially a map and the find() method returns
00305   // zero on success.  We must convert this to a boolean value.
00306   return (this->qos_properties_.find (name, value) == 0);
00307 }

00287 {
00288   CosNotification::QoSProperties_var properties;
00289 
00290   ACE_NEW_THROW_EX (properties,
00291     CosNotification::QoSProperties (),
00292     CORBA::NO_MEMORY ());
00293 
00294   this->qos_properties_.populate (properties);
00295 
00296   return properties._retn ();
00297 }

00362 {
00363   return this->worker_task_.get ();
00364 }

00072 {
00073   return this->shutdown_;
00074 }

00009 {
00010   return id_;
00011 }

00025 {
00026   this->set_proxy_poa( parent.proxy_poa() );
00027   this->set_object_poa( parent.object_poa() );
00028   this->set_poa( parent.poa() );
00029 
00030   // Do not take ownership of parent's poas
00031   own_proxy_poa_ = false;
00032   own_object_poa_ = false;
00033 }

00047 {
00048   ACE_ASSERT (parent != 0 && this->event_manager_.get() == 0);
00049 
00050   // Do not use sets to avoid asserts.
00051   // Object must be able to inherit NULL references
00052   // due to current design.
00053   this->event_manager_ = parent->event_manager_;
00054   this->admin_properties_ = parent->admin_properties_;
00055   this->inherit_poas( *parent );
00056   this->worker_task_ = parent->worker_task_;
00057 
00058   // Pass  QoS
00059   parent->qos_properties_.transfer (this->qos_properties_);
00060   this->qos_changed (this->qos_properties_);
00061 }

00349 {
00350   attrs.load (this->qos_properties_.event_reliability ());
00351   attrs.load (this->qos_properties_.connection_reliability ());
00352   attrs.load (this->qos_properties_.priority ());
00353   attrs.load (this->qos_properties_.timeout ());
00354   attrs.load (this->qos_properties_.stop_time_supported ());
00355   attrs.load (this->qos_properties_.maximum_batch_size ());
00356   attrs.load (this->qos_properties_.pacing_interval ());
00357   this->qos_properties_.init ();
00358 }

00060 {
00061   return this->object_poa_;
00062 }

00054 {
00055   return this->poa_;
00056 }

00066 {
00067   return this->proxy_poa_;
00068 }

00312 {
00313   // NOP.
00314 }

00126 {
00127   return this->poa_->id_to_reference (this->id_);
00128 }

00337 {
00338   add_qos_attr(attrs, this->qos_properties_.event_reliability ());
00339   add_qos_attr(attrs, this->qos_properties_.connection_reliability ());
00340   add_qos_attr(attrs, this->qos_properties_.priority ());
00341   add_qos_attr(attrs, this->qos_properties_.timeout ());
00342   add_qos_attr(attrs, this->qos_properties_.stop_time_supported ());
00343   add_qos_attr(attrs, this->qos_properties_.maximum_batch_size ());
00344   add_qos_attr(attrs, this->qos_properties_.pacing_interval ());
00345 }

00078 {
00079   ACE_ASSERT( admin_properties != 0 );
00080   this->admin_properties_.reset( admin_properties );
00081 }

00065 {
00066   ACE_ASSERT( event_manager != 0 );
00067   this->event_manager_.reset( event_manager );
00068 }

00229 {
00230   // shutdown current object poa.
00231   this->destroy_object_poa ();
00232 
00233   this->object_poa_ = object_poa;
00234 
00235   this->own_object_poa_ = true;
00236 }

00240 {
00241   this->poa_ = poa;
00242 }

00048 {
00049   this->set_poa( this->proxy_poa() );
00050 }

00218 {
00219   // shutdown current proxy poa.
00220   this->destroy_proxy_poa ();
00221 
00222   this->proxy_poa_ = proxy_poa;
00223 
00224   this->own_proxy_poa_ = true;
00225 }

00246 {
00247   CosNotification::PropertyErrorSeq err_seq;
00248 
00249   TAO_Notify_QoSProperties new_qos_properties;
00250 
00251   if (new_qos_properties.init (qos, err_seq) == -1)
00252     throw CORBA::INTERNAL ();
00253 
00254   // Apply the appropriate concurrency QoS
00255   if (new_qos_properties.thread_pool ().is_valid ())
00256   {
00257     if (new_qos_properties.thread_pool ().value ().static_threads == 0)
00258       {
00259         TAO_Notify_PROPERTIES::instance()->builder()->apply_reactive_concurrency (*this);
00260       }
00261     else
00262       {
00263         TAO_Notify_PROPERTIES::instance()->builder()->
00264         apply_thread_pool_concurrency (*this, new_qos_properties.thread_pool ().value ());
00265       }
00266   }
00267   else if (new_qos_properties.thread_pool_lane ().is_valid ())
00268     TAO_Notify_PROPERTIES::instance()->builder()->
00269     apply_lane_concurrency (*this, new_qos_properties.thread_pool_lane ().value ());
00270 
00271   // Update the Thread Task's QoS properties..
00272   this->worker_task_->update_qos_properties (new_qos_properties);
00273 
00274   // Inform subclasses of QoS changed.
00275   this->qos_changed (new_qos_properties);
00276 
00277   // Init the the overall QoS on this object.
00278   if (new_qos_properties.copy (this->qos_properties_) == -1)
00279     throw CORBA::INTERNAL ();
00280 
00281   if (err_seq.length () > 0) // Unsupported Property
00282     throw CosNotification::UnsupportedQoS (err_seq);
00283 }

00205 {
00206   ACE_ASSERT( worker_task != 0 );
00207 
00208   // shutdown the current worker.
00209   this->shutdown_worker_task ();
00210 
00211   this->worker_task_.reset (worker_task);
00212 
00213   this->own_worker_task_ = true;
00214 }

00107 {
00108   {
00109     ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, ace_mon, this->lock_, 1);
00110 
00111     if (this->shutdown_ == 1)
00112       return 1; // Another thread has already run shutdown.
00113 
00114     this->shutdown_ = 1;
00115   }
00116 
00117   this->deactivate ();
00118 
00119   this->shutdown_worker_task ();
00120 
00121   return 0;
00122 }

00132 {
00133   // Only do this if we are the owner.
00134   TAO_Notify_Worker_Task::Ptr task( this->worker_task_ );
00135   this->worker_task_.reset();
00136   if ( task.isSet() )
00137   {
00138     if ( this->own_worker_task_ )
00139     {
00140       task->shutdown ();
00141     }
00142   }
00143 }

00318 {
00319   ACE_ASSERT (worker_task_.get() != 0);
00320   return this->worker_task_->timer ();
00321 }


Public Types
typedef CORBA::Long	ID
	Id for Objects.
Public Member Functions
virtual	~TAO_Notify_Object (void)
	Destructor.
ID	id (void) const
	This Object's ID.
virtual CORBA::Object_ptr	activate (PortableServer::Servant servant)
	Activate.
virtual CORBA::Object_ptr	activate (PortableServer::Servant servant, CORBA::Long id)
	Activate with existing id.
void	deactivate (void)
	Deactivate.
int	has_shutdown (void)
	Have we been shutdown. returns 1 if shutdown.
void	execute_task (TAO_Notify_Method_Request &method_request)
CORBA::Object_ptr	ref (void)
	Get CORBA Ref.
virtual void	set_qos (const CosNotification::QoSProperties &qos)
	Set the QoS Properties.
CosNotification::QoSProperties *	get_qos (void)
	Get the QoS Properties.
bool	find_qos_property_value (const char *name, CosNotification::PropertyValue &value) const
virtual TAO_Notify_Timer *	timer (void)
	Obtain the Timer manager associated with this object.
TAO_Notify_Event_Manager &	event_manager (void)
	Accessor for the Event Manager.
virtual int	shutdown (void)
	shutdown. Returns 1 ifif the shutdown was already run once before.
virtual void	load_attrs (const TAO_Notify::NVPList &attrs)
TAO_Notify_Worker_Task *	get_worker_task (void)
	Allow access to the underlying worker task.
Protected Member Functions
	TAO_Notify_Object (void)
	Constructor.
void	initialize (TAO_Notify_Object *parent)
	Init this object with data from .
void	inherit_poas (TAO_Notify_Object &parent)
	Uses the poas from the supplied object.
void	adopt_poa (TAO_Notify_POA_Helper *single)
	Adopts the supplied poa as all are poas.
void	set_primary_as_proxy_poa ()
	Changes the primary poa to the current proxy poa.
TAO_Notify_POA_Helper *	proxy_poa (void)
	Accessor for the proxy_poa_.
TAO_Notify_POA_Helper *	object_poa (void)
	Accessor for the object_poa_.
TAO_Notify_POA_Helper *	poa (void)
	Get the POA assigned to us.
void	set_event_manager (TAO_Notify_Event_Manager *event_manager)
void	set_admin_properties (TAO_Notify_AdminProperties *admin_properties)
TAO_Notify_AdminProperties &	admin_properties (void)
	Accessor for the Admin Properties.
virtual void	qos_changed (const TAO_Notify_QoSProperties &qos_properties)
	Notification that can be overridden by subclasses to be informed that have been modified.
virtual void	save_attrs (TAO_Notify::NVPList &attrs)
Protected Attributes
TAO_Notify_QoSProperties	qos_properties_
	= Protected data members. QoS Properties.
TAO_SYNCH_MUTEX	lock_
	The mutex to serialize access to state variables.
Private Member Functions
void	set_worker_task (TAO_Notify_Worker_Task *worker_task)
	Set Worker Task. This object assume ownership of the set object.
void	set_proxy_poa (TAO_Notify_POA_Helper *proxy_poa)
	Setting the proxy_poa_ gives ownership to this class.
void	set_object_poa (TAO_Notify_POA_Helper *object_poa)
	Setting the object_poa_ gives ownership to this class.
void	set_poa (TAO_Notify_POA_Helper *object_poa)
	Setting the object_poa_ gives ownership to this class.
void	shutdown_worker_task (void)
	Shutdown the current worker task and delete it if we own it.
void	destroy_proxy_poa (void)
	Shutdown the current proxy poa.
void	destroy_object_poa (void)
	Shutdown the current object poa.
void	destroy_poa (void)
	Shutdown the current poa.
Private Attributes
TAO_Notify_POA_Helper *	poa_
	The POA in which the object is activated.
TAO_Notify_POA_Helper *	proxy_poa_
	The POA in which the proxys are activated.
bool	own_proxy_poa_
TAO_Notify_POA_Helper *	object_poa_
	The POA in which the object's children are activated.
bool	own_object_poa_
ID	id_
	Id assigned to this object.
TAO_Notify_Refcountable_Guard_T< TAO_Notify_Event_Manager >	event_manager_
	The event manager.
TAO_Notify_AdminProperties::Ptr	admin_properties_
	Admin Properties.
TAO_Notify_Worker_Task::Ptr	worker_task_
	Worker Task.
bool	own_worker_task_
bool	shutdown_
	Are we shutdown (i,e. scheduled for destroy).
Friends
class	TAO_Notify_Builder
class	TAO_Notify_RT_Builder

TAO_Notify_Object Class Reference

Public Types

Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Friends

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation