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
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
|
// $Id$
#include "EventTypeSeq.h"
#if ! defined (__ACE_INLINE__)
#include "EventTypeSeq.inl"
#endif /* __ACE_INLINE__ */
#include "Topology_Saver.h"
#include "tao/debug.h"
//#define DEBUG_LEVEL 9
#ifndef DEBUG_LEVEL
# define DEBUG_LEVEL TAO_debug_level
#endif //DEBUG_LEVEL
ACE_RCSID(Notify, TAO_Notify_EventTypeSeq, "$Id$")
TAO_Notify_EventTypeSeq::TAO_Notify_EventTypeSeq (void)
{
}
TAO_Notify_EventTypeSeq::TAO_Notify_EventTypeSeq (const CosNotification::EventTypeSeq& event_type_seq)
{
this->insert_seq (event_type_seq);
}
TAO_Notify_EventTypeSeq &
TAO_Notify_EventTypeSeq::operator = (const TAO_Notify_EventTypeSeq & rhs)
{
ACE_Unbounded_Set <TAO_Notify_EventType>::operator = (rhs);
return *this;
}
TAO_Notify_EventTypeSeq::TAO_Notify_EventTypeSeq (const TAO_Notify_EventTypeSeq & rhs)
: ACE_Unbounded_Set <TAO_Notify_EventType> (rhs)
, TAO_Notify::Topology_Object ()
{
}
void
TAO_Notify_EventTypeSeq::populate (CosNotification::EventTypeSeq& event_type_seq) const
{
event_type_seq.length (ACE_static_cast (CORBA::ULong, this->size ()));
inherited::CONST_ITERATOR iter (*this);
TAO_Notify_EventType* event_type;
CORBA::ULong i = 0;
for (iter.first (); iter.next (event_type); iter.advance (), ++i)
event_type_seq[i] = event_type->native ();
}
void
TAO_Notify_EventTypeSeq::populate_no_special (CosNotification::EventTypeSeq& event_type_seq) const
{
// If the special exists in us, don't include it.
const TAO_Notify_EventType& special = TAO_Notify_EventType::special ();
if (this->find (special) == 0)
{
event_type_seq.length (ACE_static_cast (CORBA::ULong, this->size () - 1));
}
else
event_type_seq.length (ACE_static_cast (CORBA::ULong, this->size ()));
inherited::CONST_ITERATOR iter (*this);
TAO_Notify_EventType* event_type;
CORBA::ULong i = 0;
for (iter.first (); iter.next (event_type); iter.advance (), ++i)
{
if (event_type->is_special () == 0) // if its not the special event type.
event_type_seq[i] = event_type->native ();
}
}
void
TAO_Notify_EventTypeSeq::insert_seq (const CosNotification::EventTypeSeq& event_type_seq)
{
TAO_Notify_EventType event_type;
for (CORBA::ULong i = 0; i < event_type_seq.length (); ++i)
{
event_type = event_type_seq[i];
inherited::insert (event_type);
}
}
void
TAO_Notify_EventTypeSeq::remove_seq (const CosNotification::EventTypeSeq& event_type_seq)
{
TAO_Notify_EventType event_type;
for (CORBA::ULong i = 0; i < event_type_seq.length (); ++i)
{
event_type = event_type_seq[i];
inherited::remove (event_type);
}
}
void
TAO_Notify_EventTypeSeq::insert_seq (const TAO_Notify_EventTypeSeq& event_type_seq)
{
TAO_Notify_EventTypeSeq::CONST_ITERATOR iter (event_type_seq);
TAO_Notify_EventType* event_type;
for (iter.first (); iter.next (event_type); iter.advance ())
inherited::insert (*event_type);
}
void
TAO_Notify_EventTypeSeq::remove_seq (const TAO_Notify_EventTypeSeq& event_type_seq)
{
TAO_Notify_EventTypeSeq::CONST_ITERATOR iter (event_type_seq);
TAO_Notify_EventType* event_type;
for (iter.first (); iter.next (event_type); iter.advance ())
inherited::remove (*event_type);
}
void
TAO_Notify_EventTypeSeq::init (TAO_Notify_EventTypeSeq& seq_added, TAO_Notify_EventTypeSeq& seq_remove)
{
const TAO_Notify_EventType& special = TAO_Notify_EventType::special ();
if (this->find (special) == 0) // If this object has the special type.
{
if (seq_added.find (special) == 0) // if the seq. being added has the special type, you cannot be adding or removing anythings. * overrides.
{
seq_added.reset (); // remove everything from the sequence bening added.
seq_remove.reset (); // remove everything form whats being removed.
}
else // sequence being added does not have *
{
if (!seq_added.is_empty ()) // if sequence being added is non empty
{
this->reset (); // take away the * from this object.
this->insert_seq (seq_added); // insert the sequence being added as the new list of types.
seq_remove.reset (); // reset all that is being removed.
seq_remove.insert (special); // remove *
}
else // nothing is being added
{
if (seq_remove.find (special) == 0) // we're removing everything
{
this->reset ();
seq_remove.reset (); // reset all that is being removed.
seq_remove.insert (special); // remove *
}
else if (!seq_remove.is_empty ())
{
// if we're currently subscribed for everything and did not added anything, we can't remove something.
seq_remove.reset ();
}
}
}
}
else // if this object does not have the special type.
{
if (seq_added.find (special) == 0) // but the seq. being added has the special type,
{
if (seq_remove.find (special) == 0) // and you're removing * as well
{
seq_added.reset (); // ignore the request
seq_remove.reset (); // ignore the request
}
else // seq being removed does not have the special type
{
seq_remove.reset (); // everything that we're subscribed for is being removed.
seq_remove.insert_seq (*this);
this->reset (); // insert the special in this object.
this->insert (special);
seq_added.reset (); // also clear our set and add only *
seq_added.insert (special);
}
}
else // seq being added does not have special.
{
if (seq_remove.find (special) == 0) // but we're removing everything.
{
seq_remove.reset (); // move all that we have currently to removed.
seq_remove.insert_seq (*this);
}
// so now there are no specials anywhere..
{
//= First remove the duplicates in the added and removes lists.
// compute the intersection.
TAO_Notify_EventTypeSeq common;
common.intersection (seq_added, seq_remove);
// remove the common elements from both the lists so Added {BCDK} and Removed {CDEA} will yield Added {BK} and Removed {EA}
seq_added.remove_seq (common);
seq_remove.remove_seq (common);
// If we're already subscribed for an element we should not subscribe again (duplicate events).
// so if we currently subscribe for ABC and we Added {BK} we should now get ABCK as current subscription and Added {K}
common.reset ();
common.intersection (*this, seq_added);
// remove the common elements from the added list. i,e. doent ask to add what we're already added for.
seq_added.remove_seq (common);
// update the current subscription.
this->insert_seq (seq_added);
// Similarly for removed.. if we're removing EA and now our current list looks like ABC we should emd up with
// current subscription BC and Removed {A}
common.reset ();
common.intersection (*this, seq_remove);
seq_remove.reset ();
seq_remove.insert_seq (common); // only remove what we currently have.
this->remove_seq (seq_remove);
}
}
}
}
void
TAO_Notify_EventTypeSeq::intersection (const TAO_Notify_EventTypeSeq& rhs, const TAO_Notify_EventTypeSeq& lhs)
{
// linear search.
TAO_Notify_EventTypeSeq::CONST_ITERATOR rhs_iter (rhs);
TAO_Notify_EventType* rhs_event_type;
TAO_Notify_EventTypeSeq::CONST_ITERATOR lhs_iter (lhs);
TAO_Notify_EventType* lhs_event_type;
for (rhs_iter.first (); rhs_iter.next (rhs_event_type); rhs_iter.advance ())
{
for (lhs_iter.first (); lhs_iter.next (lhs_event_type); lhs_iter.advance ())
{
if (*rhs_event_type == *lhs_event_type) // if both are same add to this object.
this->insert (*rhs_event_type);
}
}
}
void
TAO_Notify_EventTypeSeq::dump (void) const
{
TAO_Notify_EventTypeSeq::CONST_ITERATOR iter (*this);
TAO_Notify_EventType* event_type;
for (iter.first (); iter.next (event_type); iter.advance ())
{
event_type->dump ();
ACE_DEBUG ((LM_DEBUG, ", "));
}
}
// TAO_Notify::Topology_Object
void
TAO_Notify_EventTypeSeq::save_persistent (TAO_Notify::Topology_Saver& saver ACE_ENV_ARG_DECL)
{
bool changed = this->self_changed_;
this->self_changed_ = false;
this->children_changed_ = false;
TAO_Notify::NVPList attrs;
TAO_Notify_EventTypeSeq::ITERATOR iter (*this);
TAO_Notify_EventType* event_type;
if (this->size() != 0)
{
saver.begin_object(0, "subscriptions", attrs, changed ACE_ENV_ARG_PARAMETER);
ACE_CHECK;
for (iter.first (); iter.next (event_type) != 0; iter.advance ())
{
event_type->save_persistent(saver ACE_ENV_ARG_PARAMETER);
ACE_CHECK;
}
// todo:
// for all deleted children
// {
// saver.delete_child(child_type, child_id);
// }
saver.end_object(0, "subscriptions" ACE_ENV_ARG_PARAMETER);
ACE_CHECK;
}
}
TAO_Notify::Topology_Object*
TAO_Notify_EventTypeSeq::load_child (const ACE_CString &type, CORBA::Long id,
const TAO_Notify::NVPList& attrs ACE_ENV_ARG_DECL)
{
ACE_UNUSED_ARG (id);
TAO_Notify::Topology_Object *result = this;
TAO_Notify_EventType et;
if ((type == "subscription") && et.init(attrs))
{
if (DEBUG_LEVEL) ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%P|%t) Event_Type reload subscription\n")
));
inherited::insert(et);
}
return result;
}
void
TAO_Notify_EventTypeSeq::release (void)
{
delete this;
}
|