diff options
Diffstat (limited to 'trunk/TAO/orbsvcs/orbsvcs/Notify/EventTypeSeq.cpp')
| -rw-r--r-- | trunk/TAO/orbsvcs/orbsvcs/Notify/EventTypeSeq.cpp | 317 |
1 files changed, 317 insertions, 0 deletions
diff --git a/trunk/TAO/orbsvcs/orbsvcs/Notify/EventTypeSeq.cpp b/trunk/TAO/orbsvcs/orbsvcs/Notify/EventTypeSeq.cpp new file mode 100644 index 00000000000..bd9d489dd63 --- /dev/null +++ b/trunk/TAO/orbsvcs/orbsvcs/Notify/EventTypeSeq.cpp @@ -0,0 +1,317 @@ +// $Id$ + +#include "orbsvcs/Notify/EventTypeSeq.h" +#include "orbsvcs/Notify/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_BEGIN_VERSIONED_NAMESPACE_DECL + +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) + : TAO_Notify_Object () + , TAO_Notify::Topology_Savable () + , 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 (static_cast<CORBA::ULong> (this->size ())); + + inherited::CONST_ITERATOR iter (*this); + + TAO_Notify_EventType* event_type = 0; + + 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 (static_cast<CORBA::ULong> (this->size () - 1)); + } + else + event_type_seq.length (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::add_and_remove (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_NOT_USED) +{ + 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; +} + +TAO_END_VERSIONED_NAMESPACE_DECL |