TAO_RTEvent: TAO_EC_Event_Channel

00359        {
00360     EC_S_IDLE
00361     , EC_S_ACTIVATING
00362     , EC_S_ACTIVE
00363     , EC_S_DESTROYING
00364     , EC_S_DESTROYED
00365   };

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 }

00313 {
00314   return this->observer_strategy_->append_observer (observer
00315                                                     ACE_ENV_ARG_PARAMETER);
00316 }

00251 {
00252   this->supplier_admin_->peer_connected (supplier ACE_ENV_ARG_PARAMETER);
00253   ACE_CHECK;
00254   this->consumer_admin_->connected (supplier ACE_ENV_ARG_PARAMETER);
00255   ACE_CHECK;
00256   this->observer_strategy_->connected (supplier ACE_ENV_ARG_PARAMETER);
00257   ACE_CHECK;
00258 }

00215 {
00216   this->consumer_admin_->peer_connected (consumer ACE_ENV_ARG_PARAMETER);
00217   ACE_CHECK;
00218   this->supplier_admin_->connected (consumer ACE_ENV_ARG_PARAMETER);
00219   ACE_CHECK;
00220   this->observer_strategy_->connected (consumer ACE_ENV_ARG_PARAMETER);
00221   ACE_CHECK;
00222 }

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 }

00193 {
00194   ACE_TRY_NEW_ENV
00195     {
00196       PortableServer::POA_var consumer_poa =
00197         this->consumer_admin_->_default_POA (ACE_ENV_SINGLE_ARG_PARAMETER);
00198       ACE_TRY_CHECK;
00199       PortableServer::ObjectId_var consumer_id =
00200         consumer_poa->servant_to_id (this->consumer_admin_ ACE_ENV_ARG_PARAMETER);
00201       ACE_TRY_CHECK;
00202       consumer_poa->deactivate_object (consumer_id.in () ACE_ENV_ARG_PARAMETER);
00203       ACE_TRY_CHECK;
00204     }
00205   ACE_CATCHANY
00206     {
00207             // The deactivation can throw...
00208     }
00209   ACE_ENDTRY;
00210 }

00171 {
00172   ACE_DECLARE_NEW_CORBA_ENV;
00173   ACE_TRY
00174     {
00175       PortableServer::POA_var supplier_poa =
00176         this->supplier_admin_->_default_POA (ACE_ENV_SINGLE_ARG_PARAMETER);
00177       ACE_TRY_CHECK;
00178       PortableServer::ObjectId_var supplier_id =
00179         supplier_poa->servant_to_id (this->supplier_admin_ ACE_ENV_ARG_PARAMETER);
00180       ACE_TRY_CHECK;
00181       supplier_poa->deactivate_object (supplier_id.in () ACE_ENV_ARG_PARAMETER);
00182       ACE_TRY_CHECK;
00183     }
00184   ACE_CATCHANY
00185     {
00186             // The deactivation can throw...
00187     }
00188   ACE_ENDTRY;
00189 }

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 }

00275 {
00276   this->supplier_admin_->peer_disconnected (supplier ACE_ENV_ARG_PARAMETER);
00277   ACE_CHECK;
00278   this->consumer_admin_->disconnected (supplier ACE_ENV_ARG_PARAMETER);
00279   ACE_CHECK;
00280   this->observer_strategy_->disconnected (supplier ACE_ENV_ARG_PARAMETER);
00281   ACE_CHECK;
00282 }

00239 {
00240   this->consumer_admin_->peer_disconnected (consumer ACE_ENV_ARG_PARAMETER);
00241   ACE_CHECK;
00242   this->supplier_admin_->disconnected (consumer ACE_ENV_ARG_PARAMETER);
00243   ACE_CHECK;
00244   this->observer_strategy_->disconnected (consumer ACE_ENV_ARG_PARAMETER);
00245   ACE_CHECK;
00246 }

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 }

00263 {
00264   this->supplier_admin_->peer_reconnected (supplier ACE_ENV_ARG_PARAMETER);
00265   ACE_CHECK;
00266   this->consumer_admin_->reconnected (supplier ACE_ENV_ARG_PARAMETER);
00267   ACE_CHECK;
00268   this->observer_strategy_->connected (supplier ACE_ENV_ARG_PARAMETER);
00269   ACE_CHECK;
00270 }

00227 {
00228   this->consumer_admin_->peer_reconnected (consumer ACE_ENV_ARG_PARAMETER);
00229   ACE_CHECK;
00230   this->supplier_admin_->reconnected (consumer ACE_ENV_ARG_PARAMETER);
00231   ACE_CHECK;
00232   this->observer_strategy_->connected (consumer ACE_ENV_ARG_PARAMETER);
00233   ACE_CHECK;
00234 }

00326 {
00327   this->observer_strategy_->remove_observer (handle
00328                                              ACE_ENV_ARG_PARAMETER);
00329 }

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

00075 {
00076   return this->scheduling_strategy_;
00077 }

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 (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)
virtual void	shutdown (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)
virtual void	for_each_consumer (TAO_ESF_Worker< TAO_EC_ProxyPushSupplier > *worker ACE_ENV_ARG_DECL) throw (CORBA::SystemException)
virtual void	for_each_supplier (TAO_ESF_Worker< TAO_EC_ProxyPushConsumer > *worker ACE_ENV_ARG_DECL) throw (CORBA::SystemException)
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 *ACE_ENV_ARG_DECL_NOT_USED)
virtual void	reconnected (TAO_EC_ProxyPushConsumer *ACE_ENV_ARG_DECL_NOT_USED)
virtual void	disconnected (TAO_EC_ProxyPushConsumer *ACE_ENV_ARG_DECL_NOT_USED)
virtual void	connected (TAO_EC_ProxyPushSupplier *ACE_ENV_ARG_DECL_NOT_USED)
virtual void	reconnected (TAO_EC_ProxyPushSupplier *ACE_ENV_ARG_DECL_NOT_USED)
virtual void	disconnected (TAO_EC_ProxyPushSupplier *ACE_ENV_ARG_DECL_NOT_USED)
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 (ACE_ENV_SINGLE_ARG_DECL) throw (CORBA::SystemException)
virtual RtecEventChannelAdmin::SupplierAdmin_ptr	for_suppliers (ACE_ENV_SINGLE_ARG_DECL) throw (CORBA::SystemException)
virtual void	destroy (ACE_ENV_SINGLE_ARG_DECL) throw (CORBA::SystemException)
	Commit suicide.
virtual RtecEventChannelAdmin::Observer_Handle	append_observer (RtecEventChannelAdmin::Observer_ptr ACE_ENV_ARG_DECL) throw ( CORBA::SystemException, RtecEventChannelAdmin::EventChannel::SYNCHRONIZATION_ERROR, RtecEventChannelAdmin::EventChannel::CANT_APPEND_OBSERVER)
virtual void	remove_observer (RtecEventChannelAdmin::Observer_Handle ACE_ENV_ARG_DECL) throw ( CORBA::SystemException, RtecEventChannelAdmin::EventChannel::SYNCHRONIZATION_ERROR, RtecEventChannelAdmin::EventChannel::CANT_REMOVE_OBSERVER)
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