TAO_RTEvent: TAO_EC_Event_Channel

00336        {
00337     EC_S_IDLE
00338     , EC_S_ACTIVATING
00339     , EC_S_ACTIVE
00340     , EC_S_DESTROYING
00341     , EC_S_DESTROYED
00342   };

00049 {
00050   // Destroy Strategies in the reverse order of creation, they
00051   // refere to each other during destruction and thus need to be
00052   // cleaned up properly.
00053   this->factory_->destroy_supplier_control (this->supplier_control_);
00054   this->supplier_control_ = 0;
00055   this->factory_->destroy_consumer_control (this->consumer_control_);
00056   this->consumer_control_ = 0;
00057 
00058   this->factory_->destroy_scheduling_strategy (this->scheduling_strategy_);
00059   this->scheduling_strategy_ = 0;
00060 
00061   this->factory_->destroy_observer_strategy (this->observer_strategy_);
00062   this->observer_strategy_ = 0;
00063 
00064   this->factory_->destroy_timeout_generator (this->timeout_generator_);
00065   this->timeout_generator_ = 0;
00066 
00067   this->factory_->destroy_supplier_admin (this->supplier_admin_);
00068   this->supplier_admin_ = 0;
00069   this->factory_->destroy_consumer_admin (this->consumer_admin_);
00070   this->consumer_admin_ = 0;
00071 
00072   this->factory_->destroy_supplier_filter_builder (this->supplier_filter_builder_);
00073   this->supplier_filter_builder_ = 0;
00074 
00075   this->factory_->destroy_filter_builder (this->filter_builder_);
00076   this->filter_builder_ = 0;
00077 
00078   this->factory_->destroy_dispatching (this->dispatching_);
00079   this->dispatching_ = 0;
00080 
00081   this->factory (0, 0);
00082 }

00025   : supplier_poa_ (PortableServer::POA::_duplicate (attr.supplier_poa)),
00026     consumer_poa_ (PortableServer::POA::_duplicate (attr.consumer_poa)),
00027     factory_ (factory),
00028     own_factory_ (own_factory),
00029     dispatching_ (0),
00030     filter_builder_ (0),
00031     supplier_filter_builder_ (0),
00032     consumer_admin_ (0),
00033     supplier_admin_ (0),
00034     timeout_generator_ (0),
00035     observer_strategy_ (0),
00036     scheduling_strategy_(0),
00037     consumer_reconnect_ (attr.consumer_reconnect),
00038     supplier_reconnect_ (attr.supplier_reconnect),
00039     disconnect_callbacks_ (attr.disconnect_callbacks),
00040     consumer_control_ (0),
00041     supplier_control_ (0),
00042     status_ (EC_S_IDLE)
00043 {
00044   this->scheduler_ =
00045     CORBA::Object::_duplicate (attr.scheduler);
00046 }

00113 {
00114   {
00115     // First check if the EC is idle, if it is not then we need to
00116     // return right away...
00117     ACE_GUARD (TAO_SYNCH_MUTEX, ace_mon, this->mutex_);
00118     if (this->status_ != EC_S_IDLE)
00119       return;
00120     this->status_ = EC_S_ACTIVATING;
00121   }
00122   this->dispatching_->activate ();
00123   this->timeout_generator_->activate ();
00124   this->consumer_control_->activate ();
00125   this->supplier_control_->activate ();
00126   {
00127     // Only when all the operations complete successfully we can mark
00128     // the EC as active...
00129     ACE_GUARD (TAO_SYNCH_MUTEX, ace_mon, this->mutex_);
00130     ACE_ASSERT (this->status_ == EC_S_ACTIVATING);
00131     this->status_ = EC_S_ACTIVE;
00132   }
00133 }

00270 {
00271   return this->observer_strategy_->append_observer (observer);
00272 }

00227 {
00228   this->supplier_admin_->peer_connected (supplier);
00229   this->consumer_admin_->connected (supplier);
00230   this->observer_strategy_->connected (supplier);
00231 }

00203 {
00204   this->consumer_admin_->peer_connected (consumer);
00205   this->supplier_admin_->connected (consumer);
00206   this->observer_strategy_->connected (consumer);
00207 }

00057 {
00058   return this->consumer_admin_;
00059 }

00081 {
00082   return this->consumer_control_;
00083 }

00147 {
00148   return PortableServer::POA::_duplicate (this->consumer_poa_.in ());
00149 }

00177 {
00178   return this->consumer_reconnect_;
00179 }

00153 {
00154   return this->factory_->create_consumer_lock ();
00155 }

00105 {
00106   x = this->factory_->create_proxy_push_consumer (this);
00107 }

00093 {
00094   x = this->factory_->create_proxy_push_supplier (this);
00095 }

00117 {
00118   x = this->factory_->create_proxy_push_consumer_collection (this);
00119 }

00129 {
00130   x = this->factory_->create_proxy_push_supplier_collection (this);
00131 }

00086 {
00087   this->dispatching_ =
00088     this->factory_->create_dispatching (this);
00089   this->filter_builder_ =
00090     this->factory_->create_filter_builder (this);
00091   this->supplier_filter_builder_ =
00092     this->factory_->create_supplier_filter_builder (this);
00093   this->consumer_admin_ =
00094     this->factory_->create_consumer_admin (this);
00095   this->supplier_admin_ =
00096     this->factory_->create_supplier_admin (this);
00097   this->timeout_generator_ =
00098     this->factory_->create_timeout_generator (this);
00099   this->observer_strategy_ =
00100     this->factory_->create_observer_strategy (this);
00101 
00102   this->scheduling_strategy_ =
00103     this->factory_->create_scheduling_strategy (this);
00104 
00105   this->consumer_control_ =
00106     this->factory_->create_consumer_control (this);
00107   this->supplier_control_ =
00108     this->factory_->create_supplier_control (this);
00109 }

00165 {
00166   return this->factory_->create_supplier_lock ();
00167 }

00186 {
00187   try
00188     {
00189       PortableServer::POA_var consumer_poa =
00190         this->consumer_admin_->_default_POA ();
00191       PortableServer::ObjectId_var consumer_id =
00192         consumer_poa->servant_to_id (this->consumer_admin_);
00193       consumer_poa->deactivate_object (consumer_id.in ());
00194     }
00195   catch (const CORBA::Exception&)
00196     {
00197             // The deactivation can throw...
00198     }
00199 }

00169 {
00170   try
00171     {
00172       PortableServer::POA_var supplier_poa =
00173         this->supplier_admin_->_default_POA ();
00174       PortableServer::ObjectId_var supplier_id =
00175         supplier_poa->servant_to_id (this->supplier_admin_);
00176       supplier_poa->deactivate_object (supplier_id.in ());
00177     }
00178   catch (const CORBA::Exception&)
00179     {
00180             // The deactivation can throw...
00181     }
00182 }

00263 {
00264   this->shutdown ();
00265 }

00159 {
00160   this->factory_->destroy_consumer_lock (x);
00161 }

00111 {
00112   this->factory_->destroy_proxy_push_consumer (consumer);
00113 }

00099 {
00100   this->factory_->destroy_proxy_push_supplier (supplier);
00101 }

00123 {
00124   this->factory_->destroy_proxy_push_consumer_collection (x);
00125 }

00135 {
00136   this->factory_->destroy_proxy_push_supplier_collection (x);
00137 }

00171 {
00172   this->factory_->destroy_supplier_lock (x);
00173 }

00201 {
00202   ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, ace_mon, this->mutex_, 0);
00203   return (this->status_ == EC_S_DESTROYED);
00204 }

00189 {
00190   return this->disconnect_callbacks_;
00191 }

00243 {
00244   this->supplier_admin_->peer_disconnected (supplier);
00245   this->consumer_admin_->disconnected (supplier);
00246   this->observer_strategy_->disconnected (supplier);
00247 }

00219 {
00220   this->consumer_admin_->peer_disconnected (consumer);
00221   this->supplier_admin_->disconnected (consumer);
00222   this->observer_strategy_->disconnected (consumer);
00223 }

00039 {
00040   return this->dispatching_;
00041 }

00029 {
00030   if (this->own_factory_)
00031     delete this->factory_;
00032 
00033   this->factory_ = factory;
00034   this->own_factory_ = own_factory;
00035 }

00022 {
00023   return this->factory_;
00024 }

00045 {
00046   return this->filter_builder_;
00047 }

00251 {
00252   return this->consumer_admin_->_this ();
00253 }

00284 {
00285   this->consumer_admin_->for_each (worker);
00286 }

00291 {
00292   this->supplier_admin_->for_each (worker);
00293 }

00257 {
00258   return this->supplier_admin_->_this ();
00259 }

00235 {
00236   this->supplier_admin_->peer_reconnected (supplier);
00237   this->consumer_admin_->reconnected (supplier);
00238   this->observer_strategy_->connected (supplier);
00239 }

00211 {
00212   this->consumer_admin_->peer_reconnected (consumer);
00213   this->supplier_admin_->reconnected (consumer);
00214   this->observer_strategy_->connected (consumer);
00215 }

00277 {
00278   this->observer_strategy_->remove_observer (handle);
00279 }

00195 {
00196   return CORBA::Object::_duplicate (this->scheduler_.in ());
00197 }

00075 {
00076   return this->scheduling_strategy_;
00077 }

00137 {
00138   {
00139     // First check if the EC is already active, if it is not then we
00140     // need to return right away...
00141     ACE_GUARD (TAO_SYNCH_MUTEX, ace_mon, this->mutex_);
00142     if (this->status_ != EC_S_ACTIVE)
00143       return;
00144     this->status_ = EC_S_DESTROYING;
00145   }
00146   this->dispatching_->shutdown ();
00147   this->timeout_generator_->shutdown ();
00148   this->supplier_control_->shutdown ();
00149   this->consumer_control_->shutdown ();
00150 
00151   this->deactivate_supplier_admin ();
00152   this->deactivate_consumer_admin ();
00153 
00154   this->supplier_admin_->shutdown ();
00155 
00156   this->consumer_admin_->shutdown ();
00157 
00158   {
00159     // Wait until all the shutdown() operations return before marking
00160     // the EC as destroyed...
00161     ACE_GUARD (TAO_SYNCH_MUTEX, ace_mon, this->mutex_);
00162     ACE_ASSERT (this->status_ == EC_S_DESTROYING);
00163     this->status_ = EC_S_DESTROYED;
00164   }
00165 }

00063 {
00064   return this->supplier_admin_;
00065 }

00087 {
00088   return this->supplier_control_;
00089 }

00051 {
00052   return this->supplier_filter_builder_;
00053 }

00141 {
00142   return PortableServer::POA::_duplicate (this->supplier_poa_.in ());
00143 }

00183 {
00184   return this->supplier_reconnect_;
00185 }

00069 {
00070   return this->timeout_generator_;
00071 }


Public Member Functions
virtual	~TAO_EC_Event_Channel_Base (void)
	destructor
virtual void	activate (void)
virtual void	shutdown (void)
virtual void	for_each_consumer (TAO_ESF_Worker< TAO_EC_ProxyPushSupplier > *worker)
virtual void	for_each_supplier (TAO_ESF_Worker< TAO_EC_ProxyPushConsumer > *worker)
TAO_EC_Dispatching *	dispatching (void) const
	Access the dispatching module....
TAO_EC_Filter_Builder *	filter_builder (void) const
	Access the filter builder....
TAO_EC_Supplier_Filter_Builder *	supplier_filter_builder (void) const
	Access the filter builder....
TAO_EC_ConsumerAdmin *	consumer_admin (void) const
TAO_EC_SupplierAdmin *	supplier_admin (void) const
TAO_EC_Timeout_Generator *	timeout_generator (void) const
	Access the timer module...
TAO_EC_Scheduling_Strategy *	scheduling_strategy (void) const
	Access the scheduling strategy.
TAO_EC_ConsumerControl *	consumer_control (void) const
	Access the client control strategies.
TAO_EC_SupplierControl *	supplier_control (void) const
void	create_proxy (TAO_EC_ProxyPushSupplier *&)
	Create and destroy a ProxyPushSupplier.
void	destroy_proxy (TAO_EC_ProxyPushSupplier *)
void	create_proxy (TAO_EC_ProxyPushConsumer *&)
	Create and destroy a ProxyPushConsumer.
void	destroy_proxy (TAO_EC_ProxyPushConsumer *)
void	create_proxy_collection (TAO_EC_ProxyPushSupplier_Collection *&)
void	destroy_proxy_collection (TAO_EC_ProxyPushSupplier_Collection *)
void	create_proxy_collection (TAO_EC_ProxyPushConsumer_Collection *&)
void	destroy_proxy_collection (TAO_EC_ProxyPushConsumer_Collection *)
PortableServer::POA_ptr	supplier_poa (void)
	Access the supplier and consumer POAs from the factory.
PortableServer::POA_ptr	consumer_poa (void)
ACE_Lock *	create_consumer_lock (void)
void	destroy_consumer_lock (ACE_Lock *)
ACE_Lock *	create_supplier_lock (void)
void	destroy_supplier_lock (ACE_Lock *)
virtual void	connected (TAO_EC_ProxyPushConsumer *)
virtual void	reconnected (TAO_EC_ProxyPushConsumer *)
virtual void	disconnected (TAO_EC_ProxyPushConsumer *)
virtual void	connected (TAO_EC_ProxyPushSupplier *)
virtual void	reconnected (TAO_EC_ProxyPushSupplier *)
virtual void	disconnected (TAO_EC_ProxyPushSupplier *)
int	consumer_reconnect (void) const
	Can the consumers reconnect to the EC?
int	supplier_reconnect (void) const
	Can the suppliers reconnect to the EC?
int	disconnect_callbacks (void) const
CORBA::Object_ptr	scheduler (void)
	Obtain the scheduler, the user must release.
virtual RtecEventChannelAdmin::ConsumerAdmin_ptr	for_consumers (void)
virtual RtecEventChannelAdmin::SupplierAdmin_ptr	for_suppliers (void)
virtual void	destroy (void)
	Commit suicide.
virtual RtecEventChannelAdmin::Observer_Handle	append_observer (RtecEventChannelAdmin::Observer_ptr)
virtual void	remove_observer (RtecEventChannelAdmin::Observer_Handle)
int	destroyed (void)
	Return 1 if the event channel is already destroyed.
Protected Types
enum	{ EC_S_IDLE, EC_S_ACTIVATING, EC_S_ACTIVE, EC_S_DESTROYING, EC_S_DESTROYED }
	Flag to track the status of the event channel. More...
Protected Member Functions
	TAO_EC_Event_Channel_Base (const TAO_EC_Event_Channel_Attributes &attributes, TAO_EC_Factory *factory=0, int own_factory=0)
TAO_EC_Factory *	factory (void) const
void	factory (TAO_EC_Factory *factory, int own_factory=0)
void	create_strategies (void)

void	deactivate_supplier_admin (void)
void	deactivate_consumer_admin (void)
Protected Attributes
PortableServer::POA_var	supplier_poa_
PortableServer::POA_var	consumer_poa_
TAO_EC_Factory *	factory_
int	own_factory_
	Flag that indicates if we own the factory.
TAO_EC_Dispatching *	dispatching_
	The dispatching "module".
TAO_EC_Filter_Builder *	filter_builder_
	The filter builder.
TAO_EC_Supplier_Filter_Builder *	supplier_filter_builder_
	The filter builder for suppliers.
TAO_EC_ConsumerAdmin *	consumer_admin_
	The ConsumerAdmin implementation.
TAO_EC_SupplierAdmin *	supplier_admin_
	The SupplierAdmin implementation.
TAO_EC_Timeout_Generator *	timeout_generator_
	The timeout generator.
TAO_EC_ObserverStrategy *	observer_strategy_
	The observer strategy.
CORBA::Object_var	scheduler_
	The scheduler (may be nil).
TAO_EC_Scheduling_Strategy *	scheduling_strategy_
	The scheduling strategy.
int	consumer_reconnect_
	Consumer reconnection flags.
int	supplier_reconnect_
	Supplier reconnection flags.
int	disconnect_callbacks_
	If not zero we send callbacks when a proxy is disconnected.
TAO_EC_ConsumerControl *	consumer_control_
	Strategies to disconnect misbehaving or destroyed consumers.
TAO_EC_SupplierControl *	supplier_control_
	Strategies to disconnect misbehaving or destroyed suppliers.
TAO_SYNCH_MUTEX	mutex_
	Mutex to protect the internal state.
int	status_

TAO_EC_Event_Channel_Base Class Reference

Public Member Functions

Protected Types

Protected Member Functions

Protected Attributes

Detailed Description

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation