1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
|
/* -*- C++ -*- */
// $Id$
//
// ============================================================================
//
// = LIBRARY
// ORBSVCS Real-time Event Channel
//
// = FILENAME
// EC_Event_Channel
//
// = AUTHOR
// Carlos O'Ryan (coryan@cs.wustl.edu)
//
// = DESCRIPTION
// A new implementation of the Real Time Event Services.
// Based on previous work by Tim Harrison (harrison@cs.wustl.edu)
// and other members of the DOC group.
// More details can be found in:
// http://www.cs.wustl.edu/~schmidt/oopsla.ps.gz
// http://www.cs.wustl.edu/~schmidt/JSAC-98.ps.gz
//
//
// ============================================================================
#ifndef TAO_EC_EVENT_CHANNEL_H
#define TAO_EC_EVENT_CHANNEL_H
#include "ace/OS.h"
#if !defined (ACE_LACKS_PRAGMA_ONCE)
# pragma once
#endif /* ACE_LACKS_PRAGMA_ONCE */
#include "orbsvcs/RtecEventChannelAdminS.h"
#include "EC_Factory.h"
class TAO_ORBSVCS_Export TAO_EC_Event_Channel : public POA_RtecEventChannelAdmin::EventChannel
{
// = TITLE
// The RtecEventChannelAdmin::EventChannel implementation.
//
// = DESCRIPTION
// 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.
//
public:
TAO_EC_Event_Channel (TAO_EC_Factory* factory);
// constructor
virtual ~TAO_EC_Event_Channel (void);
// destructor
virtual void activate (CORBA::Environment& env);
// Start the internal threads (if any), etc.
// After this call the EC can be used.
virtual void shutdown (CORBA::Environment &env);
// Shutdown any internal threads, cleanup all the internal
// structures, flush all the messages, etc.
TAO_EC_Dispatching* dispatching (void) const;
// Access the dispatching module....
TAO_EC_Filter_Builder* filter_builder (void) const;
// Access the filter builder....
TAO_EC_ConsumerAdmin* consumer_admin (void) const;
// Access the consumer admin implementation, useful for controlling
// the activation...
TAO_EC_SupplierAdmin* supplier_admin (void) const;
// Access the supplier admin implementation, useful for controlling
// the activation...
TAO_EC_Timeout_Generator* timeout_generator (void) const;
// Access the timer module...
// = The factory methods, they delegate on the EC_Factory.
TAO_EC_ProxyPushSupplier* create_proxy_push_supplier (void);
void destroy_proxy_push_supplier (TAO_EC_ProxyPushSupplier*);
// Create and destroy a ProxyPushSupplier
TAO_EC_ProxyPushConsumer* create_proxy_push_consumer (void);
void destroy_proxy_push_consumer (TAO_EC_ProxyPushConsumer*);
// Create and destroy a ProxyPushConsumer
TAO_EC_ProxyPushSupplier_Set* create_proxy_push_supplier_set (void);
void destroy_proxy_push_supplier_set (TAO_EC_ProxyPushSupplier_Set*);
// Create and destroy a ProxyPushSupplier_Set
PortableServer::POA_ptr supplier_poa (CORBA::Environment&);
PortableServer::POA_ptr consumer_poa (CORBA::Environment&);
// Access the supplier and consumer POAs from the factory.
ACE_Lock* create_consumer_lock (void);
void destroy_consumer_lock (ACE_Lock*);
ACE_Lock* create_supplier_lock (void);
void destroy_supplier_lock (ACE_Lock*);
// Locking strategies for the ProxyPushConsumer and
// ProxyPushSupplier objects
virtual void connected (TAO_EC_ProxyPushConsumer*,
CORBA::Environment&);
virtual void disconnected (TAO_EC_ProxyPushConsumer*,
CORBA::Environment&);
// Used to inform the EC that a Consumer has connected or
// disconnected from it.
virtual void connected (TAO_EC_ProxyPushSupplier*,
CORBA::Environment&);
virtual void disconnected (TAO_EC_ProxyPushSupplier*,
CORBA::Environment&);
// Used to inform the EC that a Supplier has connected or
// disconnected from it.
// = The RtecEventChannelAdmin::EventChannel methods...
virtual RtecEventChannelAdmin::ConsumerAdmin_ptr
for_consumers (CORBA::Environment& env);
// The default implementation is:
// this->consumer_admin ()->_this (env);
virtual RtecEventChannelAdmin::SupplierAdmin_ptr
for_suppliers (CORBA::Environment& env);
// The default implementation is:
// this->supplier_admin ()->_this (env);
virtual void destroy (CORBA::Environment &env);
// Commit suicide.
virtual RtecEventChannelAdmin::Observer_Handle
append_observer (RtecEventChannelAdmin::Observer_ptr,
CORBA::Environment &env)
TAO_THROW_SPEC ((CORBA::SystemException,
RtecEventChannel::EventChannel::SYNCHRONIZATION_ERROR,
RtecEventChannel::EventChannel::CANT_APPEND_OBSERVER));
virtual void
remove_observer (RtecEventChannelAdmin::Observer_Handle,
CORBA::Environment &env)
TAO_THROW_SPEC ((CORBA::SystemException,
RtecEventChannel::EventChannel::SYNCHRONIZATION_ERROR,
RtecEventChannel::EventChannel::CANT_REMOVE_OBSERVER));
private:
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.
TAO_EC_Dispatching *dispatching_;
// The dispatching "module"
TAO_EC_Filter_Builder *filter_builder_;
// The filter builder
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
};
#if defined (__ACE_INLINE__)
#include "EC_Event_Channel.i"
#endif /* __ACE_INLINE__ */
#endif /* TAO_EC_EVENT_CHANNEL_H */
|
