TAO_Notify_EventTypeSeq Class Reference

Allows operations using the CosNotification::EventTypeSeq type. More...

#include <EventTypeSeq.h>

Inheritance diagram for TAO_Notify_EventTypeSeq:

[legend]Collaboration diagram for TAO_Notify_EventTypeSeq:

[legend]List of all members.

Public Member Functions
	TAO_Notify_EventTypeSeq (void)
	Constructor.
	TAO_Notify_EventTypeSeq (const CosNotification::EventTypeSeq &event_type_seq)
	TAO_Notify_EventTypeSeq (const TAO_Notify_EventTypeSeq &rhs)
TAO_Notify_EventTypeSeq &	operator= (const TAO_Notify_EventTypeSeq &rhs)
void	add_and_remove (TAO_Notify_EventTypeSeq &added, TAO_Notify_EventTypeSeq &removed)
	Preprocess the types added and removed.
void	intersection (const TAO_Notify_EventTypeSeq &rhs, const TAO_Notify_EventTypeSeq &lhs)
	Populate this sequence with the intersection of rhs and lhs.
void	insert_seq (const CosNotification::EventTypeSeq &event_type_seq)
	insert_seq the contents of <event_type_seq> into this object.
void	remove_seq (const CosNotification::EventTypeSeq &event_type_seq)
	remove_seq the contents of <event_type_seq> from this object.
void	insert_seq (const TAO_Notify_EventTypeSeq &event_type_seq)
	insert_seq the contents of <event_type_seq> into this object.
void	remove_seq (const TAO_Notify_EventTypeSeq &event_type_seq)
	remove_seq the contents of <event_type_seq> from this object.
void	populate (CosNotification::EventTypeSeq &event_type) const
	Populate <event_type_seq> with the contents of this object.
void	populate_no_special (CosNotification::EventTypeSeq &event_type) const
void	dump (void) const
	Print the contents.
virtual void	save_persistent (TAO_Notify::Topology_Saver &saver)
virtual TAO_Notify::Topology_Object *	load_child (const ACE_CString &type, CORBA::Long id, const TAO_Notify::NVPList &attrs)
	Create a child of the appropriate type and return it.
Private Types
typedef ACE_Unbounded_Set< TAO_Notify_EventType >	inherited
Private Member Functions
virtual void	release (void)
	The release method is called when the refcount reaches 0.

---

Detailed Description

Allows operations using the CosNotification::EventTypeSeq type.

Definition at line 33 of file EventTypeSeq.h.

---

Member Typedef Documentation

typedef ACE_Unbounded_Set<TAO_Notify_EventType> TAO_Notify_EventTypeSeq::inherited [private]

Definition at line 37 of file EventTypeSeq.h.

---

Constructor & Destructor Documentation

TAO_BEGIN_VERSIONED_NAMESPACE_DECL TAO_Notify_EventTypeSeq::TAO_Notify_EventTypeSeq

(

void

)

Constructor.

Definition at line 16 of file EventTypeSeq.cpp.

{
}

TAO_Notify_EventTypeSeq::TAO_Notify_EventTypeSeq

(

const CosNotification::EventTypeSeq &

event_type_seq

)

Definition at line 20 of file EventTypeSeq.cpp.

References insert_seq().

{
  this->insert_seq (event_type_seq);
}

TAO_Notify_EventTypeSeq::TAO_Notify_EventTypeSeq

(

const TAO_Notify_EventTypeSeq &

rhs

)

Definition at line 32 of file EventTypeSeq.cpp.

  : TAO_Notify_Object ()
  , TAO_Notify::Topology_Savable ()
  , ACE_Unbounded_Set <TAO_Notify_EventType> (rhs)
  , TAO_Notify::Topology_Object ()
{
}

---

Member Function Documentation

void TAO_Notify_EventTypeSeq::add_and_remove	(	TAO_Notify_EventTypeSeq &	added,
		TAO_Notify_EventTypeSeq &	removed
	)

Preprocess the types added and removed.

Definition at line 126 of file EventTypeSeq.cpp.

References ACE_Unbounded_Set_Ex< T, C >::find(), ACE_Unbounded_Set_Ex< TAO_Notify_EventType, ACE_Unbounded_Set_Default_Comparator< TAO_Notify_EventType > >::insert(), ACE_Unbounded_Set_Ex< T, C >::insert(), insert_seq(), intersection(), ACE_Unbounded_Set_Ex< T, C >::is_empty(), remove_seq(), ACE_Unbounded_Set_Ex< TAO_Notify_EventType, ACE_Unbounded_Set_Default_Comparator< TAO_Notify_EventType > >::reset(), ACE_Unbounded_Set_Ex< T, C >::reset(), and TAO_Notify_EventType::special().

Referenced by TAO_Notify_SupplierAdmin::offer_change(), TAO_Notify_ProxyConsumer_T< SERVANT_TYPE >::offer_change(), TAO_Notify_ProxySupplier_T< SERVANT_TYPE >::subscription_change(), and TAO_Notify_ConsumerAdmin::subscription_change().

{
  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::dump

(

void

)

const

Print the contents.

Reimplemented from ACE_Unbounded_Set_Ex< TAO_Notify_EventType, ACE_Unbounded_Set_Default_Comparator< TAO_Notify_EventType > >.

Definition at line 249 of file EventTypeSeq.cpp.

References ACE_DEBUG, TAO_Notify_EventType::dump(), and LM_DEBUG.

{
  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, ", "));
    }
}

void TAO_Notify_EventTypeSeq::insert_seq

(

const TAO_Notify_EventTypeSeq &

event_type_seq

)

insert_seq the contents of <event_type_seq> into this object.

Definition at line 104 of file EventTypeSeq.cpp.

References ACE_Unbounded_Set_Ex< TAO_Notify_EventType, ACE_Unbounded_Set_Default_Comparator< TAO_Notify_EventType > >::insert().

{
  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::insert_seq

(

const CosNotification::EventTypeSeq &

event_type_seq

)

insert_seq the contents of <event_type_seq> into this object.

Definition at line 80 of file EventTypeSeq.cpp.

References ACE_Unbounded_Set_Ex< TAO_Notify_EventType, ACE_Unbounded_Set_Default_Comparator< TAO_Notify_EventType > >::insert().

Referenced by add_and_remove(), and TAO_Notify_EventTypeSeq().

{
  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::intersection	(	const TAO_Notify_EventTypeSeq &	rhs,
		const TAO_Notify_EventTypeSeq &	lhs
	)

Populate this sequence with the intersection of rhs and lhs.

Definition at line 229 of file EventTypeSeq.cpp.

References ACE_Unbounded_Set_Ex< TAO_Notify_EventType, ACE_Unbounded_Set_Default_Comparator< TAO_Notify_EventType > >::insert().

Referenced by add_and_remove(), and TAO_Notify_Peer::dispatch_updates().

{
  // 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);
        }
    }
}

TAO_Notify::Topology_Object * TAO_Notify_EventTypeSeq::load_child	(	const ACE_CString &	type,
		CORBA::Long	id,
		const TAO_Notify::NVPList &	attrs
	)			[virtual]

Create a child of the appropriate type and return it.

Use "type" as passed in to determine what kind of child (supporting the Topology_Object interface) to create and return. Inform it of its new ID.

Reimplemented from TAO_Notify::Topology_Object.

Definition at line 291 of file EventTypeSeq.cpp.

References ACE_DEBUG, ACE_TEXT(), DEBUG_LEVEL, TAO_Notify_EventType::init(), ACE_Unbounded_Set_Ex< TAO_Notify_EventType, ACE_Unbounded_Set_Default_Comparator< TAO_Notify_EventType > >::insert(), and LM_DEBUG.

{
  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;
}

TAO_Notify_EventTypeSeq & TAO_Notify_EventTypeSeq::operator=

(

const TAO_Notify_EventTypeSeq &

rhs

)

Definition at line 26 of file EventTypeSeq.cpp.

{
  ACE_Unbounded_Set <TAO_Notify_EventType>::operator = (rhs);
  return *this;
}

void TAO_Notify_EventTypeSeq::populate

(

CosNotification::EventTypeSeq &

event_type

)

const

Populate <event_type_seq> with the contents of this object.

Definition at line 41 of file EventTypeSeq.cpp.

References TAO_Notify_EventType::native().

Referenced by TAO_Notify_Proxy::obtain_types().

{
  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

)

const

Populate <event_type_seq> with the contents of this object. Excludes the special event type. This is used to avoid sending * type updates to proxys.

Definition at line 55 of file EventTypeSeq.cpp.

References TAO_Notify_EventType::is_special(), TAO_Notify_EventType::native(), and TAO_Notify_EventType::special().

Referenced by TAO_Notify_Peer::dispatch_updates().

{
  // 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 = 0;

  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::release

(

void

)

[private, virtual]

The release method is called when the refcount reaches 0.

Implements TAO_Notify_Refcountable.

Definition at line 309 of file EventTypeSeq.cpp.

{
  delete this;
}

void TAO_Notify_EventTypeSeq::remove_seq

(

const TAO_Notify_EventTypeSeq &

event_type_seq

)

remove_seq the contents of <event_type_seq> from this object.

Definition at line 115 of file EventTypeSeq.cpp.

References ACE_Unbounded_Set_Ex< TAO_Notify_EventType, ACE_Unbounded_Set_Default_Comparator< TAO_Notify_EventType > >::remove().

{
  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::remove_seq

(

const CosNotification::EventTypeSeq &

event_type_seq

)

remove_seq the contents of <event_type_seq> from this object.

Definition at line 92 of file EventTypeSeq.cpp.

References ACE_Unbounded_Set_Ex< TAO_Notify_EventType, ACE_Unbounded_Set_Default_Comparator< TAO_Notify_EventType > >::remove().

Referenced by add_and_remove(), and TAO_Notify_Peer::dispatch_updates().

{
  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::save_persistent

(

TAO_Notify::Topology_Saver &

saver

)

[virtual]

Save our state to a Topology_Saver.

Use the methods of a Topology_Saver to store all information we want persisted. This function is called by our parent, which gives us a saver to use. In turn, we must call this function on all of our children. The implementation should look like: bool change = this->self_changed_; this->self_changed_ = false; this->children_changed_ = false; if (is_persistent ()) { bool want_all_children = saver.begin_object( this->id(), type, attrs, change); for all children { if (want_all_children || child.is_changed()) { child.save_persistent(saver); } } for all deleted children { saver.delete_child(child_type, child_id); } saver.end_object(this->id(), type); )

Implements TAO_Notify::Topology_Savable.

Definition at line 264 of file EventTypeSeq.cpp.

References TAO_Notify::Topology_Saver::begin_object(), TAO_Notify::Topology_Object::children_changed_, TAO_Notify::Topology_Saver::end_object(), TAO_Notify_EventType::save_persistent(), and TAO_Notify::Topology_Object::self_changed_.

{
  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);
    for (iter.first (); iter.next (event_type) != 0; iter.advance ())
    {
      event_type->save_persistent(saver);
    }
// todo:
//    for all deleted children
//    {
//      saver.delete_child(child_type, child_id);
//    }
    saver.end_object(0, "subscriptions");
  }
}

---

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

• EventTypeSeq.h
• EventTypeSeq.cpp

---