TAO_CosNotification: TAO_Notify_FilterAdmin Class Reference

typedef ACE_Hash_Map_Manager<CosNotifyFilter::FilterID, CosNotifyFilter::Filter_var, ACE_SYNCH_NULL_MUTEX> TAO_Notify_FilterAdmin::FILTER_LIST [private]

Definition at line 72 of file FilterAdmin.h.

TAO_BEGIN_VERSIONED_NAMESPACE_DECL TAO_Notify_FilterAdmin::TAO_Notify_FilterAdmin ( void )

Constructor.

Definition at line 18 of file FilterAdmin.cpp.

00019 {
00020 }

TAO_Notify_FilterAdmin::~TAO_Notify_FilterAdmin ( void ) [virtual]

Destructor.

Definition at line 23 of file FilterAdmin.cpp.

00024 {
00025 }

CosNotifyFilter::FilterID TAO_Notify_FilterAdmin::add_filter ( CosNotifyFilter::Filter_ptr new_filter ) [virtual]

Definition at line 28 of file FilterAdmin.cpp.

References ACE_GUARD_THROW_EX, filter_ids_, TAO_Notify_ID_Factory::id(), CORBA::is_nil(), and TAO_SYNCH_MUTEX.

Referenced by TAO_Notify_SupplierAdmin::add_filter(), TAO_Notify_Proxy_T< SERVANT_TYPE >::add_filter(), and TAO_Notify_ConsumerAdmin::add_filter().

00029 {
00030   if (CORBA::is_nil (new_filter))
00031     throw CORBA::BAD_PARAM ();
00032 
00033   ACE_GUARD_THROW_EX (TAO_SYNCH_MUTEX, ace_mon, this->lock_,
00034                       CORBA::INTERNAL ());
00035 
00036   CosNotifyFilter::FilterID new_id = this->filter_ids_.id ();
00037 
00038   CosNotifyFilter::Filter_var new_filter_var =
00039     CosNotifyFilter::Filter::_duplicate (new_filter);
00040 
00041   if (this->filter_list_.bind (new_id, new_filter_var) == -1)
00042       throw CORBA::INTERNAL ();
00043   else
00044     return new_id;
00045 }

CosNotifyFilter::FilterIDSeq * TAO_Notify_FilterAdmin::get_all_filters ( void ) [virtual]

Definition at line 73 of file FilterAdmin.cpp.

References ACE_GUARD_THROW_EX, ACE_NEW_THROW_EX, ACE_Hash_Map_Manager_Ex< EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK >::current_size(), filter_list_, and TAO_SYNCH_MUTEX.

Referenced by TAO_Notify_SupplierAdmin::get_all_filters(), TAO_Notify_Proxy_T< SERVANT_TYPE >::get_all_filters(), and TAO_Notify_ConsumerAdmin::get_all_filters().

00074 {
00075   ACE_GUARD_THROW_EX (TAO_SYNCH_MUTEX, ace_mon, this->lock_,
00076                       CORBA::INTERNAL ());
00077 
00078   // Figure out the length of the list.
00079   size_t len = this->filter_list_.current_size ();
00080 
00081   CosNotifyFilter::FilterIDSeq* list_ptr = 0;
00082 
00083   // Allocate the list of <len> length.
00084   ACE_NEW_THROW_EX (list_ptr,
00085                     CosNotifyFilter::FilterIDSeq,
00086                     CORBA::NO_MEMORY ());
00087 
00088   CosNotifyFilter::FilterIDSeq_var list (list_ptr);
00089 
00090   list->length (static_cast<CORBA::ULong> (len));
00091 
00092   FILTER_LIST::ITERATOR iter (this->filter_list_);
00093   FILTER_LIST::ENTRY *entry;
00094 
00095   u_int index;
00096 
00097   for (index = 0; iter.next (entry) != 0; iter.advance (), ++index)
00098     {
00099       list[index] = entry->ext_id_;
00100     }
00101 
00102   return list._retn ();
00103 }

CosNotifyFilter::Filter_ptr TAO_Notify_FilterAdmin::get_filter ( CosNotifyFilter::FilterID filter ) [virtual]

Definition at line 58 of file FilterAdmin.cpp.

References ACE_GUARD_THROW_EX, and TAO_SYNCH_MUTEX.

Referenced by TAO_Notify_SupplierAdmin::get_filter(), TAO_Notify_Proxy_T< SERVANT_TYPE >::get_filter(), and TAO_Notify_ConsumerAdmin::get_filter().

00059 {
00060   ACE_GUARD_THROW_EX (TAO_SYNCH_MUTEX, ace_mon, this->lock_,
00061                       CORBA::INTERNAL ());
00062 
00063   CosNotifyFilter::Filter_var filter_var;
00064 
00065   if (this->filter_list_.find (filter_id,
00066                                filter_var) == -1)
00067     throw CosNotifyFilter::FilterNotFound ();
00068 
00069   return filter_var._retn ();
00070 }

TAO_Notify::Topology_Object * TAO_Notify_FilterAdmin::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 148 of file FilterAdmin.cpp.

References ACE_ASSERT, ACE_String_Base< CHAR >::c_str(), filter_ids_, TAO_Pseudo_Var_T< T >::in(), TAO_Notify_Properties::instance(), CORBA::is_nil(), TAO_Notify::NVPList::load(), TAO_Notify_Properties::orb(), and TAO_Notify_ID_Factory::set_last_used().

00150 {
00151   if (type == "filter")
00152   {
00153     TAO_Notify_Properties* properties = TAO_Notify_PROPERTIES::instance();
00154     CORBA::ORB_var orb = properties->orb();
00155     ACE_ASSERT(! CORBA::is_nil(orb.in()));
00156     ACE_CString ior;
00157 
00158     (void) attrs.load("IOR", ior);
00159     CORBA::Object_var obj = orb->string_to_object(ior.c_str());
00160     CosNotifyFilter::Filter_var filter = CosNotifyFilter::Filter::_unchecked_narrow(obj.in());
00161 
00162     if (! CORBA::is_nil(filter.in()))
00163     {
00164       this->filter_ids_.set_last_used(id);
00165       if (this->filter_list_.bind (id, filter) != 0)
00166         throw CORBA::INTERNAL ();
00167     }
00168   }
00169   return this;
00170 }

TAO_BEGIN_VERSIONED_NAMESPACE_DECL ACE_INLINE CORBA::Boolean TAO_Notify_FilterAdmin::match ( const TAO_Notify_Event * event )

See if any of the filters match.

Definition at line 8 of file FilterAdmin.inl.

References ACE_GUARD_THROW_EX, TAO_Notify_Event::do_match(), and TAO_SYNCH_MUTEX.

00009 {
00010   ACE_GUARD_THROW_EX (TAO_SYNCH_MUTEX, ace_mon, this->lock_,
00011                       CORBA::INTERNAL ());
00012 
00013   // If no filter is active, match is successfull.
00014   if (this->filter_list_.current_size () == 0)
00015     return 1;
00016 
00017   // We want to return true if atleast one constraint matches.
00018   FILTER_LIST::ITERATOR iter (this->filter_list_);
00019   FILTER_LIST::ENTRY *entry;
00020   CORBA::Boolean ret_val = 0;
00021 
00022   for (; iter.next (entry); iter.advance ())
00023     {
00024       ret_val = event->do_match (entry->int_id_.in ());
00025 
00026       if (ret_val == 1)
00027         return 1;
00028     }
00029 
00030   return 0;
00031 }

CORBA::Boolean TAO_Notify_FilterAdmin::match ( const TAO_Notify_Event::Ptr & event )

See if any of the filters match.

Referenced by TAO_Notify_Proxy::check_filters().

void TAO_Notify_FilterAdmin::release ( void ) [private, virtual]

The release method is called when the refcount reaches 0.

Implements TAO_Notify_Refcountable.

Definition at line 173 of file FilterAdmin.cpp.

00174 {
00175   delete this;
00176 }

void TAO_Notify_FilterAdmin::remove_all_filters ( void ) [virtual]

Definition at line 106 of file FilterAdmin.cpp.

References ACE_GUARD_THROW_EX, filter_list_, TAO_SYNCH_MUTEX, and ACE_Hash_Map_Manager_Ex< EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK >::unbind_all().

Referenced by TAO_Notify_SupplierAdmin::remove_all_filters(), TAO_Notify_Proxy_T< SERVANT_TYPE >::remove_all_filters(), and TAO_Notify_ConsumerAdmin::remove_all_filters().

00107 {
00108   ACE_GUARD_THROW_EX (TAO_SYNCH_MUTEX, ace_mon, this->lock_,
00109                       CORBA::INTERNAL ());
00110 
00111   this->filter_list_.unbind_all ();
00112 }

void TAO_Notify_FilterAdmin::remove_filter ( CosNotifyFilter::FilterID filter ) [virtual]

Definition at line 48 of file FilterAdmin.cpp.

References ACE_GUARD_THROW_EX, and TAO_SYNCH_MUTEX.

Referenced by TAO_Notify_SupplierAdmin::remove_filter(), TAO_Notify_Proxy_T< SERVANT_TYPE >::remove_filter(), and TAO_Notify_ConsumerAdmin::remove_filter().

00049 {
00050   ACE_GUARD_THROW_EX (TAO_SYNCH_MUTEX, ace_mon, this->lock_,
00051                       CORBA::INTERNAL ());
00052 
00053   if (this->filter_list_.unbind (filter_id) == -1)
00054     throw CosNotifyFilter::FilterNotFound ();
00055 }

void TAO_Notify_FilterAdmin::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 115 of file FilterAdmin.cpp.

References ACE_ASSERT, TAO_Notify::Topology_Saver::begin_object(), TAO_Notify::Topology_Saver::end_object(), TAO_Pseudo_Var_T< T >::in(), TAO_Notify_Properties::instance(), CORBA::is_nil(), and TAO_Notify_Properties::orb().

00116 {
00117   if (this->filter_list_.current_size() == 0)
00118     return;
00119 
00120   bool changed = true;
00121 
00122   TAO_Notify::NVPList attrs;
00123   bool want_children = saver.begin_object(0, "filter_admin", attrs, changed);
00124   if (want_children)
00125   {
00126     FILTER_LIST::ITERATOR iter (this->filter_list_);
00127     FILTER_LIST::ENTRY* entry;
00128 
00129     TAO_Notify_Properties* properties = TAO_Notify_PROPERTIES::instance();
00130     CORBA::ORB_var orb = properties->orb();
00131     ACE_ASSERT(! CORBA::is_nil(orb.in()));
00132 
00133     for (; iter.next(entry) != 0; iter.advance())
00134     {
00135       TAO_Notify::NVPList fattrs;
00136       CORBA::Long id = entry->ext_id_;
00137       CORBA::String_var ior = orb->object_to_string(entry->int_id_.in());
00138       fattrs.push_back(TAO_Notify::NVP("IOR", ior.in()));
00139       saver.begin_object(id, "filter", fattrs, changed);
00140       saver.end_object(id, "filter");
00141     }
00142   }
00143 
00144   saver.end_object(0, "filter_admin");
00145 }

TAO_Notify_ID_Factory TAO_Notify_FilterAdmin::filter_ids_ [private]

Id generator for proxy suppliers.

Definition at line 83 of file FilterAdmin.h.

Referenced by add_filter(), and load_child().

FILTER_LIST TAO_Notify_FilterAdmin::filter_list_ [private]

List of filters.

Definition at line 80 of file FilterAdmin.h.

Referenced by get_all_filters(), and remove_all_filters().

TAO_SYNCH_MUTEX TAO_Notify_FilterAdmin::lock_ [private]

Mutex to serialize access to data members.

Reimplemented from TAO_Notify_Object.

Definition at line 77 of file FilterAdmin.h.


Public Member Functions
	TAO_Notify_FilterAdmin (void)
	Constructor.
virtual	~TAO_Notify_FilterAdmin (void)
	Destructor.
CORBA::Boolean	match (const TAO_Notify_Event::Ptr &event)
	See if any of the filters match.
CORBA::Boolean	match (const TAO_Notify_Event *event)
	See if any of the filters match.
virtual CosNotifyFilter::FilterID	add_filter (CosNotifyFilter::Filter_ptr new_filter)
virtual void	remove_filter (CosNotifyFilter::FilterID filter)
virtual CosNotifyFilter::Filter_ptr	get_filter (CosNotifyFilter::FilterID filter)
virtual CosNotifyFilter::FilterIDSeq *	get_all_filters (void)
virtual void	remove_all_filters (void)
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_Hash_Map_Manager< CosNotifyFilter::FilterID, CosNotifyFilter::Filter_var, ACE_SYNCH_NULL_MUTEX >	FILTER_LIST
Private Member Functions
virtual void	release (void)
	The release method is called when the refcount reaches 0.
Private Attributes
TAO_SYNCH_MUTEX	lock_
	Mutex to serialize access to data members.
FILTER_LIST	filter_list_
	List of filters.
TAO_Notify_ID_Factory	filter_ids_
	Id generator for proxy suppliers.

TAO_Notify_FilterAdmin Class Reference

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation