TAO_EC_Disjunction_Filter Class Reference

The disjunction filter. More...

#include <EC_Disjunction_Filter.h>

Inheritance diagram for TAO_EC_Disjunction_Filter:

Inheritance graph
[legend]
Collaboration diagram for TAO_EC_Disjunction_Filter:

Collaboration graph
[legend]
List of all members.

Public Member Functions

 TAO_EC_Disjunction_Filter (TAO_EC_Filter *children[], size_t n)
virtual ~TAO_EC_Disjunction_Filter (void)
 Destructor.
virtual ChildrenIterator begin (void) const
virtual ChildrenIterator end (void) const
virtual int size (void) const
virtual int filter (const RtecEventComm::EventSet &event, TAO_EC_QOS_Info &qos_info)
virtual int filter_nocopy (RtecEventComm::EventSet &event, TAO_EC_QOS_Info &qos_info)
virtual void push (const RtecEventComm::EventSet &event, TAO_EC_QOS_Info &qos_info)
virtual void push_nocopy (RtecEventComm::EventSet &event, TAO_EC_QOS_Info &qos_info)
virtual void clear (void)
virtual CORBA::ULong max_event_size (void) const
 Returns the maximum size of the events pushed by this filter.
virtual int can_match (const RtecEventComm::EventHeader &header) const
virtual int add_dependencies (const RtecEventComm::EventHeader &header, const TAO_EC_QOS_Info &qos_info)

Private Member Functions

 TAO_EC_Disjunction_Filter (const TAO_EC_Disjunction_Filter &)
TAO_EC_Disjunction_Filter & operator= (const TAO_EC_Disjunction_Filter &)

Private Attributes

TAO_EC_Filter ** children_
 The children.
size_t n_
 The number of children.

Detailed Description

The disjunction filter.

This filter has a set of children (fixed at creation time), if any of the children accepts an event then it also does.

Memory Management

It assumes ownership of the children.

Definition at line 39 of file EC_Disjunction_Filter.h.

Constructor & Destructor Documentation

TAO_BEGIN_VERSIONED_NAMESPACE_DECL TAO_EC_Disjunction_Filter::TAO_EC_Disjunction_Filter ( TAO_EC_Filter *  children[],
size_t  n 
)

Constructor. It assumes ownership of both the array and the children.

Definition at line 10 of file EC_Disjunction_Filter.cpp.

00012   :  children_ (children),
00013      n_ (n)
00014 {
00015   ChildrenIterator end = this->end ();
00016   for (ChildrenIterator i = this->begin ();
00017        i != end;
00018        ++i)
00019     {
00020       this->adopt_child (*i);
00021     }
00022 }

TAO_EC_Disjunction_Filter::~TAO_EC_Disjunction_Filter ( void   )  [virtual]

Destructor.

Definition at line 24 of file EC_Disjunction_Filter.cpp.

References children_, end(), and n_.

00025 {
00026   TAO_EC_Filter** end = this->children_ + this->n_;
00027   for (TAO_EC_Filter** i = this->children_;
00028        i != end;
00029        ++i)
00030     {
00031       delete *i;
00032       *i = 0;
00033     }
00034   delete[] this->children_;
00035   this->children_ = 0;
00036   this->n_ = 0;
00037 }

TAO_EC_Disjunction_Filter::TAO_EC_Disjunction_Filter ( const TAO_EC_Disjunction_Filter &   )  [private]

Member Function Documentation

int TAO_EC_Disjunction_Filter::add_dependencies ( const RtecEventComm::EventHeader &  header,
const TAO_EC_QOS_Info &  qos_info 
) [virtual]

This is used for computing the scheduling dependencies:

Leaf filters check if the header could be matched, similar to the can_match() method; if it does they return 1, and 0 otherwise. Intermediate nodes always return 0.

This is used to build precise dependencies between the suppliers and the leaf of the filters that accept that event. Notice that only the nodes doing scheduling recurse through the list, so in configurations that do no require scheduling the recursion stops fairly soon.

Implements TAO_EC_Filter.

Definition at line 149 of file EC_Disjunction_Filter.cpp.

00152 {
00153   return 0;
00154 }

TAO_EC_Filter::ChildrenIterator TAO_EC_Disjunction_Filter::begin ( void   )  const [virtual]

STL-like iterators Filters follow the Composite pattern. All filters expose the same interface as if they all had children, but for simple filters the iterators return an empty range.

Reimplemented from TAO_EC_Filter.

Definition at line 40 of file EC_Disjunction_Filter.cpp.

References children_.

00041 {
00042   return this->children_;
00043 }

int TAO_EC_Disjunction_Filter::can_match ( const RtecEventComm::EventHeader &  header  )  const [virtual]

Returns 0 if an event with that header could never be accepted. This can used by the suppliers to filter out consumers that couldn't possibly be interested in their events. The rt_info and

Implements TAO_EC_Filter.

Definition at line 134 of file EC_Disjunction_Filter.cpp.

References end().

00136 {
00137   ChildrenIterator end = this->end ();
00138   for (ChildrenIterator i = this->begin ();
00139        i != end;
00140        ++i)
00141     {
00142       if ((*i)->can_match (header) != 0)
00143         return 1;
00144     }
00145   return 0;
00146 }

void TAO_EC_Disjunction_Filter::clear ( void   )  [virtual]

Clear any saved state, must reset and assume no events have been received.

Implements TAO_EC_Filter.

Definition at line 106 of file EC_Disjunction_Filter.cpp.

References end().

00107 {
00108   ChildrenIterator end = this->end ();
00109   for (ChildrenIterator i = this->begin ();
00110        i != end;
00111        ++i)
00112     {
00113       (*i)->clear ();
00114     }
00115 }

TAO_EC_Filter::ChildrenIterator TAO_EC_Disjunction_Filter::end ( void   )  const [virtual]

Reimplemented from TAO_EC_Filter.

Definition at line 46 of file EC_Disjunction_Filter.cpp.

References children_, and n_.

Referenced by can_match(), clear(), filter(), filter_nocopy(), max_event_size(), and ~TAO_EC_Disjunction_Filter().

00047 {
00048   return this->children_ + this->n_;
00049 }

int TAO_EC_Disjunction_Filter::filter ( const RtecEventComm::EventSet &  event,
TAO_EC_QOS_Info &  qos_info 
) [virtual]

Filter this event, returns 1 if the event is accepted, 0 otherwise. Notice that there are two versions of the method, if the event is not const then filter can take ownership of the event.

Attention:
There seems to be a disparity in interfaces: Supplier always push event sets of size 1 to the EC_ProxyPushSupplier, and EC_Filters do not implement handling of sets of more than 1 event. Then, why is this not enforced by the interface by having EC_ProxyPushSupplier take an event rather than a set?

Implements TAO_EC_Filter.

Definition at line 58 of file EC_Disjunction_Filter.cpp.

References end().

00060 {
00061   ChildrenIterator end = this->end ();
00062   for (ChildrenIterator i = this->begin ();
00063        i != end;
00064        ++i)
00065     {
00066       int n = (*i)->filter (event, qos_info);
00067       if (n != 0)
00068         return n;
00069     }
00070   return 0;
00071 }

int TAO_EC_Disjunction_Filter::filter_nocopy ( RtecEventComm::EventSet &  event,
TAO_EC_QOS_Info &  qos_info 
) [virtual]

Implements TAO_EC_Filter.

Definition at line 74 of file EC_Disjunction_Filter.cpp.

References end().

00076 {
00077   ChildrenIterator end = this->end ();
00078   for (ChildrenIterator i = this->begin ();
00079        i != end;
00080        ++i)
00081     {
00082       int n = (*i)->filter (event, qos_info);
00083       if (n != 0)
00084         return n;
00085     }
00086   return 0;
00087 }

CORBA::ULong TAO_EC_Disjunction_Filter::max_event_size ( void   )  const [virtual]

Returns the maximum size of the events pushed by this filter.

Implements TAO_EC_Filter.

Definition at line 118 of file EC_Disjunction_Filter.cpp.

References end().

00119 {
00120   CORBA::ULong n = 0;
00121   ChildrenIterator end = this->end ();
00122   for (ChildrenIterator i = this->begin ();
00123        i != end;
00124        ++i)
00125     {
00126       CORBA::ULong m = (*i)->max_event_size ();
00127       if (n < m)
00128         n = m;
00129     }
00130   return n;
00131 }

TAO_EC_Disjunction_Filter& TAO_EC_Disjunction_Filter::operator= ( const TAO_EC_Disjunction_Filter &   )  [private]

void TAO_EC_Disjunction_Filter::push ( const RtecEventComm::EventSet &  event,
TAO_EC_QOS_Info &  qos_info 
) [virtual]

This is called by the children when they accept an event and which to pass it up. Notice that there are two versions of the method, if the event is not const then filter can take ownership of the event.

Implements TAO_EC_Filter.

Definition at line 90 of file EC_Disjunction_Filter.cpp.

00092 {
00093   if (this->parent () != 0)
00094     this->parent ()->push (event, qos_info);
00095 }

void TAO_EC_Disjunction_Filter::push_nocopy ( RtecEventComm::EventSet &  event,
TAO_EC_QOS_Info &  qos_info 
) [virtual]

Implements TAO_EC_Filter.

Definition at line 98 of file EC_Disjunction_Filter.cpp.

00100 {
00101   if (this->parent () != 0)
00102     this->parent ()->push_nocopy (event, qos_info);
00103 }

int TAO_EC_Disjunction_Filter::size ( void   )  const [virtual]

Reimplemented from TAO_EC_Filter.

Definition at line 52 of file EC_Disjunction_Filter.cpp.

References n_.

00053 {
00054   return static_cast<int> (this->n_);
00055 }

Member Data Documentation

TAO_EC_Filter** TAO_EC_Disjunction_Filter::children_ [private]

The children.

Definition at line 76 of file EC_Disjunction_Filter.h.

Referenced by begin(), end(), and ~TAO_EC_Disjunction_Filter().

size_t TAO_EC_Disjunction_Filter::n_ [private]

The number of children.

Definition at line 79 of file EC_Disjunction_Filter.h.

Referenced by end(), size(), and ~TAO_EC_Disjunction_Filter().

The documentation for this class was generated from the following files:
Generated on Tue Feb 2 17:44:28 2010 for TAO_RTEvent by  doxygen 1.4.7