Main Page Namespace List Class Hierarchy Alphabetical List Compound List File List Namespace Members Compound Members File Members Related Pages

# TAO_EC_Event_Channel Class Reference

The RtecEventChannelAdmin::EventChannel implementation. More...

`#include <EC_Event_Channel.h>`

Collaboration diagram for TAO_EC_Event_Channel:

[legend]
List of all members.

## Public Methods
| TAO_EC_Event_Channel (const TAO_EC_Event_Channel_Attributes &attributes, TAO_EC_Factory *factory=0, int own_factory=0)
| constructor If <own_factory> is not 0 it assumes ownership of the factory. More...
virtual | ~TAO_EC_Event_Channel (void)
| destructor. More...
virtual void | activate (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)
| Start the internal threads (if any), etc. After this call the EC can be used. More...
virtual void | shutdown (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)
| Shutdown any internal threads, cleanup all the internal structures, flush all the messages, etc. More...
TAO_EC_Dispatching * | dispatching (void) const
| Access the dispatching module.... More...
TAO_EC_Filter_Builder * | filter_builder (void) const
| Access the filter builder.... More...
TAO_EC_Supplier_Filter_Builder * | supplier_filter_builder (void) const
| Access the filter builder.... More...
TAO_EC_ConsumerAdmin * | consumer_admin (void) const
| Access the consumer admin implementation, useful for controlling the activation... More...
TAO_EC_SupplierAdmin * | supplier_admin (void) const
| Access the supplier admin implementation, useful for controlling the activation... More...
TAO_EC_Timeout_Generator * | timeout_generator (void) const
| Access the timer module... More...
TAO_EC_Scheduling_Strategy * | scheduling_strategy (void) const
| Access the scheduling strategy. More...
TAO_EC_ConsumerControl * | consumer_control (void) const
| Access the client control strategies. More...
TAO_EC_SupplierControl * | supplier_control (void) const
void | create_proxy (TAO_EC_ProxyPushSupplier *&)
| Create and destroy a ProxyPushSupplier. More...
void | destroy_proxy (TAO_EC_ProxyPushSupplier *)
void | create_proxy (TAO_EC_ProxyPushConsumer *&)
| Create and destroy a ProxyPushConsumer. More...
void | destroy_proxy (TAO_EC_ProxyPushConsumer *)
void | create_proxy_collection (TAO_EC_ProxyPushSupplier_Collection *&)
| Create and destroy a the collections used to store ProxyPushSuppliers. More...
void | destroy_proxy_collection (TAO_EC_ProxyPushSupplier_Collection *)
void | create_proxy_collection (TAO_EC_ProxyPushConsumer_Collection *&)
| Create and destroy a the collections used to store ProxyPushConsumers. More...
void | destroy_proxy_collection (TAO_EC_ProxyPushConsumer_Collection *)
PortableServer::POA_ptr | supplier_poa (void)
| Access the supplier and consumer POAs from the factory. More...
PortableServer::POA_ptr | consumer_poa (void)
ACE_Lock * | create_consumer_lock (void)
| Locking strategies for the ProxyPushConsumer and ProxyPushSupplier objects. More...
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)
| Used to inform the EC that a Consumer has connected or disconnected from it. More...
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)
| Used to inform the EC that a Supplier has connected or disconnected from it. More...
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? More...
int | supplier_reconnect (void) const
| Can the suppliers reconnect to the EC? More...
int | disconnect_callbacks (void) const
| Should we send callback disconnect messages when a proxy is disconnected by the client. More...
CORBA::Object_ptr | scheduler (void)
| Obtain the scheduler, the user must release. More...
int | busy_hwm (void) const
| Control the concurrency of the delayed connect/disconnect operations. More...
int | max_write_delay (void) const
virtual RtecEventChannelAdmin::ConsumerAdmin_ptr | for_consumers (ACE_ENV_SINGLE_ARG_DECL) throw (CORBA::SystemException)
| The default implementation is: this->consumer_admin ()->_this (ACE_ENV_SINGLE_ARG_PARAMETER);. More...
virtual RtecEventChannelAdmin::SupplierAdmin_ptr | for_suppliers (ACE_ENV_SINGLE_ARG_DECL) throw (CORBA::SystemException)
| The default implementation is: this->supplier_admin ()->_this (ACE_ENV_SINGLE_ARG_PARAMETER);. More...
virtual void | destroy (ACE_ENV_SINGLE_ARG_DECL) throw (CORBA::SystemException)
| Commit suicide. More...
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. More...
## Private 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...
## Private Attributes
PortableServer::POA_var | supplier_poa_
| The POAs used to activate "supplier-side" and "consumer-side" objects. More...
PortableServer::POA_var | consumer_poa_
TAO_EC_Factory * | factory_
| This is the abstract factory that creates all the objects that compose an event channel, the event channel simply acts as a Mediator among them. More...
int | own_factory_
| Flag that indicates if we own the factory. More...
TAO_EC_Dispatching * | dispatching_
| The dispatching "module". More...
TAO_EC_Filter_Builder * | filter_builder_
| The filter builder. More...
TAO_EC_Supplier_Filter_Builder * | supplier_filter_builder_
| The filter builder for suppliers. More...
TAO_EC_ConsumerAdmin * | consumer_admin_
| The ConsumerAdmin implementation. More...
TAO_EC_SupplierAdmin * | supplier_admin_
| The SupplierAdmin implementation. More...
TAO_EC_Timeout_Generator * | timeout_generator_
| The timeout generator. More...
TAO_EC_ObserverStrategy * | observer_strategy_
| The observer strategy. More...
CORBA::Object_var | scheduler_
| The scheduler (may be nil). More...
TAO_EC_Scheduling_Strategy * | scheduling_strategy_
| The scheduling strategy. More...
int | consumer_reconnect_
| Consumer/Supplier reconnection flags. More...
int | supplier_reconnect_
int | disconnect_callbacks_
| If not zero we send callbacks when a proxy is disconnected. More...
int | busy_hwm_
| Control the level of concurrency in the supplier sets with delayed operations. More...
int | max_write_delay_
TAO_EC_ConsumerControl * | consumer_control_
| Strategies to disconnect misbehaving or destroyed consumers and suppliers. More...
TAO_EC_SupplierControl * | supplier_control_
TAO_SYNCH_MUTEX | mutex_
| Mutex to protect the internal state. More...
int | status_

## Detailed Description

The RtecEventChannelAdmin::EventChannel implementation.

This class is the Mediator between all the classes in the EC implementation, its main task is to redirect the messages to the right components, to hold and manage the lifetime of the long lived objects (Timer_Module, SupplierAdmin, ConsumerAdmin and Dispatching) and to provide a simpler interface to the EC_Factory.

## Member Enumeration Documentation

anonymous enum`[private]`

  | Flag to track the status of the event channel. Enumeration values:
  EC_S_IDLE |
  EC_S_ACTIVATING |
  EC_S_ACTIVE |
  EC_S_DESTROYING |
  EC_S_DESTROYED |

## Constructor & Destructor Documentation

TAO_EC_Event_Channel::TAO_EC_Event_Channel | ( | const TAO_EC_Event_Channel_Attributes & | attr,
|  | TAO_EC_Factory * | factory = 0,
|  | int | own_factory = 0
| ) |

| constructor If <own_factory> is not 0 it assumes ownership of the factory. If the factory is <nil> it uses the Service_Configurator to load the Factory, if not found it uses TAO_EC_Default_Resource_Factory

TAO_EC_Event_Channel::~TAO_EC_Event_Channel | ( | void |  | ) | `[virtual]`

| destructor.

## Member Function Documentation

void TAO_EC_Event_Channel::activate | ( | ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS |  | ) | `[virtual]`

| Start the internal threads (if any), etc. After this call the EC can be used.

RtecEventChannelAdmin::Observer_Handle TAO_EC_Event_Channel::append_observer | ( | RtecEventChannelAdmin::Observer_ptr | observer | ) | throw ( CORBA::SystemException, RtecEventChannelAdmin::EventChannel::SYNCHRONIZATION_ERROR, RtecEventChannelAdmin::EventChannel::CANT_APPEND_OBSERVER)`[virtual]`

ACE_INLINE int TAO_EC_Event_Channel::busy_hwm | ( | void |  | ) | const

| Control the concurrency of the delayed connect/disconnect operations.

virtual void TAO_EC_Event_Channel::connected | ( | TAO_EC_ProxyPushSupplier * | ACE_ENV_ARG_DECL_NOT_USED | ) | `[virtual]`

| Used to inform the EC that a Supplier has connected or disconnected from it.

virtual void TAO_EC_Event_Channel::connected | ( | TAO_EC_ProxyPushConsumer * | ACE_ENV_ARG_DECL_NOT_USED | ) | `[virtual]`

| Used to inform the EC that a Consumer has connected or disconnected from it.

ACE_INLINE TAO_EC_ConsumerAdmin * TAO_EC_Event_Channel::consumer_admin | ( | void |  | ) | const

| Access the consumer admin implementation, useful for controlling the activation...

ACE_INLINE TAO_EC_ConsumerControl * TAO_EC_Event_Channel::consumer_control | ( | void |  | ) | const

| Access the client control strategies.

ACE_INLINE PortableServer::POA_ptr TAO_EC_Event_Channel::consumer_poa | ( | void |  | ) |

ACE_INLINE int TAO_EC_Event_Channel::consumer_reconnect | ( | void |  | ) | const

| Can the consumers reconnect to the EC?

ACE_INLINE ACE_Lock * TAO_EC_Event_Channel::create_consumer_lock | ( | void |  | ) |

| Locking strategies for the ProxyPushConsumer and ProxyPushSupplier objects.

ACE_INLINE void TAO_EC_Event_Channel::create_proxy | ( | TAO_EC_ProxyPushConsumer *& | x | ) |

| Create and destroy a ProxyPushConsumer.

ACE_INLINE void TAO_EC_Event_Channel::create_proxy | ( | TAO_EC_ProxyPushSupplier *& | x | ) |

| Create and destroy a ProxyPushSupplier.

ACE_INLINE void TAO_EC_Event_Channel::create_proxy_collection | ( | TAO_EC_ProxyPushConsumer_Collection *& | x | ) |

| Create and destroy a the collections used to store ProxyPushConsumers.

ACE_INLINE void TAO_EC_Event_Channel::create_proxy_collection | ( | TAO_EC_ProxyPushSupplier_Collection *& | x | ) |

| Create and destroy a the collections used to store ProxyPushSuppliers.

ACE_INLINE ACE_Lock * TAO_EC_Event_Channel::create_supplier_lock | ( | void |  | ) |

void TAO_EC_Event_Channel::destroy | ( | ACE_ENV_SINGLE_ARG_DECL |  | ) | throw (CORBA::SystemException)`[virtual]`

| Commit suicide.

ACE_INLINE void TAO_EC_Event_Channel::destroy_consumer_lock | ( | ACE_Lock * | x | ) |

ACE_INLINE void TAO_EC_Event_Channel::destroy_proxy | ( | TAO_EC_ProxyPushConsumer * | consumer | ) |

ACE_INLINE void TAO_EC_Event_Channel::destroy_proxy | ( | TAO_EC_ProxyPushSupplier * | supplier | ) |

ACE_INLINE void TAO_EC_Event_Channel::destroy_proxy_collection | ( | TAO_EC_ProxyPushConsumer_Collection * | x | ) |

ACE_INLINE void TAO_EC_Event_Channel::destroy_proxy_collection | ( | TAO_EC_ProxyPushSupplier_Collection * | x | ) |

ACE_INLINE void TAO_EC_Event_Channel::destroy_supplier_lock | ( | ACE_Lock * | x | ) |

ACE_INLINE int TAO_EC_Event_Channel::destroyed | ( | void |  | ) |

| Return 1 if the event channel is already destroyed.

ACE_INLINE int TAO_EC_Event_Channel::disconnect_callbacks | ( | void |  | ) | const

| Should we send callback disconnect messages when a proxy is disconnected by the client.

virtual void TAO_EC_Event_Channel::disconnected | ( | TAO_EC_ProxyPushSupplier * | ACE_ENV_ARG_DECL_NOT_USED | ) | `[virtual]`

virtual void TAO_EC_Event_Channel::disconnected | ( | TAO_EC_ProxyPushConsumer * | ACE_ENV_ARG_DECL_NOT_USED | ) | `[virtual]`

ACE_INLINE TAO_EC_Dispatching * TAO_EC_Event_Channel::dispatching | ( | void |  | ) | const

| Access the dispatching module....

ACE_INLINE TAO_EC_Filter_Builder * TAO_EC_Event_Channel::filter_builder | ( | void |  | ) | const

| Access the filter builder....

RtecEventChannelAdmin::ConsumerAdmin_ptr TAO_EC_Event_Channel::for_consumers | ( | ACE_ENV_SINGLE_ARG_DECL |  | ) | throw (CORBA::SystemException)`[virtual]`

| The default implementation is: this->consumer_admin ()->_this (ACE_ENV_SINGLE_ARG_PARAMETER);.

RtecEventChannelAdmin::SupplierAdmin_ptr TAO_EC_Event_Channel::for_suppliers | ( | ACE_ENV_SINGLE_ARG_DECL |  | ) | throw (CORBA::SystemException)`[virtual]`

| The default implementation is: this->supplier_admin ()->_this (ACE_ENV_SINGLE_ARG_PARAMETER);.

ACE_INLINE int TAO_EC_Event_Channel::max_write_delay | ( | void |  | ) | const

virtual void TAO_EC_Event_Channel::reconnected | ( | TAO_EC_ProxyPushSupplier * | ACE_ENV_ARG_DECL_NOT_USED | ) | `[virtual]`

virtual void TAO_EC_Event_Channel::reconnected | ( | TAO_EC_ProxyPushConsumer * | ACE_ENV_ARG_DECL_NOT_USED | ) | `[virtual]`

void TAO_EC_Event_Channel::remove_observer | ( | RtecEventChannelAdmin::Observer_Handle | handle | ) | throw ( CORBA::SystemException, RtecEventChannelAdmin::EventChannel::SYNCHRONIZATION_ERROR, RtecEventChannelAdmin::EventChannel::CANT_REMOVE_OBSERVER)`[virtual]`

ACE_INLINE CORBA::Object_ptr TAO_EC_Event_Channel::scheduler | ( | void |  | ) |

| Obtain the scheduler, the user must release.

ACE_INLINE TAO_EC_Scheduling_Strategy * TAO_EC_Event_Channel::scheduling_strategy | ( | void |  | ) | const

| Access the scheduling strategy.

void TAO_EC_Event_Channel::shutdown | ( | ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS |  | ) | `[virtual]`

| Shutdown any internal threads, cleanup all the internal structures, flush all the messages, etc.

ACE_INLINE TAO_EC_SupplierAdmin * TAO_EC_Event_Channel::supplier_admin | ( | void |  | ) | const

| Access the supplier admin implementation, useful for controlling the activation...

ACE_INLINE TAO_EC_SupplierControl * TAO_EC_Event_Channel::supplier_control | ( | void |  | ) | const

ACE_INLINE TAO_EC_Supplier_Filter_Builder * TAO_EC_Event_Channel::supplier_filter_builder | ( | void |  | ) | const

| Access the filter builder....

ACE_INLINE PortableServer::POA_ptr TAO_EC_Event_Channel::supplier_poa | ( | void |  | ) |

| Access the supplier and consumer POAs from the factory.

ACE_INLINE int TAO_EC_Event_Channel::supplier_reconnect | ( | void |  | ) | const

| Can the suppliers reconnect to the EC?

ACE_INLINE TAO_EC_Timeout_Generator * TAO_EC_Event_Channel::timeout_generator | ( | void |  | ) | const

| Access the timer module...

## Member Data Documentation

int TAO_EC_Event_Channel::busy_hwm_`[private]`

| Control the level of concurrency in the supplier sets with delayed operations.

TAO_EC_ConsumerAdmin* TAO_EC_Event_Channel::consumer_admin_`[private]`

| The ConsumerAdmin implementation.

TAO_EC_ConsumerControl* TAO_EC_Event_Channel::consumer_control_`[private]`

| Strategies to disconnect misbehaving or destroyed consumers and suppliers.

PortableServer::POA_var TAO_EC_Event_Channel::consumer_poa_`[private]`

int TAO_EC_Event_Channel::consumer_reconnect_`[private]`

| Consumer/Supplier reconnection flags.

int TAO_EC_Event_Channel::disconnect_callbacks_`[private]`

| If not zero we send callbacks when a proxy is disconnected.

TAO_EC_Dispatching* TAO_EC_Event_Channel::dispatching_`[private]`

| The dispatching "module".

TAO_EC_Factory* TAO_EC_Event_Channel::factory_`[private]`

| This is the abstract factory that creates all the objects that compose an event channel, the event channel simply acts as a Mediator among them.

TAO_EC_Filter_Builder* TAO_EC_Event_Channel::filter_builder_`[private]`

| The filter builder.

int TAO_EC_Event_Channel::max_write_delay_`[private]`

TAO_SYNCH_MUTEX TAO_EC_Event_Channel::mutex_`[private]`

| Mutex to protect the internal state.

TAO_EC_ObserverStrategy* TAO_EC_Event_Channel::observer_strategy_`[private]`

| The observer strategy.

int TAO_EC_Event_Channel::own_factory_`[private]`

| Flag that indicates if we own the factory.

CORBA::Object_var TAO_EC_Event_Channel::scheduler_`[private]`

| The scheduler (may be nil).

TAO_EC_Scheduling_Strategy* TAO_EC_Event_Channel::scheduling_strategy_`[private]`

| The scheduling strategy.

int TAO_EC_Event_Channel::status_`[private]`

TAO_EC_SupplierAdmin* TAO_EC_Event_Channel::supplier_admin_`[private]`

| The SupplierAdmin implementation.

TAO_EC_SupplierControl* TAO_EC_Event_Channel::supplier_control_`[private]`

TAO_EC_Supplier_Filter_Builder* TAO_EC_Event_Channel::supplier_filter_builder_`[private]`

| The filter builder for suppliers.

PortableServer::POA_var TAO_EC_Event_Channel::supplier_poa_`[private]`

| The POAs used to activate "supplier-side" and "consumer-side" objects.

int TAO_EC_Event_Channel::supplier_reconnect_`[private]`

TAO_EC_Timeout_Generator* TAO_EC_Event_Channel::timeout_generator_`[private]`

| The timeout generator.

The documentation for this class was generated from the following files:

- EC_Event_Channel.h
- EC_Event_Channel.cpp
- EC_Event_Channel.i